not really working well - aborting this path.

bhouston · bhouston · commit 563e28b86706 · 2025-02-10T14:13:57.000-05:00
diff --git a/src/tools/interaction/subAgentMessage.ts b/src/tools/interaction/subAgentMessage.ts
@@ -1,4 +1,3 @@
-import Anthropic from "@anthropic-ai/sdk";
 import { Tool } from "../../core/types.js";
 import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
@@ -11,7 +10,9 @@ const parameterSchema = z.object({
   message: z
     .string()
     .optional()
-    .describe("The message to send to the sub-agent (required unless aborting)"),
+    .describe(
+      "The message to send to the sub-agent (required unless aborting)"
+    ),
   description: z
     .string()
     .max(80)
@@ -24,97 +25,54 @@ const parameterSchema = z.object({
 
 const returnSchema = z
   .object({
-    response: z.string().describe("Response from the sub-agent or abort confirmation"),
+    messages: z.array(z.string()).describe("Output from the sub-agent"),
   })
   .describe("Result containing the sub-agent's response or abort status");
 
 type Parameters = z.infer<typeof parameterSchema>;
 type ReturnType = z.infer<typeof returnSchema>;
 
-export const subAgentMessageTool: Tool<Parameters, ReturnType> = {
+export const subAgentStatusTool: Tool<Parameters, ReturnType> = {
   name: "subAgentMessage",
   description: "Sends a message to or aborts an existing sub-agent",
   parameters: zodToJsonSchema(parameterSchema),
   returns: zodToJsonSchema(returnSchema),
 
-  execute: async (
-    params,
-    { logger },
-  ): Promise<ReturnType> => {
-    if (!process.env.ANTHROPIC_API_KEY) {
-      throw new Error("ANTHROPIC_API_KEY environment variable is not set");
-    }
-
+  execute: async (params, { logger }): Promise<ReturnType> => {
     const state = subAgentStates.get(params.instanceId);
     if (!state) {
-      throw new Error("Sub-agent not found");
+      throw new Error(`Sub-agent not found with ID: ${params.instanceId}`);
     }
 
     if (state.aborted) {
-      throw new Error("Sub-agent has been aborted");
+      throw new Error(`Sub-agent ${params.instanceId} has been aborted`);
     }
 
     if (params.abort) {
       logger.verbose(`Aborting sub-agent ${params.instanceId}`);
+      state.toolAgentState.inMessages.write({ abort: true });
       state.aborted = true;
-      return {
-        response: "Sub-agent aborted",
-      };
     }
 
-    if (!params.message) {
-      throw new Error("Message is required when not aborting");
-    }
-
-    const anthropic = new Anthropic({
-      apiKey: process.env.ANTHROPIC_API_KEY,
-    });
-
-    // Create messages array with conversation history
-    const messages = [
-      {
-        role: "user" as const,
-        content: state.prompt,
-      },
-      ...state.messages,
-      {
-        role: "user" as const,
-        content: params.message,
-      },
-    ];
+    if (params.message) {
+      // Send message
+      logger.verbose(`Sending message to tool agent`);
+      state.toolAgentState.inMessages.write(params.message);
 
-    // Get response
-    logger.verbose(`Sending message to Anthropic API`);
-    const response = await anthropic.messages.create({
-      model: "claude-3-opus-20240229",
-      max_tokens: 4096,
-      messages,
-    });
-
-    // Check if response content exists and has the expected structure
-    if (!response.content?.[0]?.text) {
-      throw new Error("Invalid response from Anthropic API");
+      // Store the interaction
+      state.messages.push({ role: "user", content: params.message });
     }
-
-    const responseText = response.content[0].text;
-    logger.verbose(`Received response from sub-agent`);
-
-    // Store the interaction
-    state.messages.push(
-      { role: "user", content: params.message },
-      { role: "assistant", content: responseText }
-    );
-
-    return {
-      response: responseText,
-    };
   },
 
   logParameters: (input, { logger }) => {
     if (input.abort) {
-      logger.info(`Aborting sub-agent ${input.instanceId}: ${input.description}`);
+      logger.info(
+        `Aborting sub-agent ${input.instanceId}: ${input.description}`
+      );
     } else {
-      logger.info(`Sending message to sub-agent ${input.instanceId}: ${input.description}`);
+      logger.info(
+        `Sending message to sub-agent ${input.instanceId}: ${input.description}`
+      );
       logger.verbose(`Message: ${input.message}`);
     }
   },
diff --git a/src/tools/interaction/subAgentStart.ts b/src/tools/interaction/subAgentStart.ts
@@ -1,14 +1,13 @@
-import Anthropic from "@anthropic-ai/sdk";
 import { Tool } from "../../core/types.js";
 import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { subAgentStates } from "./subAgentState.js";
+import { subAgentStates, SubAgentState } from "./subAgentState.js";
 import { v4 as uuidv4 } from "uuid";
+import { toolAgent } from "../../core/toolAgent.js";
+import { getTools } from "../getTools.js";
 
 const parameterSchema = z.object({
-  prompt: z
-    .string()
-    .describe("The prompt/task for the sub-agent"),
+  prompt: z.string().describe("The prompt/task for the sub-agent"),
   description: z
     .string()
     .max(80)
@@ -17,7 +16,9 @@ const parameterSchema = z.object({
 
 const returnSchema = z
   .object({
-    instanceId: z.string().describe("Unique identifier for the sub-agent instance"),
+    instanceId: z
+      .string()
+      .describe("Unique identifier for the sub-agent instance"),
     response: z.string().describe("Initial response from the sub-agent"),
   })
   .describe("Result containing sub-agent instance ID and initial response");
@@ -27,65 +28,77 @@ type ReturnType = z.infer<typeof returnSchema>;
 
 export const subAgentStartTool: Tool<Parameters, ReturnType> = {
   name: "subAgentStart",
-  description: "Creates a sub-agent that has access to all tools to solve a specific task",
+  description:
+    "Creates a sub-agent that has access to all tools to solve a specific task",
   parameters: zodToJsonSchema(parameterSchema),
   returns: zodToJsonSchema(returnSchema),
 
-  execute: async (
-    params,
-    { logger },
-  ): Promise<ReturnType> => {
-    if (!process.env.ANTHROPIC_API_KEY) {
-      throw new Error("ANTHROPIC_API_KEY environment variable is not set");
-    }
-
-    const anthropic = new Anthropic({
-      apiKey: process.env.ANTHROPIC_API_KEY,
-    });
-
-    // Create new instance ID
+  execute: async (params, { logger }): Promise<ReturnType> => {
     const instanceId = uuidv4();
     logger.verbose(`Creating new sub-agent with instance ID: ${instanceId}`);
 
-    // Initialize sub-agent state
-    subAgentStates.set(instanceId, {
-      prompt: params.prompt,
-      messages: [],
-      aborted: false,
-    });
-
-    // Get initial response
-    logger.verbose(`Getting initial response from Anthropic API`);
-    const response = await anthropic.messages.create({
-      model: "claude-3-opus-20240229",
-      max_tokens: 4096,
-      messages: [
-        {
-          role: "user",
-          content: params.prompt,
-        },
-      ],
-    });
-
-    // Check if response content exists and has the expected structure
-    if (!response.content?.[0]?.text) {
-      throw new Error("Invalid response from Anthropic API");
-    }
+    try {
+      const tools = (await getTools()).filter(
+        (tool) => tool.name !== "userPrompt"
+      );
+
+      // Initialize toolAgent
+      const toolAgentState = toolAgent(params.prompt, tools, logger);
 
-    const responseText = response.content[0].text;
-    logger.verbose(`Received response from sub-agent`);
+      // Initialize sub-agent state
+      const state: SubAgentState = {
+        prompt: params.prompt,
+        messages: [],
+        aborted: false,
+        toolAgentState,
+      };
+      subAgentStates.set(instanceId, state);
 
-    // Store the interaction
-    const state = subAgentStates.get(instanceId)!;
-    state.messages.push(
-      { role: "user", content: params.prompt },
-      { role: "assistant", content: responseText },
-    );
+      // Set up message handling
+      return new Promise((resolve, reject) => {
+        let messageReceived = false;
 
-    return {
-      instanceId,
-      response: responseText,
-    };
+        const messageHandler = (message: any) => {
+          if (message.type === "assistant" && !messageReceived) {
+            messageReceived = true;
+            const initialResponse = message.content;
+
+            // Store the interaction
+            state.messages.push(
+              { role: "user", content: params.prompt },
+              { role: "assistant", content: initialResponse }
+            );
+
+            resolve({
+              instanceId,
+              response: initialResponse,
+            });
+          }
+        };
+
+        const errorHandler = (error: Error) => {
+          state.aborted = true;
+          reject(error);
+        };
+
+        const endHandler = () => {
+          if (!messageReceived) {
+            state.aborted = true;
+            reject(
+              new Error("Stream ended without receiving assistant message")
+            );
+          }
+        };
+
+        toolAgentState.outMessages
+          .on("data", messageHandler)
+          .on("error", errorHandler)
+          .on("end", endHandler);
+      });
+    } catch (error) {
+      logger.error(`Failed to start sub-agent: ${error}`);
+      throw error;
+    }
   },
 
   logParameters: (input, { logger }) => {
diff --git a/src/tools/interaction/subAgentState.ts b/src/tools/interaction/subAgentState.ts
@@ -1,8 +1,11 @@
+import { ToolAgentState } from "../../core/toolAgent.js";
+
 // Map to store sub-agent states
 export interface SubAgentState {
   prompt: string;
   messages: Array<{ role: "user" | "assistant"; content: string }>;
   aborted: boolean;
+  toolAgentState: ToolAgentState;
 }
 
 export const subAgentStates = new Map<string, SubAgentState>();
