AgentDefinition

type ReasoningOptions = {
  enabled?: boolean
  exclude?: boolean  // Remove reasoning from response
} & (
  | { max_tokens: number }
  | { effort: 'high' | 'medium' | 'low' | 'minimal' | 'none' }
)

reasoningOptions: {
  enabled: true,
  effort: 'high',
  exclude: false  // Include reasoning in output
}

providerOptions: {
  order: ['anthropic', 'openai'],
  allow_fallbacks: true,
  max_price: {
    completion: 0.01  // $0.01 per token max
  }
}

type MCPConfig = {
  command: string
  args?: string[]
  env?: Record<string, string>
}

mcpServers: {
  'github': {
    command: 'npx',
    args: ['-y', '@modelcontextprotocol/server-github'],
    env: { GITHUB_TOKEN: process.env.GITHUB_TOKEN }
  }
}

toolNames: ['read_files', 'github/get-issue', 'github/create-pr']

toolNames: [
  'read_files',
  'write_file', 
  'code_search',
  'run_terminal_command'
]

spawnableAgents: ['codebuff/[email protected]']

spawnableAgents: ['my-local-agent']

type InputSchema = {
  prompt?: { type: 'string'; description?: string }
  params?: JsonObjectSchema
}

inputSchema: {
  prompt: { 
    type: 'string', 
    description: 'Description of what the agent needs' 
  }
}

inputSchema: {
  prompt: { type: 'string' },
  params: {
    type: 'object',
    properties: {
      maxFiles: { type: 'number' },
      pattern: { type: 'string' }
    },
    required: ['pattern']
  }
}

outputMode: 'structured_output'

outputSchema: {
  type: 'object',
  properties: {
    summary: { type: 'string' },
    issues: {
      type: 'array',
      items: {
        type: 'object',
        properties: {
          severity: { type: 'string' },
          description: { type: 'string' }
        }
      }
    }
  },
  required: ['summary']
}

spawnerPrompt: `Use this agent to analyze code quality and suggest improvements.

Best for:
- Code review feedback
- Identifying anti-patterns
- Suggesting refactoring opportunities

The agent will read the specified files and provide detailed analysis.`

systemPrompt: 'You are an expert TypeScript developer with 10 years of experience.'

instructionsPrompt: `Analyze the code for the following issues:
1. Security vulnerabilities
2. Performance bottlenecks
3. Code style violations

Provide specific line numbers and suggestions for each issue found.`

handleSteps?: (context: AgentStepContext) => Generator<
  ToolCall | 'STEP' | 'STEP_ALL' | StepText | GenerateN,
  void,
  YieldResult
>

type AgentStepContext = {
  agentState: AgentState
  prompt?: string
  params?: Record<string, any>
  logger: Logger
}

{
  agentState: AgentState
  toolResult: ToolResultOutput[] | undefined
  stepsComplete: boolean
  nResponses?: string[]
}

function* handleSteps({ agentState, prompt, logger }) {
  logger.info('Starting file read process')
  
  // Execute tool programmatically
  const { toolResult } = yield {
    toolName: 'read_files',
    input: { paths: ['file1.ts', 'file2.ts'] }
  }
  
  // Let agent continue naturally
  yield 'STEP_ALL'
  
  // Post-processing
  logger.info('Setting final output')
  yield {
    toolName: 'set_output',
    input: { output: 'Files processed successfully' }
  }
}

function* handleSteps({ agentState, logger }) {
  while (true) {
    logger.debug('Spawning thinker agent')
    
    yield {
      toolName: 'spawn_agents',
      input: {
        agents: [{
          agent_type: 'thinker',
          prompt: 'Analyze the current situation'
        }]
      }
    }
    
    const { stepsComplete } = yield 'STEP'
    if (stepsComplete) break
  }
}