zidane 5.8.4 → 5.9.1

package/docs/RESTATE.md

@@ -1,6 +1,6 @@
 # Zidane × Restate — durable agents
 
-`zidane/restate` is an **optional** adapter that runs the agent loop inside a [Restate](https://docs.restate.dev/) handler so every LLM call and tool execution becomes a journaled side effect. Crash mid-run → resume from the journal without re-billing tokens or re-firing tool side effects.
+`zidane/restate` is an **optional** adapter that runs the agent loop inside a [Restate](https://docs.restate.dev/) handler so every LLM call and completed tool execution becomes a journaled side effect. Crash mid-run → resume from the journal without re-billing tokens or re-running persisted tool calls.
 
 It's a thin layer over the existing agent surface — no fork, no separate runtime. The core harness has zero dependency on Restate; you opt in by wiring four wrappers.
 
@@ -9,14 +9,14 @@ zidane (core)
    └── zidane/restate  ← this adapter (Bun + Node, structurally typed against @restatedev/restate-sdk)
 ```
 
-A runnable example lives at `examples/restate/agent.ts`.
+A production-style runnable example lives at `examples/restate/agent.ts`. The `bun start --restate` CLI path is a local/demo runner around the same adapter; it is useful for exercising the flow against a local Restate runtime, but production services should wire `zidane/restate` inside their own Restate handlers.
 
 ## When to use it (and when not to)
 
 **Use Restate when** you need a server-side, long-running agent that must survive process restarts mid-run: an unattended job, a webhook-driven worker, a multi-hour pipeline that calls expensive providers and writes to external systems. The journal turns crash recovery from "replay from a session snapshot" into "replay from the last completed side effect, mid-turn".
 
 **Skip Restate when** you're running:
-- A TUI / CLI session (the user owns process lifetime; sessions are the recovery story).
+- A normal interactive TUI / CLI session (the user owns process lifetime; sessions are the recovery story).
 - A request/response API where the agent finishes inside the request lifetime.
 - A worker where crash → start-over is acceptable (sessions still persist conversation; you just lose the in-flight turn).
 
@@ -24,13 +24,15 @@ Restate adds a deployment surface (runtime + SDK + journal storage). Don't pay f
 
 ## Wrappers
 
-Four pure wrappers — pick the ones you need. Pass-through for everything else (`Provider.formatTools`, `ToolDef.spec`, etc.) so the rest of Zidane is unchanged.
+Adapter helpers — pick the ones you need. Pass-through for everything else (`Provider.formatTools`, `ToolDef.spec`, etc.) so the rest of Zidane is unchanged.
 
-| Wrapper | Wraps | What gets journaled |
+| Helper | Wraps / configures | What it does |
 |---|---|---|
-| `restateClock(ctx)` | `AgentClock` | `now()`, `randomUUID()` — turn ids + timestamps stable across replays |
+| `restateBehavior()` | `AgentBehavior` | Strict Restate defaults: sequential tools, no background tasks, cache on, Restate control errors re-thrown |
+| `restateClock(ctx)` | `AgentClock` | `now()`, `randomUUID()` — timestamps, run IDs, and fallback turn IDs stable across replays |
 | `restateProvider(provider, ctx)` | `Provider.stream` | Each LLM turn's `TurnResult` — replay returns cached value, no re-billing |
-| `restateTool(tool, ctx)` / `wrapAgentTools(tools, ctx)` | `ToolDef.execute` | Each tool invocation's result — side effects fire exactly once |
+| `restateTool(tool, ctx)` / `wrapAgentTools(tools, ctx)` | `ToolDef.execute` | Each completed tool invocation's result — replay skips re-running persisted tools |
+| `restateToolBatchExecutor({ promises })` | Tool scheduler | Opt-in Restate-native parallel join for concurrency-safe tool fleets |
 | `restateSessionStore(ctx)` | `SessionStore` | Session header + turns + runs as virtual-object K/V state |
 
 ### Minimal wiring
@@ -39,7 +41,7 @@ Four pure wrappers — pick the ones you need. Pass-through for everything else
 import * as restate from '@restatedev/restate-sdk'
 import { createAgent } from 'zidane'
 import { anthropic } from 'zidane/providers'
-import { restateClock, restateProvider, restateSessionStore, wrapAgentTools } from 'zidane/restate'
+import { restateBehavior, restateClock, restateProvider, restateSessionStore, wrapAgentTools } from 'zidane/restate'
 import { createSession } from 'zidane/session'
 import { shell } from 'zidane/tools'
 
@@ -57,6 +59,7 @@ const zidaneAgent = restate.object({
         tools: wrapAgentTools({ shell }, ctx),
         clock: restateClock(ctx),
         session,
+        behavior: restateBehavior(),
       })
 
       return await agent.run({ prompt })
@@ -67,6 +70,38 @@ const zidaneAgent = restate.object({
 restate.serve({ services: [zidaneAgent] })
 ```
 
+### Local CLI runner
+
+`bun start --restate` starts a local Restate endpoint in the current process, waits for the Admin API, probes the local service port, registers the deployment, and invokes the `zidane-start-agent` virtual object through ingress. It is intentionally a convenience runner for local validation and demos.
+
+```bash
+bun run restate:fixture:up
+bun start \
+  --restate \
+  --prompt "exercise the durable runner" \
+  --session-id demo-1
+```
+
+Useful flags:
+
+- `--restate-admin-url` / `--restate-ingress-url` — Restate control-plane and ingress URLs. Defaults match the Docker fixture.
+- `--restate-service-port` — local Bun endpoint port. Defaults to `19081`. The Docker smoke fixture's standalone service uses `19080`; the start CLI uses `19081` to avoid colliding with it.
+- `--restate-deployment-uri` — URI Restate uses to reach the local endpoint. Defaults to `http://host.docker.internal:<service-port>` for the Docker fixture.
+- `--restate-keep-alive` — keep the local endpoint alive after the first invocation so Restate can retry or you can inspect/reinvoke it.
+- `--restate-invocation-timeout-ms` — optional client-side timeout for the CLI's ingress `fetch`. This is not a durable handler execution timeout. Omit it for long-running local agent runs.
+- `--restate-provider-retry-attempts` / `--restate-tool-retry-attempts` — advanced overrides for the `ctx.run` retry attempts used by the CLI runner's provider and tool wrappers.
+- `--restate-random-failure` — local chaos switch that injects retryable provider failures for exercising replay/retry behavior.
+
+`--session-db` is rejected in Restate mode because the virtual-object state owns the session projection.
+
+The CLI service exposes:
+
+- `run` — drive an agent run for the object key.
+- `status` — read the last run status: `idle`, `running`, `completed`, or `failed`.
+- `history` — read the `restateSessionStore` projection for the object key.
+
+When a run completes, the service stores the input fingerprint plus a small completion summary. A later `run` with the same object key and same input returns the persisted session result; a completed object key with different input is rejected with a 409-style terminal error. Use a new `--session-id` for a distinct local run.
+
 ## How replay works
 
 Restate journals each `ctx.run(name, fn)` call. The original execution runs `fn` and stores its return value (or error). On any subsequent invocation of the same handler attempt — typically a crash recovery — `ctx.run(name, fn)` looks the entry up by `name` and returns the cached value **without invoking `fn`**.
@@ -111,11 +146,11 @@ Restate gives one concurrent invocation per virtual-object key. With sessions bo
 
 ### `restateClock`
 
-`AgentClock` backed by `ctx.date.now()` + `ctx.rand.uuidv4()`. Pass it via `AgentRunOptions.clock` (or `createAgent({ clock })`) so journaled metadata — `SessionTurn.id`, `SessionTurn.createdAt`, `runId` — stays byte-identical across replays.
+`AgentClock` backed by `ctx.date.now()` + `ctx.rand.uuidv4()`. Pass it via `AgentRunOptions.clock` (or `createAgent({ clock })`) so journaled metadata — timestamps, run IDs, and fallback turn IDs — stays byte-identical across replays.
 
 `ctx.date.now()` is async (the SDK routes it through `ctx.run` internally; replay returns the journaled timestamp). `ctx.rand.uuidv4()` is sync (the SDK seeds an in-memory RNG from the invocation id, itself replay-stable).
 
-**Gotcha**: when you pair a `restateSessionStore` with a session, the store's own `generateTurnId` runs ahead of `clock.randomUUID()` (the loop short-circuits via `session?.generateTurnId() ?? clock.randomUUID()`). The store implements `generateTurnId: () => ctx.rand.uuidv4()` precisely so turn ids stay journal-stable even when the clock falls through. If you wire a custom store, replicate that or your turn ids will drift on replay.
+**Gotcha**: when you pair a `restateSessionStore` with a session, the store's own `generateTurnId` runs ahead of `clock.randomUUID()` (the loop short-circuits via `session?.generateTurnId() ?? clock.randomUUID()`). The store derives deterministic IDs from the persisted turn count (`turn_1`, `turn_2`, …) so turn IDs stay stable across replay and across later invocations on the same object key. If you wire a custom store, keep turn ID generation deterministic from persisted state or let the Restate-backed clock provide the fallback UUIDs.
 
 ### `restateProvider`
 
@@ -123,15 +158,17 @@ Wraps `Provider.stream` in `ctx.run`. One journal entry per assistant turn carry
 
 Default `runOptions`: `{ maxRetryAttempts: 3 }`. Provider transients (rate limits, 5xx, connection resets) get retried inside the journal entry. Once the cap is reached the failure becomes terminal and surfaces through Zidane's normal `AgentProviderError` path.
 
+`streamCallbacks: 'suppress'` disables live `onText` / `onThinking` / server-tool callbacks inside the durable step. Use this for strict replay-safe deployments where UIs reconstruct from persisted `session.turns`; the default remains `'live'` for compatibility.
+
 ### `restateTool` / `wrapAgentTools`
 
-Wraps `ToolDef.execute` in `ctx.run`. The tool body runs once on the original execution; on replay `ctx.run` returns the journaled result without re-executing. Tools that hit the network / write to disk / poke external systems fire **exactly once** across crashes + retries — the entire reason to pair Zidane with Restate.
+Wraps `ToolDef.execute` in `ctx.run`. Once Restate persists the result, replay returns the journaled value without re-executing the tool. If the process dies before that journal entry is durable, the latest in-flight tool can run again; tools that hit the network, write to disk, or poke external systems still need application-level idempotency keys.
 
 Default `runOptions`: `{ maxRetryAttempts: 1 }`. Tool errors are typically deterministic (validation failures, missing files); blind retries waste budget. Override per-tool for network-heavy custom tools that benefit from SDK-level retries.
 
-`isConcurrencySafe` is preserved. Restate's per-key serialization doesn't preclude in-handler parallelism — the loop's scheduler still fans out safe tools up to `behavior.maxConcurrentTools`, each call lands in its own journal entry. Journal-completion order doesn't affect replay correctness (entries are keyed by name).
+`isConcurrencySafe` is preserved. `restateBehavior()` defaults `maxConcurrentTools` to `1` so strict Restate mode is deterministic first. If you want parallel tools, opt into the Restate scheduler below instead of relying on native promise fan-out.
 
-`wrapAgentTools(tools, ctx, { exclude })` is a batch helper. Pass-through for `exclude`-listed names (fully-deterministic local helpers where journaling is overhead).
+`wrapAgentTools(tools, ctx, { exclude })` is a batch helper. Pass-through for `exclude`-listed names (fully-deterministic local helpers where journaling is overhead). By default it hides and rejects the built-in `shell` tool's `run_in_background` mode because host-local background processes are not recoverable by Restate; pass `{ disableShellBackground: false }` only if the host owns that lifecycle.
 
 ### `restateSessionStore`
 
@@ -146,23 +183,40 @@ Limitations baked into the contract:
 - `delete()` only clears the current object's keys (no cross-key fan-out).
 - Single-tenant per virtual-object key: every method ignores the `sessionId` argument because the object is already keyed. Calling `appendTurns('other-id', …)` writes to the CURRENT object. Bind one virtual-object key per session and the contract holds.
 
+### Restate-native parallel tools
+
+```ts
+import { RestatePromise } from '@restatedev/restate-sdk'
+import { restateBehavior, restateToolBatchExecutor } from 'zidane/restate'
+
+createAgent({
+  tools: wrapAgentTools(tools, ctx),
+  behavior: restateBehavior({
+    maxConcurrentTools: 4,
+    toolBatchExecutor: restateToolBatchExecutor({ promises: RestatePromise }),
+  }),
+})
+```
+
+The scheduler starts concurrency-safe, Restate-wrapped tools in submission order, joins each chunk through `RestatePromise.all()`, and emits tool results back to the model in original call order. Unsafe tools remain barriers. If a safe tool is not wrapped with `restateTool()` / `wrapAgentTools()`, Restate mode runs that chunk sequentially instead of falling back to native promise parallelism. This mode is opt-in so the TUI/headless harness keeps its native sliding-window scheduler.
+
 ## Recommended `AgentBehavior` for Restate deployments
 
 ```ts
 createAgent({
   // ... wrappers as above
-  behavior: {
-    disableBackgroundTasks: true,
-    cache: true,
+  behavior: restateBehavior({
     maxCostUsd: 5,
     maxTotalTokens: 2_000_000,
-  },
+  }),
 })
 ```
 
+- **`maxConcurrentTools: 1`** — strict Restate default. Enable parallelism explicitly with `restateToolBatchExecutor`.
 - **`disableBackgroundTasks: true`** — background tasks (`shell` with `run_in_background: true`) aren't journaled and don't survive process death. Leaving them on creates orphaned processes on crash.
 - **`cache: true`** (default) — prompt-cache breakpoints reward stable system/tool prefixes. Cuts cold-start cost on retries when the cache is still warm.
-- **`maxCostUsd` / `maxTotalTokens`** — server-side budget circuit breaker. Throws `AgentBudgetExceededError` and finalizes the session run as `aborted`. Especially useful here because Restate's exactly-once + retry guarantees mean a runaway loop is a runaway *bill*; a soft cap stops it cleanly. See ARCHITECTURE.md → run-level budget circuit breaker.
+- **`shouldRethrowToolError`** — Restate terminal/suspension control errors escape the tool-result path.
+- **`maxCostUsd` / `maxTotalTokens`** — server-side budget circuit breaker. Throws `AgentBudgetExceededError` and finalizes the session run as `aborted`. Especially useful here because durable replay + retry means a runaway loop is a runaway *bill*; a soft cap stops it cleanly. See ARCHITECTURE.md → run-level budget circuit breaker.
 
 MCP servers re-bootstrap on every handler invocation (`warmup()` is lazy + idempotent); their tool *results* are journaled by `restateTool` so the model sees the same outputs on replay.
 
@@ -188,7 +242,7 @@ createAgent({
 |---|---|
 | Crash between turn N and N+1 | Re-enter the handler. Journal replays turns 1..N from cache. Turn N+1 runs live. |
 | Crash mid-tool-call | Re-enter. Journal replays prior turns + already-completed tools. The in-flight tool re-executes (Restate didn't see it complete). Tools that should not be re-run on retry need application-level idempotency (e.g. a `requestId` in the API call). |
-| Provider rate limit / 5xx | The agent loop's `behavior.retry` (3 attempts, exponential backoff) runs first, inside a single journal entry. If still failing, `restateProvider`'s default `maxRetryAttempts: 3` retries the whole journal entry. Beyond that, surfaces as `AgentProviderError`. |
+| Provider rate limit / 5xx | `restateProvider` wraps `Provider.stream` in `ctx.run` and applies its `runOptions` (default `{ maxRetryAttempts: 3 }`) to that durable side effect. The agent loop's own provider retry policy can still retry failed turns before the error escapes the loop; each retry calls the wrapped provider again and therefore gets its own durable side-effect boundary. Beyond the configured retries, the failure surfaces as `AgentProviderError`. |
 | Tool throws | `restateTool`'s default `maxRetryAttempts: 1` — no blind retry. The error is journaled; replay returns the same error. |
 | Restate runtime down | Handler invocations queue / fail at the SDK transport layer; Zidane never sees them. Recovery is operational, not in-app. |
 
@@ -196,6 +250,8 @@ createAgent({
 
 `test/restate.test.ts` covers each wrapper individually + end-to-end agent.run() with the clock + provider in place. A fake `RestateContextLike` records `ctx.run` calls and can be pre-seeded with a journal to verify replay semantics (inner fn not invoked, cached value returned verbatim).
 
+`test/start.test.ts` covers the local `bun start --restate` runner helpers: option parsing, deployment registration, ingress invocation timeout wiring, readiness/service probing, runtime-state cleanup, cached completion, changed-input rejection, and `status` / `history` handlers.
+
 The fake structural types live in `src/restate/types.ts` — the adapter typechecks **without** `@restatedev/restate-sdk` installed, useful in monorepos that vend `zidane` upstream of Restate. Consumers wiring the real SDK pass `restate.Context` / `restate.ObjectContext` directly; they're structurally assignable to the in-house shapes.
 
 ## Related

package/docs/SKILL.md

@@ -87,7 +87,7 @@ All providers accept runtime keys via params. Env vars are fallbacks. OAuth cred
 ```ts
 import { anthropic, openai, openrouter, cerebras, openaiCompat } from 'zidane'
 
-anthropic({ apiKey: 'sk-ant-...', defaultModel: 'claude-opus-4-7' })
+anthropic({ apiKey: 'sk-ant-...', defaultModel: 'claude-opus-4-8' })
 anthropic({ access: 'sk-ant-oat-...', refresh: '...', expires: 1234567890 })  // OAuth
 anthropic({ apiKey: 'sk-ant-...', baseURL: 'https://gateway.corp/anthropic' }) // full proxy
 anthropic({                                                                    // first-party betas
@@ -102,7 +102,7 @@ anthropic({                                                                    /
     }],
   },
 })
-openai({ apiKey: 'sk-...', defaultModel: 'gpt-5.4' })                          // OpenAI Codex (OAuth too)
+openai({ apiKey: 'sk-...', defaultModel: 'gpt-5.5' })                          // OpenAI Codex (OAuth too)
 openrouter({ apiKey: 'sk-or-...', defaultModel: 'google/gemini-pro' })
 cerebras({ apiKey: 'csk-...', defaultModel: 'zai-glm-4.7' })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zidane",
-  "version": "5.8.4",
+  "version": "5.9.1",
   "description": "an agent that goes straight to the goal",
   "type": "module",
   "private": false,
@@ -113,6 +113,11 @@
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "test": "bun test",
+    "restate:fixture:up": "docker compose -f test/fixtures/restate-docker/docker-compose.yml up --build -d",
+    "restate:fixture:down": "docker compose -f test/fixtures/restate-docker/docker-compose.yml down -v",
+    "restate:fixture:service": "PORT=19080 bun run test/fixtures/restate-docker/service.ts",
+    "restate:fixture:smoke": "bun run test/fixtures/restate-docker/smoke.ts",
+    "restate:fixture:test": "bun run test/fixtures/restate-docker/run.ts",
     "release": "bumpp package.json tui/package.json tui/npm/*/package.json --execute \"bun install --cpu='*' --os='*'\" --all",
     "typecheck": "tsc --noEmit"
   },

package/dist/agent-CL4nT5Ti.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent-CL4nT5Ti.d.ts","names":[],"sources":["../src/chat/context-breakdown.ts","../src/errors.ts","../src/types.ts","../src/providers/oauth.ts","../src/providers/anthropic.ts","../src/providers/cerebras.ts","../src/providers/cursor.ts","../src/providers/local.ts","../src/providers/openai.ts","../src/providers/openai-compat.ts","../src/providers/openrouter.ts","../src/providers/schema-sanitize.ts","../src/providers/index.ts","../src/session/messages.ts","../src/session/file-map.ts","../src/session/memory.ts","../src/session/remote.ts","../src/session/index.ts","../src/skills/types.ts","../src/tools/read-state.ts","../src/tools/types.ts","../src/mcp/index.ts","../src/skills/activation.ts","../src/agent.ts"],"mappings":"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"}

package/dist/mcp-Bp4tWsdM.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mcp-Bp4tWsdM.js","names":[],"sources":["../src/mcp/oauth-provider.ts","../src/mcp/sse-to-json-fetch.ts","../src/mcp/tolerant-client.ts","../src/mcp/index.ts"],"sourcesContent":["/**\n * OAuth 2.1 client provider for MCP servers.\n *\n * Implements the MCP SDK's `OAuthClientProvider` interface — the SDK handles\n * the protocol (PKCE, RFC 9728 protected-resource discovery, RFC 8414 / OIDC\n * authorization-server metadata, RFC 7591 dynamic client registration, token\n * refresh). This class provides the two halves the SDK delegates to consumers:\n *\n *   - **Persistence** — tokens, registered client info, optional discovery\n *     state cache, and PKCE code verifier. Storage is injected via the\n *     `McpCredentialStore` interface so the SDK adapter has no FS dependency;\n *     the chat layer wires a file-backed store, tests use the in-memory one.\n *\n *   - **Redirect** — when the SDK wants the user agent to navigate to the\n *     authorization URL, we hand the URL to the host (the TUI opens a\n *     browser + surfaces the URL in a status row). The PKCE code verifier\n *     stays in process memory for the lifetime of the flow; persisting it\n *     across process restarts would expose it on disk for no real benefit\n *     since the loopback callback server is also process-local.\n *\n * Two modes by `redirectUri`:\n *\n *   - **Non-interactive** (`redirectUri: undefined`) — used during bootstrap.\n *     The SDK will use stored tokens, auto-refresh on expiry, but cannot\n *     trigger a browser flow. Missing tokens cause the SDK to throw\n *     `UnauthorizedError`, which the caller catches and converts to a\n *     `mcp:auth:required` signal.\n *\n *   - **Interactive** (`redirectUri: 'http://127.0.0.1:<port>/callback'`) —\n *     used when the user explicitly triggers login. The caller has already\n *     stood up a loopback callback server (see `oauth-callback.ts`) and\n *     orchestrates: `client.connect()` → catches `UnauthorizedError` →\n *     waits on the callback for the `code` → `transport.finishAuth(code)`\n *     → retry `client.connect()`.\n */\n\nimport type {\n  OAuthClientProvider,\n  OAuthDiscoveryState,\n} from '@modelcontextprotocol/sdk/client/auth.js'\nimport type {\n  OAuthClientInformationMixed,\n  OAuthClientMetadata,\n  OAuthTokens,\n} from '@modelcontextprotocol/sdk/shared/auth.js'\n\n/**\n * Per-server persisted state. Subfields are optional so a partial save\n * (e.g. `saveCodeVerifier` arriving before `saveTokens`) doesn't blow away\n * earlier subfields — the provider always patches, never replaces.\n */\nexport interface McpCredentialEntry {\n  tokens?: OAuthTokens\n  clientInformation?: OAuthClientInformationMixed\n  discoveryState?: OAuthDiscoveryState\n}\n\nexport interface McpCredentialStore {\n  load: (name: string) => McpCredentialEntry | undefined\n  save: (name: string, entry: McpCredentialEntry) => void\n  delete: (name: string) => void\n}\n\n/**\n * In-memory store — primarily for tests, but valid as a no-persistence option\n * (tokens evaporate on process exit, the user re-auths every cold start).\n */\nexport function createMemoryMcpCredentialStore(seed?: Record<string, McpCredentialEntry>): McpCredentialStore {\n  const state = new Map<string, McpCredentialEntry>(Object.entries(seed ?? {}))\n  return {\n    load: name => state.get(name),\n    save: (name, entry) => { state.set(name, entry) },\n    delete: (name) => { state.delete(name) },\n  }\n}\n\nexport interface McpOAuthProviderOptions {\n  /** Server name — used as the storage key. */\n  name: string\n  /** Persistence backend. */\n  store: McpCredentialStore\n  /**\n   * Loopback callback URI. Pass `undefined` for bootstrap (non-interactive\n   * mode — stored tokens + refresh only, never opens a browser).\n   */\n  redirectUri?: string\n  /**\n   * Invoked when the SDK wants the user agent to navigate to the authorization\n   * URL. Typically the host opens the browser AND emits a hook so the TUI can\n   * render the URL in a status row. No-op in non-interactive mode (the SDK\n   * still calls this before throwing `UnauthorizedError` from connect).\n   */\n  onAuthorizationUrl?: (url: URL) => void | Promise<void>\n  /**\n   * `client_name` used in dynamic client registration. Defaults to `'zidane'`.\n   * Some servers display this string to the user on the consent screen.\n   */\n  clientName?: string\n  /**\n   * Override the requested OAuth scope. Default: unset (the SDK negotiates\n   * via the server's metadata).\n   */\n  scope?: string\n}\n\nconst DEFAULT_CLIENT_NAME = 'zidane'\n\nexport class McpOAuthProvider implements OAuthClientProvider {\n  private readonly name: string\n  private readonly store: McpCredentialStore\n  private readonly _redirectUri?: string\n  private readonly onAuthorizationUrl?: (url: URL) => void | Promise<void>\n  private readonly clientName: string\n  private readonly _scope?: string\n  // PKCE verifier is process-local — see file header. Module-scoped Map would\n  // leak across concurrent flows for different servers; per-instance is the\n  // right granularity.\n  private codeVerifierValue: string | undefined\n\n  constructor(opts: McpOAuthProviderOptions) {\n    this.name = opts.name\n    this.store = opts.store\n    this._redirectUri = opts.redirectUri\n    this.onAuthorizationUrl = opts.onAuthorizationUrl\n    this.clientName = opts.clientName ?? DEFAULT_CLIENT_NAME\n    this._scope = opts.scope\n  }\n\n  get redirectUrl(): string | URL | undefined {\n    return this._redirectUri\n  }\n\n  get clientMetadata(): OAuthClientMetadata {\n    return {\n      // The SDK validates `redirect_uris` non-empty; we use a placeholder\n      // when running non-interactively (no callback server is up). The\n      // server won't actually redirect anywhere because the SDK throws\n      // `UnauthorizedError` before any browser navigation in that mode.\n      redirect_uris: [this._redirectUri ?? 'http://127.0.0.1:0/callback'],\n      client_name: this.clientName,\n      // PKCE-only public client — no client_secret. RFC 8252 native-app pattern.\n      token_endpoint_auth_method: 'none',\n      grant_types: ['authorization_code', 'refresh_token'],\n      response_types: ['code'],\n      ...(this._scope ? { scope: this._scope } : {}),\n    }\n  }\n\n  tokens(): OAuthTokens | undefined {\n    return this.store.load(this.name)?.tokens\n  }\n\n  saveTokens(tokens: OAuthTokens): void {\n    this.patch({ tokens })\n  }\n\n  clientInformation(): OAuthClientInformationMixed | undefined {\n    return this.store.load(this.name)?.clientInformation\n  }\n\n  saveClientInformation(info: OAuthClientInformationMixed): void {\n    this.patch({ clientInformation: info })\n  }\n\n  discoveryState(): OAuthDiscoveryState | undefined {\n    return this.store.load(this.name)?.discoveryState\n  }\n\n  saveDiscoveryState(state: OAuthDiscoveryState): void {\n    this.patch({ discoveryState: state })\n  }\n\n  saveCodeVerifier(verifier: string): void {\n    this.codeVerifierValue = verifier\n  }\n\n  codeVerifier(): string {\n    if (!this.codeVerifierValue) {\n      // Spec-correct error — the SDK would otherwise complete the code\n      // exchange with an empty verifier and the auth server would 400.\n      throw new Error(\n        `MCP OAuth: code verifier missing for \"${this.name}\" — `\n        + 'the flow must call saveCodeVerifier() before the redirect',\n      )\n    }\n    return this.codeVerifierValue\n  }\n\n  async redirectToAuthorization(url: URL): Promise<void> {\n    await this.onAuthorizationUrl?.(url)\n  }\n\n  /**\n   * Wipe stored credentials when the server reports the cached state is no\n   * longer valid. The SDK calls this with a scope hint:\n   *   - `'tokens'`  → access/refresh revoked, keep client registration\n   *   - `'client'`  → client registration invalidated, reset everything\n   *   - `'verifier'`→ PKCE state stale (e.g. mismatched state param)\n   *   - `'discovery'` → discovery metadata stale (servers re-keyed)\n   *   - `'all'`     → full reset\n   */\n  async invalidateCredentials(scope: 'all' | 'client' | 'tokens' | 'verifier' | 'discovery'): Promise<void> {\n    if (scope === 'verifier') {\n      this.codeVerifierValue = undefined\n      return\n    }\n    const current = this.store.load(this.name)\n    if (!current)\n      return\n    if (scope === 'all') {\n      this.codeVerifierValue = undefined\n      this.store.delete(this.name)\n      return\n    }\n    const next: McpCredentialEntry = { ...current }\n    if (scope === 'tokens')\n      delete next.tokens\n    if (scope === 'client') {\n      delete next.clientInformation\n      // Client identity changed; previously-issued tokens and discovery\n      // are no longer valid against the new registration.\n      delete next.tokens\n      delete next.discoveryState\n    }\n    if (scope === 'discovery')\n      delete next.discoveryState\n    this.store.save(this.name, next)\n  }\n\n  private patch(updates: Partial<McpCredentialEntry>): void {\n    const existing = this.store.load(this.name) ?? {}\n    this.store.save(this.name, { ...existing, ...updates })\n  }\n}\n\n/**\n * True when an HTTP transport's auth headers already include an explicit\n * Authorization. Used by the bootstrap escape-hatch: a user who provided\n * their own bearer token shouldn't be auto-promoted to OAuth on a 401.\n *\n * Case-insensitive — Node normalizes outgoing headers to lowercase but\n * users hand-write `Authorization` in configs.\n */\nexport function hasAuthorizationHeader(headers: Record<string, string> | undefined): boolean {\n  if (!headers)\n    return false\n  for (const key of Object.keys(headers)) {\n    if (key.toLowerCase() === 'authorization')\n      return true\n  }\n  return false\n}\n","/**\n * `fetch` shim that converts streamable-http POST responses with\n * `Content-Type: text/event-stream` into synthetic `application/json`\n * responses, preserving every original header (notably `mcp-session-id`).\n *\n * Why this exists\n * ----------------\n * The MCP SDK's streamable-http transport handles POST responses two ways\n * depending on `content-type`:\n *\n *   - `application/json` → `await response.json()` (works on every runtime).\n *   - `text/event-stream` → `body.pipeThrough(TextDecoderStream)\n *                              .pipeThrough(EventSourceParserStream)`\n *                          and forward each parsed event to `onmessage`.\n *\n * On Bun + MCP SDK 1.29.x the second pipeline silently drops the parsed\n * event: the full `event: message\\ndata: {...}\\n\\n` arrives intact, the\n * stream closes, but `onmessage` is never called. Bootstrap then waits the\n * full `bootstrapTimeout` (10s default) and the agent loses every tool the\n * server would have exposed.\n *\n * The MCP spec lets clients accept either content type\n * (`Accept: application/json, text/event-stream`), so flipping the stream\n * to JSON at the boundary is a transparent, server-agnostic workaround.\n *\n * Scope of the shim\n * -----------------\n *   - POST + `text/event-stream` → drain, parse SSE message events, return\n *     a synthetic `application/json` response. Single event becomes a JSON\n *     object (matching the shape the SDK expects from non-streaming\n *     servers); multiple events become a JSON array (the SDK already\n *     iterates `Array.isArray(data)` from a JSON response).\n *   - GET (long-lived `_startOrAuthSse` listener) → untouched. Per-event\n *     latency matters there and the SSE pipeline isn't always broken on\n *     GET in the same way (different code path inside Bun's stream impl).\n *   - 202 / non-SSE / malformed SSE / no body → passthrough.\n *\n * Runtime gating\n * --------------\n * `sseToJsonFetchIfNeeded()` only returns a wrapper on Bun. Node + browser\n * runtimes get `undefined` and the SDK uses global `fetch` directly — no\n * extra buffer-and-redrain on the happy path, and no risk of collapsing a\n * future progress-streaming response into a single batched array. If you\n * need to apply the shim unconditionally (testing, custom hosts), call\n * `sseToJsonFetch()` directly.\n *\n * Cleanup\n * -------\n * Remove this file and its `fetch:` injection in `createTransport` once\n * either Bun fixes the `pipeThrough` chain or the SDK switches off the\n * streaming pipeline by default.\n */\n\n/**\n * Detect whether we're running on Bun. The `Bun` global is set by the\n * runtime itself and isn't faked by Bun's Node-compat layer.\n */\nfunction isBunRuntime(): boolean {\n  return typeof (globalThis as { Bun?: unknown }).Bun !== 'undefined'\n}\n\n/**\n * Returns the `sseToJsonFetch` wrapper only on runtimes that need it\n * (currently Bun). Returns `undefined` everywhere else, which makes the\n * SDK fall back to the global `fetch` and keeps the streaming pipeline\n * intact on Node where it works correctly.\n *\n * Designed as the value to pass directly to `StreamableHTTPClientTransport`'s\n * `fetch` option:\n *\n *     new StreamableHTTPClientTransport(url, {\n *       fetch: sseToJsonFetchIfNeeded(),\n *     })\n */\nexport function sseToJsonFetchIfNeeded(): typeof fetch | undefined {\n  return isBunRuntime() ? sseToJsonFetch() : undefined\n}\n\n/**\n * Wrap a `fetch` implementation so streamable-http POST responses that come\n * back as `text/event-stream` are converted to JSON. Pass the result as\n * `opts.fetch` to `StreamableHTTPClientTransport`.\n *\n * Always-on (i.e. unconditional) — for the runtime-gated entry point,\n * use {@link sseToJsonFetchIfNeeded} instead.\n */\nexport function sseToJsonFetch(baseFetch: typeof fetch = fetch): typeof fetch {\n  return async function sseToJsonWrappedFetch(input, init) {\n    const response = await baseFetch(input, init)\n\n    // Only intercept POSTs. The SDK's GET path opens a long-lived SSE\n    // listener (`_startOrAuthSse`) that we must not buffer-drain.\n    const method = (init?.method ?? 'GET').toString().toUpperCase()\n    if (method !== 'POST')\n      return response\n\n    const contentType = response.headers.get('content-type')\n    if (!contentType || !contentType.includes('text/event-stream'))\n      return response\n\n    if (!response.body)\n      return response\n\n    let raw: string\n    try {\n      raw = await response.text()\n    }\n    catch {\n      // Bun edge case: if even .text() fails, surrender — the original\n      // response is already drained, so we can't recover. Return it; the\n      // SDK will surface the underlying read error.\n      return response\n    }\n\n    const events = parseSseDataEvents(raw)\n    // Single event → bare object; multi-event or zero → array. The SDK's\n    // JSON branch handles both shapes (`Array.isArray(data) ? data.map(…) : …`).\n    const payload = events.length === 1 ? events[0] : events\n    return synthesizeJsonResponse(response, payload)\n  } as typeof fetch\n}\n\n/**\n * Parse a buffered SSE body into the JSON payloads of its `message` events.\n *\n * Skips:\n * - SSE comments (lines starting with `:`).\n * - Non-default event types (`event: foo` ≠ `message`). The MCP server\n *   only ever emits `message` events for JSON-RPC; anything else is out of\n *   band and the SDK wouldn't have surfaced it to `onmessage` either.\n * - Malformed `data:` payloads (anything that fails `JSON.parse`).\n */\nfunction parseSseDataEvents(raw: string): unknown[] {\n  const events: unknown[] = []\n  for (const block of raw.split(/\\r?\\n\\r?\\n/)) {\n    if (!block.trim())\n      continue\n\n    const dataLines: string[] = []\n    let isMessageEvent = true\n    for (const line of block.split(/\\r?\\n/)) {\n      if (line.startsWith(':'))\n        continue\n      if (line.startsWith('event:')) {\n        const eventType = line.slice('event:'.length).trim()\n        if (eventType && eventType !== 'message')\n          isMessageEvent = false\n      }\n      else if (line.startsWith('data:')) {\n        // Per SSE spec: a single leading space after `data:` is part of the\n        // separator, not the payload. Anything beyond it is.\n        const value = line.slice('data:'.length)\n        dataLines.push(value.startsWith(' ') ? value.slice(1) : value)\n      }\n    }\n\n    if (!isMessageEvent || dataLines.length === 0)\n      continue\n\n    try {\n      events.push(JSON.parse(dataLines.join('\\n')))\n    }\n    catch {\n      // Drop malformed events. The SDK's broken pipe would have dropped\n      // them too — staying silent here matches that baseline.\n    }\n  }\n  return events\n}\n\n/**\n * Build a `Response` mirroring the original's status / statusText / headers\n * but with a JSON body and `content-type: application/json`. Header\n * preservation is the whole point — `mcp-session-id` is set by the server\n * on the initialize POST and must round-trip into the SDK's\n * `_sessionId` capture (`response.headers.get('mcp-session-id')`).\n */\nfunction synthesizeJsonResponse(original: Response, payload: unknown): Response {\n  const headers = new Headers(original.headers)\n  headers.set('content-type', 'application/json')\n  return new Response(JSON.stringify(payload), {\n    status: original.status,\n    statusText: original.statusText,\n    headers,\n  })\n}\n","/**\n * Drop-in `Client` subclass whose `connect()` mirrors the upstream MCP SDK\n * sequence but treats `notifications/initialized` as best-effort.\n *\n * The MCP spec marks that notification fire-and-forget, but the SDK awaits\n * the underlying transport `send()` and rethrows on any HTTP 4xx. Several\n * real-world streamable-http servers (e.g. browser-codemode, custom MCPs\n * that gate non-initialize routes on a session id that didn't yet exist when\n * the notification posted) reject the notification with a 4xx and still\n * accept every subsequent request. The base `Client.connect()` then closes\n * the transport, the bootstrap fails, and the agent silently loses every\n * tool the server would have exposed.\n *\n * This module changes only that single step — log + continue if the\n * notification throws. Initialize, capability/version capture,\n * `setProtocolVersion`, listChanged handler wiring, and the close-on-failure\n * path for everything else are preserved verbatim from the SDK.\n *\n * Lazy SDK load: `@modelcontextprotocol/sdk` is an *optional* peer dep, so\n * the class is built inside `createTolerantClient()` via dynamic imports.\n * Importing this module does NOT trigger SDK resolution — callers only\n * incur the cost when they actually instantiate a client.\n *\n * Should be removed when the SDK lands an opt-in tolerance flag upstream.\n */\nimport type { Client } from '@modelcontextprotocol/sdk/client/index.js'\nimport { errorMessage } from '../errors'\n\n// Private fields the override needs to read/write to mirror upstream behavior.\n// Cast surface is isolated to this one type so the rest of the file stays clean.\ninterface ClientPrivates {\n  _capabilities: unknown\n  _clientInfo: unknown\n  _serverCapabilities: unknown\n  _serverVersion: unknown\n  _instructions: unknown\n  _pendingListChangedConfig?: unknown\n  _setupListChangedHandlers: (config: unknown) => void\n}\n\ninterface MaybeSessionedTransport {\n  sessionId?: unknown\n  setProtocolVersion?: (v: string) => void\n}\n\n/**\n * Options forwarded to the upstream `Client` constructor. Mirrors the\n * publicly-observable shape so we don't have to re-export `Client`'s\n * private `ClientOptions` type (which would force consumers of the lazy\n * factory below to install the SDK at type-check time too).\n */\nexport interface TolerantClientOptions {\n  /** Capabilities advertised to the server on `initialize`. */\n  capabilities?: Record<string, unknown>\n  /** When true, the SDK rejects requests for methods the server didn't advertise. */\n  enforceStrictCapabilities?: boolean\n  /** Per-request timeout in ms; the SDK falls back to its own default when unset. */\n  defaultRequestTimeout?: number\n  /**\n   * Best-effort notification sink. Fires once if the server rejected\n   * `notifications/initialized` with a 4xx — the connection survived but\n   * the client wants to know it deviated from the spec. Default: no-op.\n   *\n   * Routing this through a callback (instead of a hard-coded\n   * `console.warn`) is what lets `connectMcpServers` collect the warning,\n   * include it on the `mcp:bootstrap:end` payload, and keep hosts that\n   * don't care from seeing stray stderr.\n   */\n  onWarning?: (message: string) => void\n}\n\n/**\n * Async factory — builds an instance of the tolerant MCP client. The\n * actual `Client` subclass definition lives inside the factory so the\n * `@modelcontextprotocol/sdk` import only resolves when MCP is in use.\n *\n * Second `options` arg forwards directly into the upstream `Client`\n * constructor so tests / advanced consumers can supply capabilities,\n * `enforceStrictCapabilities`, etc.\n */\nexport async function createTolerantClient(\n  info: { name: string, version: string },\n  options?: TolerantClientOptions,\n): Promise<Client> {\n  const { Client } = await import('@modelcontextprotocol/sdk/client/index.js')\n  const { Protocol } = await import('@modelcontextprotocol/sdk/shared/protocol.js')\n  const { InitializeResultSchema, LATEST_PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS } = await import('@modelcontextprotocol/sdk/types.js')\n\n  // Capture once; the override below mustn't re-read `options.onWarning` per\n  // connect because hosts may not consider `options` long-lived.\n  const onWarning = options?.onWarning\n\n  class TolerantMcpClient extends Client {\n    async connect(\n      transport: Parameters<Client['connect']>[0],\n      options?: Parameters<Client['connect']>[1],\n    ): Promise<void> {\n      // Wire the transport (Protocol.connect — onmessage/onclose/onerror hooks\n      // and transport.start) without sending any messages. We MUST NOT call\n      // `super.connect()` here — that's `Client.connect`, which would\n      // re-execute the very initialize+notification dance we're overriding.\n      await Protocol.prototype.connect.call(this as never, transport)\n\n      // Reconnect path: the upstream client short-circuits on a transport that\n      // already carries a session id, so do we.\n      if ((transport as MaybeSessionedTransport).sessionId !== undefined)\n        return\n\n      const self = this as unknown as ClientPrivates\n\n      try {\n        const result = await this.request(\n          {\n            method: 'initialize',\n            params: {\n              protocolVersion: LATEST_PROTOCOL_VERSION,\n              capabilities: self._capabilities,\n              clientInfo: self._clientInfo,\n            },\n          },\n          InitializeResultSchema,\n          options,\n        )\n\n        if (result === undefined)\n          throw new Error(`Server sent invalid initialize result: ${result}`)\n        if (!SUPPORTED_PROTOCOL_VERSIONS.includes(result.protocolVersion))\n          throw new Error(`Server's protocol version is not supported: ${result.protocolVersion}`)\n\n        self._serverCapabilities = result.capabilities\n        self._serverVersion = result.serverInfo\n\n        const setProtocolVersion = (transport as MaybeSessionedTransport).setProtocolVersion\n        if (setProtocolVersion)\n          setProtocolVersion.call(transport, result.protocolVersion)\n\n        self._instructions = result.instructions\n\n        // Best-effort. The session id (if any) is already captured by the\n        // transport from the `initialize` response headers, so subsequent\n        // requests like `tools/list` still authenticate. Don't bring down the\n        // whole connection on a 4xx for a fire-and-forget notification.\n        try {\n          await this.notification({ method: 'notifications/initialized' })\n        }\n        catch (notifyError) {\n          // Hosts opt in to the signal via `onWarning`; default is silent\n          // so a plain `new Client()` doesn't leak stderr into every host.\n          onWarning?.(`server rejected notifications/initialized (continuing): ${errorMessage(notifyError)}`)\n        }\n\n        if (self._pendingListChangedConfig) {\n          self._setupListChangedHandlers(self._pendingListChangedConfig)\n          self._pendingListChangedConfig = undefined\n        }\n      }\n      catch (error) {\n        // Same failure path as upstream Client — anything *other* than the\n        // tolerated notification failure tears the transport down so the\n        // bootstrap surfaces a clear error.\n        void this.close()\n        throw error\n      }\n    }\n  }\n\n  return new TolerantMcpClient(info, options)\n}\n","/**\n * MCP (Model Context Protocol) server support.\n *\n * Connects to one or more MCP servers, discovers their tools,\n * and wraps them as zidane ToolDefs for use in agent loops.\n */\n\nimport type { OAuthClientProvider } from '@modelcontextprotocol/sdk/client/auth.js'\nimport type { Client } from '@modelcontextprotocol/sdk/client/index.js'\nimport type { Hookable } from 'hookable'\nimport type { AgentHooks } from '../agent'\nimport type { ToolContext, ToolDef } from '../tools/types'\nimport type { McpServerConfig, McpToolHookContext, McpToolSchema, ToolResultContent } from '../types'\nimport { Buffer } from 'node:buffer'\nimport { errorMessage } from '../errors'\nimport { reconcileImageMediaType } from '../tools/image-sniff'\nimport { toolOutputByteLength } from '../types'\nimport { hasAuthorizationHeader } from './oauth-provider'\nimport { sseToJsonFetchIfNeeded } from './sse-to-json-fetch'\nimport { createTolerantClient } from './tolerant-client'\n\n/**\n * Subset of the MCP SDK's `Transport` interface that `bootstrapServer` needs\n * to clean up. Typed structurally so a failed `createTransport()` doesn't\n * force us to pull the SDK's full transport type into our static graph.\n */\ninterface ClosableTransport {\n  close: () => void | Promise<void>\n}\n\n// NOTE: `@modelcontextprotocol/sdk` is an *optional* peer dependency\n// (see package.json). Static imports here would force every consumer of\n// `zidane` to install the SDK even if they never wire any MCP servers —\n// which fails on install with `--no-optional` or in restricted CI\n// environments. All runtime imports are inside `createTransport` /\n// `loadTolerantClient` below so the SDK is only resolved when MCP is\n// actually used. Type-only imports above are erased at compile time.\n\nexport type { McpServerConfig, McpToolSchema } from '../types'\n\nexport interface McpConnection {\n  tools: Record<string, ToolDef>\n  /**\n   * Per-server `instructions` payload from the MCP `initialize` handshake,\n   * keyed by server name. Each server may return free-form guidance the\n   * model is meant to read alongside the tool catalog — typical content\n   * is \"the database is already provisioned, use `apply_migration`\n   * directly\" or \"always wrap SELECTs in a transaction\". The agent\n   * renders these into a system-prompt section when\n   * `behavior.surfaceMcpInstructions` is on (default).\n   *\n   * Servers that omit the field, return an empty string, or fail to\n   * connect contribute no entry. Lazy-connected servers contribute an\n   * entry only once their first connect resolves — until then the model\n   * never sees their instructions, matching the schema-loading semantics\n   * of `lazyConnect`.\n   *\n   * Map (not Record) so insertion order matches server config order and\n   * the rendered section is byte-stable for the cache breakpoint.\n   *\n   * Optional so custom `mcpConnector` implementations from before this\n   * field existed still type-check; the framework's own\n   * `connectMcpServers` always returns a Map (possibly empty).\n   */\n  instructions?: Map<string, string>\n  close: () => Promise<void>\n}\n\n// ---------------------------------------------------------------------------\n// Shape normalization\n// ---------------------------------------------------------------------------\n\ninterface RawServerShape {\n  name?: string\n  transport?: string\n  type?: string\n  command?: string\n  args?: string[]\n  env?: Record<string, string>\n  strictEnv?: boolean\n  cwd?: string\n  url?: string\n  httpUrl?: string\n  sseUrl?: string\n  headers?: Record<string, string>\n  bootstrapTimeout?: number\n  toolTimeout?: number\n  enabledTools?: string[]\n  disabledTools?: string[]\n  toolFilter?: McpServerConfig['toolFilter']\n  /** Canonical OAuth flag. */\n  auth?: McpServerConfig['auth']\n  /** Cursor runtime-state alias for `auth: 'oauth'`. */\n  authMethod?: string\n  [key: string]: unknown\n}\n\nconst DEFAULT_MCP_BOOTSTRAP_TIMEOUT_MS = 10_000\n\n// ---------------------------------------------------------------------------\n// Bootstrap-internal helpers (hook safety + cleanup + error hints)\n//\n// These keep `bootstrapServer` and `connectMcpServers` readable while\n// providing three guarantees the bootstrap contract relies on:\n//\n//   1. A misbehaving hook handler MUST NOT take down the whole batch — the\n//      partial-failure tolerance (`Promise.allSettled` in the caller plus\n//      this safe-fire helper) means one bad listener degrades to a debug\n//      log instead of \"no MCP tools at all\".\n//   2. A timed-out / failed bootstrap MUST close its transport explicitly,\n//      not just the SDK client. Until `Protocol.connect(transport)` has\n//      wired the transport into the client, `client.close()` doesn't know\n//      about it and the underlying stdio subprocess / HTTP connection\n//      lingers until GC.\n//   3. Transport-mismatch failures (the common `type: 'http'` vs SSE-only\n//      server case from downstream reports) MUST surface an actionable\n//      hint in the error message, not just `HTTP 405`.\n// ---------------------------------------------------------------------------\n\n/**\n * Fire a hook without letting a listener's rejection escape. A throwing\n * listener used to bring down the whole `Promise.all` in\n * `connectMcpServers`, defeating the batch's partial-failure tolerance.\n *\n * Failures are swallowed; under `ZIDANE_DEBUG` they're traced to stderr\n * so the misbehaving listener is still discoverable when a host opts in.\n *\n * `args` is variadic to match `Hookable.callHook`'s spread shape; in\n * practice every `AgentHooks` event takes a single context object.\n */\nasync function safeCallHook<K extends keyof AgentHooks & string>(\n  hooks: Hookable<AgentHooks> | undefined,\n  event: K,\n  ...args: Parameters<AgentHooks[K]>\n): Promise<void> {\n  if (!hooks)\n    return\n  try {\n    await hooks.callHook(event, ...args)\n  }\n  catch (err) {\n    if (process.env.ZIDANE_DEBUG)\n      process.stderr.write(`[zidane/mcp] hook \"${event}\" listener rejected: ${errorMessage(err)}\\n`)\n  }\n}\n\n/**\n * Close a transport best-effort. The catch swallows everything — by the\n * time we're closing, the bootstrap has already failed and the only thing\n * worse than a leaked transport is a leaked transport AND a new error\n * masking the original cause.\n */\nasync function closeTransportQuietly(transport: ClosableTransport | null): Promise<void> {\n  if (!transport)\n    return\n  try {\n    await transport.close()\n  }\n  catch {\n    // Original bootstrap error is more actionable.\n  }\n}\n\n/**\n * Detect failure signatures that point at a transport mismatch and return\n * an actionable hint string. Conservative — only matches the signals we've\n * actually observed in the wild against MCP servers, so a real outage on\n * the right transport doesn't get misdiagnosed.\n *\n * Streamable-HTTP against an SSE-only endpoint:\n *   - The transport opens an `initialize` POST. SSE-only servers respond\n *     with `405 Method Not Allowed` or `404 Not Found` (their `/sse` GET\n *     endpoint is the only handler). The SDK wraps these as\n *     `Error POSTing to endpoint (HTTP 40X): ...`.\n *   - Some proxies return `400` with a `text/event-stream` mismatch on\n *     POST; same root cause, same fix.\n */\nfunction buildTransportMismatchHint(transport: McpServerConfig['transport'], err: Error): string | null {\n  const msg = err.message\n  if (transport === 'streamable-http') {\n    if (/\\bHTTP\\s*40[45]\\b/i.test(msg) || /\\(40[45]\\)/.test(msg))\n      return 'This server may not implement the streamable-HTTP transport. Try `transport: \\'sse\\'` (or `sseUrl` instead of `url`) on this server\\'s config.'\n  }\n  return null\n}\n\n/**\n * Wrap a bootstrap failure so the surfaced `Error` carries an actionable\n * hint while preserving the original message + stack + cause. Returns the\n * input error verbatim when no hint applies.\n *\n * `cause` (ES2022) gives hosts that introspect a way back to the raw SDK\n * error; the human-readable hint is the new message body that lands in\n * logs / hook payloads.\n */\nfunction withTransportMismatchHint(transport: McpServerConfig['transport'], err: Error): Error {\n  const hint = buildTransportMismatchHint(transport, err)\n  if (!hint)\n    return err\n  const augmented = new Error(`${err.message}\\nHint: ${hint}`, { cause: err })\n  if (err.stack)\n    augmented.stack = err.stack\n  return augmented\n}\n\nfunction inferTransport(raw: RawServerShape): McpServerConfig['transport'] {\n  if (raw.transport === 'stdio' || raw.transport === 'sse' || raw.transport === 'streamable-http')\n    return raw.transport\n  if (raw.type === 'stdio' || raw.type === 'sse' || raw.type === 'streamable-http' || raw.type === 'http')\n    return raw.type === 'http' ? 'streamable-http' : raw.type\n  if (raw.command)\n    return 'stdio'\n  if (raw.httpUrl)\n    return 'streamable-http'\n  if (raw.sseUrl)\n    return 'sse'\n  if (raw.url)\n    return 'streamable-http'\n  throw new Error(`Cannot infer MCP transport from config: ${JSON.stringify(raw)}`)\n}\n\nfunction normalizeOne(name: string, raw: RawServerShape): McpServerConfig {\n  const transport = inferTransport(raw)\n  const url = raw.url ?? raw.httpUrl ?? raw.sseUrl\n\n  const config: McpServerConfig = { name, transport }\n  if (raw.command)\n    config.command = raw.command\n  if (raw.args)\n    config.args = raw.args\n  if (raw.env)\n    config.env = raw.env\n  if (raw.strictEnv === true)\n    config.strictEnv = true\n  if (typeof raw.cwd === 'string' && raw.cwd.length > 0)\n    config.cwd = raw.cwd\n  if (url)\n    config.url = url\n  if (raw.headers)\n    config.headers = raw.headers\n  if (typeof raw.bootstrapTimeout === 'number')\n    config.bootstrapTimeout = raw.bootstrapTimeout\n  if (typeof raw.toolTimeout === 'number')\n    config.toolTimeout = raw.toolTimeout\n  if (Array.isArray(raw.enabledTools))\n    config.enabledTools = raw.enabledTools\n  if (Array.isArray(raw.disabledTools))\n    config.disabledTools = raw.disabledTools\n  if (typeof raw.toolFilter === 'function')\n    config.toolFilter = raw.toolFilter\n  // Canonical `auth` field; also recognize Cursor's `authMethod: 'mcpOAuth'`\n  // runtime-state shape so pasted ~/.cursor/mcp.json entries Just Work.\n  if (raw.auth === 'oauth' || raw.authMethod === 'mcpOAuth')\n    config.auth = 'oauth'\n\n  return config\n}\n\n/**\n * True when the input looks like a single config object (flat fields like `command`,\n * `transport`, `url`) rather than a record whose values are configs.\n */\nfunction looksLikeSingleConfig(obj: Record<string, unknown>): boolean {\n  const singleConfigKeys = ['transport', 'type', 'command', 'url', 'httpUrl', 'sseUrl']\n  return singleConfigKeys.some(key => typeof obj[key] === 'string')\n}\n\n/**\n * Normalize MCP server configs from any common shape to `McpServerConfig[]`.\n *\n * Accepts:\n * - `McpServerConfig[]` — zidane native (pass-through).\n * - `McpServerConfig` — a single config object (wrapped to a 1-element array).\n * - `Record<string, RawShape>` — name-keyed map (common in host-SDK configs), where the key is the server name.\n * - Mixed shapes with `type` vs `transport`, `httpUrl`/`sseUrl` vs `url`.\n *\n * Returns `[]` when `input` is nullish. Throws a descriptive error when the transport\n * cannot be inferred from a given entry, or when the input shape is unsupported.\n */\nexport function normalizeMcpServers(input: unknown): McpServerConfig[] {\n  if (input == null)\n    return []\n\n  if (Array.isArray(input)) {\n    return input.map((raw, idx) => {\n      const obj = raw as RawServerShape\n      const name = obj.name ?? `mcp_${idx}`\n      return normalizeOne(name, obj)\n    })\n  }\n\n  if (typeof input === 'object') {\n    const obj = input as Record<string, unknown>\n    // Single-config heuristic: flat fields like `transport`/`command`/`url` at the top\n    // level indicate a single McpServerConfig, not a record of configs.\n    if (looksLikeSingleConfig(obj)) {\n      const raw = obj as RawServerShape\n      const name = raw.name ?? 'mcp_0'\n      return [normalizeOne(name, raw)]\n    }\n    return Object.entries(obj as Record<string, RawServerShape>).map(\n      ([name, raw]) => normalizeOne(name, raw ?? {}),\n    )\n  }\n\n  throw new Error(`Unsupported MCP server config shape: ${typeof input}`)\n}\n\n/**\n * Lossy flattener — converts MCP `CallToolResult.content` blocks to a single\n * string. Text blocks are extracted; non-text blocks are JSON-stringified.\n *\n * Use this only at UI / log boundaries that require a string. The agent\n * loop itself routes through {@link normalizeMcpBlocks} so image blocks\n * survive into provider-native tool_result content (Anthropic blocks,\n * OpenAI companion-user-message).\n */\nexport function resultToString(content: unknown): string {\n  if (!content || !Array.isArray(content))\n    return ''\n  return content\n    .map((block) => {\n      if (block && typeof block === 'object' && (block as { type?: unknown }).type === 'text') {\n        const text = (block as { text?: unknown }).text\n        if (typeof text === 'string')\n          return text\n      }\n      return JSON.stringify(block)\n    })\n    .join('\\n')\n}\n\n/**\n * Normalize MCP `CallToolResult.content` to zidane's {@link ToolResultContent[]} shape.\n *\n * Handles the four MCP content block types:\n * - `text` → preserved as `{type:'text', text}`\n * - `image` → preserved as `{type:'image', mediaType, data}` (MCP uses `mimeType`)\n * - `resource` with embedded text → flattened to a text block\n * - `resource` with embedded blob whose `mimeType` is `image/*` → flattened to an image block\n * - Any unrecognized block → JSON-stringified fallback text block (lossy but safe)\n *\n * Returns `null` when the input is not an array — callers should fall back to an empty\n * result in that case.\n */\nexport function normalizeMcpBlocks(content: unknown): ToolResultContent[] | null {\n  if (!Array.isArray(content))\n    return null\n\n  const out: ToolResultContent[] = []\n  for (const raw of content) {\n    if (!raw || typeof raw !== 'object')\n      continue\n    const block = raw as Record<string, unknown>\n\n    if (block.type === 'text' && typeof block.text === 'string') {\n      out.push({ type: 'text', text: block.text })\n      continue\n    }\n\n    if (block.type === 'image' && typeof block.data === 'string') {\n      const declared = typeof block.mimeType === 'string'\n        ? block.mimeType\n        : (typeof block.mediaType === 'string' ? block.mediaType : 'image/png')\n      // Anthropic rejects the request when `media_type` disagrees with the\n      // magic bytes. Some MCP servers (browser/screenshot bridges) declare\n      // `image/webp` while actually serving JPEG; reconcile here so the\n      // wrong label never reaches the provider.\n      const mediaType = reconcileImageMediaType(declared, block.data)\n      out.push({ type: 'image', mediaType, data: block.data })\n      continue\n    }\n\n    if (block.type === 'resource' && block.resource && typeof block.resource === 'object') {\n      const res = block.resource as Record<string, unknown>\n      if (typeof res.text === 'string') {\n        out.push({ type: 'text', text: res.text })\n        continue\n      }\n      if (typeof res.blob === 'string' && typeof res.mimeType === 'string' && res.mimeType.startsWith('image/')) {\n        const mediaType = reconcileImageMediaType(res.mimeType, res.blob)\n        out.push({ type: 'image', mediaType, data: res.blob })\n        continue\n      }\n    }\n\n    // Audio, resource_link, and unknown block shapes — fall back to a JSON-stringified\n    // text block. Lossy but keeps the information addressable by the model.\n    out.push({ type: 'text', text: JSON.stringify(block) })\n  }\n\n  return out\n}\n\n/**\n * Route the MCP result content through the narrowest appropriate zidane shape:\n *\n * - All blocks are `text` → return a joined string (smaller wire payload,\n *   string-friendly for hook consumers that don't need structured access).\n * - Any block is non-text → return a structured `ToolResultContent[]`.\n * - Empty / non-array input → return `''`.\n */\nfunction packMcpResult(content: unknown): string | ToolResultContent[] {\n  const normalized = normalizeMcpBlocks(content)\n  if (!normalized || normalized.length === 0)\n    return ''\n\n  // Single pass: build the joined string as we go. Bail to the structured array\n  // the moment we hit a non-text block.\n  const parts: string[] = []\n  for (const block of normalized) {\n    if (block.type !== 'text')\n      return normalized\n    parts.push(block.text)\n  }\n  return parts.join('\\n')\n}\n\n/**\n * Create the appropriate MCP transport for a server config.\n *\n * For stdio: when `config.env` is provided, it is merged on top of the MCP SDK's\n * `getDefaultEnvironment()` whitelist (`PATH`, `HOME`, `LANG`, `SHELL`, `USER` on\n * POSIX; `APPDATA`, `PATH`, ... on Win32). Without this defensive merge, older\n * MCP SDK versions strip `PATH` the moment a consumer sets any env, breaking\n * `spawn('node', ...)` with ENOENT. Pass `strictEnv: true` to opt out and send\n * `env` verbatim.\n *\n * `config.cwd` is forwarded to `StdioClientTransport` (→ `spawn`'s `cwd`).\n * Without this, the child inherits the agent's cwd, breaking servers that\n * resolve paths relative to their own working directory (e.g. project-root\n * MCPs reading `<root>/supabase/functions/...`).\n */\nasync function createTransport(\n  config: McpServerConfig,\n  authProvider?: OAuthClientProvider,\n  hooks?: Hookable<AgentHooks>,\n) {\n  switch (config.transport) {\n    case 'stdio': {\n      // Routed through `./stdio-loader.ts` so the SDK's stdio transport\n      // lives in zidane's static module graph at build time. That lets the\n      // `cross-spawn` → shim alias in `tsdown.config.ts` fire and removes\n      // the bare `require('child_process')` from the chunk that downstream\n      // consumers re-bundle. See `./stdio-loader.ts` for the full story.\n      const { StdioClientTransport, getDefaultEnvironment } = await import('./stdio-loader')\n      const mergedEnv = config.env && !config.strictEnv\n        ? { ...getDefaultEnvironment(), ...config.env }\n        : config.env\n      const transport = new StdioClientTransport({\n        command: config.command!,\n        args: config.args,\n        env: mergedEnv,\n        // By default `inherit` prints stdio from server into TUI framebuffer\n        // and breaks UI, we'll pipe output to `mcp:warn` hook\n        stderr: 'pipe',\n        ...(config.cwd ? { cwd: config.cwd } : {}),\n      })\n      attachStderrWarnPump(transport, config.name, hooks)\n      return transport\n    }\n    case 'sse': {\n      const { SSEClientTransport } = await import('@modelcontextprotocol/sdk/client/sse.js')\n      return new SSEClientTransport(new URL(config.url!), {\n        requestInit: config.headers ? { headers: config.headers } : undefined,\n        authProvider,\n      })\n    }\n    case 'streamable-http': {\n      // `fetch: sseToJsonFetchIfNeeded()` works around a Bun + MCP SDK\n      // 1.29.x bug where `text/event-stream` POST responses are buffered\n      // correctly but never surface to `onmessage`, dead-locking bootstrap.\n      // The helper returns the wrapper only on Bun and `undefined` on Node\n      // (so the SDK's streaming pipeline stays intact where it works).\n      // See ./sse-to-json-fetch.ts.\n      const { StreamableHTTPClientTransport } = await import('@modelcontextprotocol/sdk/client/streamableHttp.js')\n      return new StreamableHTTPClientTransport(new URL(config.url!), {\n        requestInit: config.headers ? { headers: config.headers } : undefined,\n        fetch: sseToJsonFetchIfNeeded(),\n        authProvider,\n      })\n    }\n    default:\n      throw new Error(`Unknown MCP transport: ${config.transport}`)\n  }\n}\n\n/**\n * Split a stdio-transport child's stderr into lines and surface them via `mcp:warn`.\n */\nconst MAX_MCP_STDERR_LINE_CHARS = 64 * 1024\n\nexport function attachStderrWarnPump(\n  // Structural: SDK types `stderr` as Node's generic `Stream`, but at runtime\n  // it's a `Readable`. Loose-typed listener so this matches the SDK shape.\n  transport: { stderr?: { on: (event: string, listener: (...args: unknown[]) => void) => unknown } | null },\n  serverName: string,\n  hooks: Hookable<AgentHooks> | undefined,\n): void {\n  const stream = transport.stderr\n  if (!stream)\n    return\n  let buffer = ''\n  const emitLine = (line: string): void => {\n    const trimmed = line.replace(/\\r$/, '').trim()\n    if (trimmed.length === 0)\n      return\n    // Don't await — a slow handler must not backpressure the child.\n    // Also swallow listener failures; stderr capture is diagnostic-only.\n    const pending = hooks?.callHook('mcp:warn', { name: serverName, message: trimmed })\n    void pending?.catch(() => {})\n  }\n  const flush = (): void => {\n    if (buffer.length === 0)\n      return\n    emitLine(buffer)\n    buffer = ''\n  }\n  // Must consume — leaving the stream unread hangs the child once the\n  // OS pipe (~64 KiB) fills.\n  stream.on('data', (chunk: unknown) => {\n    // Node stream `data` events deliver Buffer | string (non-objectMode).\n    buffer += typeof chunk === 'string' ? chunk : (chunk as Buffer).toString('utf8')\n    let nl = buffer.indexOf('\\n')\n    while (nl !== -1) {\n      const line = buffer.slice(0, nl)\n      buffer = buffer.slice(nl + 1)\n      emitLine(line)\n      nl = buffer.indexOf('\\n')\n    }\n    while (buffer.length >= MAX_MCP_STDERR_LINE_CHARS) {\n      emitLine(buffer.slice(0, MAX_MCP_STDERR_LINE_CHARS))\n      buffer = buffer.slice(MAX_MCP_STDERR_LINE_CHARS)\n    }\n  })\n  // Connection liveness flows through the SDK's own onclose/onerror → `mcp:error`.\n  stream.on('end', flush)\n  stream.on('close', flush)\n  stream.on('error', flush)\n}\n\n/**\n * True when an error from `client.connect()` indicates the user needs to\n * (re-)authenticate against the MCP server. Two signal families:\n *\n *   1. **SDK-formal** — the MCP SDK confirmed the resource is OAuth-protected\n *      (RFC 9728 metadata advertised) and threw `UnauthorizedError`. Detected\n *      by class name + \"Unauthorized\" message prefix, since the SDK's\n *      `UnauthorizedError` class isn't a stable export across versions.\n *\n *   2. **Raw HTTP 401 with token-rejection signal** — some real-world servers\n *      (Linear is one) skip the RFC 9728 dance and just return `HTTP 401`\n *      with an OAuth-style JSON body (`{\"error\":\"invalid_token\"}` /\n *      `\"invalid_grant\"` / `\"insufficient_scope\"`). The MCP SDK wraps that\n *      into `\"Error POSTing to endpoint (HTTP 401): { ... }\"`. Without\n *      promotion, a stale Linear token reads as a generic `mcp:error`\n *      bootstrap failure instead of \"needs login\" — the user gets a noisy\n *      red banner instead of a re-login affordance.\n *\n * Promotion to the skip+auth-required path is still gated on\n * `explicitAuth || eligibleAutoPromote` in the caller, so a server that\n * legitimately requires a static `Authorization: Bearer …` header (no\n * `auth: 'oauth'` flag, host-provided header) won't be mis-promoted into\n * a doomed OAuth flow.\n */\nfunction isUnauthorizedError(err: unknown): boolean {\n  if (!err || typeof err !== 'object')\n    return false\n  const e = err as { name?: string, message?: string, constructor?: { name?: string } }\n  if (e.name === 'UnauthorizedError' || e.constructor?.name === 'UnauthorizedError')\n    return true\n  const message = typeof e.message === 'string' ? e.message : ''\n  if (message.toLowerCase().startsWith('unauthorized'))\n    return true\n  // Raw HTTP 401 with an OAuth-style token-rejection body — the\n  // streamable-http transport surfaces these as `Error POSTing to endpoint\n  // (HTTP 401): {\"error\":\"invalid_token\",\"error_description\":\"…\"}`.\n  if (/\\bHTTP\\s*401\\b/i.test(message) || /\\b\\(401\\)/.test(message)) {\n    if (/\"error\"\\s*:\\s*\"(?:invalid_token|invalid_grant|insufficient_scope|invalid_client)\"/i.test(message))\n      return true\n  }\n  return false\n}\n\n/**\n * Optional knobs threaded into per-server bootstrap. Reserved for runtime\n * concerns the agent shell injects (credential storage, OAuth providers);\n * the `McpServerConfig` shape stays pure data.\n */\nexport interface ConnectMcpServersOptions {\n  /**\n   * Build a non-interactive `OAuthClientProvider` for a given server. Called\n   * lazily — only invoked when the bootstrap actually needs auth (explicit\n   * `auth: 'oauth'` flag, or a UnauthorizedError that meets the auto-detect\n   * criteria). Return `undefined` to opt this server out of OAuth even if it\n   * was requested (e.g. the host doesn't have a credential store for it).\n   *\n   * \"Non-interactive\" — the provider must NOT trigger a browser flow during\n   * bootstrap. Use a `redirectUri` of `undefined` so the SDK reads stored\n   * tokens, refreshes on expiry, and throws `UnauthorizedError` if tokens\n   * are missing or refresh fails. The host then surfaces an\n   * `mcp:auth:required` event so the user can opt in to interactive login.\n   */\n  buildAuthProvider?: (config: McpServerConfig) => OAuthClientProvider | undefined\n}\n\n/**\n * Internal: shape received by the `_clientFactory` test-injection seam.\n * Mirrors the subset of `TolerantClientOptions` the bootstrap path forwards\n * so a mock client can opt into the same lifecycle wiring (warning sink,\n * future seams) instead of silently bypassing it.\n */\ninterface McpClientFactoryOptions {\n  /** See `TolerantClientOptions.onWarning`. */\n  onWarning?: (message: string) => void\n}\n\ntype McpClientFactory = (opts?: McpClientFactoryOptions) => Client\n\n/**\n * Connect to MCP servers and discover their tools.\n *\n * Each tool is namespaced as `mcp_{serverName}_{toolName}` to avoid\n * collisions with agent tools or tools from other servers.\n *\n * @param configs - Array of MCP server configurations\n * @param _clientFactory - Internal: override client construction for testing\n * @param hooks - Optional agent hooks for firing mcp:connect, mcp:error, mcp:close events\n * @param options - Optional bootstrap knobs (e.g. OAuth provider injection)\n */\nexport async function connectMcpServers(\n  configs: McpServerConfig[],\n  _clientFactory?: McpClientFactory,\n  hooks?: Hookable<AgentHooks>,\n  options?: ConnectMcpServersOptions,\n): Promise<McpConnection> {\n  // Per-server cleanup closure. Eager entries always have a live client; lazy\n  // entries may or may not have connected — `closeIfConnected` short-circuits\n  // when nothing was opened, and awaits any in-flight connect to avoid\n  // leaking the resulting client past `close()`.\n  const connections: { name: string, closeIfConnected: () => Promise<void> }[] = []\n  const tools: Record<string, ToolDef> = {}\n  // Insertion-ordered (config order) so the rendered system-prompt section is\n  // byte-stable across runs. Only populated from eager-connect successes;\n  // `lazyConnect: true` servers do NOT contribute here because pulling their\n  // instructions would force the connection the host asked to defer.\n  const instructions = new Map<string, string>()\n  const errors: { name: string, error: Error }[] = []\n  let closed = false\n\n  // Bootstrap every server in parallel. Previously this was a sequential for-loop,\n  // which meant a single slow server (GitHub MCP, cold streamable-http endpoints,\n  // anything on a flaky network) blocked the whole first `agent.run()` for up to\n  // N × bootstrapTimeout.\n  //\n  // `Promise.allSettled` (not `Promise.all`) is the final safety net for the\n  // partial-failure tolerance: `bootstrapServer` already internalises every\n  // expected throw, but a future regression (or a misbehaving hook that\n  // sneaks past `safeCallHook`) would otherwise reject the whole batch and\n  // wipe out every other server's connection. Converting a rejection back\n  // into an `{ ok: false }` result keeps the batch alive.\n  const settled = await Promise.allSettled(configs.map(config => bootstrapServer(config, _clientFactory, hooks, options)))\n  const bootstrapResults: BootstrapResult[] = settled.map((result, idx) => {\n    if (result.status === 'fulfilled')\n      return result.value\n    const error = result.reason instanceof Error ? result.reason : new Error(String(result.reason))\n    return { ok: false, name: configs[idx]!.name, error }\n  })\n\n  for (const result of bootstrapResults) {\n    if (result.skipped) {\n      // Auth required but no tokens — already emitted `mcp:auth:required`.\n      // Bootstrap continues with the other servers; the user opts in via\n      // the host's interactive login path (`loginMcpServer`).\n      continue\n    }\n    if (!result.ok) {\n      errors.push({ name: result.name, error: result.error })\n      await safeCallHook(hooks, 'mcp:error', { name: result.name, error: result.error })\n      continue\n    }\n\n    const toolNames: string[] = result.tools.map(t => `mcp_${result.config.name}_${t.name}`)\n    // Build a per-server `getClient` resolver before assembling the tool\n    // defs. Lazy servers wrap it with a one-shot `mcp:connect` emitter so\n    // the hook fires on the first successful connect (concurrent first\n    // calls converge on the same connector — the wrapper guards against\n    // double-fires). Eager servers fire `mcp:connect` synchronously below.\n    const getClient = result.lazy\n      ? wrapConnectWithHookFire(\n          () => result.handle.connect(),\n          onceFireConnect(result.name, result.config.transport, toolNames, hooks),\n        )\n      : (() => {\n          const client = result.client\n          return () => Promise.resolve(client)\n        })()\n\n    for (let i = 0; i < result.tools.length; i++) {\n      tools[toolNames[i]!] = buildMcpToolDef(result.config, getClient, result.tools[i]!, toolNames[i]!, hooks)\n    }\n\n    if (result.lazy) {\n      // No `mcp:connect` here — fires on first call via the wrapper above.\n      const handle = result.handle\n      const name = result.name\n      connections.push({\n        name,\n        closeIfConnected: async () => {\n          // Probe lazy state BEFORE emitting `mcp:close` so a server that\n          // was never used produces no close-noise. The handle's\n          // `closeIfConnected` is a no-op when nothing was started; we\n          // emit the hook only when a real close is about to happen.\n          await safeCallHook(hooks, 'mcp:close', { name })\n          await handle.closeIfConnected()\n        },\n      })\n    }\n    else {\n      const eagerClient = result.client\n      connections.push({\n        name: result.name,\n        closeIfConnected: async () => {\n          await safeCallHook(hooks, 'mcp:close', { name: result.name })\n          await eagerClient.close()\n        },\n      })\n      // Eager-only — see `instructions` declaration above for the lazy\n      // exclusion rationale.\n      if (result.instructions !== undefined)\n        instructions.set(result.name, result.instructions)\n      await safeCallHook(hooks, 'mcp:connect', {\n        name: result.name,\n        transport: result.config.transport,\n        tools: toolNames,\n      })\n    }\n  }\n\n  // Total failure is tolerated the same way partial failure is — every server\n  // already fired `mcp:error` (and `mcp:bootstrap:end` with `ok: false`), so\n  // the host can render status / re-auth UI from the hook stream. Throwing\n  // here used to wedge `agent.run()` on the user's first message whenever a\n  // single misconfigured / expired-token server was the only MCP configured\n  // (e.g. Linear's stored token expired → HTTP 401 doesn't match our\n  // \"Unauthorized\" prefix check → all-failed → throw → chat shows red bubble\n  // instead of the assistant reply). Returning an empty toolset lets the\n  // run proceed with no MCP tools; the next bootstrap retries automatically\n  // (see `mcpWarmupPromise` reset in `agent.ts`).\n\n  return {\n    tools,\n    instructions,\n    close: async () => {\n      // Idempotent — double-close on `agent.destroy()` retry should not\n      // re-fire the hook or call `client.close()` twice (the stdio transport\n      // treats a second close as a no-op but some transports throw).\n      if (closed)\n        return\n      closed = true\n      await Promise.allSettled(connections.map(c => c.closeIfConnected()))\n    },\n  }\n}\n\n/**\n * Build a one-shot `mcp:connect` emitter for a lazy server. The wrapper\n * around the connector calls this on the first successful connect;\n * concurrent first calls converge on the connector's in-flight promise\n * so the hook still fires exactly once.\n */\nfunction onceFireConnect(\n  name: string,\n  transport: McpServerConfig['transport'],\n  toolNames: string[],\n  hooks: Hookable<AgentHooks> | undefined,\n): () => Promise<void> {\n  let fired = false\n  return async () => {\n    if (fired)\n      return\n    fired = true\n    await safeCallHook(hooks, 'mcp:connect', { name, transport, tools: toolNames, lazy: true })\n  }\n}\n\n/**\n * Wrap a lazy connector so the first successful resolution fires\n * `mcp:connect` exactly once. Failures don't fire the hook — the\n * connection isn't live yet and a retry will eventually run through the\n * wrapper again. Both the eager and lazy paths reach the tool builder\n * through this resolver shape so `buildMcpToolDef` stays mode-agnostic.\n */\nfunction wrapConnectWithHookFire(\n  connect: () => Promise<Client>,\n  fire: () => Promise<void>,\n): () => Promise<Client> {\n  return async () => {\n    const client = await connect()\n    await fire()\n    return client\n  }\n}\n\n/**\n * Discriminated result returned by `bootstrapServer` so `connectMcpServers` can\n * aggregate successes + failures without letting a rejected promise tear down\n * the whole parallel batch.\n *\n * `skipped` is the third state: server needs OAuth login but has no tokens.\n * Not an error (we don't want a noisy `mcp:error`), not a success (no\n * connection). Caller already heard `mcp:auth:required` and decides whether\n * to surface a status row, prompt for login, etc.\n */\n/**\n * Discriminated result returned by `bootstrapServer`. Success carries either\n * an already-connected `client` (the eager path) or a `connect` thunk that\n * builds + connects a fresh client on first call (the `lazyConnect: true`\n * path). The collector translates both into a uniform `getClient` closure\n * for the tool builder so the call-site stays branch-free.\n */\ntype BootstrapResult\n  = | { ok: true, skipped?: false, name: string, config: McpServerConfig, lazy: false, client: Client, tools: Array<{ name: string, description?: string | null, inputSchema?: unknown }>, instructions?: string }\n    | { ok: true, skipped?: false, name: string, config: McpServerConfig, lazy: true, handle: LazyConnectHandle, tools: Array<{ name: string, description?: string | null, inputSchema?: unknown }> }\n    | { ok: false, skipped?: false, name: string, error: Error }\n    | { ok: false, skipped: true, name: string }\n\n/**\n * Connect one MCP server and list its tools, wrapped in a single race against\n * `config.bootstrapTimeout` (default 10s). Always emits `mcp:bootstrap:start`\n * before network I/O and `mcp:bootstrap:end` with `durationMs` + outcome, so a\n * host can build a timing view even when every server succeeds.\n *\n * Errors are captured into the `{ ok: false }` result rather than thrown — the\n * parent uses `Promise.all` across every server and we can't let one rejection\n * short-circuit the batch.\n */\nasync function bootstrapServer(\n  config: McpServerConfig,\n  _clientFactory: McpClientFactory | undefined,\n  hooks: Hookable<AgentHooks> | undefined,\n  options: ConnectMcpServersOptions | undefined,\n): Promise<BootstrapResult> {\n  const start = Date.now()\n  // Validate mutually-exclusive filter fields up-front so the consumer gets a\n  // typed `mcp:bootstrap:end` failure rather than a silent later-stage drop.\n  if (config.enabledTools && config.disabledTools) {\n    return emitConfigFailure(\n      config,\n      hooks,\n      `MCP server \"${config.name}\": enabledTools and disabledTools are mutually exclusive — set one or the other, not both.`,\n    )\n  }\n  // Lazy connect requires schemas in hand — without them there's nothing to\n  // advertise to the model, so deferring the connection has no purpose.\n  if (config.lazyConnect && (!config.cachedTools || config.cachedTools.length === 0)) {\n    return emitConfigFailure(\n      config,\n      hooks,\n      `MCP server \"${config.name}\": lazyConnect requires cachedTools (the host must pre-populate the tool schemas so they can be advertised without a connection).`,\n    )\n  }\n  // OAuth + lazy is rejected — see `McpServerConfig.lazyConnect` for the\n  // rationale. Surfacing this at bootstrap (rather than at first-call) is\n  // load-bearing: the host needs the failure proximate to the misconfig\n  // so it can render an auth affordance before the model commits to a\n  // tool call that would fail mid-run.\n  if (config.lazyConnect && config.auth === 'oauth') {\n    return emitConfigFailure(\n      config,\n      hooks,\n      `MCP server \"${config.name}\": lazyConnect is not compatible with auth: 'oauth' — OAuth servers must complete the handshake at bootstrap so a login affordance can surface before the model commits to a tool call.`,\n    )\n  }\n\n  await safeCallHook(hooks, 'mcp:bootstrap:start', { name: config.name, transport: config.transport })\n\n  // Build an auth provider when the config asks for OAuth and the host\n  // wired a factory. Non-interactive — the SDK uses stored tokens / refresh,\n  // never opens a browser during bootstrap. Missing tokens surface as\n  // `UnauthorizedError` from `connect()`, which we convert to a skip below.\n  const explicitAuth = config.auth === 'oauth'\n  const authProvider = explicitAuth ? options?.buildAuthProvider?.(config) : undefined\n\n  // Soft warnings emitted by the tolerant client (e.g. a 4xx on\n  // `notifications/initialized`). Surfaced on the success arm of\n  // `mcp:bootstrap:end` so hosts can render a \"connected with caveats\"\n  // status instead of having to subscribe to stderr.\n  const warnings: string[] = []\n  const onWarning = (message: string) => { warnings.push(message) }\n\n  // Lazy fast-path — defer transport + connect to `getClient()`. Schemas\n  // come from `cachedTools`; the host owns invalidation. We still emit\n  // `mcp:bootstrap:end ok: true, lazy: true` so timing dashboards stay\n  // honest (the row appears, just with a near-zero `durationMs`).\n  if (config.lazyConnect) {\n    const cachedSchemas = config.cachedTools!\n    const filteredTools = await applyMcpToolFilters(config, cachedSchemas, hooks)\n    const handle = makeLazyConnector(config, _clientFactory, authProvider, hooks)\n    const durationMs = Date.now() - start\n    await safeCallHook(hooks, 'mcp:bootstrap:end', {\n      name: config.name,\n      transport: config.transport,\n      durationMs,\n      ok: true,\n      toolCount: filteredTools.length,\n      lazy: true,\n      cached: true,\n    })\n    return { ok: true, name: config.name, config, lazy: true, handle, tools: filteredTools }\n  }\n\n  let client: Client | null = null\n  let transport: ClosableTransport | null = null\n  try {\n    // TolerantMcpClient is a drop-in subclass that survives a 4xx on the\n    // `notifications/initialized` post (some real-world servers reject it\n    // without that breaking subsequent `tools/list` etc.). See\n    // ./tolerant-client.ts for the exact semantics.\n    client = _clientFactory\n      ? _clientFactory({ onWarning })\n      : await createTolerantClient({ name: 'zidane', version: '1.0.0' }, { onWarning })\n    const currentClient = client\n\n    transport = await createTransport(config, authProvider, hooks) as ClosableTransport\n    const bootstrapTimeout = config.bootstrapTimeout ?? DEFAULT_MCP_BOOTSTRAP_TIMEOUT_MS\n    // When `cachedTools` is provided we still establish the connection\n    // (the SDK needs it for `tools/call`) but skip the `tools/list`\n    // round-trip — that's the cheaper of the two networking costs on\n    // a fast server, but on a slow / chatty one it's the dominant one.\n    const cachedSchemas = config.cachedTools\n    const mcpTools = await raceWithTimeout(\n      async () => {\n        await currentClient.connect(transport as Parameters<Client['connect']>[0])\n        return cachedSchemas ?? (await currentClient.listTools()).tools\n      },\n      bootstrapTimeout,\n      `MCP server \"${config.name}\" bootstrap timed out after ${bootstrapTimeout}ms (configurable via \\`bootstrapTimeout\\`).`,\n    )\n\n    // Expose the raw, pre-filter tool list to hosts so a settings UI or\n    // a tool-catalog persistence layer can capture every advertised\n    // tool — including ones the config's `disabledTools` / `toolFilter`\n    // is about to drop. Read-only; mutation goes through\n    // `mcp:tools:filter` below. See AgentHooks['mcp:tools:list'] doc.\n    await safeCallHook(hooks, 'mcp:tools:list', {\n      name: config.name,\n      transport: config.transport,\n      tools: mcpTools as McpToolSchema[],\n    })\n\n    // Per-tool filtering — config-side first (static host policy), then the\n    // `mcp:tools:filter` hook (runtime / dynamic decisions). Both compose AND-\n    // style: a tool needs to pass every stage to land in the agent registry.\n    const filteredTools = await applyMcpToolFilters(config, mcpTools, hooks)\n\n    // Capture the server-issued `instructions` from the initialize handshake.\n    // The SDK stored them on the client during `connect()` (see\n    // `tolerant-client.ts`); the public `getInstructions()` returns the\n    // string or `undefined`. We trim + nullable-coerce here so the agent's\n    // system-prompt builder gets one normalized shape, and a server that\n    // sends `\"\"` (empty string) is treated identically to \"no instructions\"\n    // rather than emitting a section with an empty body.\n    //\n    // Defensive: older `_clientFactory` test mocks don't implement\n    // `getInstructions` (the method was added to the SDK after the mocks\n    // were written). Guard so an unknown function shape degrades to\n    // \"no instructions\" instead of crashing bootstrap.\n    let rawInstructions: unknown\n    if (typeof (currentClient as { getInstructions?: unknown }).getInstructions === 'function') {\n      try {\n        rawInstructions = (currentClient as { getInstructions: () => unknown }).getInstructions()\n      }\n      catch {\n        rawInstructions = undefined\n      }\n    }\n    const instructions = typeof rawInstructions === 'string' && rawInstructions.trim().length > 0\n      ? rawInstructions\n      : undefined\n\n    const durationMs = Date.now() - start\n    await safeCallHook(hooks, 'mcp:bootstrap:end', {\n      name: config.name,\n      transport: config.transport,\n      durationMs,\n      ok: true,\n      toolCount: filteredTools.length,\n      ...(cachedSchemas ? { cached: true } : {}),\n      ...(warnings.length > 0 ? { warnings } : {}),\n    })\n    return {\n      ok: true,\n      name: config.name,\n      config,\n      lazy: false,\n      client: currentClient,\n      tools: filteredTools,\n      ...(instructions !== undefined ? { instructions } : {}),\n    }\n  }\n  catch (err) {\n    // Close in order: transport first (may not yet be wired into the\n    // client when connect() hadn't completed), then client (close()\n    // is a no-op on transports that already closed).\n    await closeTransportQuietly(transport)\n    await closeClientQuietly(client)\n    const rawError = err instanceof Error ? err : new Error(String(err))\n    const error = withTransportMismatchHint(config.transport, rawError)\n    const durationMs = Date.now() - start\n\n    // OAuth path — convert \"needs login\" into a skip instead of an error.\n    // Two cases reach here:\n    //   1. Explicit `auth: 'oauth'` with no stored tokens (provider built,\n    //      SDK threw UnauthorizedError when none could be refreshed).\n    //   2. No auth flag, but the server returned 401 + RFC 9728 metadata\n    //      AND the user did not provide a static Authorization header\n    //      (the headers escape hatch — see McpServerConfig.auth docs).\n    //      The auto-promote path requires `buildAuthProvider` so the host\n    //      can complete the login. Without it, this falls through as a\n    //      regular bootstrap error.\n    if (isUnauthorizedError(err)) {\n      const eligibleAutoPromote = !explicitAuth\n        && !hasAuthorizationHeader(config.headers)\n        && !!options?.buildAuthProvider\n      if (explicitAuth || eligibleAutoPromote) {\n        await safeCallHook(hooks, 'mcp:bootstrap:end', {\n          name: config.name,\n          transport: config.transport,\n          durationMs,\n          ok: false,\n          error,\n        })\n        await safeCallHook(hooks, 'mcp:auth:required', {\n          name: config.name,\n          transport: config.transport,\n          reason: explicitAuth ? 'no-tokens' : 'auto-promoted',\n        })\n        return { ok: false, skipped: true, name: config.name }\n      }\n    }\n\n    await safeCallHook(hooks, 'mcp:bootstrap:end', {\n      name: config.name,\n      transport: config.transport,\n      durationMs,\n      ok: false,\n      error,\n    })\n    return { ok: false, name: config.name, error }\n  }\n}\n\n/**\n * Emit the start/end hooks for a config-level failure and return the error\n * result. Centralised so the various validation branches (enabled/disabled\n * mutex, lazyConnect-without-cachedTools, lazyConnect+OAuth) stay readable.\n */\nasync function emitConfigFailure(\n  config: McpServerConfig,\n  hooks: Hookable<AgentHooks> | undefined,\n  message: string,\n): Promise<BootstrapResult> {\n  const error = new Error(message)\n  await safeCallHook(hooks, 'mcp:bootstrap:start', { name: config.name, transport: config.transport })\n  await safeCallHook(hooks, 'mcp:bootstrap:end', {\n    name: config.name,\n    transport: config.transport,\n    durationMs: 0,\n    ok: false,\n    error,\n  })\n  return { ok: false, name: config.name, error }\n}\n\n/**\n * Per-server lazy bootstrap handle returned by {@link makeLazyConnector}.\n *\n * - `connect()` triggers (or reuses the in-flight) transport build +\n *   `client.connect()`. Concurrent callers converge on a single promise;\n *   a rejection drops the cached promise so the next call retries.\n * - `closeIfConnected()` closes the live client when one exists and\n *   short-circuits when the server was never used. Always awaits a\n *   pending connect first so a `destroy()` racing with a first\n *   `tools/call` cannot leak the freshly-built client.\n */\ninterface LazyConnectHandle {\n  connect: () => Promise<Client>\n  closeIfConnected: () => Promise<void>\n}\n\n/**\n * Build a memoized lazy connector + matching close handle for a\n * `lazyConnect: true` server. State lives in the closure: the connector\n * tracks its own in-flight and resolved-client state so the close path\n * can reason about \"never connected\" vs \"in flight\" vs \"live\" without\n * forcing a connect from inside `close()`.\n *\n * Concurrency contract:\n *   - First `connect()` builds + connects a fresh client. Concurrent\n *     callers converge on the same in-flight promise.\n *   - On rejection, the cached promise is dropped so the next caller\n *     retries with a fresh client instance.\n *   - `closeIfConnected()` awaits any pending connect, closes the\n *     resulting client, and marks the handle destroyed. Any subsequent\n *     `connect()` rejects synchronously so a tool call racing the\n *     shutdown can't leak a freshly-built client past the close.\n */\nfunction makeLazyConnector(\n  config: McpServerConfig,\n  _clientFactory: McpClientFactory | undefined,\n  authProvider: OAuthClientProvider | undefined,\n  hooks: Hookable<AgentHooks> | undefined,\n): LazyConnectHandle {\n  let inFlight: Promise<Client> | null = null\n  let live: Client | null = null\n  let destroyed = false\n\n  const connect = (): Promise<Client> => {\n    if (destroyed) {\n      return Promise.reject(new Error(\n        `MCP server \"${config.name}\": cannot connect after close()`,\n      ))\n    }\n    if (live)\n      return Promise.resolve(live)\n    if (inFlight)\n      return inFlight\n    const pending = (async () => {\n      // Match the eager path's timeout — a lazy connect that hangs\n      // would wedge a tool call indefinitely without it.\n      const bootstrapTimeout = config.bootstrapTimeout ?? DEFAULT_MCP_BOOTSTRAP_TIMEOUT_MS\n      const client = _clientFactory\n        ? _clientFactory()\n        : await createTolerantClient({ name: 'zidane', version: '1.0.0' })\n      let transport: ClosableTransport | null = null\n      try {\n        transport = await createTransport(config, authProvider, hooks) as ClosableTransport\n        await raceWithTimeout(\n          () => client.connect(transport as Parameters<Client['connect']>[0]),\n          bootstrapTimeout,\n          `MCP server \"${config.name}\" lazy connect timed out after ${bootstrapTimeout}ms (configurable via \\`bootstrapTimeout\\`).`,\n        )\n        // Shutdown ran while we were connecting — close the freshly\n        // built client right here so it doesn't leak past destroy().\n        if (destroyed) {\n          await closeTransportQuietly(transport)\n          await closeClientQuietly(client)\n          throw new Error(`MCP server \"${config.name}\": closed during connect`)\n        }\n        live = client\n        return client\n      }\n      catch (err) {\n        // Close in order: transport first (may not be wired into the\n        // client yet on a connect failure), then client.\n        await closeTransportQuietly(transport)\n        await closeClientQuietly(client)\n        throw err instanceof Error\n          ? withTransportMismatchHint(config.transport, err)\n          : err\n      }\n    })()\n    inFlight = pending\n    // Clear the in-flight cache on either outcome — success leaves the\n    // resolved client cached on `live`; failure drops the slot so the\n    // next caller retries against a fresh client instance, matching the\n    // bootstrap-level retry behavior in `agent.ts`'s `mcpWarmupPromise`.\n    pending.then(\n      () => { inFlight = null },\n      () => { inFlight = null },\n    )\n    return pending\n  }\n\n  const closeIfConnected = async (): Promise<void> => {\n    destroyed = true\n    // Race-safe drain: if a connect is in flight, wait for it to settle\n    // before deciding whether to close. Successful resolution promotes\n    // the client to `live`; failure leaves both `live` and `inFlight`\n    // null. Either way, after the await the state is terminal and the\n    // close decision is unambiguous.\n    if (inFlight) {\n      try { await inFlight }\n      catch { /* connect failed; nothing to close */ }\n    }\n    if (live) {\n      const client = live\n      live = null\n      await client.close()\n    }\n  }\n\n  return { connect, closeIfConnected }\n}\n\n/**\n * Apply config-side filters (`enabledTools` / `disabledTools` / `toolFilter`)\n * and then the `mcp:tools:filter` hook to the upstream tool list.\n *\n * Composition order — narrowest-to-widest:\n * 1. Allow-list (`enabledTools`) — keep only listed tools.\n * 2. Deny-list (`disabledTools`) — drop listed tools.\n * 3. Predicate (`toolFilter`) — fine-grained metadata filtering.\n * 4. Hook (`mcp:tools:filter`) — runtime / per-host decisions.\n *\n * The mutual exclusion of `enabledTools` and `disabledTools` is checked in\n * `bootstrapServer` so this stays a pure data transform.\n */\nasync function applyMcpToolFilters(\n  config: McpServerConfig,\n  tools: Array<{ name: string, description?: string | null, inputSchema?: unknown }>,\n  hooks: Hookable<AgentHooks> | undefined,\n): Promise<Array<{ name: string, description?: string | null, inputSchema?: unknown }>> {\n  let filtered = tools\n\n  if (config.enabledTools && config.enabledTools.length > 0) {\n    const allow = new Set(config.enabledTools)\n    filtered = filtered.filter(t => allow.has(t.name))\n  }\n\n  if (config.disabledTools && config.disabledTools.length > 0) {\n    const deny = new Set(config.disabledTools)\n    filtered = filtered.filter(t => !deny.has(t.name))\n  }\n\n  if (config.toolFilter) {\n    const predicate = config.toolFilter\n    filtered = filtered.filter(t => predicate(t))\n  }\n\n  if (hooks) {\n    // Pass a fresh array so handlers cannot retroactively mutate the caller's\n    // upstream list; mutations they make to `ctx.tools` are scoped to this turn.\n    const ctx = { server: config.name, transport: config.transport, tools: [...filtered] }\n    await hooks.callHook('mcp:tools:filter', ctx)\n    filtered = ctx.tools\n  }\n\n  return filtered\n}\n\n/**\n * Build the zidane `ToolDef` that wraps a single MCP tool. Extracted so the\n * parallel bootstrap path can assemble tools from a results array without\n * inlining a 70-line closure inside the collector loop.\n *\n * `getClient` resolves to a live `Client` ready for `tools/call`. For\n * eagerly-bootstrapped servers it's a constant resolved promise; for\n * `lazyConnect: true` servers it's the memoized connector built by\n * {@link makeLazyConnector} — the first invocation pays the connect cost,\n * concurrent / subsequent calls observe the cached client. Reconnects /\n * swap-outs go through a fresh `connectMcpServers` call rather than\n * rewiring the tool in place.\n */\nfunction buildMcpToolDef(\n  config: McpServerConfig,\n  getClient: () => Promise<Client>,\n  tool: { name: string, description?: string | null, inputSchema?: unknown },\n  namespacedName: string,\n  hooks: Hookable<AgentHooks> | undefined,\n): ToolDef {\n  return {\n    spec: {\n      name: namespacedName,\n      description: tool.description || '',\n      inputSchema: (tool.inputSchema ?? { type: 'object', properties: {} }) as Record<string, unknown>,\n    },\n    execute: async (input: Record<string, unknown>, ctx: ToolContext) => {\n      const { turnId, callId, signal } = ctx\n      const displayName = ctx.toolAliases?.[namespacedName] ?? namespacedName\n\n      // Shared identity fields for every `mcp:tool:*` hook ctx the\n      // wrapper fires. Mirrors `runId / parentRunId / depth` from the\n      // tool context so subagent observability stays consistent\n      // between `tool:*` and `mcp:tool:*` events.\n      const identity = {\n        ...(ctx.runId !== undefined ? { runId: ctx.runId } : {}),\n        ...(ctx.parentRunId !== undefined ? { parentRunId: ctx.parentRunId } : {}),\n        ...(typeof ctx.depth === 'number' ? { depth: ctx.depth } : {}),\n      }\n\n      // Gate — block MCP tool execution or substitute a synthetic result.\n      const gateCtx: McpToolHookContext & {\n        block: boolean\n        reason: string\n        result?: string | ToolResultContent[]\n      } = {\n        turnId,\n        callId,\n        server: config.name,\n        tool: tool.name,\n        displayName,\n        input,\n        ...identity,\n        block: false,\n        reason: 'MCP tool execution was blocked',\n      }\n      await hooks?.callHook('mcp:tool:gate', gateCtx)\n\n      // Conflict resolution mirrors the loop's `tool:gate`: when both `block`\n      // and `result` are set (e.g. a policy gate refuses on top of a consumer\n      // cache substitute), `block` wins.\n      if (gateCtx.block)\n        return `Blocked: ${gateCtx.reason}`\n\n      const effectiveInput = gateCtx.input\n\n      // MCP gate `result` substitute — skip the upstream callTool, fire the\n      // transform + after hooks so consumers see the substitute consistently\n      // with normally-executed calls.\n      if (gateCtx.result !== undefined) {\n        let substitute: string | ToolResultContent[] = gateCtx.result\n        const transformCtx = {\n          turnId,\n          callId,\n          server: config.name,\n          tool: tool.name,\n          displayName,\n          input: effectiveInput,\n          ...identity,\n          result: substitute,\n          outputBytes: toolOutputByteLength(substitute),\n        }\n        await hooks?.callHook('mcp:tool:transform', transformCtx)\n        substitute = transformCtx.result\n        await hooks?.callHook('mcp:tool:after', {\n          turnId,\n          callId,\n          server: config.name,\n          tool: tool.name,\n          displayName,\n          input: effectiveInput,\n          ...identity,\n          result: substitute,\n          outputBytes: toolOutputByteLength(substitute),\n        })\n        return substitute\n      }\n      await hooks?.callHook('mcp:tool:before', {\n        turnId,\n        callId,\n        server: config.name,\n        tool: tool.name,\n        displayName,\n        input: effectiveInput,\n        ...identity,\n      })\n      const timeout = config.toolTimeout ?? 30_000\n      try {\n        // Resolve the live client. For eager servers this is a no-op\n        // (constant resolved promise); for `lazyConnect: true` servers\n        // this triggers the deferred connect on first call and reuses\n        // the cached client afterward.\n        const client = await getClient()\n        // Race the call against the configured timeout AND the run-level\n        // abort signal. Aborting the run has to propagate into MCP calls\n        // — otherwise a hung stdio server keeps the tool call alive\n        // until `destroy()` eventually closes the client, which can be\n        // minutes if the agent is waiting on `waitForIdle()`.\n        const result = await raceWithTimeoutAndSignal(\n          () => client.callTool({ name: tool.name, arguments: effectiveInput }),\n          timeout,\n          `MCP tool \"${tool.name}\" on server \"${config.name}\" timed out after ${timeout}ms`,\n          signal,\n        )\n        let output: string | ToolResultContent[] = packMcpResult(result.content)\n\n        // Transform — mutate result before returning. `outputBytes` reflects\n        // the size before any consumer mutation so a truncation hook can size-budget.\n        const transformCtx = {\n          turnId,\n          callId,\n          server: config.name,\n          tool: tool.name,\n          displayName,\n          input: effectiveInput,\n          ...identity,\n          result: output,\n          outputBytes: toolOutputByteLength(output),\n        }\n        await hooks?.callHook('mcp:tool:transform', transformCtx)\n        output = transformCtx.result\n\n        await hooks?.callHook('mcp:tool:after', {\n          turnId,\n          callId,\n          server: config.name,\n          tool: tool.name,\n          displayName,\n          input: effectiveInput,\n          ...identity,\n          result: output,\n          outputBytes: toolOutputByteLength(output),\n        })\n        return output\n      }\n      catch (err) {\n        const error = err instanceof Error ? err : new Error(String(err))\n        await hooks?.callHook('mcp:tool:error', {\n          turnId,\n          callId,\n          server: config.name,\n          tool: tool.name,\n          displayName,\n          input: effectiveInput,\n          ...identity,\n          error,\n        })\n        await hooks?.callHook('mcp:tool:after', {\n          turnId,\n          callId,\n          server: config.name,\n          tool: tool.name,\n          displayName,\n          input: effectiveInput,\n          ...identity,\n          result: error.message,\n          outputBytes: Buffer.byteLength(error.message),\n        })\n        throw error\n      }\n    },\n  }\n}\n\nasync function closeClientQuietly(client: Pick<Client, 'close'> | null | undefined): Promise<void> {\n  if (!client)\n    return\n  try {\n    await client.close()\n  }\n  catch {\n    // Best-effort cleanup — original bootstrap error is more actionable.\n  }\n}\n\nasync function raceWithTimeout<T>(\n  task: () => Promise<T>,\n  timeoutMs: number,\n  timeoutMessage: string,\n): Promise<T> {\n  let timer: ReturnType<typeof setTimeout> | undefined\n  try {\n    return await new Promise<T>((resolvePromise, rejectPromise) => {\n      timer = setTimeout(() => rejectPromise(new Error(timeoutMessage)), timeoutMs)\n      task().then(resolvePromise, rejectPromise)\n    })\n  }\n  finally {\n    if (timer)\n      clearTimeout(timer)\n  }\n}\n\n/**\n * Race a promise-returning task against (a) a timeout and (b) an optional\n * abort signal. Cleans up its timer and abort listener on every exit path.\n *\n * The task itself isn't cancellable (the MCP SDK doesn't take a signal), so\n * the rejection unblocks the tool call while the underlying RPC completes in\n * the background. When the agent subsequently calls `connection.close()` the\n * stdio transport kills the subprocess, which clears any stuck in-flight work.\n */\nasync function raceWithTimeoutAndSignal<T>(\n  task: () => Promise<T>,\n  timeoutMs: number,\n  timeoutMessage: string,\n  signal: AbortSignal | undefined,\n): Promise<T> {\n  if (signal?.aborted)\n    throw new Error('MCP tool call aborted')\n\n  let timer: ReturnType<typeof setTimeout> | undefined\n  let onAbort: (() => void) | undefined\n  try {\n    return await new Promise<T>((resolvePromise, rejectPromise) => {\n      timer = setTimeout(() => rejectPromise(new Error(timeoutMessage)), timeoutMs)\n      if (signal) {\n        onAbort = () => rejectPromise(new Error('MCP tool call aborted'))\n        signal.addEventListener('abort', onAbort, { once: true })\n      }\n      task().then(resolvePromise, rejectPromise)\n    })\n  }\n  finally {\n    if (timer)\n      clearTimeout(timer)\n    if (signal && onAbort)\n      signal.removeEventListener('abort', onAbort)\n  }\n}\n"],"mappings":"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"}