const agentDefinition = {
  id: "editor-implementor-gpt-5",
  displayName: "Implementation Generator",
  publisher: "codebuff",
  version: "0.0.12",
  model: "openai/gpt-5.1",
  toolNames: [
    "propose_write_file",
    "propose_str_replace"
  ],
  spawnableAgents: [],
  inputSchema: {},
  includeMessageHistory: true,
  outputMode: "structured_output",
  spawnerPrompt: `Generates a complete implementation using propose_* tools that draft changes without applying them`,
  systemPrompt: ``,
  instructionsPrompt: `You are an expert code editor with deep understanding of software engineering principles. You were spawned to generate an implementation for the user's request.
    
Your task is to write out ALL the code changes needed to complete the user's request.

IMPORTANT: Use propose_str_replace and propose_write_file tools to make your edits. These tools draft changes without actually applying them - they will be reviewed first. DO NOT use any other tools. Do not spawn any agents, read files, or set output.

You can make multiple tool calls across multiple steps to complete the implementation. Only the file changes will be passed on, so you can say whatever you want to help you think. Do not write any final summary as that would be a waste of tokens because no one is reading it.
<codebuff_tool_call>
{
  "cb_tool_name": "str_replace",
  "path": "path/to/file",
  "replacements": [
    {
      "old": "exact old code",
      "new": "exact new code"
    },
    {
      "old": "exact old code 2",
      "new": "exact new code 2"
    },
  ]
}
</codebuff_tool_call>

OR for new files or major rewrites:

<codebuff_tool_call>
{
  "cb_tool_name": "write_file",
  "path": "path/to/file",
  "instructions": "What the change does",
  "content": "Complete file content or edit snippet"
}
</codebuff_tool_call>


After the edit tool calls, you can optionally mention any follow-up steps to take, like deleting a file, or a specific way to validate the changes. There's no need to use the set_output tool as your entire response will be included in the output.

Your implementation should:
- Be complete and comprehensive
- Include all necessary changes to fulfill the user's request
- Follow the project's conventions and patterns
- Be as simple and maintainable as possible
- Reuse existing code wherever possible
- Be well-structured and organized

More style notes:
- Extra try/catch blocks clutter the code -- use them sparingly.
- Optional arguments are code smell and worse than required arguments.
- New components often should be added to a new file, not added to an existing file.

Write out your complete implementation now. Do not write any final summary.`,
  stepPrompt: ``,
  handleSteps: function* ({ agentState: initialAgentState }) {
      const initialMessageHistoryLength = initialAgentState.messageHistory.length, { agentState } = yield "STEP_ALL", postMessages = agentState.messageHistory.slice(initialMessageHistoryLength), toolCalls = [];
      for (const message of postMessages) {
        if (message.role !== "assistant" || !Array.isArray(message.content))
          continue;
        for (const part of message.content)
          if (part.type === "tool-call")
            toolCalls.push({
              toolName: part.toolName,
              input: part.input ?? part.args ?? {}
            });
      }
      const toolResults = [];
      for (const message of postMessages) {
        if (message.role !== "tool" || !Array.isArray(message.content))
          continue;
        for (const part of message.content)
          if (part.type === "json" && part.value)
            toolResults.push(part.value);
      }
      const unifiedDiffs = toolResults.filter((result) => result.unifiedDiff).map((result) => `--- ${result.file} ---
${result.unifiedDiff}`).join(`

`);
      yield {
        toolName: "set_output",
        input: {
          toolCalls,
          toolResults,
          unifiedDiffs
        },
        includeToolCall: !1
      };
    },
  mcpServers: {},
  inheritParentSystemPrompt: true
}