wip(autoagents): transition to manual tool registration with AgentDeriveT

Progress on fixing compilation errors discovered during build:

Changes:
- agent_builder.rs: Create CodeGraphReActAgent implementing AgentDeriveT
  - Manual tool registration via tools() method
  - Use shared_tools_to_boxes() for Arc<dyn ToolT> conversion
  - Pass agent to ReActAgent::new() instead of using with_tools()
- agent_builder.rs: Update AgentHandle type to DirectAgentHandle<ReActAgent<CodeGraphReActAgent>>
- graph_tools.rs: Fix ToolCallError usage (RuntimeError not ExecutionFailed)
- executor.rs: Update run_agent to use DirectAgentHandle structure

Remaining issues to fix:
- CodeGraphChatAdapter needs autoagents::llm::LLMProvider not ChatProvider
- No system_prompt() method on AgentBuilder (need alternative)
- Error::Generic doesn't exist (use correct variant)
- CodeGraphAgentOutput::structured_output_format() missing

This is WIP - compilation still failing, continuing investigation.

Author: jruokola

crates/codegraph-mcp/src/autoagents/agent_builder.rs

@@ -174,7 +174,6 @@ impl ChatResponse for CodeGraphChatResponse {
 // Agent Builder
 // ============================================================================
 
-use crate::autoagents::codegraph_agent::CodeGraphAgentOutput;
 use crate::autoagents::tier_plugin::TierAwarePromptPlugin;
 use crate::autoagents::tools::tool_executor_adapter::GraphToolFactory;
 use crate::autoagents::tools::graph_tools::*;
@@ -184,8 +183,39 @@ use crate::context_aware_limits::ContextTier;
 use autoagents::core::agent::AgentBuilder;
 use autoagents::core::agent::prebuilt::executor::ReActAgent;
 use autoagents::core::agent::memory::SlidingWindowMemory;
+use autoagents::core::agent::{AgentDeriveT, AgentHooks, DirectAgentHandle};
 use autoagents::core::error::Error as AutoAgentsError;
-use autoagents::core::tool::ToolT;
+use autoagents::core::tool::{shared_tools_to_boxes, ToolT};
+use autoagents_derive::AgentHooks;
+use crate::autoagents::codegraph_agent::CodeGraphAgentOutput;
+
+/// Agent implementation for CodeGraph with manual tool registration
+#[derive(Debug)]
+pub struct CodeGraphReActAgent {
+    tools: Vec<Arc<dyn ToolT>>,
+}
+
+impl AgentDeriveT for CodeGraphReActAgent {
+    type Output = CodeGraphAgentOutput;
+
+    fn description(&self) -> &'static str {
+        "CodeGraph agent for analyzing code dependencies and architecture"
+    }
+
+    fn name(&self) -> &'static str {
+        "codegraph_agent"
+    }
+
+    fn output_schema(&self) -> Option<serde_json::Value> {
+        Some(CodeGraphAgentOutput::structured_output_format())
+    }
+
+    fn tools(&self) -> Vec<Box<dyn ToolT>> {
+        shared_tools_to_boxes(&self.tools)
+    }
+}
+
+impl AgentHooks for CodeGraphReActAgent {}
 
 /// Builder for CodeGraph AutoAgents workflows
 pub struct CodeGraphAgentBuilder {
@@ -224,18 +254,21 @@ impl CodeGraphAgentBuilder {
         // Get executor adapter for tool construction
         let executor_adapter = self.tool_factory.adapter();
 
-        // Manually construct all 6 tools with the executor
-        let tools: Vec<Box<dyn ToolT>> = vec![
-            Box::new(GetTransitiveDependencies::new(executor_adapter.clone())),
-            Box::new(GetReverseDependencies::new(executor_adapter.clone())),
-            Box::new(TraceCallChain::new(executor_adapter.clone())),
-            Box::new(DetectCycles::new(executor_adapter.clone())),
-            Box::new(CalculateCoupling::new(executor_adapter.clone())),
-            Box::new(GetHubNodes::new(executor_adapter.clone())),
+        // Manually construct all 6 tools with the executor (Arc-wrapped for sharing)
+        let tools: Vec<Arc<dyn ToolT>> = vec![
+            Arc::new(GetTransitiveDependencies::new(executor_adapter.clone())),
+            Arc::new(GetReverseDependencies::new(executor_adapter.clone())),
+            Arc::new(TraceCallChain::new(executor_adapter.clone())),
+            Arc::new(DetectCycles::new(executor_adapter.clone())),
+            Arc::new(CalculateCoupling::new(executor_adapter.clone())),
+            Arc::new(GetHubNodes::new(executor_adapter.clone())),
         ];
 
-        // Build ReAct agent with manually constructed tools
-        let react_agent = ReActAgent::with_tools(tools);
+        // Create CodeGraph agent with tools
+        let codegraph_agent = CodeGraphReActAgent { tools };
+
+        // Build ReAct agent with our CodeGraph agent
+        let react_agent = ReActAgent::new(codegraph_agent);
 
         // Build full agent with configuration
         let agent = AgentBuilder::new(react_agent)
@@ -256,7 +289,7 @@ impl CodeGraphAgentBuilder {
 
 /// Handle for executing CodeGraph agent
 pub struct AgentHandle {
-    pub agent: Box<dyn autoagents::core::agent::Agent>,
+    pub agent: DirectAgentHandle<ReActAgent<CodeGraphReActAgent>>,
     pub tier: ContextTier,
     pub analysis_type: AnalysisType,
 }

crates/codegraph-mcp/src/autoagents/executor.rs

@@ -103,13 +103,14 @@ impl CodeGraphExecutor {
     /// Execute agent and convert output
     async fn run_agent(
         &self,
-        mut agent_handle: AgentHandle,
+        agent_handle: AgentHandle,
         query: String,
     ) -> Result<CodeGraphAgentOutput, ExecutorError> {
-        use autoagents::core::agent::Agent;
+        use autoagents::core::agent::AgentExecutor;
 
         // Execute the agent with the query
         let react_output = agent_handle
+            .agent
             .agent
             .run(&query)
             .await

crates/codegraph-mcp/src/autoagents/tools/graph_tools.rs

@@ -4,7 +4,6 @@
 use autoagents::core::tool::{ToolCallError, ToolInputT, ToolRuntime, ToolT};
 use autoagents_derive::{tool, ToolInput};
 use serde::{Deserialize, Serialize};
-use serde_json::Value;
 use std::sync::Arc;
 use crate::autoagents::tools::tool_executor_adapter::GraphToolExecutorAdapter;
 
@@ -59,7 +58,7 @@ impl ToolRuntime for GetTransitiveDependencies {
                 "edge_type": typed_args.edge_type,
                 "depth": typed_args.depth
             })
-        ).map_err(|e| ToolCallError::ExecutionFailed(e))?;
+        ).map_err(|e| ToolCallError::RuntimeError(Box::new(std::io::Error::new(std::io::ErrorKind::Other, e))))?;
 
         Ok(result)
     }
@@ -106,7 +105,7 @@ impl ToolRuntime for GetReverseDependencies {
                 "edge_type": typed_args.edge_type,
                 "depth": typed_args.depth
             })
-        ).map_err(|e| ToolCallError::ExecutionFailed(e))?;
+        ).map_err(|e| ToolCallError::RuntimeError(Box::new(std::io::Error::new(std::io::ErrorKind::Other, e))))?;
 
         Ok(result)
     }
