Struct RotaryAgentBridge 

pub struct RotaryAgentBridge { /* private fields */ }

Bridge that wraps an rx4::Agent and provides a simplified interface for apollo’s outer shell to use.

The bridge handles:

• Creating and configuring the rx4::Agent (provider, tools, system prompt)
• Translating messages between apollo and rx4 types
• Running prompts through rx4’s agent loop

Unthinkclaw’s unique features (channels, swarm, cron, heartbeat, autonomous mode, plugins) remain in the outer shell and call run_prompt() on this bridge to execute agent turns.

Implementations

impl RotaryAgentBridge

pub fn new(config: RotaryBridgeConfig) -> Self

Build a new bridge from the given configuration.

pub fn agent(&self) -> &Agent

Get a reference to the inner rx4::Agent (for advanced configuration).

pub fn agent_mut(&mut self) -> &mut Agent

Get a mutable reference to the inner rx4::Agent.

pub fn clear_messages(&mut self)

Clear the conversation history.

pub fn message_count(&self) -> usize

Get the number of messages in the conversation.

pub fn set_model(&mut self, model: &str)

Set the model for the agent.

pub fn set_system_prompt(&mut self, prompt: &str)

Set the system prompt.

pub fn set_workspace_root(&mut self, path: &Path)

Set the workspace root.

pub fn set_scope(&mut self, scope: Scope)

Set the scope (e.g., Coding, Research, Ask).

pub fn subscribe(&mut self, callback: impl Fn(&Event) + Send + Sync + 'static)

Add a subscriber to receive agent events (tool calls, deltas, etc.).

pub async fn run_prompt(&mut self, prompt: &str) -> Result<String>

Run a single user prompt through the rx4 agent loop.

This delegates the core agent loop (LLM calls, tool execution, turn cycling) to rx4::Agent. The caller (apollo’s channel/swarm/cron shell) is responsible for:

• Receiving the user message from a channel
• Calling this method with the prompt text
• Sending the final response back through the channel

Returns the final assistant response text.

pub async fn run_prompt_with_history( &mut self, prompt: &str, history: &[ChatMessage], ) -> Result<String>

Run a prompt with pre-loaded conversation history.

The history is loaded into rx4’s message buffer before running the prompt. This is used when apollo’s memory backend provides conversation history for a chat session.

pub fn register_tools(&mut self, tools: &[Arc<dyn UnthinkclawTool>])

Register additional tools at runtime.

pub fn list_tools(&self) -> Vec<String>

Get the list of registered tool names.

pub fn compact(&mut self, reason: &str)

Compact the conversation context (delegates to rx4’s compact).

pub fn messages_handle(&self) -> Arc<RwLock<Vec<Message>>>

Give rx4 a shared handle on the message buffer.

rx4 0.5.0 keeps Agent::messages behind an Arc, so a host can append to the conversation while prompt() is still running and the next tool iteration will see it. This is what apollo’s steering queue needs: a message that arrives mid-turn is pushed here rather than queued until the turn ends.

pub fn enable_skill_engine(&mut self, workspace: &Path)

Load rx4’s SkillEngine over apollo’s skill directories and hand it to the agent, which runs its background skill reviewer after each prompt.

This is additive to apollo’s own skills module: rx4’s engine does not perform apollo’s template-variable substitution or inline shell expansion, so it supplements rather than replaces skills::match_skill.

pub fn enable_graph_memory(&mut self, workspace: &Path, auto_dream: bool)

Attach an rx4 GraphMemory rooted at the workspace.

rx4 extracts concepts, decisions and patterns from the conversation after each prompt and adds them to the graph. auto_dream additionally runs one consolidation pass per prompt.