const agentDefinition = {
  id: "best-of-n-orchestrator-fast",
  displayName: "Best-of-N Fast Implementation Orchestrator",
  publisher: "codebuff",
  version: "0.0.1",
  model: "anthropic/claude-sonnet-4.5",
  toolNames: [
    "spawn_agents",
    "str_replace",
    "write_file",
    "set_messages",
    "set_output"
  ],
  spawnableAgents: [
    "codebuff/best-of-n-implementor@0.0.1",
    "codebuff/best-of-n-selector@0.0.1"
  ],
  inputSchema: {},
  includeMessageHistory: true,
  outputMode: "structured_output",
  spawnerPrompt: `Orchestrates multiple implementor agents to generate implementation proposals, selects the best one, and applies the changes.`,
  systemPrompt: ``,
  instructionsPrompt: ``,
  stepPrompt: ``,
  handleSteps: function* ({ agentState }) {
    const messages = agentState.messageHistory.concat();
    messages.pop();
    yield {
      toolName: "set_messages",
      input: {
        messages
      },
      includeToolCall: !1
    };
    const { toolResult: implementorsResult1 } = yield {
      toolName: "spawn_agents",
      input: {
        agents: [
          { agent_type: "best-of-n-implementor" },
          { agent_type: "best-of-n-implementor" },
          { agent_type: "best-of-n-implementor" },
          { agent_type: "best-of-n-implementor" },
          { agent_type: "best-of-n-implementor" }
        ]
      },
      includeToolCall: !1
    }, implementorsResult = extractSpawnResults(implementorsResult1), letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ", implementations = implementorsResult.map((content, index) => ({
      id: letters[index],
      content
    })), { toolResult: selectorResult } = yield {
      toolName: "spawn_agents",
      input: {
        agents: [
          {
            agent_type: "best-of-n-selector",
            params: { implementations }
          }
        ]
      },
      includeToolCall: !1
    }, selectorOutput = extractSpawnResults(selectorResult)[0];
    if ("errorMessage" in selectorOutput) {
      yield {
        toolName: "set_output",
        input: { error: selectorOutput.errorMessage }
      };
      return;
    }
    const { implementationId } = selectorOutput, chosenImplementation = implementations.find((implementation) => implementation.id === implementationId);
    if (!chosenImplementation) {
      yield {
        toolName: "set_output",
        input: { error: "Failed to find chosen implementation." }
      };
      return;
    }
    const { agentState: postEditsAgentState } = yield {
      type: "STEP_TEXT",
      text: chosenImplementation.content
    }, { messageHistory } = postEditsAgentState, lastAssistantMessageIndex = messageHistory.findLastIndex((message) => message.role === "assistant"), editToolResults = messageHistory.slice(lastAssistantMessageIndex).filter((message) => message.role === "tool").flatMap((message) => message.content.output).filter((output) => output.type === "json").map((output) => output.value);
    yield {
      toolName: "set_output",
      input: {
        response: chosenImplementation.content,
        toolResults: editToolResults
      }
    };
    function extractSpawnResults(results) {
      if (!results)
        return [];
      return results.filter((result) => result.type === "json").map((result) => result.value).flat().map((result) => result.value.value ?? {
        errorMessage: result.value.errorMessage ?? "Error extracting spawn results"
      });
    }
  },
  mcpServers: {},
  inheritParentSystemPrompt: true
}