zidane 5.6.11 → 5.6.13

package/dist/mcp-0jRkIV0g.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mcp-0jRkIV0g.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 { 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  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 mediaType = typeof block.mimeType === 'string'\n        ? block.mimeType\n        : (typeof block.mediaType === 'string' ? block.mediaType : 'image/png')\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        out.push({ type: 'image', mediaType: res.mimeType, 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(config: McpServerConfig, authProvider?: OAuthClientProvider) {\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      return new StdioClientTransport({\n        command: config.command!,\n        args: config.args,\n        env: mergedEnv,\n        ...(config.cwd ? { cwd: config.cwd } : {}),\n      })\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 * 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  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      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    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 }> }\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)\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) 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    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 { ok: true, name: config.name, config, lazy: false, client: currentClient, tools: filteredTools }\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): 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) 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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"}

package/dist/messages-BfmXLDT4.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"messages-BfmXLDT4.js","names":[],"sources":["../src/providers/cost.ts","../src/providers/schema-sanitize.ts","../src/providers/openai-compat.ts","../src/session/messages.ts"],"sourcesContent":["import type { TurnUsage } from '../types'\nimport { getModel } from '@mariozechner/pi-ai'\n\ninterface ModelCostRates {\n  input?: number\n  output?: number\n  cacheRead?: number\n  cacheWrite?: number\n}\n\n/**\n * Fill in `usage.cost` from pi-ai's bundled price registry when the\n * provider didn't report one. Provider-reported cost (e.g. OpenRouter's\n * `total_cost`, OpenAI's pi-ai-computed total) always wins — we only\n * estimate when `usage.cost` is undefined.\n *\n * Lookup is `(provider, usage.modelId)`. On a miss (unknown / unbundled\n * model), `cost` stays undefined and the footer indicator hides — better\n * than fabricating a $0.\n *\n * The number is an estimate: token counts come from the API, rates from\n * the locally-bundled registry that refreshes with `@mariozechner/pi-ai`\n * version bumps. If a provider changes prices between bumps the figure\n * will drift until the dep updates.\n */\nexport function fillEstimatedCost(usage: TurnUsage, provider: string): TurnUsage {\n  if (usage.cost !== undefined)\n    return usage\n  if (!usage.modelId)\n    return usage\n\n  // pi-ai's `getModel` is typed for `KnownProvider` × `keyof models[P]`; we\n  // accept arbitrary strings here (the openai-compat adapter routes both known\n  // and user-defined endpoint names through this helper) and let the function's\n  // runtime throw on a miss.\n  const lookup = getModel as (p: string, m: string) => { cost?: ModelCostRates } | undefined\n  let model: { cost?: ModelCostRates } | undefined\n  try {\n    model = lookup(provider, usage.modelId)\n  }\n  catch {\n    return usage\n  }\n\n  const rates = model?.cost\n  if (!rates)\n    return usage\n\n  const total\n    = ((rates.input ?? 0) * (usage.input ?? 0)\n      + (rates.output ?? 0) * (usage.output ?? 0)\n      + (rates.cacheRead ?? 0) * (usage.cacheRead ?? 0)\n      + (rates.cacheWrite ?? 0) * (usage.cacheCreation ?? 0)) / 1_000_000\n\n  if (total <= 0)\n    return usage\n\n  return { ...usage, cost: total }\n}\n","/**\n * JSON Schema sanitizer for tool `inputSchema` forwarded to LLM providers.\n *\n * Why this exists: MCP servers ship arbitrary JSON Schema in `tools/list`.\n * Anthropic and (to a lesser extent) OpenAI reject specific keyword\n * combinations with a 400 on `messages.create`, and the error message\n * lands deep inside an SDK exception that consumers blame on their own\n * code. The most common failure modes in the wild:\n *\n *   - Root `$ref` (server-published schema lives under `#/$defs/X`).\n *   - Root `oneOf` / `anyOf` / `allOf` (Anthropic allows neither at the\n *     top level; expects `type: 'object'`).\n *   - `type: ['object', 'null']` at the root (nullable variants of an\n *     otherwise valid object schema).\n *   - Missing `properties` on an object root.\n *   - `nullable: true` (Swagger / OpenAPI 3.0 idiom — not standard JSON\n *     Schema, ignored by every modern provider but Anthropic warns).\n *   - Nested `$ref` pointing at `#/definitions/X` without the schema\n *     actually inlining the referenced definition.\n *\n * Pure rewrite. Returns a new schema (or the same reference when nothing\n * needed to change — the hot path on stable tool registries) and a list\n * of `warnings` describing each rewrite. Providers call\n * `sanitizeToolSpecs` from `formatTools` so every tool — eager MCP, lazy\n * MCP, native, skill — gets the same treatment, and warnings surface\n * through `console.warn` once per batch (the seen-set in\n * `sanitizeToolSpecs` is local to one call, so a stable bad schema logs\n * once per request rather than every turn).\n *\n * Scope:\n *   - Pure function. No I/O, no globals.\n *   - Bounded recursion (`MAX_DEPTH = 32`) so a malicious server can't\n *     wedge the agent with a deeply self-referential schema.\n *   - Bounded `$ref` resolution (`MAX_REF_HOPS = 16`) for the same\n *     reason. Cycles fall back to `{}` (permissive) rather than\n *     throwing — the request still succeeds, the schema is just looser.\n *\n * Non-goals:\n *   - Validating that the schema is internally consistent.\n *   - Cleaning up tool *descriptions* (handled elsewhere).\n *   - Provider-side feature detection (handled by the provider's own\n *     `formatTools`; this module is a syntactic guard, not a semantic one).\n */\n\n/** Strictness profile — picks which transformations to apply. */\nexport type SchemaSanitizeProfile = 'anthropic' | 'openai' | 'permissive'\n\nexport interface SchemaSanitizeOptions {\n  /** Strictness profile. Defaults to `'permissive'`. */\n  profile?: SchemaSanitizeProfile\n  /**\n   * Tool name for context in warnings. Optional — when set, every warning\n   * is prefixed with `[tool:<name>] ` so log lines correlate to the tool.\n   */\n  toolName?: string\n}\n\nexport interface SchemaSanitizeResult {\n  /** Sanitized schema, safe to forward to the provider. */\n  schema: Record<string, unknown>\n  /**\n   * Human-readable strings describing each rewrite the sanitizer performed.\n   * Empty on a clean schema. Consumers may log these (recommended) or\n   * thread them through a hook for observability.\n   */\n  warnings: string[]\n}\n\n/** Max nesting depth before sub-schemas are replaced with `{}`. */\nconst MAX_DEPTH = 32\n\n/** Max `$ref` hop count before resolution gives up. */\nconst MAX_REF_HOPS = 16\n\n/** Keys that hold a single sub-schema. */\nconst SUBSCHEMA_KEYS = ['items', 'additionalProperties', 'contains', 'not', 'if', 'then', 'else', 'propertyNames'] as const\n\n/**\n * Keys that hold a record of sub-schemas.\n *\n * `$defs` / `definitions` are intentionally NOT included — they're\n * metaschema storage, only reached via `$ref` resolution (which has its\n * own walker in `resolveRef`), and `enforceRoot` strips them at the\n * wire layer once inlining is done. Recursing into them would cost\n * cycles and produce warnings about sub-trees the provider never sees.\n */\nconst SUBSCHEMA_RECORD_KEYS = ['properties', 'patternProperties', 'dependentSchemas'] as const\n\n/** Keys that hold an array of sub-schemas. */\nconst SUBSCHEMA_ARRAY_KEYS = ['oneOf', 'anyOf', 'allOf', 'prefixItems'] as const\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n\n/**\n * Resolve a JSON pointer like `#/$defs/Foo` against `root`. Returns\n * `undefined` when the pointer doesn't resolve or hops past `MAX_REF_HOPS`.\n * The caller treats `undefined` as \"give up, leave as a permissive schema\".\n */\nfunction resolveRef(root: Record<string, unknown>, ref: string, hops = 0): Record<string, unknown> | undefined {\n  if (hops > MAX_REF_HOPS)\n    return undefined\n  if (!ref.startsWith('#/'))\n    return undefined\n\n  const parts = ref.slice(2).split('/').map(decodeRefSegment)\n  let cursor: unknown = root\n  for (const part of parts) {\n    if (!isPlainObject(cursor))\n      return undefined\n    cursor = cursor[part]\n  }\n  if (!isPlainObject(cursor))\n    return undefined\n\n  if (typeof cursor.$ref === 'string')\n    return resolveRef(root, cursor.$ref, hops + 1)\n  return cursor\n}\n\nfunction decodeRefSegment(seg: string): string {\n  return seg.replace(/~1/g, '/').replace(/~0/g, '~')\n}\n\ninterface SanitizeCtx {\n  root: Record<string, unknown>\n  warnings: string[]\n  profile: SchemaSanitizeProfile\n  prefix: string\n}\n\n/**\n * Recursively sanitize a sub-schema. Returns the **original** reference\n * when nothing needed to change — every turn's `formatTools` re-runs the\n * sanitizer, and the no-alloc fast path keeps the hot loop cheap when\n * the registered tool set is already clean. Returns a fresh object when\n * any rewrite happened; never mutates the input.\n *\n * The dirty-tracking is local to each frame so a clean sub-tree under a\n * dirty parent doesn't get cloned uselessly.\n */\nfunction sanitizeNode(node: unknown, ctx: SanitizeCtx, depth: number, path: string): Record<string, unknown> {\n  if (depth > MAX_DEPTH) {\n    ctx.warnings.push(`${ctx.prefix}schema nested deeper than ${MAX_DEPTH} levels at ${path || '$'} — replaced with permissive {}`)\n    return {}\n  }\n  if (!isPlainObject(node))\n    return {}\n\n  let dirty = false\n  let working: Record<string, unknown> = node\n\n  // Inline `$ref` first so subsequent passes see the resolved shape.\n  // Sibling keys (per JSON Schema 2019-09+ semantics) win over the\n  // referenced definition. Unresolvable refs collapse to whatever\n  // siblings remained so the surrounding schema still validates.\n  if (typeof working.$ref === 'string') {\n    const ref = working.$ref\n    const resolved = resolveRef(ctx.root, ref)\n    const { $ref: _drop, ...rest } = working\n    if (resolved) {\n      ctx.warnings.push(`${ctx.prefix}inlined $ref \"${ref}\" at ${path || '$'}`)\n      working = { ...resolved, ...rest }\n    }\n    else {\n      ctx.warnings.push(`${ctx.prefix}dropped unresolvable $ref \"${ref}\" at ${path || '$'}`)\n      working = rest\n    }\n    dirty = true\n  }\n\n  // OpenAPI 3.0 `nullable` → JSON-Schema `type: [..., 'null']`. Modern\n  // providers don't recognise `nullable`; Anthropic in particular ignores\n  // it silently, which lets the model emit `null` and then the validator\n  // complains the value isn't the declared type. Translation keeps the\n  // intent explicit on the wire.\n  if (working.nullable === true) {\n    if (!dirty) {\n      working = { ...working }\n      dirty = true\n    }\n    const t = working.type\n    if (typeof t === 'string') {\n      working.type = [t, 'null']\n      ctx.warnings.push(`${ctx.prefix}converted nullable:true → type:[${t},null] at ${path || '$'}`)\n    }\n    else if (Array.isArray(t) && !t.includes('null')) {\n      working.type = [...t, 'null']\n      ctx.warnings.push(`${ctx.prefix}converted nullable:true → type:[…,null] at ${path || '$'}`)\n    }\n    else if (Array.isArray(t)) {\n      // Redundant — type already includes 'null'. Silent strip keeps the\n      // wire shape clean without surfacing a warning the caller can't act on.\n    }\n    else {\n      ctx.warnings.push(`${ctx.prefix}stripped nullable:true at ${path || '$'} (no base type)`)\n    }\n    delete working.nullable\n  }\n\n  // Sub-schema recursion. Sweep every key that JSON Schema 2020-12\n  // reserves for nested schemas; leave annotation keywords (`title`,\n  // `description`, `examples`, `default`, ...) and validation keywords\n  // (`minimum`, `pattern`, ...) alone.\n  for (const key of SUBSCHEMA_KEYS) {\n    const child = working[key]\n    if (isPlainObject(child)) {\n      const sanitized = sanitizeNode(child, ctx, depth + 1, `${path}/${key}`)\n      if (sanitized !== child) {\n        if (!dirty) {\n          working = { ...working }\n          dirty = true\n        }\n        working[key] = sanitized\n      }\n    }\n  }\n\n  for (const key of SUBSCHEMA_RECORD_KEYS) {\n    const rec = working[key]\n    if (isPlainObject(rec)) {\n      let recDirty = false\n      let out: Record<string, unknown> = rec\n      for (const [k, v] of Object.entries(rec)) {\n        const sanitized = sanitizeNode(v, ctx, depth + 1, `${path}/${key}/${k}`)\n        if (sanitized !== v) {\n          if (!recDirty) {\n            out = { ...rec }\n            recDirty = true\n          }\n          out[k] = sanitized\n        }\n      }\n      if (recDirty) {\n        if (!dirty) {\n          working = { ...working }\n          dirty = true\n        }\n        working[key] = out\n      }\n    }\n  }\n\n  for (const key of SUBSCHEMA_ARRAY_KEYS) {\n    const arr = working[key]\n    if (Array.isArray(arr)) {\n      let arrDirty = false\n      let out: unknown[] = arr\n      for (let i = 0; i < arr.length; i++) {\n        const sanitized = sanitizeNode(arr[i], ctx, depth + 1, `${path}/${key}/${i}`)\n        if (sanitized !== arr[i]) {\n          if (!arrDirty) {\n            out = [...arr]\n            arrDirty = true\n          }\n          out[i] = sanitized\n        }\n      }\n      if (arrDirty) {\n        if (!dirty) {\n          working = { ...working }\n          dirty = true\n        }\n        working[key] = out\n      }\n    }\n  }\n\n  return working\n}\n\n/**\n * Apply root-level coercions every supported provider expects:\n *\n *   - `type === 'object'` (Anthropic requires it; OpenAI tolerates more\n *     but rejects unions at root in strict mode).\n *   - `properties` is a plain object (Anthropic 400s when missing).\n *   - No root-level `$ref` / `oneOf` / `anyOf` / `allOf` (Anthropic rejects;\n *     OpenAI behaviour varies by endpoint).\n *   - `$defs` / `definitions` stripped (recursive pass already inlined\n *     refs; the metaschema storage is dead weight at the wire layer).\n *\n * Applied for every profile because portability matters more than the\n * marginal permissiveness of any one host. Profile-specific extras\n * (currently `$schema` stripping on `anthropic`) are gated below.\n */\nfunction enforceRoot(schema: Record<string, unknown>, ctx: SanitizeCtx): Record<string, unknown> {\n  // Decide what the final shape needs first, then materialise a clone\n  // only when at least one change is required. The recursive pass calls\n  // this last, so a fully-clean schema reaches the wire as the exact\n  // reference the consumer passed in.\n  let out: Record<string, unknown> = schema\n  let dirty = false\n  const dirtyOnce = (): void => {\n    if (!dirty) {\n      out = { ...schema }\n      dirty = true\n    }\n  }\n\n  const t = out.type\n  if (Array.isArray(t)) {\n    if (t.includes('object')) {\n      dirtyOnce()\n      out.type = 'object'\n      if (t.length > 1)\n        ctx.warnings.push(`${ctx.prefix}collapsed root type:[${t.join(',')}] to 'object'`)\n    }\n    else {\n      dirtyOnce()\n      ctx.warnings.push(`${ctx.prefix}root type:[${t.join(',')}] does not include 'object' — coerced to 'object'`)\n      out.type = 'object'\n    }\n  }\n  else if (typeof t === 'string' && t !== 'object') {\n    dirtyOnce()\n    ctx.warnings.push(`${ctx.prefix}coerced root type:'${t}' → 'object'`)\n    out.type = 'object'\n  }\n  else if (t === undefined) {\n    dirtyOnce()\n    out.type = 'object'\n  }\n\n  // Anthropic + OpenAI both require `properties` on object schemas — even\n  // when empty. Synthesise the object so the wire shape is well-formed.\n  if (!isPlainObject(out.properties)) {\n    if ('properties' in out)\n      ctx.warnings.push(`${ctx.prefix}replaced non-object 'properties' at root with {}`)\n    dirtyOnce()\n    out.properties = {}\n  }\n\n  for (const key of ['oneOf', 'anyOf', 'allOf'] as const) {\n    if (key in out) {\n      dirtyOnce()\n      ctx.warnings.push(`${ctx.prefix}stripped root '${key}' (providers require a single object schema)`)\n      delete out[key]\n    }\n  }\n\n  if ('$ref' in out) {\n    dirtyOnce()\n    ctx.warnings.push(`${ctx.prefix}stripped root $ref`)\n    delete out.$ref\n  }\n\n  if ('$defs' in out) {\n    dirtyOnce()\n    delete out.$defs\n  }\n  if ('definitions' in out) {\n    dirtyOnce()\n    delete out.definitions\n  }\n\n  if (ctx.profile === 'anthropic' && '$schema' in out) {\n    dirtyOnce()\n    delete out.$schema\n  }\n\n  return out\n}\n\n/**\n * Sanitize a single tool's `inputSchema` for safe forwarding to the\n * provider. Returns the rewritten schema + a list of warnings describing\n * everything that changed.\n *\n * Never mutates the input. Returns the **same reference** when no rewrite\n * was needed (clean-schema fast path) — `sanitizeToolSpecs` relies on\n * this to keep the formatTools hot loop allocation-free across turns\n * when the registered tool set is already wire-valid.\n */\nexport function sanitizeToolSchema(\n  input: unknown,\n  options: SchemaSanitizeOptions = {},\n): SchemaSanitizeResult {\n  const profile: SchemaSanitizeProfile = options.profile ?? 'permissive'\n  const prefix = options.toolName ? `[tool:${options.toolName}] ` : ''\n\n  // Non-object inputs always allocate a fresh `{}` root — there's no\n  // possible identity to preserve, and the wire still needs a valid object\n  // schema either way. `sanitizeToolSpecs` won't hit its no-alloc path for\n  // these, which is fine; the model has nothing useful to call on a\n  // malformed inputSchema anyway.\n  if (!isPlainObject(input)) {\n    return {\n      schema: { type: 'object', properties: {} },\n      warnings: [],\n    }\n  }\n\n  const ctx: SanitizeCtx = {\n    root: input,\n    warnings: [],\n    profile,\n    prefix,\n  }\n\n  const recursed = sanitizeNode(input, ctx, 0, '')\n  const enforced = enforceRoot(recursed, ctx)\n\n  return { schema: enforced, warnings: ctx.warnings }\n}\n\n/**\n * Convenience: sanitize a batch of tools and emit a single de-duped\n * `console.warn` per unique warning line. Returns the rewritten tools\n * preserving original ordering and reference identity for clean schemas\n * (no reallocation when nothing needed to change).\n *\n * The sanitiser runs every request, so log noise from a stable bad\n * schema would multiply across turns; the de-dupe keeps the signal\n * useful in production logs without dropping the first occurrence.\n */\nexport function sanitizeToolSpecs<T extends { name: string, inputSchema?: unknown }>(\n  tools: readonly T[],\n  options: { profile?: SchemaSanitizeProfile, onWarning?: (line: string) => void } = {},\n): T[] {\n  const seen = new Set<string>()\n  const out: T[] = []\n  for (const tool of tools) {\n    const result = sanitizeToolSchema(tool.inputSchema, {\n      profile: options.profile,\n      toolName: tool.name,\n    })\n    if (result.warnings.length === 0 && result.schema === tool.inputSchema) {\n      out.push(tool)\n      continue\n    }\n    for (const line of result.warnings) {\n      if (seen.has(line))\n        continue\n      seen.add(line);\n      (options.onWarning ?? defaultWarn)(line)\n    }\n    out.push({ ...tool, inputSchema: result.schema })\n  }\n  return out\n}\n\nfunction defaultWarn(line: string): void {\n  console.warn(`[zidane:schema] ${line}`)\n}\n","/**\n * OpenAI-compatible provider factory + shared utilities.\n *\n * `openaiCompat(params)` returns a `Provider` that talks to any OpenAI-compatible\n * HTTP endpoint (OpenRouter, Cerebras, Baseten, Fireworks, Groq, local LM servers, ...).\n * Helpers (`consumeSSE`, `toOAIMessages`, ...) are shared by the bespoke `openrouter`\n * and `cerebras` wrappers, which pin defaults on top of this factory.\n */\n\nimport type { Provider, ProviderCapabilities, StreamCallbacks, StreamOptions, ToolResult, ToolSpec, TurnResult } from '.'\nimport type { ClassifiedError } from '../errors'\nimport type { SessionContentBlock, SessionMessage, ThinkingLevel, ToolResultContent, TurnFinishReason } from '../types'\nimport { errorMessage, matchesContextExceeded } from '../errors'\nimport { fillEstimatedCost } from './cost'\nimport { sanitizeToolSpecs } from './schema-sanitize'\n\n// ---------------------------------------------------------------------------\n// OpenAI-compatible types\n// ---------------------------------------------------------------------------\n\nexport interface OAIMessage {\n  role: 'system' | 'user' | 'assistant' | 'tool'\n  content?: unknown\n  tool_calls?: { id: string, type: 'function', function: { name: string, arguments: string } }[]\n  tool_call_id?: string\n  /**\n   * OpenRouter normalized reasoning envelope. Echoed back unmodified on assistant\n   * messages so the gateway can resume an extended-reasoning chain on the\n   * upstream route. Ignored by hosts that don't speak the envelope.\n   */\n  reasoning_details?: unknown[]\n}\n\nexport interface OAITool {\n  type: 'function'\n  function: { name: string, description: string, parameters: Record<string, unknown> }\n}\n\n// Sentinel tags zidane uses to round-trip tool_calls / tool_results through\n// the OpenAI-compat session shape. `toOpenAI` writes them; `fromOpenAI` reads\n// them back. The `__zidane_` prefix avoids collisions with any literal `_tag`\n// value a host might emit on real wire messages.\nexport const TOOL_RESULTS_TAG = '__zidane_tool_results__'\nexport const ASSISTANT_TOOL_CALLS_TAG = '__zidane_assistant_tc__'\n\n// ---------------------------------------------------------------------------\n// SSE stream parser\n// ---------------------------------------------------------------------------\n\n/**\n * Ceiling on how many bytes may accumulate between two newline boundaries when\n * parsing an SSE stream. A broken or malicious server that emits an unbounded\n * stream of non-newline bytes would otherwise grow `buffer` without end and\n * eventually OOM the host. 8 MB is safely above the largest tool-call arg\n * JSON we reasonably expect and still catches a pathological stream in ~1 s on\n * a 10 MB/s connection.\n */\nconst SSE_MAX_BUFFER_BYTES = 8 * 1024 * 1024\n\nexport class OpenAICompatStreamError extends Error {\n  constructor(message: string) {\n    super(message)\n    this.name = 'OpenAICompatStreamError'\n  }\n}\n\nexport async function consumeSSE(\n  response: Response,\n  callbacks: StreamCallbacks,\n  signal?: AbortSignal,\n) {\n  const reader = response.body!.getReader()\n  const decoder = new TextDecoder()\n  let buffer = ''\n  let text = ''\n  let thinking = ''\n  let finishReason = 'stop'\n  let usage: { input: number, output: number, cost?: number, cacheRead?: number, cacheCreation?: number } = { input: 0, output: 0 }\n  const tcMap = new Map<number, { id: string, name: string, args: string }>()\n  // OpenRouter `reasoning_details` deltas, keyed by item index. Items are merged\n  // field-by-field: text/summary concatenate, signature/data/format/id/type are\n  // last-write-wins (they only appear once per item in practice).\n  const reasoningMap = new Map<number, Record<string, unknown>>()\n  let sawReasoningDetails = false\n\n  try {\n    while (true) {\n      if (signal?.aborted)\n        break\n      const { done, value } = await reader.read()\n      if (done)\n        break\n\n      buffer += decoder.decode(value, { stream: true })\n      // Cap the line-less buffer. Any single event must fit under the ceiling.\n      if (buffer.length > SSE_MAX_BUFFER_BYTES) {\n        throw new OpenAICompatStreamError(\n          `SSE buffer exceeded ${SSE_MAX_BUFFER_BYTES} bytes without a line boundary — upstream may be streaming non-SSE data.`,\n        )\n      }\n      const lines = buffer.split('\\n')\n      buffer = lines.pop() || ''\n\n      for (const line of lines) {\n        if (!line.startsWith('data: '))\n          continue\n        const data = line.slice(6).trim()\n        if (data === '[DONE]')\n          continue\n\n        let chunk: Record<string, unknown>\n        try {\n          chunk = JSON.parse(data) as Record<string, unknown>\n        }\n        catch {\n          // Malformed JSON frame — skip (SSE keepalives, injected comments, etc.)\n          continue\n        }\n\n        const choices = chunk.choices as Array<Record<string, unknown>> | undefined\n        const choice = choices?.[0]\n        if (!choice)\n          continue\n        const fr = choice.finish_reason as string | undefined\n        if (fr)\n          finishReason = fr\n\n        const delta = choice.delta as Record<string, unknown> | undefined\n\n        // OpenRouter normalized reasoning envelope. Items arrive as deltas keyed\n        // by `index`; merge into a stable list and stream the visible text portion\n        // through `onThinking` so the UI sees reasoning live.\n        const reasoningDeltaArr = delta?.reasoning_details as Array<Record<string, unknown>> | undefined\n        if (reasoningDeltaArr && reasoningDeltaArr.length > 0) {\n          sawReasoningDetails = true\n          for (const item of reasoningDeltaArr) {\n            const idx = (typeof item.index === 'number' ? item.index : 0)\n            const existing = reasoningMap.get(idx) ?? {}\n            // Concatenate text/summary across deltas.\n            if (typeof item.text === 'string') {\n              existing.text = ((existing.text as string | undefined) ?? '') + item.text\n              thinking += item.text\n              callbacks.onThinking?.(item.text)\n            }\n            if (typeof item.summary === 'string') {\n              existing.summary = ((existing.summary as string | undefined) ?? '') + item.summary\n              thinking += item.summary\n              callbacks.onThinking?.(item.summary)\n            }\n            // Last-write-wins for opaque fields.\n            for (const key of ['type', 'signature', 'data', 'format', 'id'] as const) {\n              const v = item[key]\n              if (typeof v === 'string')\n                existing[key] = v\n            }\n            reasoningMap.set(idx, existing)\n          }\n        }\n\n        // Legacy text-only reasoning fields (DeepSeek `reasoning_content`,\n        // pre-`reasoning_details` OpenRouter, Qwen-thinking, …). Suppressed\n        // when the structured envelope is in flight to avoid double-counting\n        // the same reasoning text into the `thinking` buffer.\n        if (!sawReasoningDetails) {\n          const thinkingDelta = (delta?.reasoning_content ?? delta?.reasoning) as string | undefined\n          if (thinkingDelta) {\n            thinking += thinkingDelta\n            callbacks.onThinking?.(thinkingDelta)\n          }\n        }\n\n        const contentDelta = delta?.content as string | undefined\n        if (contentDelta) {\n          text += contentDelta\n          callbacks.onText(contentDelta)\n        }\n\n        const toolCallsDelta = delta?.tool_calls as Array<{\n          index: number\n          id?: string\n          function?: { name?: string, arguments?: string }\n        }> | undefined\n        if (toolCallsDelta) {\n          for (const tc of toolCallsDelta) {\n            const existing = tcMap.get(tc.index)\n            if (existing) {\n              if (tc.function?.arguments)\n                existing.args += tc.function.arguments\n            }\n            else {\n              tcMap.set(tc.index, {\n                id: tc.id || `call_${tc.index}`,\n                name: tc.function?.name || '',\n                args: tc.function?.arguments || '',\n              })\n            }\n          }\n        }\n\n        const chunkUsage = chunk.usage as\n          | {\n            prompt_tokens?: number\n            completion_tokens?: number\n            total_cost?: number\n            cache_discount?: number\n            prompt_tokens_details?: {\n              cached_tokens?: number\n              cache_creation_input_tokens?: number\n              cache_write_tokens?: number\n            }\n            cache_creation_input_tokens?: number\n          }\n          | undefined\n        if (chunkUsage) {\n          const cachedRead = chunkUsage.prompt_tokens_details?.cached_tokens\n          // OpenRouter surfaces cache writes via `prompt_tokens_details.cache_creation_input_tokens`\n          // (Anthropic passthrough) or `cache_write_tokens` (normalized form). Either is cumulative\n          // for the request, so pick whichever the route populated.\n          const cachedWrite = chunkUsage.prompt_tokens_details?.cache_creation_input_tokens\n            ?? chunkUsage.prompt_tokens_details?.cache_write_tokens\n            ?? chunkUsage.cache_creation_input_tokens\n          usage = {\n            input: chunkUsage.prompt_tokens ?? 0,\n            output: chunkUsage.completion_tokens ?? 0,\n            cost: chunkUsage.total_cost ?? undefined,\n            ...(typeof cachedRead === 'number' && cachedRead > 0 ? { cacheRead: cachedRead } : {}),\n            ...(typeof cachedWrite === 'number' && cachedWrite > 0 ? { cacheCreation: cachedWrite } : {}),\n          }\n        }\n      }\n    }\n  }\n  finally {\n    reader.releaseLock()\n  }\n\n  // Tool call JSON is accumulated across many deltas. If the stream truncates\n  // mid-object (network hiccup, server crash) `tc.args` won't parse — fall\n  // back to an empty input and surface a stream error rather than letting the\n  // whole turn reject with `SyntaxError: Unexpected end of JSON input`, which\n  // gives callers no actionable signal.\n  const toolCalls: Array<{ id: string, name: string, input: Record<string, unknown> }> = []\n  for (const tc of tcMap.values()) {\n    if (!tc.args) {\n      toolCalls.push({ id: tc.id, name: tc.name, input: {} })\n      continue\n    }\n    try {\n      toolCalls.push({ id: tc.id, name: tc.name, input: JSON.parse(tc.args) as Record<string, unknown> })\n    }\n    catch (err) {\n      throw new OpenAICompatStreamError(\n        `Tool call \"${tc.name}\" (${tc.id}) arguments were truncated or malformed: ${errorMessage(err)}`,\n      )\n    }\n  }\n\n  // Sort by index so `reasoning_details` round-trip preserves item order.\n  const reasoningDetails = Array.from(reasoningMap.entries())\n    .sort(([a], [b]) => a - b)\n    .map(([, item]) => item)\n\n  return { text, thinking, toolCalls, finishReason, usage, reasoningDetails }\n}\n\n// ---------------------------------------------------------------------------\n// Message conversion: SessionMessage[] → OAIMessage[]\n// ---------------------------------------------------------------------------\n\n/**\n * Encode a single image block as an OpenAI `image_url` multi-part entry.\n */\nfunction toImageUrlPart(img: { mediaType: string, data: string }) {\n  return {\n    type: 'image_url' as const,\n    image_url: { url: `data:${img.mediaType};base64,${img.data}` },\n  }\n}\n\n/**\n * Summarize a `tool_result` output for the companion-user-message path — text blocks\n * are joined (separated by `\\n`) so the tool message carries all textual context; image\n * blocks are collected in a flat list for the companion user message.\n *\n * Used only on the fallback path; the native path walks `output` in-order to preserve\n * text↔image interleaving.\n */\nfunction summarizeToolResultOutput(output: string | ToolResultContent[]): {\n  text: string\n  images: Array<{ mediaType: string, data: string }>\n} {\n  if (typeof output === 'string')\n    return { text: output, images: [] }\n\n  const texts: string[] = []\n  const images: Array<{ mediaType: string, data: string }> = []\n  for (const block of output) {\n    if (block.type === 'text')\n      texts.push(block.text)\n    else if (block.type === 'image')\n      images.push({ mediaType: block.mediaType, data: block.data })\n  }\n  return { text: texts.join('\\n'), images }\n}\n\n/**\n * Options that influence OpenAI-compat message shaping.\n *\n * `imageInToolResult` defaults to `false`: the loop routes images via a companion\n * user message emitted immediately after the `tool` message. Providers with\n * genuine multi-part tool support can set it to `true` to emit a single\n * multi-part `tool` message instead.\n */\ninterface ToOAIOptions {\n  imageInToolResult?: boolean\n  /**\n   * Host accepts OpenRouter-style `reasoning_details` echoed back on assistant\n   * messages. When `true`, `provider_reasoning` blocks whose `producer`/`model`\n   * match the active route are forwarded; when `false` (default), they are\n   * silently dropped to avoid 400s on hosts that strict-validate the schema.\n   */\n  supportsReasoning?: boolean\n  /**\n   * Active model id. Used to gate `provider_reasoning` blocks — reasoning state\n   * is bound to the route that produced it, so a model switch invalidates the\n   * embedded signatures.\n   */\n  model?: string\n}\n\nexport function toOAIMessages(system: string, messages: SessionMessage[], options: ToOAIOptions = {}): OAIMessage[] {\n  const out: OAIMessage[] = [{ role: 'system', content: system }]\n  const nativeImageInTool = options.imageInToolResult === true\n  const reasoningEnabled = options.supportsReasoning === true\n  const activeModel = options.model\n\n  for (const msg of messages) {\n    const toolResults = msg.content.filter(b => b.type === 'tool_result')\n    const toolCalls = msg.content.filter(b => b.type === 'tool_call')\n    const textBlocks = msg.content.filter(b => b.type === 'text')\n    const imageBlocks = msg.content.filter(b => b.type === 'image')\n    // Provider-bound reasoning state — attached to the assistant message below\n    // when the host supports it AND the active route matches the producer.\n    const reasoningBlocks = reasoningEnabled\n      ? msg.content\n          .filter(b => b.type === 'provider_reasoning')\n          .filter((b) => {\n            if (b.producer !== 'openrouter')\n              return false\n            if (b.model && activeModel && b.model !== activeModel)\n              return false\n            return true\n          })\n      : []\n    const reasoningDetails = reasoningBlocks.flatMap(b => b.details)\n\n    // Tool results → individual tool messages (plus optional companion user message for images)\n    if (toolResults.length > 0) {\n      for (const tr of toolResults) {\n        // Pure-string output → text-only fast path, wire-identical to pre-multimodal behavior.\n        if (typeof tr.output === 'string') {\n          out.push({ role: 'tool', tool_call_id: tr.callId, content: tr.output })\n          continue\n        }\n\n        // Native multi-part path — walk blocks in order so text↔image interleaving is preserved.\n        if (nativeImageInTool) {\n          const parts = tr.output.map(block => block.type === 'image'\n            ? toImageUrlPart({ mediaType: block.mediaType, data: block.data })\n            : { type: 'text' as const, text: block.text })\n          out.push({ role: 'tool', tool_call_id: tr.callId, content: parts })\n          continue\n        }\n\n        // Companion-user-message fallback (Claude Desktop / Cline pattern).\n        // Works on any Chat Completions endpoint that accepts images in user messages.\n        const { text, images } = summarizeToolResultOutput(tr.output)\n        if (images.length === 0) {\n          // Structured array happened to be text-only — collapse to pure-text path.\n          out.push({ role: 'tool', tool_call_id: tr.callId, content: text })\n          continue\n        }\n\n        const noun = images.length === 1 ? 'image' : 'images'\n        const attachedMarker = `[${images.length} ${noun} attached — see next user message]`\n        const toolMarker = text.length > 0 ? `${text}\\n\\n${attachedMarker}` : attachedMarker\n        out.push({ role: 'tool', tool_call_id: tr.callId, content: toolMarker })\n\n        out.push({\n          role: 'user',\n          content: [\n            ...images.map(toImageUrlPart),\n            { type: 'text' as const, text: `(${noun} returned by tool call ${tr.callId})` },\n          ],\n        })\n      }\n      continue\n    }\n\n    // Tool calls → assistant message with tool_calls array\n    if (toolCalls.length > 0) {\n      const textContent = textBlocks.length > 0 ? textBlocks[0].text : null\n      const m: OAIMessage = {\n        role: 'assistant',\n        content: textContent,\n        tool_calls: toolCalls.map(tc => ({\n          id: tc.id,\n          type: 'function' as const,\n          function: { name: tc.name, arguments: JSON.stringify(tc.input) },\n        })),\n      }\n      if (reasoningDetails.length > 0)\n        m.reasoning_details = reasoningDetails\n      out.push(m)\n      continue\n    }\n\n    // Images → multimodal array\n    if (imageBlocks.length > 0) {\n      const parts: unknown[] = imageBlocks.map(img => ({\n        type: 'image_url',\n        image_url: { url: `data:${img.mediaType};base64,${img.data}` },\n      }))\n      for (const b of textBlocks) {\n        parts.push({ type: 'text', text: b.text })\n      }\n      const m: OAIMessage = { role: msg.role, content: parts }\n      if (msg.role === 'assistant' && reasoningDetails.length > 0)\n        m.reasoning_details = reasoningDetails\n      out.push(m)\n      continue\n    }\n\n    // Pure text\n    let pushed: OAIMessage\n    if (textBlocks.length === 1) {\n      pushed = { role: msg.role, content: textBlocks[0].text }\n    }\n    else if (textBlocks.length > 1) {\n      pushed = { role: msg.role, content: textBlocks.map(b => ({ type: 'text', text: b.text })) }\n    }\n    else {\n      pushed = { role: msg.role, content: null }\n    }\n    if (msg.role === 'assistant' && reasoningDetails.length > 0)\n      pushed.reasoning_details = reasoningDetails\n    out.push(pushed)\n  }\n\n  return out\n}\n\n// ---------------------------------------------------------------------------\n// Prompt caching\n// ---------------------------------------------------------------------------\n\nconst EPHEMERAL = { type: 'ephemeral' as const }\n\n/**\n * Add `cache_control: { type: 'ephemeral' }` breakpoints to the system message's\n * last text part and the last message's final content part.\n *\n * Mutates `messages` in place. Converts plain-string content into a single-element\n * content array so the cache marker can attach — this shape is accepted verbatim by\n * OpenRouter's Anthropic and Gemini routes and ignored by routes with automatic\n * caching (OpenAI, DeepSeek, Grok, Groq, Moonshot).\n *\n * Skip conditions (safe no-ops):\n * - Empty messages array.\n * - Assistant messages with no text (tool-call-only) — attaching a cache marker to a\n *   `tool_calls` block has no defined semantics, so we skip and let the prior\n *   system/tools breakpoints carry caching.\n */\nexport function applyOAICacheBreakpoints(messages: OAIMessage[]): void {\n  if (messages.length === 0)\n    return\n\n  const first = messages[0]\n  if (first.role === 'system')\n    markLastContentPart(first)\n\n  const lastIdx = messages.length - 1\n  if (lastIdx > 0)\n    markLastContentPart(messages[lastIdx])\n}\n\n/**\n * Mark the last content part of an OAI message with `cache_control`. Normalizes\n * string content into a `[{ type: 'text', text, cache_control }]` array so the\n * marker has a block to attach to.\n *\n * No-op for messages without string or array content (tool-call-only assistant\n * messages fall through; the system/tools breakpoints carry the cache prefix).\n */\nfunction markLastContentPart(msg: OAIMessage): void {\n  if (typeof msg.content === 'string') {\n    if (msg.content.length === 0)\n      return\n    msg.content = [{ type: 'text', text: msg.content, cache_control: EPHEMERAL }]\n    return\n  }\n  if (!Array.isArray(msg.content) || msg.content.length === 0)\n    return\n\n  const parts = msg.content as Array<Record<string, unknown>>\n  const lastBlockIdx = parts.length - 1\n  parts[lastBlockIdx] = { ...parts[lastBlockIdx], cache_control: EPHEMERAL }\n}\n\n/**\n * Return a copy of `tools` with `cache_control` on the last entry.\n *\n * OpenRouter accepts the marker alongside the standard `type` + `function` fields\n * and forwards it when routing to Anthropic/Gemini. Leaves the non-cached tools\n * unchanged so the caller's reference is not mutated.\n */\nexport function applyOAIToolCacheBreakpoint(tools: OAITool[]): OAITool[] {\n  if (tools.length === 0)\n    return tools\n  const lastIdx = tools.length - 1\n  return tools.map((tool, i) =>\n    i === lastIdx ? ({ ...tool, cache_control: EPHEMERAL } as OAITool & { cache_control: typeof EPHEMERAL }) : tool,\n  )\n}\n\n// ---------------------------------------------------------------------------\n// Shared message builders\n// ---------------------------------------------------------------------------\n\nexport function formatTools(tools: ToolSpec[]): OAITool[] {\n  // Same sanitization Anthropic gets — OpenAI-compat hosts (OpenRouter,\n  // Cerebras, Groq, ...) reject the same root-level shapes (missing\n  // `properties` on object schemas, root `$ref` / `oneOf` / `anyOf`). The\n  // `openai` profile is a touch more permissive about annotation\n  // keywords, but the core rewrites are identical.\n  const sanitized = sanitizeToolSpecs(tools, { profile: 'openai' })\n  return sanitized.map(t => ({\n    type: 'function' as const,\n    function: { name: t.name, description: t.description, parameters: t.inputSchema as Record<string, unknown> },\n  }))\n}\n\nexport function userMessage(content: string): SessionMessage {\n  return { role: 'user', content: [{ type: 'text', text: content }] }\n}\n\nexport function assistantMessage(content: string): SessionMessage {\n  return { role: 'assistant', content: [{ type: 'text', text: content }] }\n}\n\nexport function toolResultsMessage(results: ToolResult[]): SessionMessage {\n  return {\n    role: 'user',\n    content: results.map(r => ({\n      type: 'tool_result' as const,\n      callId: r.id,\n      output: r.content,\n      ...(r.isError ? { isError: true as const } : {}),\n    })),\n  }\n}\n\nexport function buildAssistantContent(\n  text: string,\n  toolCalls: { id: string, name: string, input: Record<string, unknown> }[],\n  thinking?: string,\n  reasoning?: { details: unknown[], producer: 'openrouter', model?: string },\n): SessionMessage {\n  const content: SessionContentBlock[] = []\n  // `provider_reasoning` precedes `thinking` so re-attached envelopes arrive\n  // before the legacy text mirror in the assistant content list.\n  if (reasoning && reasoning.details.length > 0) {\n    const block: Extract<SessionContentBlock, { type: 'provider_reasoning' }> = {\n      type: 'provider_reasoning',\n      producer: reasoning.producer,\n      details: reasoning.details,\n    }\n    if (reasoning.model)\n      block.model = reasoning.model\n    content.push(block)\n  }\n  if (thinking)\n    content.push({ type: 'thinking', text: thinking })\n  if (text)\n    content.push({ type: 'text', text })\n  for (const tc of toolCalls) {\n    content.push({ type: 'tool_call', id: tc.id, name: tc.name, input: tc.input })\n  }\n  return { role: 'assistant', content }\n}\n\n// ---------------------------------------------------------------------------\n// Error classification\n// ---------------------------------------------------------------------------\n\n/**\n * HTTP error thrown when an OpenAI-compatible endpoint returns a non-OK response.\n *\n * The body is best-effort JSON-parsed; `error.message` / `error.code` / `error.type`\n * are extracted for clean downstream classification.\n */\nexport class OpenAICompatHttpError extends Error {\n  readonly status: number\n  readonly providerCode?: string\n  readonly bodyText: string\n\n  constructor(status: number, bodyText: string) {\n    let message = bodyText\n    let code: string | undefined\n    try {\n      const parsed = JSON.parse(bodyText)\n      message = parsed?.error?.message ?? bodyText\n      code = parsed?.error?.code ?? parsed?.error?.type\n    }\n    catch {\n      // Leave message as the raw body.\n    }\n    super(`HTTP ${status}: ${message}`)\n    this.name = 'OpenAICompatHttpError'\n    this.status = status\n    this.providerCode = code\n    this.bodyText = bodyText\n  }\n}\n\nconst TRAILING_SLASH_RE = /\\/$/\n\n/**\n * Classify an OpenAI-compatible error into `ClassifiedError`.\n *\n * Recognizes:\n * - `AbortError` (from fetch) → `aborted`.\n * - `OpenAICompatHttpError` with a context-exceeded code or message → `context_exceeded`.\n * - Any other `OpenAICompatHttpError` → `provider_error`.\n *\n * Returns `null` for unrecognized error shapes (the loop falls back to `AgentProviderError`).\n */\nexport function classifyOpenAICompatError(err: unknown): ClassifiedError | null {\n  if (!err || typeof err !== 'object')\n    return null\n\n  if ((err as { name?: unknown }).name === 'AbortError')\n    return { kind: 'aborted' }\n\n  // A truncated / malformed SSE stream is a transient network-level failure —\n  // typically worth a retry from the caller's perspective.\n  if (err instanceof OpenAICompatStreamError) {\n    return {\n      kind: 'provider_error',\n      providerCode: 'stream_error',\n      message: err.message,\n      retryable: true,\n    }\n  }\n\n  if (!(err instanceof OpenAICompatHttpError))\n    return null\n\n  const code = err.providerCode\n  const msg = err.message\n\n  if (code === 'context_length_exceeded' || matchesContextExceeded(msg)) {\n    return {\n      kind: 'context_exceeded',\n      providerCode: code ?? 'context_length_exceeded',\n      message: msg,\n    }\n  }\n\n  return {\n    kind: 'provider_error',\n    providerCode: code ?? String(err.status),\n    message: msg,\n    retryable: isRetryableHttpStatus(err.status),\n  }\n}\n\n/**\n * 429 + 5xx (except 501 Not Implemented) are safe to retry with backoff;\n * 4xx other than 429 are terminal (bad request, auth, not found, etc.).\n */\nfunction isRetryableHttpStatus(status: number): boolean {\n  if (status === 429)\n    return true\n  if (status >= 500 && status !== 501)\n    return true\n  return false\n}\n\n// ---------------------------------------------------------------------------\n// Finish-reason mapping\n// ---------------------------------------------------------------------------\n\n/**\n * Map an OpenAI-compatible `finish_reason` string to the zidane `TurnFinishReason` union.\n */\nexport function mapOAIFinishReason(reason: string | null | undefined): TurnFinishReason | undefined {\n  if (!reason)\n    return undefined\n  switch (reason) {\n    case 'stop':\n      return 'stop'\n    case 'tool_calls':\n    case 'function_call':\n      return 'tool-calls'\n    case 'length':\n      return 'length'\n    case 'content_filter':\n      return 'content-filter'\n    default:\n      return 'other'\n  }\n}\n\n// ---------------------------------------------------------------------------\n// openaiCompat factory\n// ---------------------------------------------------------------------------\n\n/**\n * Auth header config. `scheme` is prepended to the api key with a space, e.g.\n * `{ name: 'Authorization', scheme: 'Bearer' }` → `Authorization: Bearer <key>`.\n * Omit `scheme` for raw header values (e.g. `{ name: 'X-Api-Key' }` → `X-Api-Key: <key>`).\n *\n * Real-world examples:\n * - Default OpenAI / OpenRouter / Cerebras: `{ name: 'Authorization', scheme: 'Bearer' }`.\n * - Baseten: `{ name: 'Authorization', scheme: 'Api-Key' }`.\n * - Some gateways: `{ name: 'X-Api-Key' }`.\n */\nexport interface OpenAICompatAuthHeader {\n  name: string\n  scheme?: string\n}\n\nexport interface OpenAICompatParams {\n  /** Bearer-style API key. */\n  apiKey: string\n  /** Base URL — `/chat/completions` is appended. */\n  baseURL: string\n  /** Default model id when `run({ model })` is omitted. */\n  defaultModel?: string\n  /** Provider name exposed as `Provider.name`. Defaults to `'openai-compat'`. */\n  name?: string\n  /** Auth header shape. Defaults to `{ name: 'Authorization', scheme: 'Bearer' }`. */\n  authHeader?: OpenAICompatAuthHeader\n  /** Extra headers sent with every request (e.g. referer, user-agent). */\n  extraHeaders?: Record<string, string>\n  /**\n   * Provider-level capability flags. Routed into the message shaper and the\n   * agent loop so images in tool results + user messages are handled correctly\n   * for the underlying model.\n   *\n   * Defaults when omitted: `vision: false`, `imageInToolResult: false` — a\n   * conservative assumption matching most OSS text-only OpenAI-compat\n   * endpoints. Override when routing to a known vision-capable endpoint\n   * (e.g. OpenRouter vision models, Baseten image-capable deployments).\n   */\n  capabilities?: ProviderCapabilities\n  /**\n   * Whether this endpoint honors `cache_control: { type: 'ephemeral' }` markers\n   * on message content parts and tool definitions.\n   *\n   * - `true`  — inject markers when the caller asks for caching. OpenRouter routes\n   *             to Anthropic/Gemini forward the markers; routes to OpenAI/DeepSeek/\n   *             Grok/Groq/Moonshot ignore them (those backends cache automatically).\n   * - `false` — never inject markers. Safe default for endpoints that strictly\n   *             validate the request schema (OpenAI direct, most OSS inference\n   *             servers) and would reject unknown fields.\n   *\n   * Default: `false`. The `openrouter` wrapper sets this to `true`.\n   */\n  cacheBreakpoints?: boolean\n  /**\n   * Whether this endpoint speaks OpenRouter's normalized reasoning envelope —\n   * `reasoning: { effort | max_tokens | exclude }` on requests and structured\n   * `reasoning_details[]` on assistant messages, round-tripped to preserve\n   * extended-reasoning state across turns.\n   *\n   * - `true`  — map zidane's `behavior.thinking` / `behavior.thinkingBudget` to\n   *             the request's `reasoning` field, capture `reasoning_details`\n   *             from streaming responses into `provider_reasoning` blocks, and\n   *             echo them back on subsequent assistant messages.\n   * - `false` — never set the field; drop any stored `provider_reasoning`\n   *             blocks before sending. Safe default for hosts that strict-\n   *             validate the request schema.\n   *\n   * Default: `false`. The `openrouter` wrapper sets this to `true`.\n   */\n  supportsReasoning?: boolean\n  /**\n   * Generic pass-through for fields on the Chat Completions request body that\n   * zidane does not yet type. Spread into the request before the typed core\n   * (model / messages / tools / max_tokens / stream / tool_choice), so\n   * explicit options always win on collision.\n   *\n   * Forward-compat escape hatch for endpoints that ship one-off fields ahead\n   * of zidane (e.g. OpenAI `reasoning_effort`, OpenRouter `provider` routing,\n   * vendor-specific `safety_level` knobs).\n   */\n  extraBodyParams?: Record<string, unknown>\n}\n\n/**\n * Map zidane's `ThinkingLevel` + optional explicit budget to the OpenRouter\n * `reasoning` request field. Returns `undefined` when reasoning should not be\n * sent (off, or no level + no budget).\n *\n * - `'low' | 'medium' | 'high'` → `{ effort }`.\n * - `'minimal'` → `{ effort: 'low' }` (closest match in OpenRouter's vocabulary).\n * - `'adaptive'` → `{}` (let upstream decide; OpenRouter passes through).\n * - explicit `thinkingBudget` → `{ max_tokens }` overlaid on the level.\n */\nfunction planOpenRouterReasoning(\n  thinking: ThinkingLevel | undefined,\n  thinkingBudget: number | undefined,\n): Record<string, unknown> | undefined {\n  if ((!thinking || thinking === 'off') && typeof thinkingBudget !== 'number')\n    return undefined\n  const out: Record<string, unknown> = {}\n  if (thinking && thinking !== 'off' && thinking !== 'adaptive') {\n    out.effort = thinking === 'minimal' ? 'low' : thinking\n  }\n  if (typeof thinkingBudget === 'number' && thinkingBudget > 0) {\n    out.max_tokens = thinkingBudget\n  }\n  return out\n}\n\n/**\n * Factory for any OpenAI-compatible HTTP endpoint.\n *\n * Speaks the standard `POST /chat/completions` + `stream: true` + SSE dialect.\n * Thin wrappers (`openrouter`, `cerebras`) call this with pinned defaults.\n *\n * @example Baseten (non-standard auth scheme)\n * ```ts\n * openaiCompat({\n *   name: 'baseten',\n *   apiKey: process.env.BASETEN_API_KEY!,\n *   baseURL: process.env.BASETEN_PROXY_URL!,\n *   authHeader: { name: 'Authorization', scheme: 'Api-Key' },\n * })\n * ```\n */\nexport function openaiCompat(params: OpenAICompatParams): Provider {\n  const name = params.name ?? 'openai-compat'\n  const defaultModel = params.defaultModel ?? 'gpt-4o-mini'\n  const authHeaderName = params.authHeader?.name ?? 'Authorization'\n  const authHeaderValue = params.authHeader?.scheme\n    ? `${params.authHeader.scheme} ${params.apiKey}`\n    : (params.authHeader ? params.apiKey : `Bearer ${params.apiKey}`)\n  const extraHeaders = params.extraHeaders ?? {}\n  const endpoint = `${params.baseURL.replace(TRAILING_SLASH_RE, '')}/chat/completions`\n  const capabilities: ProviderCapabilities = {\n    vision: params.capabilities?.vision ?? false,\n    imageInToolResult: params.capabilities?.imageInToolResult ?? false,\n  }\n\n  const cacheBreakpointsEnabled = params.cacheBreakpoints === true\n  const reasoningEnabled = params.supportsReasoning === true\n\n  return {\n    name,\n    meta: { defaultModel, capabilities },\n    formatTools,\n    userMessage,\n    assistantMessage,\n    toolResultsMessage,\n    classifyError: classifyOpenAICompatError,\n\n    async stream(options: StreamOptions, callbacks: StreamCallbacks): Promise<TurnResult> {\n      const modelId = options.model || defaultModel\n      const messages = toOAIMessages(options.system, options.messages, {\n        imageInToolResult: capabilities.imageInToolResult === true,\n        supportsReasoning: reasoningEnabled,\n        model: modelId,\n      })\n      // Prompt caching — insert `cache_control: { type: 'ephemeral' }` breakpoints on\n      // the system message's last text part, the last tool definition, and the last\n      // message's final content part. Only emitted when the factory was constructed\n      // with `cacheBreakpoints: true` (set by the `openrouter` wrapper); endpoints\n      // that strict-validate the request schema otherwise reject unknown fields.\n      const shouldCache = cacheBreakpointsEnabled && options.cache !== false\n      if (shouldCache) {\n        applyOAICacheBreakpoints(messages)\n      }\n\n      // max_tokens must cover both thinking budget and response tokens\n      const maxTokens = options.thinkingBudget\n        ? options.thinkingBudget + options.maxTokens\n        : options.maxTokens\n\n      const body: Record<string, unknown> = {\n        // Spread first so the typed core below wins on collision — explicit\n        // always overrides generic.\n        ...(params.extraBodyParams ?? {}),\n        model: modelId,\n        messages,\n        max_tokens: maxTokens,\n        stream: true,\n      }\n\n      // OpenRouter normalized reasoning request field. Only set when the host\n      // advertises support — Chat Completions hosts that don't speak it would\n      // 400 on the unknown field.\n      if (reasoningEnabled) {\n        const reasoning = planOpenRouterReasoning(options.thinking, options.thinkingBudget)\n        if (reasoning)\n          body.reasoning = reasoning\n      }\n\n      if (options.tools && (options.tools as unknown[]).length > 0) {\n        body.tools = shouldCache\n          ? applyOAIToolCacheBreakpoint(options.tools as OAITool[])\n          : options.tools\n      }\n\n      if (options.toolChoice) {\n        if (options.toolChoice.type === 'tool' && options.toolChoice.name)\n          body.tool_choice = { type: 'function', function: { name: options.toolChoice.name } }\n        else if (options.toolChoice.type === 'required')\n          body.tool_choice = 'required'\n        else\n          body.tool_choice = 'auto'\n      }\n\n      const response = await fetch(endpoint, {\n        method: 'POST',\n        headers: {\n          [authHeaderName]: authHeaderValue,\n          'Content-Type': 'application/json',\n          ...extraHeaders,\n        },\n        body: JSON.stringify(body),\n        signal: options.signal,\n      })\n\n      if (!response.ok) {\n        const errorText = await response.text()\n        throw new OpenAICompatHttpError(response.status, errorText)\n      }\n\n      const result = await consumeSSE(response, callbacks, options.signal)\n      const finishReason = mapOAIFinishReason(result.finishReason)\n\n      return {\n        assistantMessage: buildAssistantContent(\n          result.text,\n          result.toolCalls,\n          result.thinking,\n          reasoningEnabled && result.reasoningDetails.length > 0\n            ? { details: result.reasoningDetails, producer: 'openrouter', model: modelId }\n            : undefined,\n        ),\n        text: result.text,\n        toolCalls: result.toolCalls,\n        done: result.finishReason === 'stop' || result.toolCalls.length === 0,\n        usage: fillEstimatedCost({\n          input: result.usage.input,\n          output: result.usage.output,\n          ...(result.usage.cacheRead !== undefined ? { cacheRead: result.usage.cacheRead } : {}),\n          ...(result.usage.cacheCreation !== undefined ? { cacheCreation: result.usage.cacheCreation } : {}),\n          ...(result.usage.cost !== undefined ? { cost: result.usage.cost } : {}),\n          ...(finishReason ? { finishReason } : {}),\n          modelId,\n        }, name),\n      }\n    },\n  }\n}\n","/**\n * Canonical SessionMessage format with converters from/to Anthropic and OpenAI-compat formats.\n */\n\nimport type { Provider } from '../providers'\nimport type { SessionContentBlock, SessionMessage, ToolResultContent } from '../types'\nimport { ASSISTANT_TOOL_CALLS_TAG, TOOL_RESULTS_TAG } from '../providers/openai-compat'\n\ntype ToolCallBlock = Extract<SessionContentBlock, { type: 'tool_call' }>\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Decode an Anthropic `tool_result.content` wire value back to zidane's canonical\n * `string | ToolResultContent[]` shape.\n *\n * Anthropic accepts three shapes in the wire: `string`, `Array<{type:'text',text}>`,\n * or `Array<{type:'text'|'image', ...}>`. We collapse to `string` only when every\n * block is text to keep simple cases readable.\n */\nfunction decodeAnthropicToolResultContent(content: unknown): string | ToolResultContent[] {\n  if (typeof content === 'string')\n    return content\n\n  if (!Array.isArray(content))\n    return JSON.stringify(content)\n\n  const blocks: ToolResultContent[] = []\n  for (const raw of content) {\n    if (!raw || typeof raw !== 'object')\n      continue\n    const b = raw as Record<string, unknown>\n    if (b.type === 'text' && typeof b.text === 'string') {\n      blocks.push({ type: 'text', text: b.text })\n      continue\n    }\n    if (b.type === 'image' && b.source && typeof b.source === 'object') {\n      const src = b.source as Record<string, unknown>\n      if (src.type === 'base64' && typeof src.data === 'string' && typeof src.media_type === 'string') {\n        blocks.push({ type: 'image', mediaType: src.media_type, data: src.data })\n        continue\n      }\n    }\n    // Unknown block → stringify into text for visibility.\n    blocks.push({ type: 'text', text: JSON.stringify(raw) })\n  }\n\n  if (blocks.length === 0)\n    return ''\n\n  const hasNonText = blocks.some(b => b.type !== 'text')\n  if (!hasNonText)\n    return blocks.map(b => (b as { type: 'text', text: string }).text).join('\\n')\n\n  return blocks\n}\n\n/**\n * Encode zidane's canonical `string | ToolResultContent[]` shape to Anthropic's\n * wire format for `tool_result.content`.\n */\nfunction encodeAnthropicToolResultContent(\n  output: string | ToolResultContent[],\n): string | Array<{ type: 'text', text: string } | { type: 'image', source: { type: 'base64', media_type: string, data: string } }> {\n  if (typeof output === 'string')\n    return output\n  return output.map((b) => {\n    if (b.type === 'text')\n      return { type: 'text' as const, text: b.text }\n    return {\n      type: 'image' as const,\n      source: { type: 'base64' as const, media_type: b.mediaType, data: b.data },\n    }\n  })\n}\n\n// ---------------------------------------------------------------------------\n// fromAnthropic\n// ---------------------------------------------------------------------------\n\nexport function fromAnthropic(msg: { role: string, content: unknown }): SessionMessage {\n  const role = msg.role as 'user' | 'assistant'\n  const content: SessionContentBlock[] = []\n\n  if (typeof msg.content === 'string') {\n    content.push({ type: 'text', text: msg.content })\n    return { role, content }\n  }\n\n  if (Array.isArray(msg.content)) {\n    for (const block of msg.content) {\n      if (!block || typeof block !== 'object')\n        continue\n      const b = block as Record<string, unknown>\n\n      if (b.type === 'text') {\n        content.push({ type: 'text', text: b.text as string })\n      }\n      else if (b.type === 'image') {\n        const source = b.source as Record<string, unknown>\n        if (source?.type === 'base64') {\n          content.push({ type: 'image', mediaType: source.media_type as string, data: source.data as string })\n        }\n      }\n      else if (b.type === 'tool_use') {\n        content.push({ type: 'tool_call', id: b.id as string, name: b.name as string, input: b.input as Record<string, unknown> })\n      }\n      else if (b.type === 'tool_result') {\n        const output = decodeAnthropicToolResultContent(b.content)\n        const block: Extract<SessionContentBlock, { type: 'tool_result' }> = {\n          type: 'tool_result',\n          callId: b.tool_use_id as string,\n          output,\n        }\n        if (b.is_error === true)\n          block.isError = true\n        content.push(block)\n      }\n      else if (b.type === 'thinking') {\n        const block: Extract<SessionContentBlock, { type: 'thinking' }> = {\n          type: 'thinking',\n          text: (b.thinking as string | undefined) ?? '',\n        }\n        if (typeof b.signature === 'string') {\n          block.signature = b.signature\n          // Tag the producer so cross-provider senders can drop foreign signatures.\n          block.signatureProducer = 'anthropic'\n        }\n        content.push(block)\n      }\n      else if (b.type === 'redacted_thinking') {\n        // Encrypted reasoning that must be echoed back unmodified to keep\n        // interleaved-thinking + tool-use chains working on Sonnet 3.7+/Opus 4.x.\n        content.push({ type: 'redacted_thinking', data: (b.data as string | undefined) ?? '' })\n      }\n      // Unknown block types are silently skipped\n    }\n  }\n\n  return { role, content }\n}\n\n// ---------------------------------------------------------------------------\n// fromOpenAI\n// ---------------------------------------------------------------------------\n\nexport function fromOpenAI(msg: { role: string, content: unknown }): SessionMessage {\n  const role = msg.role as 'user' | 'assistant'\n  const content: SessionContentBlock[] = []\n  const c: unknown = msg.content\n\n  if (c == null) {\n    return { role, content }\n  }\n\n  if (typeof c === 'string') {\n    content.push({ type: 'text', text: c })\n    return { role, content }\n  }\n\n  if (typeof c === 'object' && !Array.isArray(c) && (c as { _tag?: unknown })._tag === ASSISTANT_TOOL_CALLS_TAG) {\n    const tagged = c as { text?: unknown, tool_calls?: unknown }\n    if (typeof tagged.text === 'string' && tagged.text) {\n      content.push({ type: 'text', text: tagged.text })\n    }\n    if (Array.isArray(tagged.tool_calls)) {\n      for (const raw of tagged.tool_calls) {\n        if (!raw || typeof raw !== 'object')\n          continue\n        const tc = raw as { id?: string, function?: { name?: string, arguments?: unknown } }\n        const rawArgs = tc.function?.arguments\n        const input: Record<string, unknown> = rawArgs\n          ? (typeof rawArgs === 'string' ? JSON.parse(rawArgs) : rawArgs as Record<string, unknown>)\n          : {}\n        content.push({ type: 'tool_call', id: tc.id ?? '', name: tc.function?.name ?? '', input })\n      }\n    }\n    return { role, content }\n  }\n\n  if (typeof c === 'object' && !Array.isArray(c) && (c as { _tag?: unknown })._tag === TOOL_RESULTS_TAG) {\n    const tagged = c as { results?: unknown }\n    if (Array.isArray(tagged.results)) {\n      for (const raw of tagged.results) {\n        if (!raw || typeof raw !== 'object')\n          continue\n        const r = raw as { tool_call_id?: string, content?: string | ToolResultContent[] }\n        content.push({ type: 'tool_result', callId: r.tool_call_id ?? '', output: r.content ?? '' })\n      }\n    }\n    return { role, content }\n  }\n\n  if (Array.isArray(c)) {\n    for (const block of c) {\n      if (!block || typeof block !== 'object')\n        continue\n      const b = block as Record<string, unknown>\n\n      if (b.type === 'text') {\n        content.push({ type: 'text', text: b.text as string })\n      }\n      else if (b.type === 'image_url') {\n        const imageUrl = (b.image_url as Record<string, unknown>)?.url as string\n        if (imageUrl?.startsWith('data:')) {\n          const [meta, data] = imageUrl.slice(5).split(',', 2)\n          const mediaType = meta.replace(';base64', '')\n          content.push({ type: 'image', mediaType, data })\n        }\n      }\n    }\n    return { role, content }\n  }\n\n  return { role, content }\n}\n\n// ---------------------------------------------------------------------------\n// toAnthropic\n// ---------------------------------------------------------------------------\n\ntype AnthropicWireBlock\n  = | { type: 'text', text: string }\n    | { type: 'image', source: { type: 'base64', media_type: string, data: string } }\n    | { type: 'tool_use', id: string, name: string, input: Record<string, unknown> }\n    | { type: 'tool_result', tool_use_id: string, content: ReturnType<typeof encodeAnthropicToolResultContent>, is_error?: true }\n    | { type: 'thinking', thinking: string, signature: string }\n    | { type: 'redacted_thinking', data: string }\n\nexport function toAnthropic(msg: SessionMessage): { role: string, content: unknown } {\n  const blocks: AnthropicWireBlock[] = msg.content\n    // Drop foreign reasoning state. Three independent rejection paths,\n    // each driven by an Anthropic API constraint we've hit in production:\n    //\n    //  1. `signatureProducer === 'openai'` — OpenAI's `encrypted_content`\n    //     isn't a valid Anthropic HMAC; sending it 400s with an unhelpful\n    //     \"invalid signature\" error.\n    //  2. `type === 'thinking' && !signature` — Anthropic's\n    //     `ThinkingBlockParam` requires a signature field. A non-Anthropic\n    //     producer that doesn't sign thinking (Cerebras, Gemini, OSS via\n    //     OpenAI-compat, etc.) leaves a block in the session that 400s\n    //     here with `messages.N.content.M.thinking.signature: Field\n    //     required` the next time the user picks an Anthropic model. Drop\n    //     them — the model can re-think on its own turn, no info loss\n    //     beyond the prior provider's chain-of-thought, which Anthropic\n    //     can't consume anyway.\n    //  3. `type === 'provider_reasoning'` — opaque OpenRouter envelope;\n    //     not an Anthropic block type at all.\n    .filter((b) => {\n      if (b.type === 'provider_reasoning')\n        return false\n      if (b.type !== 'thinking')\n        return true\n      if (b.signatureProducer === 'openai')\n        return false\n      if (!b.signature)\n        return false\n      return true\n    })\n    .map((block): AnthropicWireBlock => {\n      switch (block.type) {\n        case 'text':\n          return { type: 'text', text: block.text }\n        case 'image':\n          return { type: 'image', source: { type: 'base64', media_type: block.mediaType, data: block.data } }\n        case 'tool_call':\n          return { type: 'tool_use', id: block.id, name: block.name, input: block.input }\n        case 'tool_result': {\n          const out: AnthropicWireBlock = {\n            type: 'tool_result',\n            tool_use_id: block.callId,\n            content: encodeAnthropicToolResultContent(block.output),\n          }\n          if (block.isError)\n            out.is_error = true\n          return out\n        }\n        case 'thinking':\n          // Filter above guarantees `signature` is present and either\n          // anthropic-produced or legacy (back-compat for pre-tagging\n          // Anthropic sessions where producer was never recorded).\n          return { type: 'thinking', thinking: block.text, signature: block.signature ?? '' }\n        case 'redacted_thinking':\n          return { type: 'redacted_thinking', data: block.data }\n        default:\n          return { type: 'text', text: '' }\n      }\n    })\n\n  // Simplify to plain string if only one text block\n  const first = blocks[0]\n  if (blocks.length === 1 && first.type === 'text')\n    return { role: msg.role, content: first.text }\n\n  return { role: msg.role, content: blocks }\n}\n\n// ---------------------------------------------------------------------------\n// toOpenAI\n// ---------------------------------------------------------------------------\n\nexport function toOpenAI(msg: SessionMessage): { role: string, content: unknown } {\n  const toolCalls = msg.content.filter(b => b.type === 'tool_call')\n  const toolResults = msg.content.filter(b => b.type === 'tool_result')\n  const textBlocks = msg.content.filter(b => b.type === 'text')\n  const imageBlocks = msg.content.filter(b => b.type === 'image')\n\n  // Tool results → tagged format\n  if (toolResults.length > 0) {\n    return {\n      role: msg.role,\n      content: {\n        _tag: TOOL_RESULTS_TAG,\n        results: toolResults.map(tr => ({ tool_call_id: tr.callId, content: tr.output })),\n      },\n    }\n  }\n\n  // Tool calls → tagged format\n  if (toolCalls.length > 0) {\n    const textContent = textBlocks.length > 0 ? textBlocks[0].text : null\n    return {\n      role: msg.role,\n      content: {\n        _tag: ASSISTANT_TOOL_CALLS_TAG,\n        text: textContent,\n        tool_calls: toolCalls.map(tc => ({\n          id: tc.id,\n          type: 'function',\n          function: { name: tc.name, arguments: JSON.stringify(tc.input) },\n        })),\n      },\n    }\n  }\n\n  // Images → multimodal array\n  if (imageBlocks.length > 0) {\n    const parts: unknown[] = imageBlocks.map(img => ({\n      type: 'image_url',\n      image_url: { url: `data:${img.mediaType};base64,${img.data}` },\n    }))\n    for (const b of textBlocks)\n      parts.push({ type: 'text', text: b.text })\n    return { role: msg.role, content: parts }\n  }\n\n  // Pure text → string\n  if (textBlocks.length === 1)\n    return { role: msg.role, content: textBlocks[0].text }\n\n  // Multiple text blocks or empty\n  if (textBlocks.length > 1)\n    return { role: msg.role, content: textBlocks.map(b => ({ type: 'text', text: b.text })) }\n\n  return { role: msg.role, content: null }\n}\n\n// ---------------------------------------------------------------------------\n// autoDetectAndConvert\n// ---------------------------------------------------------------------------\n\n// ---------------------------------------------------------------------------\n// ensureToolResultPairing\n// ---------------------------------------------------------------------------\n\n/**\n * Placeholder content inserted into a synthetic `tool_result` when the harness\n * has to repair an orphan `tool_use`. Exported so downstream consumers\n * (training-data collectors, HFI submission) can reject any payload containing\n * it — the marker satisfies the wire-level pairing contract structurally but\n * the content itself is fake and would poison fine-tuning data.\n */\nexport const SYNTHETIC_TOOL_RESULT_PLACEHOLDER = '[Tool result missing due to internal error]'\n\n/**\n * Replacement text for an assistant message whose every content block was\n * stripped during pairing repair (e.g. the only blocks were orphan\n * `tool_call`s). Providers reject empty `content` arrays — the marker keeps\n * the turn shape valid while signaling \"this assistant turn lost its\n * outputs\" to the model so it can recover.\n */\nexport const TOOL_USE_INTERRUPTED_MARKER = '[Tool use interrupted]'\n\n/**\n * Replacement text for a user message whose every content block was a\n * `tool_result` with no matching upstream `tool_call` (e.g. the assistant\n * pair was stripped by an earlier compaction). Same role as\n * {@link TOOL_USE_INTERRUPTED_MARKER} on the user side.\n */\nexport const ORPHANED_TOOL_RESULT_MARKER = '[Orphaned tool result removed due to conversation resume]'\n\n/**\n * Classification of a single repair the pairing pass performed. Surfaced via\n * {@link EnsureToolResultPairingOptions.onRepair} so consumers can wire\n * telemetry, debug logs, or strict-mode rejection without re-implementing the\n * walk.\n *\n * Each entry corresponds to one of the corruption modes documented on\n * {@link ensureToolResultPairing}.\n */\nexport type PairingRepairMode\n  = | 'orphan-tool-use-prepend' // mode 1: tool_use with no matching tool_result; next msg is user → prepend synthetic\n    | 'orphan-tool-use-append' // mode 2: tool_use is followed by nothing (or a non-user msg) → append synthetic user turn\n    | 'orphan-tool-result-strip' // mode 3: tool_result with no preceding tool_call → strip block\n    | 'duplicate-tool-use-strip' // mode 4: duplicate tool_use id across assistant msgs → strip later instance\n    | 'duplicate-tool-result-strip' // mode 5: duplicate tool_result callId in one user msg → strip later instance\n    | 'empty-assistant-marker' // mode 6: assistant msg emptied by mode-4 stripping → replace with marker text\n\nexport interface PairingRepair {\n  mode: PairingRepairMode\n  /** Tool-use / tool-result id this repair concerns. Absent for empty-marker repairs. */\n  callId?: string\n  /** Zero-based index into the INPUT `messages` array where the corruption was found. */\n  messageIndex: number\n}\n\nexport interface EnsureToolResultPairingOptions {\n  /**\n   * Fired once per repair the pass performed. Synchronous so the loop can\n   * stay on its hot path. Throwing from the callback aborts the pass —\n   * consumers wanting fail-fast (strict mode) can re-throw with their own\n   * typed error.\n   */\n  onRepair?: (repair: PairingRepair) => void\n}\n\n/**\n * Defensive repair pass that rewrites a message list so it satisfies the\n * wire-level `tool_use` ↔ `tool_result` adjacency contract every modern\n * provider enforces.\n *\n * Anthropic 400s on orphans with `'tool_use' ids were found without\n * 'tool_result' blocks immediately after` (and its inverse, `tool_result\n * must be preceded by a tool_call with the same toolCallId`). OpenAI's\n * Chat Completions API rejects most mismatches with a 400 too.\n *\n * Six repair modes — modeled after Anthropic's Claude Code defenses:\n *\n * | # | Corruption | Repair |\n * |---|------------|--------|\n * | 1 | assistant `tool_use` whose next user msg lacks a matching `tool_result` | **Prepend** a synthetic `tool_result` block carrying {@link SYNTHETIC_TOOL_RESULT_PLACEHOLDER} with `isError: true` |\n * | 2 | assistant `tool_use` followed by nothing (or by a non-user msg) | **Insert** a new synthetic user message with the same placeholder |\n * | 3 | user `tool_result` with no preceding assistant `tool_call` | **Strip** the orphan block; if it empties the msg, replace with {@link ORPHANED_TOOL_RESULT_MARKER} text block |\n * | 4 | duplicate `tool_call.id` across assistant messages (CC-1212) | **Strip** later instances + their matching tool_results |\n * | 5 | duplicate `tool_result.callId` within a single user message | **Dedupe** by `callId`, keep first |\n * | 6 | assistant message emptied by mode-4 stripping | **Replace** content with {@link TOOL_USE_INTERRUPTED_MARKER} text block |\n *\n * **Repair, not drop.** Earlier versions of this pass simply dropped orphan\n * blocks, which (a) silently rewrote history the model had reasoned over and\n * (b) cascaded — dropping an assistant tool_call would orphan its\n * tool_result, which would then get dropped too, removing any trace of\n * \"what the model tried to do\" from the transcript. The repair-based pass\n * preserves the model's tool_use shape and patches the dangling result with\n * an `is_error` placeholder so the model sees \"I tried X, the result was\n * lost\" and can retry intelligently.\n *\n * Adjacency contract: `tool_result` blocks must live in the user message\n * IMMEDIATELY following the assistant message that emitted the matching\n * `tool_use`. The pass enforces strict adjacency — a tool_result two\n * messages downstream of its tool_call is still an orphan.\n *\n * Idempotent: returns the input reference unchanged when no repairs were\n * necessary. Re-running on already-repaired output is a no-op.\n *\n * Pure: does not mutate input messages or their content arrays — every\n * repair allocates a fresh array / object.\n */\nexport function ensureToolResultPairing(\n  messages: SessionMessage[],\n  options: EnsureToolResultPairingOptions = {},\n): SessionMessage[] {\n  if (messages.length === 0)\n    return messages\n\n  const fireRepair = options.onRepair ?? (() => {})\n\n  // Pre-pass: first-occurrence index of every assistant `tool_call.id`.\n  // Mode 4 strips any block whose first occurrence wasn't in the current\n  // message — the first instance wins so the original semantics stand.\n  const firstSeenAt = new Map<string, number>()\n  for (let i = 0; i < messages.length; i++) {\n    const msg = messages[i]\n    if (msg.role !== 'assistant')\n      continue\n    for (const block of msg.content) {\n      if (block.type === 'tool_call' && !firstSeenAt.has(block.id))\n        firstSeenAt.set(block.id, i)\n    }\n  }\n\n  // Scoped to this call. Keyed by INPUT index of the user message that\n  // should receive prepended synthetic results from the prior assistant\n  // turn's mode-1 repair. Drained as the outer loop reaches each user msg.\n  const pendingOrphansByUserIndex = new Map<number, string[]>()\n\n  let changed = false\n  const markChanged = () => { changed = true }\n  const out: SessionMessage[] = []\n\n  for (let i = 0; i < messages.length; i++) {\n    const msg = messages[i]\n\n    if (msg.role === 'assistant') {\n      processAssistantMessage({\n        index: i,\n        msg,\n        messages,\n        firstSeenAt,\n        pendingOrphansByUserIndex,\n        out,\n        fireRepair,\n        markChanged,\n      })\n    }\n    else {\n      processUserMessage({\n        index: i,\n        msg,\n        pendingOrphansByUserIndex,\n        out,\n        fireRepair,\n        markChanged,\n      })\n    }\n  }\n\n  return changed ? out : messages\n}\n\ninterface ProcessAssistantArgs {\n  index: number\n  msg: SessionMessage\n  messages: SessionMessage[]\n  firstSeenAt: Map<string, number>\n  pendingOrphansByUserIndex: Map<number, string[]>\n  out: SessionMessage[]\n  fireRepair: (repair: PairingRepair) => void\n  markChanged: () => void\n}\n\n/**\n * Process one assistant message: strip mode-4 duplicates, queue mode-1 / 2\n * orphan-tool-use repairs for the next user message (or insert a synthetic\n * one), and emit a mode-6 marker when dedup empties the message.\n */\nfunction processAssistantMessage(args: ProcessAssistantArgs): void {\n  const { index, msg, messages, firstSeenAt, pendingOrphansByUserIndex, out, fireRepair, markChanged } = args\n\n  // Mode 4: drop tool_call blocks that are duplicates either:\n  //   - across messages (first occurrence was in an earlier assistant msg), or\n  //   - within this same message (same id appearing twice in one turn —\n  //     pathological but observed in the wild with retry-replay providers).\n  //\n  // The per-message `seenHere` set guards against the intra-message case:\n  // `firstSeenAt` records only the first OCCURRENCE per id, so two blocks\n  // sharing an id within the same message both pass the cross-message\n  // check (`firstSeenAt.get(id) === index`). The local set tracks which\n  // ids we've already kept this iteration and strips later repeats.\n  const dedupedContent: SessionContentBlock[] = []\n  const seenHere = new Set<string>()\n  let dedupedChanged = false\n  for (const block of msg.content) {\n    if (block.type === 'tool_call') {\n      const isCrossMsgDup = firstSeenAt.get(block.id) !== index\n      const isIntraMsgDup = seenHere.has(block.id)\n      if (isCrossMsgDup || isIntraMsgDup) {\n        dedupedChanged = true\n        fireRepair({ mode: 'duplicate-tool-use-strip', callId: block.id, messageIndex: index })\n        continue\n      }\n      seenHere.add(block.id)\n    }\n    dedupedContent.push(block)\n  }\n\n  const surviving = collectIds<ToolCallBlock>(dedupedContent, 'tool_call', b => b.id)\n  const next = messages[index + 1]\n  const nextIsUser = next && next.role === 'user'\n  const nextResultIds = nextIsUser ? collectResultIds(next.content) : new Set<string>()\n  const orphans: string[] = []\n  for (const id of surviving) {\n    if (!nextResultIds.has(id))\n      orphans.push(id)\n  }\n\n  // Emit the (possibly deduped) assistant message — modes 1 / 2 patch the\n  // matching user side rather than touching tool_use blocks.\n  emitAssistantAfterDedup({ index, msg, dedupedContent, dedupedChanged, out, fireRepair, markChanged })\n\n  if (orphans.length === 0)\n    return\n\n  // Mode 1: stash for the next user msg processor to prepend.\n  if (nextIsUser) {\n    markChanged()\n    pendingOrphansByUserIndex.set(index + 1, orphans)\n    for (const callId of orphans)\n      fireRepair({ mode: 'orphan-tool-use-prepend', callId, messageIndex: index })\n    return\n  }\n\n  // Mode 2: synthesize a user message with placeholders for every orphan.\n  markChanged()\n  out.push({\n    role: 'user',\n    content: orphans.map(callId => syntheticResultBlock(callId)),\n  })\n  for (const callId of orphans)\n    fireRepair({ mode: 'orphan-tool-use-append', callId, messageIndex: index })\n}\n\ninterface EmitAssistantArgs {\n  index: number\n  msg: SessionMessage\n  dedupedContent: SessionContentBlock[]\n  dedupedChanged: boolean\n  out: SessionMessage[]\n  fireRepair: (repair: PairingRepair) => void\n  markChanged: () => void\n}\n\nfunction emitAssistantAfterDedup(args: EmitAssistantArgs): void {\n  const { index, msg, dedupedContent, dedupedChanged, out, fireRepair, markChanged } = args\n  if (!dedupedChanged) {\n    out.push(msg)\n    return\n  }\n  markChanged()\n  if (dedupedContent.length === 0) {\n    out.push({ ...msg, content: [{ type: 'text', text: TOOL_USE_INTERRUPTED_MARKER }] })\n    fireRepair({ mode: 'empty-assistant-marker', messageIndex: index })\n    return\n  }\n  out.push({ ...msg, content: dedupedContent })\n}\n\ninterface ProcessUserArgs {\n  index: number\n  msg: SessionMessage\n  pendingOrphansByUserIndex: Map<number, string[]>\n  out: SessionMessage[]\n  fireRepair: (repair: PairingRepair) => void\n  markChanged: () => void\n}\n\n/**\n * Process one user message: dedup mode-5 duplicate tool_results, strip\n * mode-3 orphans whose tool_call is missing from the previously-emitted\n * assistant message, and prepend any synthetic results queued by the prior\n * assistant's mode-1 repair.\n */\nfunction processUserMessage(args: ProcessUserArgs): void {\n  const { index, msg, pendingOrphansByUserIndex, out, fireRepair, markChanged } = args\n  const queuedOrphans = pendingOrphansByUserIndex.get(index)\n  pendingOrphansByUserIndex.delete(index)\n\n  const prev = out.length > 0 ? out[out.length - 1] : null\n  const validIds = prev && prev.role === 'assistant'\n    ? collectIds<ToolCallBlock>(prev.content, 'tool_call', b => b.id)\n    : new Set<string>()\n\n  // Pass 1 — mode 5: dedupe by callId within this msg.\n  const seenCallIds = new Set<string>()\n  let modifiedHere = false\n  const afterDedup: SessionContentBlock[] = []\n  for (const block of msg.content) {\n    if (block.type !== 'tool_result') {\n      afterDedup.push(block)\n      continue\n    }\n    if (seenCallIds.has(block.callId)) {\n      modifiedHere = true\n      fireRepair({ mode: 'duplicate-tool-result-strip', callId: block.callId, messageIndex: index })\n      continue\n    }\n    seenCallIds.add(block.callId)\n    afterDedup.push(block)\n  }\n\n  // Pass 2 — mode 3: strip orphan tool_results.\n  const afterStrip: SessionContentBlock[] = []\n  for (const block of afterDedup) {\n    if (block.type === 'tool_result' && !validIds.has(block.callId)) {\n      modifiedHere = true\n      fireRepair({ mode: 'orphan-tool-result-strip', callId: block.callId, messageIndex: index })\n      continue\n    }\n    afterStrip.push(block)\n  }\n\n  // Pass 3: prepend queued mode-1 synthetic results.\n  const finalContent: SessionContentBlock[] = queuedOrphans\n    ? [...queuedOrphans.map(syntheticResultBlock), ...afterStrip]\n    : afterStrip\n\n  if (!modifiedHere && queuedOrphans === undefined) {\n    out.push(msg)\n    return\n  }\n\n  markChanged()\n  if (finalContent.length === 0) {\n    out.push({ ...msg, content: [{ type: 'text', text: ORPHANED_TOOL_RESULT_MARKER }] })\n    return\n  }\n  out.push({ ...msg, content: finalContent })\n}\n\nfunction syntheticResultBlock(callId: string): SessionContentBlock {\n  return {\n    type: 'tool_result',\n    callId,\n    output: SYNTHETIC_TOOL_RESULT_PLACEHOLDER,\n    isError: true,\n  }\n}\n\nfunction collectResultIds(content: SessionContentBlock[]): Set<string> {\n  const ids = new Set<string>()\n  for (const block of content) {\n    if (block.type === 'tool_result')\n      ids.add(block.callId)\n  }\n  return ids\n}\n\nfunction collectIds<B extends SessionContentBlock>(\n  content: SessionContentBlock[],\n  type: B['type'],\n  getId: (block: B) => string,\n): Set<string> {\n  const ids = new Set<string>()\n  for (const block of content) {\n    if (block.type === type)\n      ids.add(getId(block as B))\n  }\n  return ids\n}\n\n// ---------------------------------------------------------------------------\n// Resume-time filters (L1)\n// ---------------------------------------------------------------------------\n\n/**\n * Drop ASSISTANT turns whose every `tool_call` block is unresolved\n * (no matching `tool_result` block anywhere later in the transcript).\n * Tool_call blocks with at least one matching tool_result are kept — modes\n * 1/3 of {@link ensureToolResultPairing} handle the partial-pair case at\n * wire-send time.\n *\n * Use case: session resume. A turn that emitted three `tool_use` blocks but\n * never persisted the matching `tool_result` turn (process death, crash,\n * `kill -9`) leaves the transcript with an orphan that Anthropic rejects on\n * the FIRST API call after reload. Dropping the whole assistant turn — not\n * just the orphan blocks — preserves text-only turns that legitimately\n * carry reasoning the model wants to see again.\n *\n * Does NOT mint fresh ids: re-id'ing on every resume would cause\n * exponential transcript growth across repeated resumes of an interrupted\n * session.\n *\n * Pure: returns the input reference unchanged when no turn was dropped.\n */\nexport function filterUnresolvedToolUses<T extends { role: string, content: SessionContentBlock[] }>(\n  turns: T[],\n): T[] {\n  if (turns.length === 0)\n    return turns\n\n  // Gather every resolved tool_result id (visible anywhere later in the\n  // transcript). A tool_use is \"resolved\" iff its id appears in this set.\n  const resolvedIds = new Set<string>()\n  for (const turn of turns) {\n    for (const block of turn.content) {\n      if (block.type === 'tool_result')\n        resolvedIds.add(block.callId)\n    }\n  }\n\n  let changed = false\n  const out: T[] = []\n  for (const turn of turns) {\n    if (turn.role !== 'assistant') {\n      out.push(turn)\n      continue\n    }\n    const toolCalls = turn.content.filter(b => b.type === 'tool_call')\n    if (toolCalls.length === 0) {\n      out.push(turn)\n      continue\n    }\n    const allUnresolved = toolCalls.every(b => b.type === 'tool_call' && !resolvedIds.has(b.id))\n    if (allUnresolved) {\n      changed = true\n      continue\n    }\n    out.push(turn)\n  }\n  return changed ? out : turns\n}\n\n/**\n * Classification of a session's tail state for resume purposes.\n *\n * - `'clean'` — the trailing turn is a user message (the model would respond\n *   next), or the transcript is empty. Safe to resume by appending a fresh\n *   user prompt.\n * - `'interrupted'` — the trailing turn is an assistant message that has at\n *   least one `tool_call` block with no matching `tool_result` anywhere\n *   later. The run was almost certainly killed between persisting the\n *   assistant turn and persisting its tool-results turn. Hosts that want\n *   Claude-Code-style auto-resume can detect this and inject a\n *   `\"Continue from where you left off.\"` user message before the next run.\n * - `'completed'` — the trailing turn is an assistant message with no\n *   orphan tool_calls. The model considers itself done. Hosts that want to\n *   resume must supply a new prompt; auto-continuation here would be a\n *   non-sequitur.\n */\nexport type TurnInterruptionState = 'clean' | 'interrupted' | 'completed'\n\n/**\n * Inspect a session's trailing turn to classify whether the run was\n * interrupted mid-tool-call. Pure / synchronous — does not modify the input.\n *\n * Pair with {@link filterUnresolvedToolUses} on the resume path: filter\n * first so the result reflects the post-cleanup state (a turn whose orphans\n * were stripped reads as 'completed', not 'interrupted').\n */\nexport function detectTurnInterruption<T extends { role: string, content: SessionContentBlock[] }>(\n  turns: T[],\n): TurnInterruptionState {\n  if (turns.length === 0)\n    return 'clean'\n  const last = turns[turns.length - 1]\n  if (last.role === 'user')\n    return 'clean'\n  if (last.role !== 'assistant')\n    return 'clean'\n  // Walk all turns to find resolved tool_result ids — a tool_use anywhere\n  // earlier in the run may still be answered by a later tool_result.\n  const resolvedIds = new Set<string>()\n  for (const turn of turns) {\n    for (const block of turn.content) {\n      if (block.type === 'tool_result')\n        resolvedIds.add(block.callId)\n    }\n  }\n  for (const block of last.content) {\n    if (block.type === 'tool_call' && !resolvedIds.has(block.id))\n      return 'interrupted'\n  }\n  return 'completed'\n}\n\n/**\n * Default directive injected by {@link ensureEndsWithUserMessage} when the\n * caller doesn't pass one. Neutral enough to read sensibly in any context —\n * compaction passes its own directive, the agent loop falls back to this.\n *\n * The trailing newline is omitted on purpose; provider `userMessage()`\n * helpers wrap the content in the right block shape and any trailing\n * whitespace would land in the wire payload as-is.\n */\nexport const DEFAULT_USER_TAIL_DIRECTIVE = 'Continue.'\n\n/**\n * Guarantee a message list ends with a `role: 'user'` message, appending a\n * synthetic directive when it doesn't.\n *\n * Why: Anthropic's API (and several OpenAI-compat reasoning models — opus\n * 4.7, the o-series translation layers on Bedrock/Vertex) rejects requests\n * whose final message is `role: 'assistant'` with\n * \"This model does not support assistant message prefill. The conversation\n * must end with a user message.\"\n *\n * Triggers in zidane:\n *   - Compaction over a session whose last turn is the agent's response\n *     (the common case — autocompact fires right after `agent.run()`).\n *   - Schema enforcement after an assistant text turn (no `tool_use`, so\n *     `ensureToolResultPairing` doesn't synthesize a user tail).\n *   - `context:transform` hooks that strip the trailing user turn.\n *\n * The pair-repair pass {@link ensureToolResultPairing} already covers the\n * orphan-`tool_use` case via mode 2; this helper closes the plain-text\n * assistant-tail case. They compose: run pair-repair first, then this\n * pass, so an assistant turn with orphan tool_uses gets its synthetic\n * `tool_result` user turn AND this pass is a no-op (the synthetic turn\n * is already user-role).\n *\n * Empty input passes through unchanged — the caller's \"nothing to send\"\n * guard is responsible for that case; we don't materialize a conversation\n * out of an empty list.\n *\n * Idempotent: returns the input reference unchanged when the list is\n * already user-terminated (or empty).\n *\n * @param messages   Wire-ready message list.\n * @param provider   Provider whose `userMessage()` shape we use so the\n *                   synthetic turn matches the wire format the rest of\n *                   the list already follows.\n * @param directive  Text to put in the synthetic user message. Defaults\n *                   to {@link DEFAULT_USER_TAIL_DIRECTIVE} (\"Continue.\").\n *                   Compaction overrides this with a summary-specific cue.\n */\nexport function ensureEndsWithUserMessage(\n  messages: SessionMessage[],\n  provider: Provider,\n  directive: string = DEFAULT_USER_TAIL_DIRECTIVE,\n): SessionMessage[] {\n  if (messages.length === 0)\n    return messages\n  if (messages[messages.length - 1].role === 'user')\n    return messages\n  return [...messages, provider.userMessage(directive)]\n}\n\nexport function autoDetectAndConvert(msg: { role: string, content: unknown }): SessionMessage {\n  const c: unknown = msg.content\n\n  // OpenAI-compat tagged messages\n  if (c && typeof c === 'object' && !Array.isArray(c)) {\n    const tag = (c as { _tag?: unknown })._tag\n    if (typeof tag === 'string' && tag.startsWith('__zidane_'))\n      return fromOpenAI(msg)\n  }\n\n  // Array: inspect block types\n  if (Array.isArray(c)) {\n    for (const block of c) {\n      if (!block || typeof block !== 'object')\n        continue\n      const b = block as Record<string, unknown>\n      if (b.type === 'tool_use' || (b.type === 'tool_result' && 'tool_use_id' in b)) {\n        return fromAnthropic(msg)\n      }\n      if (b.type === 'image_url') {\n        return fromOpenAI(msg)\n      }\n    }\n    // Default array → Anthropic\n    return fromAnthropic(msg)\n  }\n\n  // String → either format is the same\n  if (typeof c === 'string') {\n    return fromAnthropic(msg)\n  }\n\n  // Default\n  return fromAnthropic(msg)\n}\n"],"mappings":"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"}