add respawn tool

Author: bhouston

package.json

@@ -54,7 +54,6 @@
     "@vitest/browser": "^3.0.5",
     "chalk": "^5",
     "dotenv": "^16",
-    "eslint-plugin-promise": "^7.2.1",
     "playwright": "^1.50.1",
     "semver": "^7.7.1",
     "source-map-support": "^0.5",
@@ -76,6 +75,7 @@
     "eslint-config-prettier": "^9",
     "eslint-plugin-import": "^2",
     "eslint-plugin-prettier": "^5",
+    "eslint-plugin-promise": "^7.2.1",
     "eslint-plugin-unused-imports": "^4",
     "prettier": "^3",
     "rimraf": "^5",

pnpm-lock.yaml

@@ -115,13 +115,29 @@ async function executeTools(
   tools: Tool[],
   messages: Message[],
   logger: Logger,
-): Promise<ToolCallResult> {
+): Promise<ToolCallResult & { respawn?: { context: string } }> {
   if (toolCalls.length === 0) {
     return { sequenceCompleted: false, toolResults: [] };
   }
 
   logger.verbose(`Executing ${toolCalls.length} tool calls`);
 
+  // Check for respawn tool call
+  const respawnCall = toolCalls.find(call => call.name === 'respawn');
+  if (respawnCall) {
+    return {
+      sequenceCompleted: false,
+      toolResults: [{
+        type: 'tool_result',
+        tool_use_id: respawnCall.id,
+        content: 'Respawn initiated',
+      }],
+      respawn: {
+        context: respawnCall.input.respawnContext
+      }
+    };
+  }
+
   const results = await Promise.all(
     toolCalls.map(async (call) => {
       let toolResult = '';
@@ -242,13 +258,24 @@ export const toolAgent = async (
       logger.info(assistantMessage);
     }
 
-    const { sequenceCompleted, completionResult } = await executeTools(
+    const { sequenceCompleted, completionResult, respawn } = await executeTools(
       toolCalls,
       tools,
       messages,
       logger,
     );
 
+    if (respawn) {
+      logger.info('Respawning agent with new context');
+      // Reset messages to just the new context
+      messages.length = 0;
+      messages.push({
+        role: 'user',
+        content: [{ type: 'text', text: respawn.context }],
+      });
+      continue;
+    }
+
     if (sequenceCompleted) {
       const result = {
         result:

src/core/toolAgent.ts

@@ -9,6 +9,7 @@ import { shellStartTool } from './system/shellStart.js';
 import { shellMessageTool } from './system/shellMessage.js';
 import { browseMessageTool } from './browser/browseMessage.js';
 import { browseStartTool } from './browser/browseStart.js';
+import { respawnTool } from './system/respawn.js';
 
 export function getTools(): Tool[] {
   return [
@@ -22,5 +23,6 @@ export function getTools(): Tool[] {
     shellMessageTool,
     browseStartTool,
     browseMessageTool,
+    respawnTool,
   ] as Tool[];
 }

src/tools/getTools.ts

@@ -1,4 +1,5 @@
-import * as fs from 'fs/promises';
+import * as fsPromises from 'fs/promises';
+import * as fs from 'fs';
 import * as path from 'path';
 import { Tool } from '../../core/types.js';
 import { z } from 'zod';
@@ -47,32 +48,33 @@ export const updateFileTool: Tool<Parameters, ReturnType> = {
     const absolutePath = path.resolve(path.normalize(filePath));
     logger.verbose(`Updating file: ${absolutePath}`);
 
-    await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+    await fsPromises.mkdir(path.dirname(absolutePath), { recursive: true });
 
     if (operation.command === 'update') {
-      const content = await fs.readFile(absolutePath, 'utf8');
+      const content = await fsPromises.readFile(absolutePath, 'utf8');
       const occurrences = content.split(operation.oldStr).length - 1;
       if (occurrences !== 1) {
         throw new Error(
           `Found ${occurrences} occurrences of oldStr, expected exactly 1`,
         );
       }
-      await fs.writeFile(
+      await fsPromises.writeFile(
         absolutePath,
         content.replace(operation.oldStr, operation.newStr),
         'utf8',
       );
     } else if (operation.command === 'append') {
-      await fs.appendFile(absolutePath, operation.content, 'utf8');
+      await fsPromises.appendFile(absolutePath, operation.content, 'utf8');
     } else {
-      await fs.writeFile(absolutePath, operation.content, 'utf8');
+      await fsPromises.writeFile(absolutePath, operation.content, 'utf8');
     }
 
     logger.verbose(`Operation complete: ${operation.command}`);
     return { path: filePath, operation: operation.command };
   },
   logParameters: (input, { logger }) => {
-    logger.info(`Modifying "${input.path}", ${input.description}`);
+    const isFile = fs.existsSync(input.path);
+    logger.info(`${isFile ? 'Modifying' : 'Creating' } "${input.path}", ${input.description}`);
   },
   logReturns: () => {},
 };

src/tools/io/updateFile.ts

@@ -0,0 +1,29 @@
+import { Tool, ToolContext } from '../../core/types.js';
+
+export interface RespawnInput {
+  respawnContext: string;
+}
+
+export const respawnTool: Tool = {
+  name: 'respawn',
+  description: 'Resets the agent context to just the system prompt and provided context',
+  parameters: {
+    type: 'object',
+    properties: {
+      respawnContext: {
+        type: 'string',
+        description: 'The context to keep after respawning',
+      },
+    },
+    required: ['respawnContext'],
+    additionalProperties: false,
+  },
+  returns: {
+    type: 'string',
+    description: 'A message indicating that the respawn has been initiated',
+  },
+  execute: async (params: Record<string, any>, context: ToolContext): Promise<string> => {
+    // This is a special case tool - the actual respawn logic is handled in toolAgent
+    return 'Respawn initiated';
+  },
+};

src/tools/system/respawn.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { toolAgent } from '../../src/core/toolAgent.js';
+import { getTools } from '../../src/tools/getTools.js';
+import { Logger } from '../../src/utils/logger.js';
+
+// Mock Anthropic SDK
+vi.mock('@anthropic-ai/sdk', () => {
+  return {
+    default: vi.fn().mockImplementation(() => ({
+      messages: {
+        create: vi.fn()
+          .mockResolvedValueOnce({
+            content: [
+              {
+                type: 'tool_use',
+                name: 'respawn',
+                id: 'test-id',
+                input: { respawnContext: 'new context' },
+              },
+            ],
+            usage: { input_tokens: 10, output_tokens: 10 },
+          })
+          .mockResolvedValueOnce({
+            content: [],
+            usage: { input_tokens: 5, output_tokens: 5 },
+          }),
+      },
+    })),
+  };
+});
+
+describe('toolAgent respawn functionality', () => {
+  const mockLogger = new Logger({ name: 'test' });
+  const tools = getTools();
+
+  beforeEach(() => {
+    process.env.ANTHROPIC_API_KEY = 'test-key';
+    vi.clearAllMocks();
+  });
+
+  it('should handle respawn tool calls', async () => {
+    const result = await toolAgent('initial prompt', tools, mockLogger, {
+      maxIterations: 2, // Need at least 2 iterations for respawn + empty response
+      model: 'test-model',
+      maxTokens: 100,
+      temperature: 0,
+      getSystemPrompt: () => 'test system prompt',
+    });
+
+    expect(result.result).toBe(
+      'Agent returned empty message implying it is done its given task',
+    );
+  });
+});

tests/core/toolAgent.respawn.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect, vi } from 'vitest';
+import { respawnTool } from '../../src/tools/system/respawn.js';
+import { Logger } from '../../src/utils/logger.js';
+
+describe('respawnTool', () => {
+  const mockLogger = new Logger({ name: 'test' });
+
+  it('should have correct name and description', () => {
+    expect(respawnTool.name).toBe('respawn');
+    expect(respawnTool.description).toContain('Resets the agent context');
+  });
+
+  it('should have correct parameter schema', () => {
+    expect(respawnTool.parameters.type).toBe('object');
+    expect(respawnTool.parameters.properties.respawnContext).toBeDefined();
+    expect(respawnTool.parameters.required).toContain('respawnContext');
+  });
+
+  it('should execute and return confirmation message', async () => {
+    const result = await respawnTool.execute(
+      { respawnContext: 'new context' },
+      { logger: mockLogger },
+    );
+    expect(result).toBe('Respawn initiated');
+  });
+});