@@ -153,7 +152,7 @@ impl ToolRuntime for TraceCallChain {
                 "start_node_id": typed_args.start_node_id,
                 "max_depth": typed_args.max_depth
             })
-        ).map_err(|e| ToolCallError::ExecutionFailed(e))?;
+        ).map_err(|e| ToolCallError::RuntimeError(Box::new(std::io::Error::new(std::io::ErrorKind::Other, e))))?;
 
         Ok(result)
     }
@@ -201,7 +200,7 @@ impl ToolRuntime for DetectCycles {
                 "edge_type": typed_args.edge_type,
                 "max_cycle_length": typed_args.max_cycle_length
             })
-        ).map_err(|e| ToolCallError::ExecutionFailed(e))?;
+        ).map_err(|e| ToolCallError::RuntimeError(Box::new(std::io::Error::new(std::io::ErrorKind::Other, e))))?;
 
         Ok(result)
     }
@@ -244,7 +243,7 @@ impl ToolRuntime for CalculateCoupling {
                 "node_id": typed_args.node_id,
                 "edge_type": typed_args.edge_type
             })
-        ).map_err(|e| ToolCallError::ExecutionFailed(e))?;
+        ).map_err(|e| ToolCallError::RuntimeError(Box::new(std::io::Error::new(std::io::ErrorKind::Other, e))))?;
 
         Ok(result)
     }
@@ -300,7 +299,7 @@ impl ToolRuntime for GetHubNodes {
                 "min_connections": typed_args.min_connections,
                 "limit": typed_args.limit
             })
-        ).map_err(|e| ToolCallError::ExecutionFailed(e))?;
+        ).map_err(|e| ToolCallError::RuntimeError(Box::new(std::io::Error::new(std::io::ErrorKind::Other, e))))?;
 
         Ok(result)
     }