chore: get tests to pass again

Author: bhouston

docs/tools/agent-tools.md

@@ -12,10 +12,10 @@ The `subAgent` tool creates a sub-agent that runs synchronously until completion
 ```typescript
 subAgent({
   description: "A brief description of the sub-agent's purpose",
-  goal: "The main objective that the sub-agent needs to achieve",
-  projectContext: "Context about the problem or environment",
-  workingDirectory: "/path/to/working/directory", // optional
-  relevantFilesDirectories: "src/**/*.ts", // optional
+  goal: 'The main objective that the sub-agent needs to achieve',
+  projectContext: 'Context about the problem or environment',
+  workingDirectory: '/path/to/working/directory', // optional
+  relevantFilesDirectories: 'src/**/*.ts', // optional
 });
 ```
 
@@ -35,10 +35,10 @@ The `agentStart` tool creates a sub-agent and immediately returns an instance ID
 ```typescript
 const { instanceId } = agentStart({
   description: "A brief description of the sub-agent's purpose",
-  goal: "The main objective that the sub-agent needs to achieve",
-  projectContext: "Context about the problem or environment",
-  workingDirectory: "/path/to/working/directory", // optional
-  relevantFilesDirectories: "src/**/*.ts", // optional
+  goal: 'The main objective that the sub-agent needs to achieve',
+  projectContext: 'Context about the problem or environment',
+  workingDirectory: '/path/to/working/directory', // optional
+  relevantFilesDirectories: 'src/**/*.ts', // optional
   enableUserPrompt: false, // optional, default: false
 });
 ```
@@ -50,22 +50,22 @@ The `agentMessage` tool allows interaction with a running sub-agent. It can be u
 ```typescript
 // Check agent progress
 const { output, completed } = agentMessage({
-  instanceId: "agent-instance-id",
-  description: "Checking agent progress",
+  instanceId: 'agent-instance-id',
+  description: 'Checking agent progress',
 });
 
 // Provide guidance (note: guidance implementation is limited in the current version)
 agentMessage({
-  instanceId: "agent-instance-id",
-  guidance: "Focus on the task at hand and avoid unnecessary exploration",
-  description: "Providing guidance to the agent",
+  instanceId: 'agent-instance-id',
+  guidance: 'Focus on the task at hand and avoid unnecessary exploration',
+  description: 'Providing guidance to the agent',
 });
 
 // Terminate the agent
 agentMessage({
-  instanceId: "agent-instance-id",
+  instanceId: 'agent-instance-id',
   terminate: true,
-  description: "Terminating the agent",
+  description: 'Terminating the agent',
 });
 ```
 
