forked from kent/consciousness
36bde60ba0
- agent/tools/mod.rs: remove duplicated tool implementations, delegate
to thought::dispatch for shared tools, keep only agent-specific
tools (control, vision, working_stack)
- subconscious/api.rs: replace duplicated memory/tool dispatch with
thought::dispatch, use thought::all_definitions() for tool schemas
- Delete agent/tools/{bash,read,write,edit,grep,glob_tool,journal,memory}.rs
(now live in thought/)
Both poc-agent and subconscious agents now use the same tool
implementations through the thought layer. Agent-specific behavior
(node tracking in runner.rs, control tools) stays in agent/.
59 lines
1.8 KiB
Rust
59 lines
1.8 KiB
Rust
// tools/mod.rs — Agent-specific tool dispatch
|
|
//
|
|
// Shared tools (memory, files, bash, journal) live in thought/.
|
|
// This module handles agent-specific tools (control, vision,
|
|
// working_stack) and delegates everything else to thought::dispatch.
|
|
|
|
mod control;
|
|
mod vision;
|
|
pub mod working_stack;
|
|
|
|
// Re-export shared infrastructure from thought
|
|
pub use crate::thought::{ToolOutput, ProcessTracker, truncate_output};
|
|
pub use crate::thought::memory;
|
|
pub use crate::thought::journal;
|
|
|
|
use crate::agent::types::ToolDef;
|
|
|
|
/// Dispatch a tool call by name.
|
|
///
|
|
/// Tries agent-specific tools first (control, vision), then
|
|
/// delegates to thought::dispatch for shared tools.
|
|
///
|
|
/// Note: working_stack is handled in runner.rs before reaching this
|
|
/// function (it needs mutable context access).
|
|
pub async fn dispatch(
|
|
name: &str,
|
|
args: &serde_json::Value,
|
|
tracker: &ProcessTracker,
|
|
) -> ToolOutput {
|
|
// Agent-specific tools that return Result<ToolOutput> directly
|
|
let rich_result = match name {
|
|
"pause" => Some(control::pause(args)),
|
|
"switch_model" => Some(control::switch_model(args)),
|
|
"yield_to_user" => Some(control::yield_to_user(args)),
|
|
"view_image" => Some(vision::view_image(args)),
|
|
_ => None,
|
|
};
|
|
if let Some(result) = rich_result {
|
|
return result.unwrap_or_else(ToolOutput::error);
|
|
}
|
|
|
|
// Delegate to shared thought layer
|
|
if let Some(output) = crate::thought::dispatch(name, args, tracker).await {
|
|
return output;
|
|
}
|
|
|
|
ToolOutput::error(format!("Unknown tool: {}", name))
|
|
}
|
|
|
|
/// Return all tool definitions (agent-specific + shared).
|
|
pub fn definitions() -> Vec<ToolDef> {
|
|
let mut defs = vec![
|
|
vision::definition(),
|
|
working_stack::definition(),
|
|
];
|
|
defs.extend(control::definitions());
|
|
defs.extend(crate::thought::all_definitions());
|
|
defs
|
|
}
|