consciousness/src/agent/tools/mod.rs

// 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
}