@@ -74,15 +74,15 @@ agentMessage({
 ```typescript
 // Start multiple sub-agents
 const agent1 = agentStart({
-  description: "Agent 1",
-  goal: "Implement feature A",
-  projectContext: "Project X",
+  description: 'Agent 1',
+  goal: 'Implement feature A',
+  projectContext: 'Project X',
 });
 
 const agent2 = agentStart({
-  description: "Agent 2",
-  goal: "Implement feature B",
-  projectContext: "Project X",
+  description: 'Agent 2',
+  goal: 'Implement feature B',
+  projectContext: 'Project X',
 });
 
 // Check progress of both agents
@@ -93,27 +93,27 @@ while (!agent1Completed || !agent2Completed) {
   if (!agent1Completed) {
     const result1 = agentMessage({
       instanceId: agent1.instanceId,
-      description: "Checking Agent 1 progress",
+      description: 'Checking Agent 1 progress',
     });
     agent1Completed = result1.completed;
-    
+
     if (agent1Completed) {
-      console.log("Agent 1 completed with result:", result1.output);
+      console.log('Agent 1 completed with result:', result1.output);
     }
   }
-  
+
   if (!agent2Completed) {
     const result2 = agentMessage({
       instanceId: agent2.instanceId,
-      description: "Checking Agent 2 progress",
+      description: 'Checking Agent 2 progress',
     });
     agent2Completed = result2.completed;
-    
+
     if (agent2Completed) {
-      console.log("Agent 2 completed with result:", result2.output);
+      console.log('Agent 2 completed with result:', result2.output);
     }
   }
-  
+
   // Wait before checking again
   if (!agent1Completed || !agent2Completed) {
     sleep({ seconds: 5 });
@@ -127,4 +127,4 @@ while (!agent1Completed || !agent2Completed) {
 - Use `agentStart` and `agentMessage` for:
   - Parallel execution of multiple sub-agents
   - Tasks where you need to monitor progress
-  - Situations where you may need to provide guidance or terminate early
+  - Situations where you may need to provide guidance or terminate early

packages/agent/src/tools/interaction/agentMessage.ts

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 
 import { Tool } from '../../core/types.js';
+
 import { agentStates } from './agentStart.js';
 
 const parameterSchema = z.object({
@@ -21,9 +22,17 @@ const parameterSchema = z.object({
 
 const returnSchema = z.object({
   output: z.string().describe('The current output from the sub-agent'),
-  completed: z.boolean().describe('Whether the sub-agent has completed its task'),
-  error: z.string().optional().describe('Error message if the sub-agent encountered an error'),
-  terminated: z.boolean().optional().describe('Whether the sub-agent was terminated by this message'),
+  completed: z
+    .boolean()
+    .describe('Whether the sub-agent has completed its task'),
+  error: z
+    .string()
+    .optional()
+    .describe('Error message if the sub-agent encountered an error'),
+  terminated: z
+    .boolean()
+    .optional()
+    .describe('Whether the sub-agent was terminated by this message'),
 });
 
 type Parameters = z.infer<typeof parameterSchema>;
@@ -66,7 +75,7 @@ export const agentMessageTool: Tool<Parameters, ReturnType> = {
       if (terminate) {
         agentState.aborted = true;
         agentState.completed = true;
-        
+
         return {
           output: agentState.output || 'Sub-agent terminated before completion',
           completed: true,
@@ -78,14 +87,17 @@ export const agentMessageTool: Tool<Parameters, ReturnType> = {
       // In a more advanced implementation, this could inject the guidance
       // into the agent's execution context
       if (guidance) {
-        logger.info(`Guidance provided to sub-agent ${instanceId}: ${guidance}`);
+        logger.info(
+          `Guidance provided to sub-agent ${instanceId}: ${guidance}`,
+        );
         // This is a placeholder for future implementation
         // In a real implementation, we would need to interrupt the agent's
         // execution and inject this guidance
       }
 
       // Get the current output
-      const output = agentState.result?.result || agentState.output || 'No output yet';
+      const output =
+        agentState.result?.result || agentState.output || 'No output yet';
 
       return {
         output,
@@ -104,7 +116,9 @@ export const agentMessageTool: Tool<Parameters, ReturnType> = {
       }
 
       const errorMessage = String(error);
-      logger.error(`Unknown error during sub-agent interaction: ${errorMessage}`);
+      logger.error(
+        `Unknown error during sub-agent interaction: ${errorMessage}`,
+      );
       return {
         output: '',
         completed: false,
@@ -129,4 +143,4 @@ export const agentMessageTool: Tool<Parameters, ReturnType> = {
       logger.info('Sub-agent is still running');
     }
   },
-};
+};

packages/agent/src/tools/interaction/agentStart.ts

@@ -7,7 +7,8 @@ import {
   getModel,
 } from '../../core/toolAgent/config.js';
 import { toolAgent } from '../../core/toolAgent/toolAgentCore.js';
-import { Tool, ToolAgentResult, ToolContext } from '../../core/types.js';
+import { ToolAgentResult } from '../../core/toolAgent/types.js';
+import { Tool, ToolContext } from '../../core/types.js';
 import { getTools } from '../getTools.js';
 
 // Define AgentState type
@@ -48,7 +49,9 @@ const parameterSchema = z.object({
   enableUserPrompt: z
     .boolean()
     .optional()
-    .describe('Whether to allow the sub-agent to use the userPrompt tool (default: false)'),
+    .describe(
+      'Whether to allow the sub-agent to use the userPrompt tool (default: false)',
+    ),
 });
 
 const returnSchema = z.object({
@@ -130,13 +133,14 @@ export const agentStartTool: Tool<Parameters, ReturnType> = {
     agentStates.set(instanceId, agentState);
 
     // Start the agent in a separate promise that we don't await
+    // eslint-disable-next-line promise/catch-or-return
     Promise.resolve().then(async () => {
       try {
         const result = await toolAgent(prompt, tools, subAgentConfig, {
           ...context,
           workingDirectory: workingDirectory ?? context.workingDirectory,
         });
-        
+
         // Update agent state with the result
         const state = agentStates.get(instanceId);
         if (state && !state.aborted) {
@@ -152,6 +156,7 @@ export const agentStartTool: Tool<Parameters, ReturnType> = {
           state.error = error instanceof Error ? error.message : String(error);
         }
       }
+      return true;
     });
 
     return {
@@ -165,4 +170,4 @@ export const agentStartTool: Tool<Parameters, ReturnType> = {
   logReturns: (output, { logger }) => {
     logger.info(`Sub-agent started with instance ID: ${output.instanceId}`);
   },
-};
+};

packages/agent/src/tools/interaction/__tests__/agentTools.test.ts packages/agent/src/tools/interaction/agentTools.test.ts

@@ -1,31 +1,29 @@
 import { describe, expect, it, vi } from 'vitest';
 
-import { agentMessageTool } from '../agentMessage.js';
-import { agentStartTool, agentStates } from '../agentStart.js';
+import { TokenTracker } from '../../core/tokens.js';
+import { ToolContext } from '../../core/types.js';
+import { MockLogger } from '../../utils/mockLogger.js';
+
+import { agentMessageTool } from './agentMessage.js';
+import { agentStartTool, agentStates } from './agentStart.js';
 
 // Mock the toolAgent function
-vi.mock('../../../core/toolAgent/toolAgentCore.js', () => ({
+vi.mock('../../core/toolAgent/toolAgentCore.js', () => ({
   toolAgent: vi.fn().mockResolvedValue({
     result: 'Mock agent result',
     interactions: 1,
   }),
 }));
 
 // Mock context
-const mockContext = {
-  logger: {
-    info: vi.fn(),
-    verbose: vi.fn(),
-    error: vi.fn(),
-    debug: vi.fn(),
-    warn: vi.fn(),
-  },
-  tokenTracker: {
-    tokenUsage: {
-      add: vi.fn(),
-    },
-  },
+const mockContext: ToolContext = {
+  logger: new MockLogger(),
+  tokenTracker: new TokenTracker(),
   workingDirectory: '/test',
+  headless: true,
+  userSession: false,
+  pageFilter: 'none',
+  githubMode: false,
 };
 
 describe('Agent Tools', () => {
@@ -46,7 +44,7 @@ describe('Agent Tools', () => {
 
       // Verify the agent state was created
       expect(agentStates.has(result.instanceId)).toBe(true);
-      
+
       const state = agentStates.get(result.instanceId);
       expect(state).toHaveProperty('goal', 'Test the agent tools');
       expect(state).toHaveProperty('prompt');
@@ -116,11 +114,11 @@ describe('Agent Tools', () => {
 
       expect(messageResult).toHaveProperty('terminated', true);
       expect(messageResult).toHaveProperty('completed', true);
-      
+
       // Verify the agent state was updated
       const state = agentStates.get(startResult.instanceId);
       expect(state).toHaveProperty('aborted', true);
       expect(state).toHaveProperty('completed', true);
     });
   });
-});
+});