Merge remote-tracking branch 'origin/main' into image-support

Author: brandonkachen

.agents/editor/editor-lite.ts .agents-graveyard/editor-lite.ts.agents/editor/editor-lite.ts renamed to .agents-graveyard/editor-lite.ts

@@ -1,10 +1,10 @@
-import { publisher } from '../constants'
+import { publisher } from '../.agents/constants'
 import {
   PLACEHOLDER,
   type SecretAgentDefinition,
-} from '../types/secret-agent-definition'
+} from '../.agents/types/secret-agent-definition'
 
-import type { Message } from 'types/util-types'
+import type { Message } from '../.agents/types/util-types'
 
 const editor: SecretAgentDefinition = {
   id: 'editor-lite',

.agents-graveyard/editor.ts

@@ -0,0 +1,151 @@
+import { publisher } from '../.agents/constants'
+import { type SecretAgentDefinition } from '../.agents/types/secret-agent-definition'
+
+import type { Message } from '../.agents/types/util-types'
+
+const editor: SecretAgentDefinition = {
+  id: 'editor',
+  publisher,
+  model: 'anthropic/claude-sonnet-4.5',
+  displayName: 'Code Editor',
+  spawnerPrompt:
+    'Expert code editor with access to tools to find and edit files, run terminal commands, and search the web. Can handle small to medium sized tasks, or work off of a plan for more complex tasks. For easy tasks, you can spawn this agent directly rather than invoking a researcher or planner first. Spawn mulitple in parallel if needed, but only on totally distinct tasks.',
+  inputSchema: {
+    prompt: {
+      type: 'string',
+      description: 'The coding task to implement',
+    },
+    params: {
+      type: 'object',
+      properties: {
+        maxContextLength: {
+          type: 'number',
+        },
+      },
+      required: [],
+    },
+  },
+  outputMode: 'structured_output',
+  toolNames: [
+    'read_files',
+    'write_file',
+    'str_replace',
+    'run_terminal_command',
+    'code_search',
+    'spawn_agents',
+    'add_message',
+    'set_output',
+    'end_turn',
+  ],
+  spawnableAgents: ['file-explorer', 'researcher-web', 'researcher-docs'],
+
+  includeMessageHistory: true,
+  inheritParentSystemPrompt: true,
+
+  instructionsPrompt: `You are an expert code editor with deep understanding of software engineering principles.
+
+Implement the requested changes, using your judgment as needed, but referring to the original <user_message> as the most important source of information.
+
+# Instructions
+
+- Read any relevant files that have not already been read. Or, spawn a file-explorer to find any other relevant parts of the codebase.
+- Implement changes using str_replace or write_file.
+- Verify your changes by running tests, typechecking, etc. Keep going until you are sure the changes are correct.
+- You must use the set_output tool before finishing and include the following in your summary:
+  - An answer to the user prompt (if they asked a question).
+  - An explanation of the changes made.
+  - A note on any checks you ran to verify the changes, such as tests, typechecking, etc., and the results of those checks.
+  - Do not include a section on the benefits of the changes, as we're most interested in the changes themselves and what still needs to be done.
+- Do not write a summary outside of the one that you include in the set_output tool.
+- As soon as you use set_output, you must end your turn using the end_turn tool.
+`,
+
+  handleSteps: function* ({ agentState: initialAgentState }) {
+    const stepLimit = 25
+    let stepCount = 0
+    let agentState = initialAgentState
+    let accumulatedEditToolResults: any[] = []
+
+    while (true) {
+      stepCount++
+
+      const stepResult = yield 'STEP'
+      agentState = stepResult.agentState // Capture the latest state
+
+      // Accumulate new tool messages from this step
+      const { messageHistory } = agentState
+
+      // Extract and accumulate new edit tool results using helper function
+      accumulatedEditToolResults.push(
+        ...getLatestEditToolResults(messageHistory),
+      )
+
+      if (stepResult.stepsComplete) {
+        break
+      }
+
+      // If we've reached within one of the step limit, ask LLM to summarize progress
+      if (stepCount === stepLimit - 1) {
+        yield {
+          toolName: 'add_message',
+          input: {
+            role: 'user',
+            content:
+              'You have reached the step limit. Please use the set_output tool now to summarize your progress so far including all specific actions you took (note that any file changes will be included automatically in the output), what you still need to solve, and provide any insights that could help complete the remaining work. Please end your turn after using the set_output tool with the end_turn tool.',
+          },
+          includeToolCall: false,
+        }
+
+        // One final step to produce the summary
+        const finalStepResult = yield 'STEP'
+        agentState = finalStepResult.agentState
+
+        // Extract and accumulate final edit tool results using helper function
+        accumulatedEditToolResults.push(
+          ...getLatestEditToolResults(agentState.messageHistory),
+        )
+        break
+      }
+    }
+
+    yield {
+      toolName: 'set_output',
+      input: {
+        ...agentState.output,
+        edits: accumulatedEditToolResults,
+      },
+      includeToolCall: false,
+    }
+
+    function getLatestEditToolResults(messageHistory: Message[]) {
+      const lastAssistantMessageIndex = messageHistory.findLastIndex(
+        (message) => message.role === 'assistant',
+      )
+
+      // Get all edit tool messages after the last assistant message
+      const newToolMessages = messageHistory
+        .slice(lastAssistantMessageIndex + 1)
+        .filter((message) => message.role === 'tool')
+        .filter(
+          (message) =>
+            message.toolName === 'write_file' ||
+            message.toolName === 'str_replace',
+        )
+
+      // Extract and return new edit tool results
+      return (
+        newToolMessages
+          .flatMap((message) => message.content)
+          .filter((output) => output.type === 'json')
+          .map((output) => output.value)
+          // Only successful edits!
+          .filter(
+            (toolResult) =>
+              toolResult && !('errorMessage' in (toolResult as any)),
+          )
+      )
+    }
+  },
+}
+
+export default editor

.agents/__tests__/editor-best-of-n.integration.test.ts

@@ -0,0 +1,91 @@
+import { API_KEY_ENV_VAR } from '@codebuff/common/old-constants'
+import { describe, expect, it } from 'bun:test'
+
+import { CodebuffClient } from '@codebuff/sdk'
+
+import type { PrintModeEvent } from '@codebuff/common/types/print-mode'
+
+/**
+ * Integration tests for the editor-best-of-n-max agent.
+ * These tests verify that the best-of-n editor workflow works correctly:
+ * 1. Spawns multiple implementor agents in parallel
+ * 2. Collects their implementation proposals
+ * 3. Uses a selector agent to choose the best implementation
+ * 4. Applies the chosen implementation
+ */
+describe('Editor Best-of-N Max Agent Integration', () => {
+  it(
+    'should generate and select the best implementation for a simple edit',
+    async () => {
+      const apiKey = process.env[API_KEY_ENV_VAR]
+      if (!apiKey) {
+        throw new Error('API key not found')
+      }
+
+      // Create mock project files with a simple TypeScript file to edit
+      const projectFiles: Record<string, string> = {
+        'src/utils/math.ts': `
+export function add(a: number, b: number): number {
+  return a + b
+}
+
+export function subtract(a: number, b: number): number {
+  return a - b
+}
+`,
+        'src/index.ts': `
+import { add, subtract } from './utils/math'
+
+console.log(add(1, 2))
+console.log(subtract(5, 3))
+`,
+        'package.json': JSON.stringify({
+          name: 'test-project',
+          version: '1.0.0',
+          dependencies: {},
+        }),
+      }
+
+      const client = new CodebuffClient({
+        apiKey,
+        cwd: '/tmp/test-best-of-n-project',
+        projectFiles,
+      })
+
+      const events: PrintModeEvent[] = []
+
+      // Run the editor-best-of-n-max agent with a simple task
+      // Using n=2 to keep the test fast while still testing the best-of-n workflow
+      const run = await client.run({
+        agent: 'editor-best-of-n-max',
+        prompt:
+          'Add a multiply function to src/utils/math.ts that takes two numbers and returns their product',
+        params: { n: 2 },
+        handleEvent: (event) => {
+          console.log(event)
+          events.push(event)
+        },
+      })
+
+      // The output should not be an error
+      expect(run.output.type).not.toEqual('error')
+
+      // Verify we got some output
+      expect(run.output).toBeDefined()
+
+      // The output should contain the implementation response
+      const outputStr =
+        typeof run.output === 'string' ? run.output : JSON.stringify(run.output)
+      console.log('Output:', outputStr)
+
+      // Should contain evidence of the multiply function being added
+      const relevantTerms = ['multiply', 'product', 'str_replace', 'write_file']
+      const foundRelevantTerm = relevantTerms.some((term) =>
+        outputStr.toLowerCase().includes(term.toLowerCase()),
+      )
+
+      expect(foundRelevantTerm).toBe(true)
+    },
+    { timeout: 120_000 }, // 2 minute timeout for best-of-n workflow
+  )
+})