@skaile/workspaces 0.8.5

package/dist/bridge/drivers/claude-sdk.js

@@ -0,0 +1,836 @@
+import { classifyClaudeSdkError, AuthError } from '../../chunk-EWP5HZBV.js';
+import { fetchProviderModels } from '../../chunk-KOVLSBXK.js';
+import { dispatchCapability } from '../../chunk-RRVQAE5D.js';
+import { registerDriver, DRIVER_CATALOG, AgentDriver, getBridgeLogger } from '../../chunk-MBBTBKAS.js';
+import '../../chunk-V37HONL7.js';
+import '../../chunk-NSBPE2FW.js';
+import { spawnSync } from 'child_process';
+import { existsSync } from 'fs';
+import { createRequire } from 'module';
+import * as zNS from 'zod';
+
+var zStatic = zNS.z ?? zNS.default ?? zNS;
+function jsonSchemaToZodLoose(schema, z2) {
+  const props = schema?.properties ?? null;
+  if (!props || typeof props !== "object") return null;
+  const required = new Set(Array.isArray(schema?.required) ? schema.required : []);
+  const out = {};
+  for (const [key, def] of Object.entries(props)) {
+    let zod;
+    switch (def?.type) {
+      case "string":
+        zod = z2.string();
+        break;
+      case "number":
+      case "integer":
+        zod = z2.number();
+        break;
+      case "boolean":
+        zod = z2.boolean();
+        break;
+      case "array":
+        zod = z2.array(z2.any());
+        break;
+      case "object":
+        zod = z2.record(z2.any());
+        break;
+      default:
+        zod = z2.any();
+    }
+    if (def?.description && typeof def.description === "string") {
+      zod = zod.describe(def.description);
+    }
+    if (!required.has(key)) zod = zod.optional();
+    out[key] = zod;
+  }
+  return out;
+}
+if (typeof globalThis.require === "undefined") {
+  try {
+    const metaUrl = (0, eval)("import.meta.url");
+    globalThis.require = createRequire(metaUrl);
+  } catch {
+  }
+}
+var ClaudeSdkDriver = class extends AgentDriver {
+  driverInfo = {
+    id: "claude-sdk",
+    name: "Claude Agent SDK",
+    modelAgnostic: false,
+    supportsInBandAbort: true
+  };
+  log = getBridgeLogger("claude-sdk");
+  config;
+  abortController = null;
+  running = false;
+  sdk = null;
+  toolIdToName = /* @__PURE__ */ new Map();
+  prevText = "";
+  /** Active query — may stay alive between turns if streamInput works. */
+  query = null;
+  /** Resolves when the current turn completes. */
+  turnResolve = null;
+  /** Rejects when the current turn errors. */
+  turnReject = null;
+  /** Guards against duplicate agent_end emissions per turn. */
+  turnCompleted = false;
+  /** Tracks whether a session has been started (for continue: true). */
+  hasSession = false;
+  /** Session ID from the SDK — used for streamInput messages. */
+  sessionId = "";
+  /** Cached slash commands discovered from the SDK. */
+  cachedCommands = [];
+  /** Token usage from the most recent completed turn. */
+  _lastTokens = null;
+  /** Context window size from the most recent result's modelUsage. */
+  _contextWindow = null;
+  /**
+   * `true` when the active credential is a Claude Code OAuth subscription
+   * (no API key in config) rather than a raw `ANTHROPIC_API_KEY`. Set on
+   * every `startQuery` because the credential source can be reconfigured
+   * at runtime via `configure`. Threaded into `classifyClaudeSdkError` so
+   * upstream auth-shaped failures get a quota-aware hint when warranted.
+   */
+  usingOauthCredential = false;
+  /**
+   * @param config - Driver configuration. Claude SDK-relevant fields:
+   *   - `cwd` — working directory; SDK session files and agent definitions are read from here.
+   *   - `model` — Anthropic model identifier (e.g. `"claude-sonnet-4-5"`). Defaults to `"sonnet"`.
+   *   - `apiKeys.anthropic` / `env.ANTHROPIC_API_KEY` — API key forwarded to the SDK query.
+   *   - `agentName` — name of a `.claude/agents/<name>.md` agent definition to use as identity.
+   *   - `mcpServers` — in-process MCP server instances injected as native `tool_use` tools.
+   *   - `systemPrompt` — appended to the `claude_code` preset system prompt.
+   *   - `resumeSessionId` — SDK session UUID to resume from a prior driver lifetime.
+   *   - `maxTurns` — maximum agentic turns per `prompt()` call (default: 15).
+   */
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  get runtimeSessionId() {
+    return this.sessionId || void 0;
+  }
+  reconfigure(patch) {
+    if (patch.model !== void 0) this.config.model = patch.model;
+    if (patch.thinking !== void 0) this.config.thinking = patch.thinking;
+    if (patch.effort !== void 0) this.config.effort = patch.effort;
+  }
+  getModel() {
+    return this.config.model;
+  }
+  /**
+   * Dynamically imports `@anthropic-ai/claude-agent-sdk`.
+   *
+   * @throws {Error} When the SDK package is not installed. Install it with
+   *   `bun add @anthropic-ai/claude-agent-sdk`.
+   */
+  async start() {
+    try {
+      this.sdk = await import('@anthropic-ai/claude-agent-sdk');
+      this.log.info("Claude Agent SDK loaded");
+    } catch {
+      throw new Error(
+        "Claude Agent SDK not installed. Run: bun add @anthropic-ai/claude-agent-sdk"
+      );
+    }
+  }
+  /**
+   * Sends a user message to the Claude Agent SDK and resolves when the turn completes.
+   *
+   * If a live SDK query already exists (from a prior turn in this session) the message
+   * is fed via `streamInput()` for efficient multi-turn continuity. Otherwise a new query
+   * is started applying the resume chain described in the class-level remarks.
+   *
+   * @param message - Plain-text user prompt.
+   * @throws {Error} When the SDK reports a fatal error that cannot be auto-recovered.
+   *
+   * @remarks
+   * A single automatic retry is performed when the SDK throws
+   * "No conversation found with session ID …" — a recoverable stale-resume error that
+   * occurs after a container crash that prevented the SDK from flushing its session file.
+   */
+  async prompt(message, _retryCount = 0) {
+    if (!this.sdk) await this.start();
+    let retrying = false;
+    if (_retryCount === 0) this._lastTokens = null;
+    this.running = true;
+    this.prevText = "";
+    this.turnCompleted = false;
+    const turnPromise = new Promise((resolve, reject) => {
+      this.turnResolve = resolve;
+      this.turnReject = reject;
+    });
+    try {
+      if (this.query) {
+        const userMsg = this.buildUserMessage(message);
+        this.query.streamInput(this.singleItemIterable(userMsg));
+      } else {
+        await this.startQuery(message);
+      }
+    } catch (err) {
+      this.turnResolve = null;
+      this.turnReject = null;
+      this.running = false;
+      throw err;
+    }
+    try {
+      await turnPromise;
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      const isStaleResume = _retryCount === 0 && /No conversation found with session ID/i.test(errMsg);
+      if (isStaleResume) {
+        const staleId = this.config.resumeSessionId || this.sessionId || "unknown";
+        this.log.warn("stale Claude Code session, retrying with a fresh session", { staleId });
+        this.emit("agent-event", {
+          type: "resume_failed",
+          resumeSessionId: staleId,
+          reason: "jsonl_lost"
+        });
+        this.emit("agent-event", {
+          type: "error",
+          error: "Claude Code session state was lost (likely a prior crash). Restarting with a fresh session \u2014 previous conversation context is not available.",
+          fatal: false
+        });
+        this.sessionId = "";
+        this.hasSession = false;
+        this.query = null;
+        this.config.resumeSessionId = void 0;
+        this.turnResolve = null;
+        this.turnReject = null;
+        this.running = false;
+        retrying = true;
+        return this.prompt(message, _retryCount + 1);
+      }
+      const isAuthError = err instanceof AuthError && _retryCount === 0;
+      if (isAuthError && this.config.onAuthError) {
+        this.log.info("auth error caught; invoking onAuthError refresh callback");
+        let refreshed = false;
+        try {
+          const mint = await this.config.onAuthError({
+            configId: this.config.aiProviderConfigId ?? ""
+          });
+          refreshed = mint.ok;
+          if (!mint.ok) {
+            this.log.info("onAuthError reported refresh failure; surfacing AuthError", {
+              code: mint.code
+            });
+          }
+        } catch (refreshErr) {
+          this.log.warn("onAuthError callback threw; surfacing original AuthError", {
+            error: refreshErr instanceof Error ? refreshErr.message : String(refreshErr)
+          });
+        }
+        if (refreshed) {
+          this.log.info("credentials refreshed; retrying prompt");
+          this.query = null;
+          this.turnResolve = null;
+          this.turnReject = null;
+          this.running = false;
+          retrying = true;
+          return this.prompt(message, _retryCount + 1);
+        }
+      }
+      throw err;
+    } finally {
+      if (!retrying) {
+        this.turnResolve = null;
+        this.turnReject = null;
+        this.running = false;
+      }
+    }
+  }
+  async startQuery(message) {
+    this.abortController = new AbortController();
+    const apiKey = this.config.apiKeys?.anthropic || this.config.env?.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY;
+    this.usingOauthCredential = !apiKey;
+    const claudePath = this.findClaudeBinary();
+    const options = {
+      cwd: this.config.cwd,
+      // Load project + user settings so .claude/skills/ are discovered
+      settingSources: ["user", "project"],
+      // Use full Claude Code tool preset so skills, agents, etc. work
+      tools: { type: "preset", preset: "claude_code" },
+      permissionMode: "bypassPermissions",
+      allowDangerouslySkipPermissions: true,
+      abortController: this.abortController,
+      model: this.config.model || "sonnet",
+      maxTurns: this.config.maxTurns ?? 15,
+      includePartialMessages: true,
+      // Thinking mode — maps simple string config to SDK ThinkingConfig objects
+      ...this.config.thinking ? { thinking: this.mapThinkingConfig(this.config.thinking) } : {},
+      // Reasoning effort — passed directly to the SDK
+      ...this.config.effort ? { effort: this.config.effort } : {},
+      hooks: {},
+      stderr: (data) => this.log.warn("claude stderr", { line: data.trim() }),
+      ...claudePath ? { pathToClaudeCodeExecutable: claudePath } : {},
+      ...this.config.systemPrompt ? {
+        systemPrompt: {
+          type: "preset",
+          preset: "claude_code",
+          append: this.config.systemPrompt
+        }
+      } : {},
+      // ── Session continuity ────────────────────────────────────────────────
+      // Three-level fallback ensures the right session is always resumed:
+      //   resumeSessionId — caller explicitly wants this session (skaile resume)
+      //   sessionId       — a session was already started this driver lifetime (multi-turn)
+      //   continue: true  — resume the most recent session in cwd (between restarts)
+      //   (none)          — start fresh
+      ...this.config.resumeSessionId ? { resume: this.config.resumeSessionId } : this.sessionId ? { resume: this.sessionId } : this.hasSession ? { continue: true } : {},
+      // ── Connector tool injection ──────────────────────────────────────────
+      // In-process MCP servers from ConnectorManager (buildSdkConnectorTools in resources.ts).
+      // These expose skaile.yaml connectors as native tool_use calls inside the session.
+      // omp does not use this — it falls back to `skaile res <id> <op>` CLI commands
+      // documented in the system prompt section (buildConnectorPromptSection).
+      //
+      // Protocol v2: when `config.capabilities` is provided, the runner's
+      // CapabilityRegistry contributes an additional `skaile-capabilities`
+      // synthetic MCP server alongside any pre-existing `mcpServers`. Tool
+      // calls into that server route back through `hooks.invoke()` so the
+      // registry's per-handler logger fires and fire-and-forget / render
+      // semantics apply uniformly.
+      ...await this.buildEffectiveMcpServers(),
+      // ── Main-agent handoff ────────────────────────────────────────────────
+      // agentName (from AgentConfig) is the equivalent of `claude --agent <name>`.
+      // The SDK reads .claude/agents/<agentName>.md from the cwd; that file was
+      // rendered by asset-manager (claudeCodeRenderer) during `skaile install`.
+      // Its YAML frontmatter sets model / tools / maxTurns; its markdown body is the
+      // assembled system prompt (SOUL + fragments + RULES + abilities + contracts).
+      // Omitting agentName uses Claude Code's default identity (no custom agent file).
+      ...this.config.agentName ? { agent: this.config.agentName } : {},
+      // Tool restrictions from agent.yaml — always include a wildcard allow-entry for each
+      // injected MCP server so connector tools aren't silently blocked by an allowlist.
+      ...this.buildToolRestrictions()
+    };
+    this.log.debug("query start", {
+      model: this.config.model || "default",
+      session: this.config.resumeSessionId || this.sessionId || this.config.sessionId || "new"
+    });
+    const { query } = this.sdk;
+    const queryArgs = {
+      prompt: message,
+      options
+    };
+    if (apiKey) queryArgs.apiKey = apiKey;
+    this.query = query(queryArgs);
+    this.consumeMessages();
+  }
+  getSlashCommands() {
+    return this.cachedCommands;
+  }
+  /**
+   * Compose the MCP servers passed to the SDK query. Merges the legacy
+   * `config.mcpServers` (connectors / workspace plugin / declarative skaile.yaml
+   * entries) with a synthetic `skaile-capabilities` server built from the
+   * runner-provided {@link BridgeCapabilityHooks} when present.
+   *
+   * Returns an empty options patch when neither source is configured, so legacy
+   * v1 sessions remain unaffected.
+   */
+  async buildEffectiveMcpServers() {
+    const out = {};
+    if (this.config.mcpServers) {
+      Object.assign(out, this.config.mcpServers);
+    }
+    const hooks = this.config.capabilities;
+    if (hooks) {
+      const capServer = await this.buildCapabilityMcpServer();
+      if (capServer) {
+        out["skaile-capabilities"] = capServer;
+      }
+    }
+    return Object.keys(out).length > 0 ? { mcpServers: out } : {};
+  }
+  /**
+   * Build the synthetic MCP server that exposes registered capabilities to the
+   * Claude Agent SDK. Lazy-imports `createSdkMcpServer` from the SDK and `zod`
+   * (an SDK peer) since both are optional peers of this bridge.
+   *
+   * Returns null when the SDK or zod is unavailable, or when the registry
+   * exposes no tools — leaving the legacy `mcpServers` untouched.
+   */
+  async buildCapabilityMcpServer() {
+    const hooks = this.config.capabilities;
+    if (!hooks) return null;
+    const tools = hooks.composeTools();
+    if (tools.length === 0) return null;
+    let sdk;
+    try {
+      sdk = await import('@anthropic-ai/claude-agent-sdk');
+    } catch {
+      this.log.warn("claude-agent-sdk unavailable; cannot build capability MCP server");
+      return null;
+    }
+    const z2 = zStatic;
+    const sdkTools = tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      // Pass through the JSON Schema object directly. The SDK forwards it to
+      // the LLM as the function parameter spec. Concrete validation runs in
+      // `hooks.invoke()`, not the SDK.
+      inputSchema: jsonSchemaToZodLoose(tool.parameters, z2) ?? { args: z2.unknown().optional() },
+      handler: async (input) => {
+        const callId = `cap-${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
+        try {
+          const dispatch = await dispatchCapability(
+            hooks,
+            callId,
+            tool.name,
+            input,
+            (err) => this.log.warn("background capability handler failed", {
+              name: tool.name,
+              error: String(err)
+            })
+          );
+          const text = typeof dispatch.result === "string" ? dispatch.result : JSON.stringify(dispatch.result ?? {});
+          return { content: [{ type: "text", text }] };
+        } catch (err) {
+          return {
+            content: [{ type: "text", text: `Error: ${err?.message ?? String(err)}` }],
+            isError: true
+          };
+        }
+      }
+    }));
+    return sdk.createSdkMcpServer({ name: "skaile-capabilities", tools: sdkTools });
+  }
+  /** Fetch and cache slash commands from the SDK query. */
+  async fetchSlashCommands() {
+    if (!this.query) return;
+    try {
+      const commands = await this.query.supportedCommands();
+      this.cachedCommands = commands.map((c) => ({
+        name: c.name,
+        description: c.description,
+        argumentHint: c.argumentHint || void 0
+      }));
+      this.emit("agent-event", {
+        type: "commands_available",
+        commands: this.cachedCommands
+      });
+      this.log.debug("discovered slash commands", { count: this.cachedCommands.length });
+    } catch (err) {
+      this.log.warn("failed to fetch slash commands", { error: String(err) });
+    }
+  }
+  /**
+   * Background loop — consumes the query's async generator continuously.
+   * The generator stays alive between turns; streamInput() feeds new messages.
+   * If it ends unexpectedly, query is nulled so the next prompt() restarts.
+   */
+  async consumeMessages() {
+    this.fetchSlashCommands();
+    try {
+      for await (const msg of this.query) {
+        if (this.abortController?.signal.aborted) break;
+        const sessionId = "session_id" in msg ? msg.session_id : void 0;
+        if (sessionId) {
+          if (!this.hasSession) {
+            this.hasSession = true;
+            this.log.debug("session id assigned", { sessionId });
+          }
+          this.sessionId = sessionId;
+        }
+        this.handleSdkMessage(msg);
+        if (msg.type === "result" && !msg.is_error) {
+          this.completeTurn();
+        }
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      if (error.name === "AbortError" || this.abortController?.signal.aborted) {
+        this.log.info("aborted");
+      } else {
+        const detail = classifyClaudeSdkError({
+          errors: [error.message],
+          oauthCredential: this.usingOauthCredential
+        });
+        this.log.error("consumer error", {
+          message: error.message,
+          category: detail.category,
+          retryable: detail.retryable
+        });
+        const surfaced = detail.category === "auth" ? new AuthError(detail) : error;
+        this.failTurn(surfaced, detail);
+      }
+    } finally {
+      this.log.debug("query generator ended");
+      this.completeTurn();
+      this.query = null;
+    }
+  }
+  /**
+   * Signal the current turn as done — idempotent per turn.
+   *
+   * Same defensive ordering as {@link failTurn}: settle the turn promise
+   * before emitting `agent_end` so a misbehaving listener cannot trap the
+   * promise in a pending state. See failTurn's docblock for the production
+   * incident that motivated this pattern.
+   */
+  completeTurn() {
+    if (this.turnCompleted) return;
+    this.turnCompleted = true;
+    if (this.turnResolve) {
+      this.turnResolve();
+      this.turnResolve = null;
+      this.turnReject = null;
+    }
+    try {
+      this.emit("agent-event", { type: "agent_end" });
+    } catch (emitErr) {
+      this.log.warn("agent-event listener threw during completeTurn; suppressing", {
+        error: emitErr instanceof Error ? emitErr.message : String(emitErr)
+      });
+    }
+  }
+  /**
+   * Signal the current turn as failed. When a structured `detail` is
+   * supplied, the AgentEvent carries the category + hint so downstream
+   * consumers (normalizer → runner → platform → frontend) can surface a
+   * useful diagnosis instead of the raw upstream string.
+   *
+   * Reject ordering: `turnReject()` runs FIRST, then the agent-event is
+   * emitted. `EventEmitter#emit` calls listeners synchronously; if any
+   * listener throws (transport.send on a closed socket, normalizer bug,
+   * compaction tracking error, etc.) the throw would otherwise propagate
+   * out of failTurn before `turnReject` can run, leaving `await
+   * turnPromise` pending forever and silently hanging `driver.prompt(...)`
+   * — which in turn prevents the runner's `onAuthError` callback from
+   * firing on stale-token 401s. Settling the promise first guarantees the
+   * caller transitions even if the listener chain misbehaves; the emit is
+   * wrapped in try/catch so a listener failure cannot leak out.
+   *
+   * Spec: `_devlog/specs/2026-05-07-unified-credential-mediation.md`
+   * § "Runner-side handling on 401" (the AI 401 mediation path that
+   * exposed this hang).
+   */
+  failTurn(err, detail) {
+    if (this.turnReject) {
+      this.turnReject(err);
+      this.turnResolve = null;
+      this.turnReject = null;
+    }
+    try {
+      this.emit("agent-event", {
+        type: "error",
+        error: err.message,
+        ...detail ? { detail } : {}
+      });
+    } catch (emitErr) {
+      this.log.warn("agent-event listener threw during failTurn; suppressing", {
+        error: emitErr instanceof Error ? emitErr.message : String(emitErr)
+      });
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Message handling
+  // ---------------------------------------------------------------------------
+  handleSdkMessage(msg) {
+    const maybeRateLimit = msg;
+    if (maybeRateLimit.type === "rate_limit_event" && maybeRateLimit.rate_limit_info) {
+      const info = maybeRateLimit.rate_limit_info;
+      this.log.warn("upstream rate-limit telemetry", {
+        status: info.status,
+        type: info.rateLimitType,
+        utilization: info.utilization,
+        resetsAt: info.resetsAt
+      });
+      return;
+    }
+    if (msg.type === "assistant") {
+      const agentMsg = this.mapAssistantMessage(msg);
+      this.emit("agent-event", { type: "message_start", message: agentMsg });
+      if (agentMsg.toolCalls) {
+        for (const tc of agentMsg.toolCalls) {
+          this.emit("agent-event", {
+            type: "tool_call",
+            name: tc.name,
+            tool: { name: tc.name },
+            input: tc.input
+          });
+        }
+      }
+      this.prevText = "";
+      this.emit("agent-event", { type: "message_end", message: agentMsg });
+    } else if (msg.type === "stream_event") {
+      const event = msg.event;
+      if (event?.type === "content_block_delta" && event.delta?.type === "text_delta" && event.delta.text) {
+        const delta = event.delta.text;
+        this.prevText += delta;
+        const agentMsg = {
+          role: "assistant",
+          content: [{ type: "text", text: this.prevText }]
+        };
+        this.emit("agent-event", {
+          type: "message_update",
+          message: agentMsg,
+          _textDelta: delta
+        });
+      }
+    } else if (msg.type === "user") {
+      const toolResults = this.mapToolResults(msg);
+      for (const result of toolResults) {
+        this.emit("agent-event", {
+          type: "tool_execution_end",
+          toolName: result.toolName
+        });
+      }
+      if (toolResults.length > 0) {
+        this.emit("agent-event", { type: "turn_end", toolResults });
+      }
+    } else if (msg.type === "result") {
+      const usage = msg.usage;
+      if (usage) {
+        const tokens = {};
+        if (typeof usage.input_tokens === "number") tokens.inputTokens = usage.input_tokens;
+        if (typeof usage.output_tokens === "number") tokens.outputTokens = usage.output_tokens;
+        if (typeof usage.cache_read_input_tokens === "number")
+          tokens.cacheReadTokens = usage.cache_read_input_tokens;
+        if (typeof usage.cache_creation_input_tokens === "number")
+          tokens.cacheCreationTokens = usage.cache_creation_input_tokens;
+        this._lastTokens = tokens;
+      }
+      const modelUsage = msg.modelUsage;
+      if (modelUsage) {
+        const first = Object.values(modelUsage)[0];
+        if (first?.contextWindow) this._contextWindow = first.contextWindow;
+      }
+      if (msg.subtype === "success" && !msg.is_error) {
+        if (msg.result) {
+          const agentMsg = {
+            role: "assistant",
+            content: msg.result
+          };
+          this.emit("agent-event", { type: "message_end", message: agentMsg });
+        }
+        this.emit("agent-event", {
+          type: "result",
+          subtype: msg.subtype,
+          summary: msg.result ?? "Task completed",
+          costUsd: msg.total_cost_usd ?? 0,
+          ...this._lastTokens ? { tokens: this._lastTokens } : {}
+        });
+      } else {
+        const looseMsg = msg;
+        const errors = looseMsg.errors?.length ? looseMsg.errors : [];
+        if (looseMsg.is_error) {
+          const detail = classifyClaudeSdkError({
+            errors,
+            terminalReason: msg.terminal_reason,
+            subtype: msg.subtype,
+            oauthCredential: this.usingOauthCredential
+          });
+          this.log.error("turn ended with error", {
+            subtype: msg.subtype,
+            terminalReason: msg.terminal_reason,
+            errorsCount: errors.length,
+            category: detail.category,
+            retryable: detail.retryable
+          });
+          const errorText = errors.join("; ") || `Agent stopped: ${msg.subtype}`;
+          if (detail.category === "auth") {
+            this.failTurn(new AuthError({ ...detail, message: errorText }), detail);
+          } else if (errors.length > 0) {
+            this.emit("agent-event", {
+              type: "error",
+              error: errorText,
+              detail
+            });
+          }
+        }
+        this.emit("agent-event", {
+          type: "result",
+          subtype: msg.subtype,
+          errors
+        });
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  /** Build an SDKUserMessage for streamInput. */
+  buildUserMessage(text) {
+    return {
+      type: "user",
+      message: {
+        role: "user",
+        content: text
+      },
+      parent_tool_use_id: null,
+      session_id: this.sessionId
+    };
+  }
+  /** Wrap a single value as an AsyncIterable that yields once. */
+  async *singleItemIterable(item) {
+    yield item;
+  }
+  mapAssistantMessage(msg) {
+    const contentBlocks = [];
+    const toolCalls = [];
+    const content = msg.message.content;
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if (block.type === "text") {
+          contentBlocks.push({ type: "text", text: block.text });
+        } else if (block.type === "tool_use") {
+          contentBlocks.push({
+            type: "tool_use",
+            id: block.id,
+            name: block.name,
+            input: block.input
+          });
+          toolCalls.push({ id: block.id, name: block.name, input: block.input });
+          this.toolIdToName.set(block.id, block.name);
+        } else if (block.type === "thinking") {
+          contentBlocks.push({ type: "thinking", text: block.thinking });
+        }
+      }
+    }
+    return {
+      role: "assistant",
+      content: contentBlocks,
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+    };
+  }
+  mapToolResults(msg) {
+    const results = [];
+    const content = msg.message.content;
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if (block.type === "tool_result") {
+          results.push({
+            role: "tool",
+            content: typeof block.content === "string" ? block.content : JSON.stringify(block.content),
+            toolName: this.toolIdToName.get(block.tool_use_id) ?? block.tool_use_id,
+            isError: block.is_error
+          });
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * Requests the current SDK query to stop processing via `query.interrupt()` and
+   * signals the underlying `AbortController`. The driver remains usable after abort.
+   *
+   * @remarks Best-effort: if `interrupt()` throws (e.g. query already ended) the
+   *   error is silently swallowed and the abort signal is still sent.
+   */
+  async abort() {
+    if (this.query) {
+      try {
+        await this.query.interrupt();
+      } catch {
+      }
+    }
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+  }
+  /** `true` while the driver is processing a `prompt()` call. */
+  get isRunning() {
+    return this.running;
+  }
+  /**
+   * Closes the active SDK query and resets all session state.
+   *
+   * The driver instance must not be reused after `kill()`. Session IDs are cleared,
+   * so a new `ClaudeSdkDriver` will start a fresh session.
+   */
+  kill() {
+    if (this.query) {
+      try {
+        this.query.close();
+      } catch {
+      }
+      this.query = null;
+    }
+    this.abortController?.abort();
+    this.running = false;
+    this.sessionId = "";
+    this.hasSession = false;
+  }
+  async listModels() {
+    const apiKey = this.config.apiKeys?.anthropic || this.config.env?.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) return [];
+    const result = await fetchProviderModels("anthropic", apiKey);
+    return result.ok ? result.models : [];
+  }
+  getTokenUsage() {
+    return this._lastTokens;
+  }
+  getContextWindow() {
+    return this._contextWindow;
+  }
+  async resetSession() {
+    if (this.query) {
+      try {
+        this.query.close();
+      } catch {
+      }
+      this.query = null;
+    }
+    this.abortController?.abort();
+    this.sessionId = "";
+    this.hasSession = false;
+    this._lastTokens = null;
+    this._contextWindow = null;
+  }
+  /**
+   * Build allowedTools / disallowedTools options from AgentConfig.tools.
+   *
+   * When an allowlist is active, automatically prepend a wildcard entry for
+   * every configured MCP server (e.g. `mcp__skaile-connectors__*`) so that
+   * connector tools are never silently blocked by agent.yaml restrictions.
+   */
+  buildToolRestrictions() {
+    const mcpWildcards = this.config.mcpServers ? Object.keys(this.config.mcpServers).map((name) => `mcp__${name}__*`) : [];
+    const result = {};
+    const allowed = this.config.tools?.allowed;
+    if (allowed?.length) {
+      result.allowedTools = [...allowed, ...mcpWildcards];
+    }
+    if (this.config.tools?.denied?.length) {
+      result.disallowedTools = this.config.tools.denied;
+    }
+    return result;
+  }
+  /**
+   * Map the simple string thinking config to SDK ThinkingConfig objects.
+   * This keeps the platform-layer SDK-agnostic while the bridge handles the mapping.
+   */
+  mapThinkingConfig(thinking) {
+    switch (thinking) {
+      case "adaptive":
+        return { type: "adaptive" };
+      case "enabled":
+        return { type: "enabled" };
+      case "disabled":
+        return { type: "disabled" };
+    }
+  }
+  /**
+   * Find the Claude Code CLI executable.
+   *
+   * Resolution order:
+   * 1. CLAUDE_CODE_PATH env var (set in Docker containers where cli.js is
+   *    extracted from the SDK during build — bun-compiled binaries can't
+   *    access the SDK's bundled cli.js via $bunfs)
+   * 2. `which claude` on PATH (dev machines with claude installed globally)
+   * 3. undefined — let the SDK resolve its own bundled cli.js (works when
+   *    not running inside a bun-compiled binary)
+   */
+  findClaudeBinary() {
+    const envPath = process.env.CLAUDE_CODE_PATH;
+    if (envPath && existsSync(envPath)) return envPath;
+    const result = spawnSync("which", ["claude"], { encoding: "utf-8" });
+    const p = result.stdout?.trim();
+    return p || void 0;
+  }
+};
+registerDriver("claude-sdk", (config) => new ClaudeSdkDriver(config), DRIVER_CATALOG["claude-sdk"]);
+
+export { ClaudeSdkDriver };
+//# sourceMappingURL=claude-sdk.js.map
+//# sourceMappingURL=claude-sdk.js.map