A mental model for agent harnesses

const messages = [
  {
    role: 'user',
    content: 'Read src/app/page.tsx and summarize it.',
  },
]

await runAgentLoop({
  model: 'gpt-5.5',
  messages,
  tools: [readFileTool],
})

const mcpTool = {
  name: 'read_file',
  description: 'Read a UTF-8 file from the workspace.',
  inputSchema: {
    type: 'object',
    properties: { path: { type: 'string' } },
    required: ['path'],
  },
}

const readFileTool = {
  name: mcpTool.name,
  description: mcpTool.description,
  inputSchema: mcpTool.inputSchema,
  execute: async ({ path }, { abortSignal }) => {
    return await mcp.callTool(
      { name: 'read_file', arguments: { path } },
      { signal: abortSignal },
    )
  },
}

const maxTurns = 5
let pendingToolCalls = []

for (let turn = 0; turn < maxTurns; turn += 1) {
  if (pendingToolCalls.length > 0) {
    await runToolsAndAppendResults(pendingToolCalls, messages)
  }

  const modelTurn = await askModel({ messages, tools })

  if (modelTurn.finalAnswer) return modelTurn.finalAnswer
  pendingToolCalls = modelTurn.toolCalls
}

async function askModel({ messages, tools }) {
  const providerTools = tools.map(toProviderTool)
  const request = toProviderRequest({
    model: 'gpt-5.5',
    messages,
    tools: providerTools,
  })

  return streamProviderTurn(request)
}

function toProviderTool(tool) {
  return {
    type: 'function',
    name: tool.name,
    description: tool.description,
    parameters: tool.inputSchema,
  }
}

const openAITool = toProviderTool(readFileTool)

openAITool === {
  type: 'function',
  name: 'read_file',
  description: 'Read a UTF-8 file from the workspace.',
  parameters: {
    type: 'object',
    properties: { path: { type: 'string' } },
    required: ['path'],
  },
}

const request = {
  model: 'gpt-5.5',
  instructions: 'system/developer prompts...',
  input: [
    { role: 'user', content: 'Read src/app/page.tsx and summarize it.' }
  ],
  tools: [
    {
      type: 'function',
      name: 'read_file',
      description: 'Read a UTF-8 file from the workspace.',
      parameters: {
        type: 'object',
        properties: { path: { type: 'string' } },
        required: ['path'],
      }
    }
  ],
  stream: true,
}

for await (const event of provider.stream(request)) {
  handleProviderEvent(event)
}

if (chunk.type === 'response.output_text.delta') {
  yield { type: EventType.TEXT_MESSAGE_CONTENT, delta: textDelta }
}

if (chunk.type === 'response.function_call_arguments.done') {
  yield {
    type: EventType.TOOL_CALL_END,
    toolCallId: chunk.item_id,
    toolName: metadata.name,
    input: JSON.parse(chunk.arguments),
  }
}

if (chunk.type === 'response.reasoning_text.delta') {
  yield { type: EventType.STEP_FINISHED, stepType: 'thinking', delta }
}

const toolCall = {
  id: 'call_123',
  name: 'read_file',
  arguments: { path: 'src/app/page.tsx' },
}

const result = await readFileTool.execute(toolCall.arguments)

messages.push({ role: 'assistant', toolCall })
messages.push({
  role: 'tool',
  toolCallId: 'call_123',
  content: result,
})

await runNextModelTurn({ messages, tools })

<|user|>
Solve 2+2.
<|assistant|>
<think>
Need add 2 and 2. Result 4.
</think>
The answer is 4.

request.reasoning = { effort: 'high', summary: 'auto' }

stream events may include:
- response.reasoning_summary_text.delta
- encrypted reasoning continuity
- usage.reasoning_tokens

full hidden chain of thought: provider-private

messages.push({ role: 'system', content: 'First produce a short plan.' })
plan = await runInference(messages)

messages.push({ role: 'assistant', content: plan })
messages.push({ role: 'system', content: 'Critique the plan against repo evidence.' })
critique = await runInference(messages)

messages.push({ role: 'assistant', content: critique })
messages.push({ role: 'system', content: 'Now revise and execute with tools.' })
final = await agentLoop(messages, tools)

// direct API-key style
POST https://api.openai.com/v1/responses
Authorization: Bearer sk-...

// ChatGPT/Codex subscription style
POST https://chatgpt.com/backend-api/codex/responses
Authorization: Bearer <ChatGPT OAuth access token>
chatgpt-account-id: <account id from access token>
originator: <client identifier>
OpenAI-Beta: responses=experimental

new Anthropic({
  apiKey: null,
  authToken: oauthAccessToken,
  baseURL: 'https://api.anthropic.com',
  defaultHeaders: {
    'anthropic-beta': 'claude-code-20250219,oauth-2025-04-20,...',
    'user-agent': 'claude-cli/2.1.75',
    'x-app': 'cli',
  },
})

params.system = [
  { type: 'text', text: "You are Claude Code, Anthropic's official CLI for Claude." },
  { type: 'text', text: customSystemPrompt },
]

toClaudeCodeName('bash') // 'Bash'
toClaudeCodeName('read') // 'Read'

GET https://api.github.com/copilot_internal/v2/token
Authorization: Bearer <GitHub device-flow access token>

proxy-ep=proxy.individual.githubcopilot.com
baseUrl = 'https://api.individual.githubcopilot.com'

User-Agent: GitHubCopilotChat/0.35.0
Editor-Version: vscode/1.107.0
Copilot-Integration-Id: vscode-chat
X-Initiator: user | agent
Openai-Intent: conversation-edits

type ProductDialect = {
  endpoint: string
  auth: 'api-key' | 'chatgpt-oauth' | 'claude-oauth' | 'copilot-token'
  headers: Record<string, string>
  toolFormat: 'openai-functions' | 'anthropic-tools' | 'claude-code-compatible-tools'
  identity?: 'raw-api-client' | 'claude-code-compatible-cli' | 'vscode-copilot-chat'
}