{
  "id": "page:docs-development-03-babysitter-plugin-flows",
  "_kind": "Page",
  "_file": "wiki/docs/development/03-babysitter-plugin-flows.md",
  "_cluster": "wiki",
  "attributes": {
    "nodeKind": "Page",
    "sourcePath": "docs/development/03-babysitter-plugin-flows.md",
    "sourceKind": "repo-docs",
    "title": "Babysitter Plugin Architecture",
    "displayName": "Babysitter Plugin Architecture",
    "slug": "docs/development/03-babysitter-plugin-flows",
    "articlePath": "wiki/docs/development/03-babysitter-plugin-flows.md",
    "article": "\n# Babysitter Plugin Architecture\n\nHow the babysitter orchestration system works across coding agent harnesses, from plugin generation through session lifecycle to run completion.\n\n## Table of Contents\n\n1. [System Overview](#system-overview)\n2. [The Three Muxes](#the-three-muxes)\n3. [Plugin Generation](#plugin-generation)\n4. [Activation Modes](#activation-modes)\n5. [Session Lifecycle](#session-lifecycle)\n6. [Run Orchestration](#run-orchestration)\n7. [Harness-Specific Flows](#harness-specific-flows)\n\n---\n\n## System Overview\n\nThe babysitter plugin installs into any supported coding agent (Claude Code, Codex, Pi, Gemini CLI, etc.) and provides orchestrated process execution. Three \"adapter\" layers compensate for the differences between harnesses:\n\n```mermaid\ngraph TB\n    subgraph \"User Layer\"\n        USER[\"Developer\"]\n        USER -->|\"/babysitter:call task\"| HARNESS\n    end\n\n    subgraph \"Harness Layer\"\n        HARNESS[\"Coding Agent<br/>(Claude Code, Codex, Pi, ...)\"]\n        HARNESS -->|\"native hooks\"| HM[\"hooks-adapter\"]\n        HARNESS -->|\"API calls\"| TM[\"transport-adapter\"]\n        HARNESS -->|\"skill invocation\"| SDK[\"babysitter SDK\"]\n    end\n\n    subgraph \"Adapter Layer\"\n        HM -->|\"canonical events\"| SDK\n        TM -->|\"normalized protocol\"| UPSTREAM[\"Any Provider<br/>(Anthropic, OpenAI, Google, Azure)\"]\n        AM[\"adapters\"] -->|\"launch + proxy\"| HARNESS\n    end\n\n    subgraph \"Orchestration Layer\"\n        SDK -->|\"run:iterate\"| PROCESS[\"Process Definition\"]\n        PROCESS -->|\"effects\"| SDK\n        SDK -->|\"tasks\"| HARNESS\n    end\n```\n\nEach layer solves a specific interoperability problem:\n\n| Adapter | Problem | Solution |\n|-----|---------|----------|\n| **hooks-adapter** | Each harness has different hook event names, payloads, output formats | Normalizes native events to canonical phases, runs unified handlers, renders results back to harness format |\n| **transport-adapter** | Harnesses speak different API protocols (Anthropic, OpenAI, Google) | HTTP proxy translates between the harness's native protocol and any upstream provider |\n| **adapters** | Harnesses have different CLI surfaces, capabilities, plugin loading | Unified `adapters launch` resolves provider config, starts proxy if needed, spawns harness with correct args |\n\n---\n\n## The Three Muxes\n\n### hooks-adapter: Hook Surface Normalization\n\nEach harness fires lifecycle hooks differently. hooks-adapter normalizes them into a canonical interface:\n\n```mermaid\ngraph LR\n    subgraph \"Native Hook Surfaces\"\n        CC[\"Claude Code<br/>shell hooks via hooks.json\"]\n        CX[\"Codex<br/>shell hooks via hooks.json\"]\n        PI[\"Pi<br/>in-process programmatic hooks\"]\n        GC[\"Gemini CLI<br/>shell hooks\"]\n    end\n\n    subgraph \"hooks-adapter\"\n        AC[\"adapter-claude<br/>normalizer.ts\"]\n        AX[\"adapter-codex<br/>normalizer.ts\"]\n        AP[\"adapter-pi<br/>normalizer.ts\"]\n        AG[\"adapter-gemini<br/>normalizer.ts\"]\n        CORE[\"core engine<br/>normalize → run handlers → merge → propagate\"]\n    end\n\n    CC --> AC --> CORE\n    CX --> AX --> CORE\n    PI --> AP --> CORE\n    GC --> AG --> CORE\n\n    CORE --> |\"UnifiedHookEvent\"| HANDLERS[\"babysitter hook handlers\"]\n```\n\n**Adapter families:**\n- **shell-hook** (Claude Code, Codex, Cursor, Gemini CLI): Hook handlers are shell scripts invoked via subprocess. stdin receives JSON event, stdout returns JSON result.\n- **programmatic** (Pi, OpenCode): Hook handlers are in-process functions. No subprocess overhead.\n\n**Canonical phases:** `sessionStart`, `stop`, `sessionEnd`, `preToolUse`, `postToolUse`, `userPromptSubmit`, `notification`, `preCompact`, `beforePromptBuild`\n\nEach adapter maps native event names → canonical phases via `mappings.ts` sourced from the atlas graph.\n\n### transport-adapter: Provider Protocol Bridge\n\nWhen a harness needs to talk to a provider it doesn't support natively, transport-adapter runs as a local HTTP proxy:\n\n```mermaid\ngraph LR\n    subgraph \"Harness speaks Anthropic\"\n        CC[\"Claude Code\"]\n    end\n\n    subgraph \"transport-adapter proxy\"\n        SERVER[\"HTTP Server<br/>/v1/messages\"]\n        DECODE[\"Decode Anthropic request<br/>Extract messages, tools, rawContent\"]\n        ENGINE[\"Completion Engine\"]\n        ENCODE[\"Encode Anthropic response<br/>Render tool_use blocks, input_json_delta\"]\n    end\n\n    subgraph \"Upstream speaks OpenAI\"\n        FOUNDRY[\"Azure Foundry\"]\n    end\n\n    CC -->|\"POST /v1/messages<br/>(Anthropic format)\"| SERVER\n    SERVER --> DECODE\n    DECODE -->|\"CompletionRequest\"| ENGINE\n    ENGINE -->|\"translateMessagesToOpenAi()\"| FOUNDRY\n    FOUNDRY -->|\"SSE delta.tool_calls\"| ENGINE\n    ENGINE -->|\"CompletionStreamEvent\"| ENCODE\n    ENCODE -->|\"SSE content_block_start(tool_use)\"| CC\n```\n\n**Engines:**\n- `createOpenAICompletionEngine()` — Foundry/Azure path. Handles `input_schema → parameters` tool normalization, streaming `delta.tool_calls` accumulation, `tool_result → role:\"tool\"` message translation.\n- `createGoogleCompletionEngine()` — Vertex/Gemini path. Handles `functionCall/functionResponse` translation, `thoughtSignature` server-side store for multi-turn preservation.\n\n**When proxy is needed:** Determined by `translateForHarness()` — if the harness adapter declares `proxyRequired: true` for a given provider, transport-adapter bridges the gap.\n\n### adapters: Unified Launch Surface\n\n`adapters launch` resolves provider config, decides if a proxy is needed, prepares harness automation state, and spawns the harness:\n\n```mermaid\nsequenceDiagram\n    participant U as User / CI\n    participant AM as adapters launch\n    participant CAT as agent-catalog\n    participant TM as transport-adapter\n    participant H as Harness\n\n    U->>AM: adapters launch claude foundry --model gpt-5.5\n    AM->>AM: resolveProvider(foundry) → ProviderConfig\n    AM->>AM: translateForHarness(claude, config) → proxyRequired=true\n    AM->>CAT: getBridgeCapabilities(claude)\n    AM->>TM: startTransportMuxRuntime({exposedTransport: anthropic})\n    TM-->>AM: { url, authToken }\n    AM->>AM: applyHarnessEnv() → ANTHROPIC_BASE_URL=proxy\n    AM->>AM: prepareClaudeAutomationState() → pre-approve API key, onboarding\n    AM->>H: spawn(\"claude\", [\"-p\", prompt, \"--max-turns\", \"15\"])\n```\n\n---\n\n## Plugin Generation\n\n`npm run generate:plugins` compiles unified plugin source into harness-specific distributions via the `extensions-adapter` compiler:\n\n```mermaid\ngraph TB\n    UPF[\"Unified Plugin Source<br/>(skills, hooks, commands)\"] --> COMPILER[\"extensions-adapter compiler\"]\n\n    COMPILER --> CC_OUT[\"artifacts/generated-plugins/claude-code/<br/>plugin.json + hooks.json + *.sh scripts\"]\n    COMPILER --> CX_OUT[\"artifacts/generated-plugins/codex/<br/>.codex-plugin/plugin.json + hooks.json + shell hooks\"]\n    COMPILER --> PI_OUT[\"artifacts/generated-plugins/pi/<br/>package.json + extensions\"]\n    COMPILER --> GC_OUT[\"artifacts/generated-plugins/gemini/<br/>hooks + config\"]\n```\n\n**Per-harness output structure:**\n\n| Harness | Plugin Format | Hook Mechanism |\n|---------|---------------|----------------|\n| Claude Code | `plugin.json` + `hooks/hooks.json` + shell scripts | Shell hooks: `babysitter-proxied-session-start.sh` → `a5c-hooks-adapter invoke --adapter claude` |\n| Codex | `.codex-plugin/plugin.json` + `hooks/hooks.json` + shell scripts | Shell hooks via hooks.json (auto-detected at `./hooks/hooks.json`) |\n| Pi | `package.json` with `pi.extensions` | In-process programmatic hooks |\n| Gemini CLI | Gemini-native hook config | Shell hooks via adapter |\n\n**Installation:**\n- Claude Code: `claude plugin marketplace add a5c-ai/babysitter-claude && claude plugin install --scope project babysitter@a5c.ai`\n- Codex: `codex plugin marketplace add a5c-ai/babysitter-codex && codex plugin add babysitter --marketplace babysitter` (per-repo manifest; monorepo alt uses `a5c-ai/babysitter --sparse .agents/plugins`, never `--ref staging`)\n- Others: `babysitter harness:install-plugin <harness> --workspace <cwd>`\n\n---\n\n## Activation Modes\n\nThe babysitter plugin activates differently depending on how the harness is launched:\n\n### Hook-Driven (Interactive)\n\nThe harness runs interactively with native hook support. Hooks drive the orchestration loop — the stop hook decides whether to continue or yield.\n\n```mermaid\nsequenceDiagram\n    participant U as User\n    participant CC as Claude Code (interactive)\n    participant HM as hooks-adapter\n    participant SDK as babysitter SDK\n\n    U->>CC: /babysitter:call \"build a REST API\"\n    Note over CC: Skill loads, calls instructions:babysit-skill\n    CC->>SDK: babysitter instructions:babysit-skill --harness claude-code --interactive\n    SDK-->>CC: Full orchestration instructions (hookDriven=true)\n\n    Note over CC: Agent interviews user, builds process, calls run:create\n    CC->>SDK: babysitter run:create --process-id my-api --entry process.mjs#process --harness claude-code\n    SDK-->>CC: { runId, runDir }\n\n    loop Orchestration loop (driven by stop hook)\n        CC->>SDK: babysitter run:iterate <runDir>\n        SDK-->>CC: { status: \"waiting\", effects: [{kind: \"agent\", prompt: \"...\"}] }\n        CC->>CC: Execute effect (write code, run tests, etc.)\n        CC->>SDK: babysitter task:post --effect-id <id> --result-file result.json\n\n        Note over CC: Claude Code turn ends, fires Stop hook\n        CC->>HM: Stop hook (native)\n        HM->>SDK: Check run state, pending effects\n        SDK-->>HM: { needsMoreIterations: true }\n        HM-->>CC: { decision: \"block\", systemMessage: \"Continue orchestration...\" }\n        Note over CC: Claude Code continues (doesn't yield to user)\n    end\n\n    CC->>SDK: run:iterate → { status: \"completed\", completionProof: \"...\" }\n    CC->>HM: Stop hook\n    HM-->>CC: { decision: \"allow\" }\n    CC-->>U: \"Run completed successfully\"\n```\n\n**Key: `hookDriven=true`** — The stop hook controls the loop. When the agent finishes a turn, Claude Code fires the stop hook. The hook checks if the babysitter run needs more iterations and returns `decision: \"block\"` (continue) or `\"allow\"` (stop).\n\n### Agent-Driven (Non-Interactive)\n\nThe harness runs headless with `-p` or `exec`. No native hooks fire. The agent drives the loop in-turn by calling `run:iterate` repeatedly.\n\n```mermaid\nsequenceDiagram\n    participant AM as adapters launch\n    participant CC as Claude Code (-p mode)\n    participant SDK as babysitter SDK\n\n    AM->>CC: spawn(\"claude\", [\"-p\", \"/babysitter:yolo build a REST API\"])\n    Note over CC: Skill loads, calls instructions:babysit-skill\n    CC->>SDK: babysitter instructions:babysit-skill --harness claude-code --no-interactive\n    SDK-->>CC: Full orchestration instructions (hookDriven=false)\n\n    Note over CC: Agent parses prompt, researches repo, builds process\n    CC->>SDK: babysitter run:create --process-id my-api --entry process.mjs#process\n    SDK-->>CC: { runId, runDir }\n\n    loop Agent-driven loop (no hooks)\n        CC->>SDK: babysitter run:iterate <runDir>\n        SDK-->>CC: { status: \"waiting\", effects: [...] }\n        CC->>CC: Execute effects\n        CC->>SDK: babysitter task:post --effect-id <id> --result-file result.json\n        Note over CC: Agent decides to continue (no stop hook)\n    end\n\n    CC->>SDK: run:iterate → { status: \"completed\", completionProof: \"...\" }\n    CC-->>AM: exit 0\n```\n\n**Key: `hookDriven=false`** — The agent owns the loop. It calls `run:iterate`, executes effects, posts results, and loops until completion. No hooks needed.\n\n### Bridge-Hooks (Emulated)\n\nWhen the harness is non-interactive but the babysitter lifecycle needs hooks, `adapters launch --bridge-hooks` emulates them via CLI calls:\n\n```mermaid\nsequenceDiagram\n    participant AM as adapters launch\n    participant BHE as BridgeHookEmulator\n    participant CC as Claude Code (-p mode)\n    participant SDK as babysitter SDK\n\n    AM->>BHE: emulateSessionStart()\n    BHE->>SDK: babysitter hook:run --hook-type session-start\n    SDK-->>BHE: Session initialized\n\n    AM->>CC: spawn with prompt\n    CC->>CC: Agent executes (run:iterate loop)\n    CC-->>AM: exit\n\n    AM->>BHE: emulateStop()\n    BHE->>SDK: babysitter run:status <runDir>\n    SDK-->>BHE: { shouldContinue: true, resumeId }\n\n    AM->>CC: respawn with --resume <resumeId>\n    CC-->>AM: exit\n\n    AM->>BHE: emulateStop()\n    BHE->>SDK: { shouldContinue: false }\n    AM->>BHE: emulateSessionEnd()\n```\n\n### Bridge-Interactive (PTY Bridge)\n\nThe harness runs interactively via PTY but presents structured NDJSON output externally. Used when the harness needs TTY for tool use but the caller wants machine-readable output:\n\n```mermaid\nsequenceDiagram\n    participant AM as adapters launch\n    participant PTY as node-pty\n    participant CC as Claude Code (interactive, TTY)\n    participant HM as hooks-adapter (native)\n\n    AM->>PTY: spawn(\"claude\", [\"--bare\", ...])\n    PTY-->>AM: onData: ANSI welcome screen\n    AM->>AM: Auto-respond to onboarding prompts\n    AM->>PTY: write(prompt + '\\r')\n    \n    CC->>HM: SessionStart hook (native, from plugin)\n    Note over CC: Full interactive session with native hooks\n    \n    PTY-->>AM: onData: ANSI output\n    AM->>AM: Strip ANSI → feed to adapter.parseEvent()\n    AM->>AM: Emit NDJSON bridge events to stdout\n    \n    Note over AM: Turn detection via message_stop/turn_end events\n    \n    CC-->>PTY: Process exits\n    PTY-->>AM: onExit → flush final output event\n```\n\n---\n\n## Session Lifecycle\n\n### The `instructions:babysit-skill` Command\n\nWhen the babysitter skill activates (via `/babysitter:call` or equivalent), it first calls `instructions:babysit-skill` to get orchestration guidance:\n\n```mermaid\nsequenceDiagram\n    participant SKILL as babysitter:call skill\n    participant SDK as babysitter CLI\n    participant STATE as Session State\n    participant GRAPH as atlas graph\n\n    SKILL->>SDK: instructions:babysit-skill --harness claude-code --interactive\n    SDK->>STATE: Check existing session/run state\n    SDK->>GRAPH: Query library processes for active context\n    SDK->>SDK: Compose prompt strata:<br/>1. Non-negotiables<br/>2. Dependencies<br/>3. Interview phase<br/>4. Process creation<br/>5. Run creation<br/>6. Iteration loop<br/>7. Effect execution<br/>8. Breakpoint handling<br/>9. Completion proof\n    SDK-->>SKILL: Full orchestration instructions<br/>(hookDriven, existing runs, library suggestions)\n```\n\n**Context detection:**\n- CI vs local, trigger type, repo info\n- Existing session state from `~/.a5c/state/hooks/sessions/`\n- Active run state from `.a5c/runs/`\n- Library process suggestions matching active capabilities\n\n### Stop Hook Decision Logic\n\nThe stop hook is the key control point in hook-driven mode:\n\n```mermaid\nflowchart TD\n    STOP[\"Stop hook fires\"] --> READ[\"Read session state<br/>~/.a5c/state/.../session.json\"]\n    READ --> ACTIVE{\"session.active?\"}\n    ACTIVE -->|No| ALLOW[\"decision: allow<br/>(session not active)\"]\n    ACTIVE -->|Yes| MAXITER{\"iteration >= maxIterations?\"}\n    MAXITER -->|Yes| ALLOW2[\"decision: allow<br/>(max iterations reached)\"]\n    MAXITER -->|No| RUNSTATE[\"Load run state from journal\"]\n    RUNSTATE --> COMPLETED{\"run completed?\"}\n    COMPLETED -->|Yes| ALLOW3[\"decision: allow<br/>(run finished)\"]\n    COMPLETED -->|No| PENDING{\"pending effects?\"}\n    PENDING -->|Yes| BLOCK[\"decision: block<br/>systemMessage: 'Continue with run:iterate'\"]\n    PENDING -->|No| BLOCK2[\"decision: block<br/>systemMessage: 'Call run:iterate to advance'\"]\n```\n\n---\n\n## Run Orchestration\n\n### Run Lifecycle\n\n```mermaid\nstateDiagram-v2\n    [*] --> Created: run:create\n    Created --> Iterating: run:iterate\n    Iterating --> Waiting: effects requested\n    Waiting --> Executing: agent executes effect\n    Executing --> Resolved: task:post\n    Resolved --> Iterating: run:iterate (next step)\n    Iterating --> Completed: process returns output\n    Iterating --> Failed: process throws error\n    Completed --> [*]\n    Failed --> [*]\n```\n\n### Effect Types\n\nProcesses emit effects via `ctx.task()`:\n\n| Effect Kind | Executed By | Example |\n|-------------|-------------|---------|\n| `agent` | The coding agent (Claude Code, Codex, etc.) | \"Write unit tests for the API module\" |\n| `skill` | A babysitter skill | \"Run the TDD triplet skill\" |\n| `shell` | Direct shell command | \"npm test\", \"git commit\", \"eslint --fix\" |\n\n### Journal Event Flow\n\nEvery state change is recorded in the run journal (`.a5c/runs/<runId>/journal/`):\n\n```\nRUN_CREATED → EFFECT_REQUESTED → EFFECT_RESOLVED → EFFECT_REQUESTED → EFFECT_RESOLVED → RUN_COMPLETED\n```\n\nThe replay engine reconstructs state from journal events, enabling resumption after crashes or session switches.\n\n---\n\n## Harness-Specific Flows\n\n### Claude Code\n\n```mermaid\nsequenceDiagram\n    participant U as User\n    participant CC as Claude Code\n    participant PLUGIN as babysitter plugin (installed)\n    participant HM as hooks-adapter (claude adapter)\n    participant SDK as babysitter CLI\n    participant TM as transport-adapter (if proxying)\n    participant LLM as Upstream LLM\n\n    U->>CC: /babysitter:call \"implement user auth\"\n    CC->>SDK: instructions:babysit-skill --harness claude-code --interactive\n    SDK-->>CC: Orchestration prompt (hookDriven=true)\n\n    Note over CC: Interview → Process creation → run:create\n    CC->>SDK: run:create --process-id auth-impl --harness claude-code\n    SDK-->>CC: { runId }\n\n    CC->>SDK: run:iterate <runDir>\n    SDK-->>CC: { effects: [{kind: \"agent\", prompt: \"Write auth middleware\"}] }\n    \n    CC->>TM: API call (if provider needs proxy)\n    TM->>LLM: Translated request\n    LLM-->>TM: Response with tool_calls\n    TM-->>CC: Translated response (tool_use blocks)\n    \n    CC->>CC: Execute: Write auth/middleware.ts\n    CC->>SDK: task:post --effect-id <id>\n    \n    Note over CC: Turn ends\n    CC->>PLUGIN: Stop hook fires (native)\n    PLUGIN->>HM: a5c-hooks-adapter invoke --adapter claude\n    HM->>SDK: babysitter hook:run --hook-type stop\n    SDK-->>HM: { decision: \"block\", systemMessage: \"Continue...\" }\n    HM-->>PLUGIN: { block: true }\n    PLUGIN-->>CC: Continue session\n\n    CC->>SDK: run:iterate → { status: \"completed\" }\n    CC->>PLUGIN: Stop hook\n    HM-->>CC: { decision: \"allow\" }\n    CC-->>U: \"Auth implementation complete\"\n```\n\n### Codex\n\n```mermaid\nsequenceDiagram\n    participant AM as adapters launch\n    participant CX as Codex (exec mode)\n    participant SDK as babysitter CLI\n    participant TM as transport-adapter (if proxying)\n\n    AM->>CX: spawn(\"codex\", [\"exec\", \"$babysitter:yolo implement auth\"])\n    \n    Note over CX: Skill loads, hookDriven=false (exec mode)\n    CX->>SDK: instructions:babysit-skill --harness codex --no-interactive\n    SDK-->>CX: Orchestration prompt (hookDriven=false)\n\n    CX->>SDK: run:create --process-id auth-impl\n    \n    loop Agent-driven loop\n        CX->>SDK: run:iterate\n        SDK-->>CX: { effects }\n        CX->>CX: Execute effects (tools)\n        CX->>SDK: task:post\n    end\n\n    CX->>SDK: run:iterate → { completed, completionProof }\n    CX-->>AM: exit 0\n```\n\n### Pi\n\n```mermaid\nsequenceDiagram\n    participant AM as adapters launch\n    participant PI as Pi (--prompt mode)\n    participant SDK as babysitter CLI\n    participant TM as transport-adapter proxy\n\n    Note over AM: Pi needs proxy (doesn't speak Foundry natively)\n    AM->>TM: startTransportMuxRuntime()\n    AM->>AM: Write models.json to ~/.pi/agent/<br/>(Pi ignores env vars, reads config file)\n    AM->>PI: spawn(\"pi\", [\"--prompt\", \"Invoke babysitter:yolo...\"])\n\n    PI->>TM: API calls (OpenAI format via models.json provider)\n    TM->>TM: Translate OpenAI → upstream\n    \n    Note over PI: hookDriven=false, agent drives loop\n    PI->>SDK: run:create, iterate, post loop\n    \n    PI-->>AM: (idle — Pi doesn't exit after task)\n    Note over AM: Idle timeout (30s) kills process\n```\n\n---\n\n## Provider Path Details\n\nWhen a harness speaks a different protocol than the upstream provider, transport-adapter bridges the gap:\n\n```mermaid\ngraph TB\n    subgraph \"Harness Protocol\"\n        ANT[\"Anthropic<br/>(Claude Code)\"]\n        OAI[\"OpenAI<br/>(Codex)\"]\n        OAI2[\"OpenAI<br/>(Pi via models.json)\"]\n    end\n\n    subgraph \"transport-adapter\"\n        P1[\"Proxy: Anthropic → OpenAI\"]\n        P2[\"Proxy: Anthropic → Google\"]\n        P3[\"Pass-through (no proxy needed)\"]\n    end\n\n    subgraph \"Upstream Provider\"\n        FOUNDRY[\"Azure Foundry<br/>(OpenAI protocol)\"]\n        VERTEX[\"Vertex AI<br/>(Google protocol)\"]\n    end\n\n    ANT -->|\"Claude + Foundry\"| P1 --> FOUNDRY\n    ANT -->|\"Claude + Google\"| P2 --> VERTEX\n    OAI -->|\"Codex + Foundry\"| P3 --> FOUNDRY\n    OAI2 -->|\"Pi + Foundry\"| P1 --> FOUNDRY\n```\n\n**Message translation details:**\n\n| Direction | From | To | Key Translation |\n|-----------|------|----|-----------------|\n| Request | Anthropic `tool_use` | OpenAI `role:\"assistant\"` + `tool_calls` | `input` → `arguments`, `id` → `tool_call_id` |\n| Request | Anthropic `tool_result` | OpenAI `role:\"tool\"` | `tool_use_id` → `tool_call_id`, `content` → `content` |\n| Request | Anthropic `tool_use` | Google `functionCall` | `input` → `args`, `thoughtSignature` from server-side store |\n| Request | Anthropic `tool_result` | Google `functionResponse` | `tool_use_id` → name lookup via `toolIdToName` map |\n| Response | OpenAI `delta.tool_calls` | Anthropic `tool_use` stream | Accumulate chunks → `content_block_start` + `input_json_delta` |\n| Response | Google `functionCall` | Anthropic `tool_use` stream | Extract `thoughtSignature` → store server-side |\n",
    "documents": []
  },
  "outgoingEdges": [],
  "incomingEdges": [
    {
      "from": "page:docs-development",
      "to": "page:docs-development-03-babysitter-plugin-flows",
      "kind": "contains_page"
    }
  ]
}