@witqq/agent-sdk 0.6.1 → 0.7.0

package/dist/chat/backends.js

@@ -0,0 +1,3501 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/errors.ts
+var AgentSDKError, ReentrancyError, DisposedError, BackendNotFoundError, BackendAlreadyRegisteredError, SubprocessError, DependencyError, AbortError, ToolExecutionError, StructuredOutputError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    AgentSDKError = class extends Error {
+      /** @internal Marker for cross-bundle identity checks */
+      _agentSDKError = true;
+      constructor(message, options) {
+        super(message, options);
+        this.name = "AgentSDKError";
+      }
+      /** Check if an error is an AgentSDKError (works across bundled copies) */
+      static is(error) {
+        return error instanceof Error && "_agentSDKError" in error && error._agentSDKError === true;
+      }
+    };
+    ReentrancyError = class extends AgentSDKError {
+      constructor() {
+        super("Agent is already running. Await the current run before starting another.");
+        this.name = "ReentrancyError";
+      }
+    };
+    DisposedError = class extends AgentSDKError {
+      constructor(entity) {
+        super(`${entity} has been disposed and cannot be used.`);
+        this.name = "DisposedError";
+      }
+    };
+    BackendNotFoundError = class extends AgentSDKError {
+      constructor(backend) {
+        super(
+          `Unknown backend: "${backend}". Built-in: copilot, claude, vercel-ai. Custom: use registerBackend() first.`
+        );
+        this.name = "BackendNotFoundError";
+      }
+    };
+    BackendAlreadyRegisteredError = class extends AgentSDKError {
+      constructor(backend) {
+        super(`Backend "${backend}" is already registered. Use a different name or unregister first.`);
+        this.name = "BackendAlreadyRegisteredError";
+      }
+    };
+    SubprocessError = class extends AgentSDKError {
+      constructor(message, options) {
+        super(message, options);
+        this.name = "SubprocessError";
+      }
+    };
+    DependencyError = class extends AgentSDKError {
+      packageName;
+      constructor(packageName) {
+        super(`${packageName} is not installed. Install it: npm install ${packageName}`);
+        this.name = "DependencyError";
+        this.packageName = packageName;
+      }
+    };
+    AbortError = class extends AgentSDKError {
+      constructor() {
+        super("Agent run was aborted.");
+        this.name = "AbortError";
+      }
+    };
+    ToolExecutionError = class extends AgentSDKError {
+      toolName;
+      constructor(toolName, message, options) {
+        super(`Tool "${toolName}" failed: ${message}`, options);
+        this.name = "ToolExecutionError";
+        this.toolName = toolName;
+      }
+    };
+    StructuredOutputError = class extends AgentSDKError {
+      constructor(message, options) {
+        super(`Structured output error: ${message}`, options);
+        this.name = "StructuredOutputError";
+      }
+    };
+  }
+});
+
+// src/types.ts
+function isToolDefinition(tool) {
+  return "execute" in tool && typeof tool.execute === "function";
+}
+function isTextContent(content) {
+  return typeof content === "string";
+}
+function isMultiPartContent(content) {
+  return Array.isArray(content);
+}
+function getTextContent(content) {
+  if (typeof content === "string") return content;
+  return content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+}
+var init_types = __esm({
+  "src/types.ts"() {
+  }
+});
+
+// src/base-agent.ts
+var BaseAgent;
+var init_base_agent = __esm({
+  "src/base-agent.ts"() {
+    init_errors();
+    BaseAgent = class {
+      state = "idle";
+      abortController = null;
+      config;
+      _cleanupExternalSignal = null;
+      /** CLI session ID for persistent mode. Override in backends that support it. */
+      get sessionId() {
+        return void 0;
+      }
+      constructor(config) {
+        this.config = Object.freeze({ ...config });
+      }
+      // ─── Public Interface ─────────────────────────────────────────
+      async run(prompt, options) {
+        this.guardReentrancy();
+        this.guardDisposed();
+        const ac = this.createAbortController(options?.signal);
+        this.state = "running";
+        try {
+          const messages = [{ role: "user", content: prompt }];
+          const result = await this.executeRun(messages, options, ac.signal);
+          this.enrichAndNotifyUsage(result);
+          return result;
+        } finally {
+          this.cleanupRun();
+        }
+      }
+      async runWithContext(messages, options) {
+        this.guardReentrancy();
+        this.guardDisposed();
+        const ac = this.createAbortController(options?.signal);
+        this.state = "running";
+        try {
+          const result = await this.executeRun(messages, options, ac.signal);
+          this.enrichAndNotifyUsage(result);
+          return result;
+        } finally {
+          this.cleanupRun();
+        }
+      }
+      async runStructured(prompt, schema, options) {
+        this.guardReentrancy();
+        this.guardDisposed();
+        const ac = this.createAbortController(options?.signal);
+        this.state = "running";
+        try {
+          const messages = [{ role: "user", content: prompt }];
+          const result = await this.executeRunStructured(
+            messages,
+            schema,
+            options,
+            ac.signal
+          );
+          this.enrichAndNotifyUsage(result);
+          return result;
+        } finally {
+          this.cleanupRun();
+        }
+      }
+      async *stream(prompt, options) {
+        this.guardReentrancy();
+        this.guardDisposed();
+        const ac = this.createAbortController(options?.signal);
+        this.state = "streaming";
+        try {
+          const messages = [{ role: "user", content: prompt }];
+          const enriched = this.enrichStream(this.executeStream(messages, options, ac.signal));
+          yield* this.heartbeatStream(enriched);
+        } finally {
+          this.cleanupRun();
+        }
+      }
+      async *streamWithContext(messages, options) {
+        this.guardReentrancy();
+        this.guardDisposed();
+        const ac = this.createAbortController(options?.signal);
+        this.state = "streaming";
+        try {
+          const enriched = this.enrichStream(this.executeStream(messages, options, ac.signal));
+          yield* this.heartbeatStream(enriched);
+        } finally {
+          this.cleanupRun();
+        }
+      }
+      abort() {
+        if (this.abortController) {
+          this.abortController.abort();
+        }
+      }
+      /** Default interrupt — falls back to abort(). Backends may override with graceful shutdown. */
+      async interrupt() {
+        this.abort();
+      }
+      getState() {
+        return this.state;
+      }
+      getConfig() {
+        return this.config;
+      }
+      /** Mark agent as disposed. Override to add cleanup. */
+      dispose() {
+        this._cleanupExternalSignal?.();
+        this._cleanupExternalSignal = null;
+        this.abort();
+        this.state = "disposed";
+      }
+      // ─── Usage Enrichment ───────────────────────────────────────────
+      /** Enrich result usage with model/backend and fire onUsage callback */
+      enrichAndNotifyUsage(result) {
+        if (result.usage) {
+          result.usage = {
+            ...result.usage,
+            model: this.config.model,
+            backend: this.backendName
+          };
+          this.callOnUsage(result.usage);
+        }
+      }
+      /** Wrap a stream to enrich usage_update events and fire onUsage callback */
+      async *enrichStream(source) {
+        for await (const event of source) {
+          if (event.type === "usage_update") {
+            const usage = {
+              promptTokens: event.promptTokens,
+              completionTokens: event.completionTokens,
+              model: this.config.model,
+              backend: this.backendName
+            };
+            this.callOnUsage(usage);
+            yield { type: "usage_update", ...usage };
+          } else {
+            yield event;
+          }
+        }
+      }
+      /** Fire onUsage callback (fire-and-forget: errors logged, not propagated) */
+      callOnUsage(usage) {
+        if (!this.config.onUsage) return;
+        try {
+          this.config.onUsage(usage);
+        } catch (e) {
+          console.warn(
+            "[agent-sdk] onUsage callback error:",
+            e instanceof Error ? e.message : String(e)
+          );
+        }
+      }
+      // ─── Heartbeat ───────────────────────────────────────────────
+      /** Wrap a stream to emit heartbeat events at configured intervals.
+       *  When heartbeatInterval is not set, passes through directly. */
+      async *heartbeatStream(source) {
+        const interval = this.config.heartbeatInterval;
+        if (!interval || interval <= 0) {
+          yield* source;
+          return;
+        }
+        const iterator = source[Symbol.asyncIterator]();
+        let pendingEvent = null;
+        let heartbeatResolve = null;
+        const timer = setInterval(() => {
+          if (heartbeatResolve) {
+            const resolve2 = heartbeatResolve;
+            heartbeatResolve = null;
+            resolve2();
+          }
+        }, interval);
+        try {
+          while (true) {
+            if (!pendingEvent) {
+              pendingEvent = iterator.next();
+            }
+            const heartbeatPromise = new Promise((resolve2) => {
+              heartbeatResolve = resolve2;
+            });
+            const eventDone = pendingEvent.then(
+              (r) => ({ kind: "event", result: r })
+            );
+            const heartbeatDone = heartbeatPromise.then(
+              () => ({ kind: "heartbeat" })
+            );
+            const winner = await Promise.race([eventDone, heartbeatDone]);
+            if (winner.kind === "heartbeat") {
+              yield { type: "heartbeat" };
+            } else {
+              pendingEvent = null;
+              heartbeatResolve = null;
+              if (winner.result.done) break;
+              yield winner.result.value;
+            }
+          }
+        } finally {
+          clearInterval(timer);
+          heartbeatResolve = null;
+        }
+      }
+      // ─── Guards ───────────────────────────────────────────────────
+      guardReentrancy() {
+        if (this.state === "running" || this.state === "streaming") {
+          throw new ReentrancyError();
+        }
+      }
+      guardDisposed() {
+        if (this.state === "disposed") {
+          throw new DisposedError("Agent");
+        }
+      }
+      /** Throw AbortError if signal is already aborted */
+      checkAbort(signal) {
+        if (signal.aborted) {
+          throw new AbortError();
+        }
+      }
+      // ─── Internal Helpers ─────────────────────────────────────────
+      /** Clean up after a run completes (success, error, or abort). */
+      cleanupRun() {
+        this._cleanupExternalSignal?.();
+        this._cleanupExternalSignal = null;
+        this.state = "idle";
+        this.abortController = null;
+      }
+      createAbortController(externalSignal) {
+        const ac = new AbortController();
+        this.abortController = ac;
+        this._cleanupExternalSignal = null;
+        if (externalSignal) {
+          if (externalSignal.aborted) {
+            ac.abort();
+          } else {
+            const listener = () => ac.abort();
+            externalSignal.addEventListener("abort", listener, { once: true });
+            this._cleanupExternalSignal = () => externalSignal.removeEventListener("abort", listener);
+          }
+        }
+        return ac;
+      }
+    };
+  }
+});
+
+// src/utils/schema.ts
+function zodToJsonSchema(schema) {
+  const schemaAny = schema;
+  if ("toJSONSchema" in schema && typeof schemaAny.toJSONSchema === "function") {
+    return schemaAny.toJSONSchema();
+  }
+  if ("jsonSchema" in schema && typeof schemaAny.jsonSchema === "function") {
+    return schemaAny.jsonSchema();
+  }
+  return extractSchemaFromDef(schema);
+}
+function extractSchemaFromDef(schema) {
+  const def = schema._def;
+  const typeName = def.typeName;
+  switch (typeName) {
+    case "ZodString":
+      return { type: "string" };
+    case "ZodNumber":
+      return { type: "number" };
+    case "ZodBoolean":
+      return { type: "boolean" };
+    case "ZodNull":
+      return { type: "null" };
+    case "ZodArray":
+      return {
+        type: "array",
+        items: extractSchemaFromDef(def.type)
+      };
+    case "ZodObject": {
+      const shape = schema.shape;
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        const valueDef = value._def;
+        if (valueDef.typeName === "ZodOptional") {
+          properties[key] = extractSchemaFromDef(valueDef.innerType);
+        } else {
+          properties[key] = extractSchemaFromDef(value);
+          required.push(key);
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        ...required.length > 0 ? { required } : {}
+      };
+    }
+    case "ZodOptional":
+      return extractSchemaFromDef(def.innerType);
+    case "ZodEnum":
+      return { type: "string", enum: def.values };
+    default:
+      return {};
+  }
+}
+var init_schema = __esm({
+  "src/utils/schema.ts"() {
+  }
+});
+
+// src/backends/copilot.ts
+var copilot_exports = {};
+__export(copilot_exports, {
+  _injectSDK: () => _injectSDK,
+  _resetSDK: () => _resetSDK,
+  createCopilotService: () => createCopilotService
+});
+async function loadSDK() {
+  if (sdkModule) return sdkModule;
+  try {
+    sdkModule = await import('@github/copilot-sdk');
+    return sdkModule;
+  } catch {
+    throw new SubprocessError(
+      "@github/copilot-sdk is not installed. Install it: npm install @github/copilot-sdk"
+    );
+  }
+}
+function _injectSDK(mock) {
+  sdkModule = mock;
+}
+function _resetSDK() {
+  sdkModule = null;
+}
+function mapToolsToSDK(tools) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    parameters: convertParameters(tool.parameters),
+    handler: async (args) => {
+      const result = await tool.execute(args);
+      return typeof result === "string" ? result : JSON.stringify(result);
+    }
+  }));
+}
+function convertParameters(params) {
+  if (!params) return void 0;
+  if (params && typeof params === "object" && "_def" in params) {
+    return zodToJsonSchema(params);
+  }
+  return params;
+}
+async function mapToolsToSDKAsync(tools) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    parameters: convertParameters(tool.parameters),
+    handler: async (args) => {
+      const result = await tool.execute(args);
+      return typeof result === "string" ? result : JSON.stringify(result);
+    }
+  }));
+}
+function buildPermissionHandler(config) {
+  const onPermission = config.supervisor?.onPermission;
+  if (!onPermission) {
+    return async () => ({ kind: "approved" });
+  }
+  const permissionStore = config.permissionStore;
+  return async (request) => {
+    const toolName = String(request.kind);
+    if (permissionStore && await permissionStore.isApproved(toolName)) {
+      return { kind: "approved" };
+    }
+    const unifiedRequest = {
+      toolName,
+      toolArgs: { ...request },
+      rawSDKRequest: request
+    };
+    const ac = new AbortController();
+    const decision = await onPermission(unifiedRequest, ac.signal);
+    if (decision.allowed) {
+      if (permissionStore && decision.scope) {
+        await permissionStore.approve(toolName, decision.scope);
+      }
+      return { kind: "approved" };
+    }
+    return { kind: "denied-interactively-by-user" };
+  };
+}
+function buildUserInputHandler(config) {
+  const onAskUser = config.supervisor?.onAskUser;
+  if (!onAskUser) {
+    return async () => ({
+      answer: "Complete the task autonomously without asking questions.",
+      wasFreeform: true
+    });
+  }
+  return async (request) => {
+    const ac = new AbortController();
+    const response = await onAskUser(
+      {
+        question: request.question,
+        choices: request.choices,
+        allowFreeform: request.allowFreeform
+      },
+      ac.signal
+    );
+    return { answer: response.answer, wasFreeform: response.wasFreeform };
+  };
+}
+function mapSessionEvent(event, tracker, thinkingTracker) {
+  const data = event.data;
+  switch (event.type) {
+    case "assistant.message_delta": {
+      const textEvent = {
+        type: "text_delta",
+        text: String(data.deltaContent ?? "")
+      };
+      if (thinkingTracker.endThinking()) {
+        return [{ type: "thinking_end" }, textEvent];
+      }
+      return textEvent;
+    }
+    case "assistant.reasoning":
+    case "assistant.reasoning_delta": {
+      if (thinkingTracker.isCompleted()) return null;
+      const events = [];
+      if (!thinkingTracker.isActive()) {
+        thinkingTracker.startThinking();
+        events.push({ type: "thinking_start" });
+      }
+      const reasoningText = String(data.deltaContent ?? data.content ?? "");
+      if (reasoningText) {
+        events.push({ type: "thinking_delta", text: reasoningText });
+      }
+      return events.length === 1 ? events[0] : events.length > 1 ? events : null;
+    }
+    case "tool.execution_start": {
+      const toolCallId = String(data.toolCallId ?? "");
+      const toolName = String(data.toolName ?? "unknown");
+      let args = {};
+      if (typeof data.arguments === "string") {
+        try {
+          args = JSON.parse(data.arguments);
+        } catch {
+          args = data.arguments;
+        }
+      } else if (data.arguments != null) {
+        args = data.arguments;
+      }
+      tracker.trackStart(toolCallId, toolName, args);
+      const toolStartEvent = { type: "tool_call_start", toolCallId, toolName, args };
+      const events = [];
+      if (thinkingTracker.endThinking()) {
+        events.push({ type: "thinking_end" });
+      }
+      thinkingTracker.reset();
+      events.push(toolStartEvent);
+      return events.length === 1 ? events[0] : events;
+    }
+    case "tool.execution_complete": {
+      const toolCallId = String(data.toolCallId ?? "");
+      const info = tracker.getInfo(toolCallId);
+      const rawResult = data.result;
+      const result = (rawResult && typeof rawResult === "object" && "content" in rawResult ? rawResult.content : rawResult) ?? null;
+      return {
+        type: "tool_call_end",
+        toolCallId,
+        toolName: info?.toolName ?? "unknown",
+        result
+      };
+    }
+    case "assistant.usage":
+      return {
+        type: "usage_update",
+        promptTokens: Number(data.inputTokens ?? 0),
+        completionTokens: Number(data.outputTokens ?? 0)
+      };
+    case "session.error":
+      console.error("[copilot] mapSessionEvent error:", JSON.stringify(data));
+      return {
+        type: "error",
+        error: String(data.message ?? "Unknown error"),
+        recoverable: false
+      };
+    case "assistant.message": {
+      const doneEvent = {
+        type: "done",
+        finalOutput: data.content ? String(data.content) : null
+      };
+      if (thinkingTracker.endThinking()) {
+        return [{ type: "thinking_end" }, doneEvent];
+      }
+      return doneEvent;
+    }
+    default:
+      return null;
+  }
+}
+function extractLastUserPrompt(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role === "user") {
+      return getTextContent(msg.content);
+    }
+  }
+  return "";
+}
+function serializeToolCall(tc) {
+  const args = typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args);
+  return `  Tool call: ${tc.name}(${args})`;
+}
+function serializeToolResult(tr) {
+  const result = typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result);
+  const prefix = tr.isError ? "[ERROR] " : "";
+  return `  ${tr.name} \u2192 ${prefix}${result}`;
+}
+function buildContextualPrompt(messages) {
+  if (messages.length <= 1) {
+    return extractLastUserPrompt(messages);
+  }
+  const history = messages.slice(0, -1).map((msg) => {
+    if (msg.role === "user") {
+      return `User: ${msg.content ? getTextContent(msg.content) : ""}`;
+    }
+    if (msg.role === "tool" && msg.toolResults) {
+      const results = msg.toolResults.map(serializeToolResult).join("\n");
+      return `Tool results:
+${results}`;
+    }
+    if (msg.role === "assistant") {
+      const parts = [];
+      const thinking = msg.thinking;
+      if (thinking) {
+        parts.push(`[reasoning: ${thinking}]`);
+      }
+      const text2 = msg.content ? getTextContent(msg.content) : "";
+      if (text2) parts.push(text2);
+      if (msg.toolCalls && msg.toolCalls.length > 0) {
+        parts.push(msg.toolCalls.map(serializeToolCall).join("\n"));
+      }
+      return `Assistant: ${parts.join("\n")}`;
+    }
+    const text = msg.content ? getTextContent(msg.content) : "";
+    return `${msg.role}: ${text}`;
+  }).join("\n");
+  const lastPrompt = extractLastUserPrompt(messages);
+  return `Conversation history:
+${history}
+
+User: ${lastPrompt}`;
+}
+function withTimeout(promise, ms, message) {
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => reject(new SubprocessError(message)), ms);
+    promise.then(
+      (val) => {
+        clearTimeout(timer);
+        resolve2(val);
+      },
+      (err) => {
+        clearTimeout(timer);
+        reject(err);
+      }
+    );
+  });
+}
+function createCopilotService(options) {
+  return new CopilotAgentService(options);
+}
+var sdkModule, ToolCallTracker, ThinkingTracker, CopilotAgent, CopilotAgentService;
+var init_copilot = __esm({
+  "src/backends/copilot.ts"() {
+    init_types();
+    init_base_agent();
+    init_errors();
+    init_schema();
+    sdkModule = null;
+    ToolCallTracker = class {
+      map = /* @__PURE__ */ new Map();
+      trackStart(toolCallId, toolName, args) {
+        this.map.set(toolCallId, { toolName, args });
+      }
+      getInfo(toolCallId) {
+        return this.map.get(toolCallId);
+      }
+      clear() {
+        this.map.clear();
+      }
+    };
+    ThinkingTracker = class {
+      active = false;
+      completed = false;
+      isActive() {
+        return this.active;
+      }
+      /** Returns true if thinking already completed (should ignore further reasoning events). */
+      isCompleted() {
+        return this.completed;
+      }
+      startThinking() {
+        this.active = true;
+      }
+      /** Returns true if thinking was active and is now ended. */
+      endThinking() {
+        if (!this.active) return false;
+        this.active = false;
+        this.completed = true;
+        return true;
+      }
+      /** Reset for next turn (e.g. after done event). */
+      reset() {
+        this.active = false;
+        this.completed = false;
+      }
+    };
+    CopilotAgent = class extends BaseAgent {
+      backendName = "copilot";
+      getClient;
+      sdkTools;
+      sessionConfig;
+      sendAndWaitTimeout;
+      isPersistent;
+      persistentSession = null;
+      _sessionId;
+      activeSession = null;
+      _resumeSessionId;
+      _toolsReady = null;
+      constructor(config, getClient, sendAndWaitTimeout, resumeSessionId) {
+        super(config);
+        this.getClient = getClient;
+        this.sendAndWaitTimeout = sendAndWaitTimeout;
+        this.isPersistent = config.sessionMode === "persistent";
+        this.sdkTools = mapToolsToSDK(config.tools ?? []);
+        this.sessionConfig = {
+          model: config.model,
+          tools: this.sdkTools,
+          systemMessage: {
+            mode: config.systemMessageMode ?? "append",
+            content: config.systemPrompt
+          },
+          onPermissionRequest: buildPermissionHandler(config),
+          onUserInputRequest: buildUserInputHandler(config),
+          ...config.availableTools?.length ? { availableTools: config.availableTools } : {}
+        };
+        this._toolsReady = this._initToolsAsync(config);
+        this._resumeSessionId = resumeSessionId;
+      }
+      /** Pre-convert Zod schemas to JSON Schema asynchronously.
+       *  Updates sdkTools and sessionConfig.tools before first session creation. */
+      async _initToolsAsync(config) {
+        this.sdkTools = await mapToolsToSDKAsync(config.tools ?? []);
+        this.sessionConfig.tools = this.sdkTools;
+      }
+      get sessionId() {
+        return this._sessionId;
+      }
+      async interrupt() {
+        if (this.activeSession) {
+          this.activeSession.abort().catch(() => {
+          });
+        }
+        this.abort();
+      }
+      emitSessionInfo(sessionId) {
+        const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+        const transcriptPath = home ? `${home}/.copilot/session-state/${sessionId}/events.jsonl` : void 0;
+        return { type: "session_info", sessionId, transcriptPath, backend: "copilot" };
+      }
+      clearPersistentSession() {
+        if (this.isPersistent) {
+          this.persistentSession?.destroy().catch(() => {
+          });
+          this.persistentSession = null;
+          this._sessionId = void 0;
+        }
+      }
+      async getOrCreateSession(streaming) {
+        if (this.isPersistent && this.persistentSession) {
+          return { session: this.persistentSession, isNew: false };
+        }
+        if (this._toolsReady) {
+          await this._toolsReady;
+          this._toolsReady = null;
+        }
+        const client = await this.getClient();
+        if (this._resumeSessionId) {
+          const storedId = this._resumeSessionId;
+          this._resumeSessionId = void 0;
+          try {
+            const session2 = await client.resumeSession(storedId, {
+              ...this.sessionConfig,
+              streaming: this.isPersistent ? true : streaming
+            });
+            if (this.isPersistent) {
+              this.persistentSession = session2;
+              this._sessionId = session2.sessionId;
+            }
+            return { session: session2, isNew: false };
+          } catch {
+          }
+        }
+        const session = await client.createSession({
+          ...this.sessionConfig,
+          streaming: this.isPersistent ? true : streaming
+        });
+        if (this.isPersistent) {
+          this.persistentSession = session;
+          this._sessionId = session.sessionId;
+        }
+        return { session, isNew: true };
+      }
+      // ─── executeRun ─────────────────────────────────────────────────
+      async executeRun(messages, _options, signal) {
+        this.checkAbort(signal);
+        const { session, isNew: isNewSession } = await this.getOrCreateSession(false);
+        this.activeSession = session;
+        const prompt = this.isPersistent && !isNewSession ? extractLastUserPrompt(messages) : buildContextualPrompt(messages);
+        const tracker = new ToolCallTracker();
+        const toolCalls = [];
+        let usage;
+        const unsubscribe = session.on((event) => {
+          if (event.type === "tool.execution_start") {
+            tracker.trackStart(
+              String(event.data.toolCallId ?? ""),
+              String(event.data.toolName ?? "unknown"),
+              event.data.arguments ?? {}
+            );
+          }
+          if (event.type === "tool.execution_complete") {
+            const info = tracker.getInfo(String(event.data.toolCallId ?? ""));
+            const resultContent = event.data.result?.content;
+            toolCalls.push({
+              toolName: info?.toolName ?? "unknown",
+              args: info?.args ?? {},
+              result: resultContent ?? null,
+              approved: Boolean(event.data.success ?? true)
+            });
+          }
+          if (event.type === "assistant.usage") {
+            usage = {
+              promptTokens: Number(event.data.inputTokens ?? 0),
+              completionTokens: Number(event.data.outputTokens ?? 0)
+            };
+          }
+        });
+        const onAbort = () => {
+          session.abort().catch(() => {
+          });
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        try {
+          const response = this.sendAndWaitTimeout !== void 0 ? await session.sendAndWait({ prompt }, this.sendAndWaitTimeout) : await session.sendAndWait({ prompt });
+          const output = response?.data?.content ?? null;
+          return {
+            output,
+            structuredOutput: void 0,
+            toolCalls,
+            messages: [
+              ...messages,
+              ...output !== null ? [{ role: "assistant", content: output }] : []
+            ],
+            usage
+          };
+        } catch (error) {
+          this.clearPersistentSession();
+          throw error;
+        } finally {
+          this.activeSession = null;
+          signal.removeEventListener("abort", onAbort);
+          unsubscribe();
+          tracker.clear();
+          if (!this.isPersistent) {
+            session.destroy().catch(() => {
+            });
+          }
+        }
+      }
+      // ─── executeRunStructured ───────────────────────────────────────
+      async executeRunStructured(messages, schema, options, signal) {
+        const jsonSchema = zodToJsonSchema(schema.schema);
+        const instruction = `
+
+You MUST respond with ONLY valid JSON matching this schema:
+` + JSON.stringify(jsonSchema, null, 2);
+        const augmented = [...messages];
+        const lastIdx = augmented.length - 1;
+        if (lastIdx >= 0 && augmented[lastIdx].role === "user") {
+          const orig = augmented[lastIdx];
+          augmented[lastIdx] = {
+            role: "user",
+            content: getTextContent(orig.content) + instruction
+          };
+        }
+        const result = await this.executeRun(augmented, options, signal);
+        let structuredOutput;
+        if (result.output) {
+          try {
+            const jsonMatch = result.output.match(
+              /```(?:json)?\s*([\s\S]*?)```/
+            );
+            const raw = jsonMatch ? jsonMatch[1].trim() : result.output.trim();
+            structuredOutput = schema.schema.parse(JSON.parse(raw));
+          } catch {
+          }
+        }
+        return {
+          ...result,
+          structuredOutput
+        };
+      }
+      // ─── executeStream ──────────────────────────────────────────────
+      async *executeStream(messages, _options, signal) {
+        this.checkAbort(signal);
+        const { session, isNew: isNewSession } = await this.getOrCreateSession(true);
+        this.activeSession = session;
+        if (isNewSession) {
+          yield this.emitSessionInfo(session.sessionId);
+        }
+        const prompt = this.isPersistent && !isNewSession ? extractLastUserPrompt(messages) : buildContextualPrompt(messages);
+        const tracker = new ToolCallTracker();
+        const thinkingTracker = new ThinkingTracker();
+        const queue = [];
+        let notify = null;
+        const push = (item) => {
+          queue.push(item);
+          if (notify) {
+            notify();
+            notify = null;
+          }
+        };
+        const waitForItem = () => new Promise((resolve2) => {
+          notify = resolve2;
+        });
+        const unsubscribe = session.on((event) => {
+          const mapped = mapSessionEvent(event, tracker, thinkingTracker);
+          if (mapped) {
+            if (Array.isArray(mapped)) {
+              for (const e of mapped) push({ event: e });
+            } else {
+              push({ event: mapped });
+            }
+          }
+          if (event.type === "session.idle") {
+            if (thinkingTracker.endThinking()) {
+              push({ event: { type: "thinking_end" } });
+            }
+            push({ done: true });
+          } else if (event.type === "session.error") {
+            console.error("[copilot] session.error:", JSON.stringify(event.data));
+            push({
+              error: new Error(
+                String(event.data.message ?? "Session error")
+              )
+            });
+          }
+        });
+        const onAbort = () => {
+          session.abort().catch(() => {
+          });
+          push({ error: new AbortError() });
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        try {
+          await session.send({ prompt });
+          while (true) {
+            while (queue.length === 0) await waitForItem();
+            const item = queue.shift();
+            if ("done" in item) break;
+            if ("error" in item) {
+              this.clearPersistentSession();
+              throw item.error;
+            }
+            yield item.event;
+          }
+        } catch (error) {
+          this.clearPersistentSession();
+          throw error;
+        } finally {
+          this.activeSession = null;
+          signal.removeEventListener("abort", onAbort);
+          unsubscribe();
+          tracker.clear();
+          if (!this.isPersistent) {
+            session.destroy().catch(() => {
+            });
+          }
+        }
+      }
+      // ─── dispose ────────────────────────────────────────────────────
+      dispose() {
+        if (this.persistentSession) {
+          this.persistentSession.destroy().catch(() => {
+          });
+          this.persistentSession = null;
+          this._sessionId = void 0;
+        }
+        super.dispose();
+      }
+    };
+    CopilotAgentService = class {
+      name = "copilot";
+      client = null;
+      clientPromise = null;
+      disposed = false;
+      options;
+      constructor(options) {
+        this.options = options;
+      }
+      async ensureClient() {
+        if (this.disposed) throw new DisposedError("CopilotAgentService");
+        if (this.client) return this.client;
+        if (this.clientPromise) return this.clientPromise;
+        this.clientPromise = (async () => {
+          try {
+            const sdk = await loadSDK();
+            const client = new sdk.CopilotClient({
+              cliPath: this.options.cliPath,
+              cwd: this.options.workingDirectory,
+              useStdio: true,
+              autoStart: false,
+              autoRestart: true,
+              logLevel: "error",
+              githubToken: this.options.githubToken,
+              useLoggedInUser: this.options.useLoggedInUser ?? !this.options.githubToken,
+              ...this.options.cliArgs ? { cliArgs: this.options.cliArgs } : {},
+              ...this.options.env ? { env: { ...process.env, ...this.options.env } } : {}
+            });
+            const startupTimeout = this.options.startupTimeoutMs ?? 3e4;
+            await withTimeout(client.start(), startupTimeout, "CLI startup timed out");
+            const auth = await withTimeout(
+              client.getAuthStatus(),
+              startupTimeout,
+              "Auth status check timed out \u2014 token may be expired"
+            );
+            if (!auth.isAuthenticated) {
+              await client.stop();
+              throw new SubprocessError(
+                "Not authenticated with GitHub Copilot. Run 'copilot auth login' or set GITHUB_TOKEN."
+              );
+            }
+            this.client = client;
+            return client;
+          } catch (e) {
+            this.clientPromise = null;
+            throw e;
+          }
+        })();
+        return this.clientPromise;
+      }
+      createAgent(config) {
+        if (this.disposed) throw new DisposedError("CopilotAgentService");
+        return new CopilotAgent(config, () => this.ensureClient(), this.options.timeout, this.options.resumeSessionId);
+      }
+      async listModels() {
+        const client = await this.ensureClient();
+        const models = await client.listModels();
+        return models.map((m) => ({
+          id: m.id,
+          name: m.name,
+          provider: "copilot"
+        }));
+      }
+      async validate() {
+        const errors = [];
+        try {
+          const client = await this.ensureClient();
+          const auth = await client.getAuthStatus();
+          if (!auth.isAuthenticated) {
+            errors.push(
+              "Not authenticated with GitHub Copilot. Run 'copilot auth login'."
+            );
+          }
+        } catch (e) {
+          errors.push(
+            `Failed to connect to Copilot CLI: ${e instanceof Error ? e.message : String(e)}`
+          );
+        }
+        return { valid: errors.length === 0, errors };
+      }
+      async dispose() {
+        if (this.disposed) return;
+        this.disposed = true;
+        if (this.clientPromise) {
+          try {
+            await this.clientPromise;
+          } catch {
+          }
+        }
+        if (this.client) {
+          await this.client.stop();
+          this.client = null;
+        }
+        this.clientPromise = null;
+      }
+    };
+  }
+});
+
+// src/backends/claude.ts
+var claude_exports = {};
+__export(claude_exports, {
+  _injectSDK: () => _injectSDK2,
+  _resetSDK: () => _resetSDK2,
+  createClaudeService: () => createClaudeService
+});
+function mcpToolName(toolName) {
+  return `${MCP_TOOL_PREFIX}${toolName}`;
+}
+function stripMcpPrefix(name) {
+  return name.startsWith(MCP_TOOL_PREFIX) ? name.slice(MCP_TOOL_PREFIX.length) : name;
+}
+async function loadSDK2() {
+  if (sdkModule2) return sdkModule2;
+  try {
+    sdkModule2 = await import('@anthropic-ai/claude-agent-sdk');
+    return sdkModule2;
+  } catch {
+    throw new SubprocessError(
+      "@anthropic-ai/claude-agent-sdk is not installed. Install it: npm install @anthropic-ai/claude-agent-sdk"
+    );
+  }
+}
+function _injectSDK2(mock) {
+  sdkModule2 = mock;
+}
+function _resetSDK2() {
+  sdkModule2 = null;
+}
+function buildMcpServer(sdk, tools, toolResultCapture) {
+  if (tools.length === 0) return void 0;
+  const mcpTools = tools.map((tool) => {
+    const zodSchema = tool.parameters;
+    const inputSchema = zodSchema.shape ?? zodToJsonSchema(tool.parameters);
+    return sdk.tool(
+      tool.name,
+      tool.description ?? "",
+      inputSchema,
+      async (args) => {
+        const result = await tool.execute(args);
+        if (toolResultCapture) {
+          toolResultCapture.set(tool.name, result);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: typeof result === "string" ? result : JSON.stringify(result)
+            }
+          ]
+        };
+      }
+    );
+  });
+  return sdk.createSdkMcpServer({
+    name: MCP_SERVER_NAME,
+    version: "1.0.0",
+    tools: mcpTools
+  });
+}
+function scopeToDestination(scope) {
+  switch (scope) {
+    case "once":
+      return "session";
+    case "session":
+      return "session";
+    case "project":
+      return "projectSettings";
+    case "always":
+      return "userSettings";
+  }
+}
+function destinationToScope(dest) {
+  switch (dest) {
+    case "session":
+    case "cliArg":
+      return "session";
+    case "projectSettings":
+    case "localSettings":
+      return "project";
+    case "userSettings":
+      return "always";
+  }
+}
+function extractSuggestedScope(suggestions) {
+  if (!suggestions || suggestions.length === 0) return void 0;
+  return destinationToScope(suggestions[0].destination);
+}
+function buildCanUseTool(config) {
+  const onPermission = config.supervisor?.onPermission;
+  if (!onPermission) return void 0;
+  const permissionStore = config.permissionStore;
+  return async (rawToolName, input, options) => {
+    const toolName = stripMcpPrefix(rawToolName);
+    if (permissionStore && await permissionStore.isApproved(toolName)) {
+      return {
+        behavior: "allow",
+        toolUseID: options.toolUseID
+      };
+    }
+    const unifiedRequest = {
+      toolName,
+      toolArgs: input,
+      suggestedScope: extractSuggestedScope(options.suggestions),
+      rawSDKRequest: { toolName, input, ...options }
+    };
+    const decision = await onPermission(
+      unifiedRequest,
+      options.signal
+    );
+    if (decision.allowed) {
+      if (permissionStore && decision.scope) {
+        await permissionStore.approve(toolName, decision.scope);
+      }
+      const result = {
+        behavior: "allow",
+        toolUseID: options.toolUseID
+      };
+      if (decision.modifiedInput) {
+        result.updatedInput = decision.modifiedInput;
+      }
+      if (decision.scope && decision.scope !== "once" && options.suggestions) {
+        result.updatedPermissions = options.suggestions.map((s) => ({
+          ...s,
+          destination: scopeToDestination(decision.scope)
+        }));
+      }
+      return result;
+    }
+    return {
+      behavior: "deny",
+      message: decision.reason ?? "Permission denied",
+      toolUseID: options.toolUseID
+    };
+  };
+}
+function aggregateUsage(modelUsage) {
+  let promptTokens = 0;
+  let completionTokens = 0;
+  for (const u of Object.values(modelUsage ?? {})) {
+    promptTokens += u.inputTokens ?? 0;
+    completionTokens += u.outputTokens ?? 0;
+  }
+  return { promptTokens, completionTokens };
+}
+function mapSDKMessage(msg, thinkingBlockIndices, toolCallTracker) {
+  switch (msg.type) {
+    case "assistant": {
+      const betaMessage = msg.message;
+      if (!betaMessage?.content) return null;
+      const events = [];
+      for (const block of betaMessage.content) {
+        if (block.type === "tool_use") {
+          const toolCallId = String(block.id ?? "");
+          const toolName = stripMcpPrefix(block.name ?? "unknown");
+          if (toolCallTracker) {
+            toolCallTracker.trackStart(toolCallId, toolName);
+          }
+          events.push({
+            type: "tool_call_start",
+            toolCallId,
+            toolName,
+            args: block.input ?? {}
+          });
+        }
+      }
+      return events.length > 0 ? events : null;
+    }
+    case "user": {
+      const toolResult = msg.tool_use_result;
+      if (toolResult !== void 0) {
+        return null;
+      }
+      return null;
+    }
+    case "tool_use_summary": {
+      const summary = msg.summary;
+      const toolName = stripMcpPrefix(msg.tool_name ?? "unknown");
+      const precedingIds = msg.preceding_tool_use_ids;
+      let toolCallId = "";
+      if (precedingIds && precedingIds.length > 0) {
+        toolCallId = precedingIds[0];
+        if (toolCallTracker) toolCallTracker.consumeToolCallId(toolName);
+      } else if (toolCallTracker) {
+        toolCallId = toolCallTracker.consumeToolCallId(toolName);
+      }
+      return {
+        type: "tool_call_end",
+        toolCallId,
+        toolName,
+        result: summary ?? null
+      };
+    }
+    case "stream_event": {
+      const event = msg.event;
+      if (!event) return null;
+      if (event.type === "content_block_delta" && event.index !== void 0 && thinkingBlockIndices?.has(event.index)) {
+        const thinkingText = String(event.delta?.thinking ?? event.delta?.text ?? "");
+        if (thinkingText) {
+          return { type: "thinking_delta", text: thinkingText };
+        }
+        return null;
+      }
+      if (event.type === "content_block_delta" && event.delta?.type === "text_delta" && event.delta.text) {
+        return { type: "text_delta", text: event.delta.text };
+      }
+      if (event.type === "content_block_start" && event.content_block?.type === "thinking") {
+        if (thinkingBlockIndices && event.index !== void 0) {
+          thinkingBlockIndices.add(event.index);
+        }
+        return { type: "thinking_start" };
+      }
+      if (event.type === "content_block_stop" && event.index !== void 0 && thinkingBlockIndices?.has(event.index)) {
+        thinkingBlockIndices.delete(event.index);
+        return { type: "thinking_end" };
+      }
+      return null;
+    }
+    case "tool_progress": {
+      return null;
+    }
+    case "result": {
+      if (msg.subtype === "success") {
+        const r = msg;
+        return {
+          type: "usage_update",
+          ...aggregateUsage(r.modelUsage)
+        };
+      }
+      if (msg.is_error) {
+        const r = msg;
+        return {
+          type: "error",
+          error: r.errors?.join("; ") ?? "Unknown error",
+          recoverable: false
+        };
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+function extractLastUserPrompt2(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role === "user") {
+      return getTextContent(msg.content);
+    }
+  }
+  return "";
+}
+function serializeToolCall2(tc) {
+  const args = typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args);
+  return `  Tool call: ${tc.name}(${args})`;
+}
+function serializeToolResult2(tr) {
+  const result = typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result);
+  const prefix = tr.isError ? "[ERROR] " : "";
+  return `  ${tr.name} \u2192 ${prefix}${result}`;
+}
+function buildContextualPrompt2(messages) {
+  if (messages.length <= 1) {
+    return extractLastUserPrompt2(messages);
+  }
+  const history = messages.slice(0, -1).map((msg) => {
+    if (msg.role === "user") {
+      return `User: ${msg.content ? getTextContent(msg.content) : ""}`;
+    }
+    if (msg.role === "tool" && msg.toolResults) {
+      const results = msg.toolResults.map(serializeToolResult2).join("\n");
+      return `Tool results:
+${results}`;
+    }
+    if (msg.role === "assistant") {
+      const parts = [];
+      const thinking = msg.thinking;
+      if (thinking) {
+        parts.push(`[reasoning: ${thinking}]`);
+      }
+      const text2 = msg.content ? getTextContent(msg.content) : "";
+      if (text2) parts.push(text2);
+      if (msg.toolCalls && msg.toolCalls.length > 0) {
+        parts.push(msg.toolCalls.map(serializeToolCall2).join("\n"));
+      }
+      return `Assistant: ${parts.join("\n")}`;
+    }
+    const text = msg.content ? getTextContent(msg.content) : "";
+    return `${msg.role}: ${text}`;
+  }).join("\n");
+  const lastPrompt = extractLastUserPrompt2(messages);
+  return `Conversation history:
+${history}
+
+User: ${lastPrompt}`;
+}
+function createClaudeService(options) {
+  return new ClaudeAgentService(options);
+}
+var MCP_SERVER_NAME, MCP_TOOL_PREFIX, sdkModule2, ANTHROPIC_MODELS_URL, ANTHROPIC_API_VERSION, ANTHROPIC_OAUTH_BETA, ClaudeToolCallTracker, ClaudeAgent, ClaudeAgentService;
+var init_claude = __esm({
+  "src/backends/claude.ts"() {
+    init_types();
+    init_base_agent();
+    init_errors();
+    init_schema();
+    MCP_SERVER_NAME = "agent-sdk-tools";
+    MCP_TOOL_PREFIX = `mcp__${MCP_SERVER_NAME}__`;
+    sdkModule2 = null;
+    ANTHROPIC_MODELS_URL = "https://api.anthropic.com/v1/models";
+    ANTHROPIC_API_VERSION = "2023-06-01";
+    ANTHROPIC_OAUTH_BETA = "oauth-2025-04-20";
+    ClaudeToolCallTracker = class {
+      queues = /* @__PURE__ */ new Map();
+      trackStart(toolCallId, toolName) {
+        if (!this.queues.has(toolName)) {
+          this.queues.set(toolName, []);
+        }
+        this.queues.get(toolName).push(toolCallId);
+      }
+      /** Peek at the current tool call ID for a tool name (does not consume) */
+      peekToolCallId(toolName) {
+        const queue = this.queues.get(toolName);
+        if (!queue || queue.length === 0) return "";
+        return queue[0];
+      }
+      /** Consume and return the first tool call ID for a tool name */
+      consumeToolCallId(toolName) {
+        const queue = this.queues.get(toolName);
+        if (!queue || queue.length === 0) return "";
+        return queue.shift();
+      }
+      clear() {
+        this.queues.clear();
+      }
+    };
+    ClaudeAgent = class extends BaseAgent {
+      backendName = "claude";
+      options;
+      tools;
+      canUseTool;
+      isPersistent;
+      _sessionId;
+      activeQuery = null;
+      constructor(config, options) {
+        super(config);
+        this.options = options;
+        this.tools = config.tools ?? [];
+        this.canUseTool = buildCanUseTool(config);
+        this.isPersistent = config.sessionMode === "persistent";
+        if (options.resumeSessionId) {
+          this._sessionId = options.resumeSessionId;
+        }
+        if (config.supervisor?.onAskUser) {
+          console.warn(
+            "[agent-sdk/claude] supervisor.onAskUser is not supported by the Claude CLI backend. User interaction requests from the model will not be forwarded."
+          );
+        }
+      }
+      get sessionId() {
+        return this._sessionId;
+      }
+      async interrupt() {
+        try {
+          if (this.activeQuery) {
+            await this.activeQuery.interrupt();
+          }
+        } catch {
+        } finally {
+          this.abort();
+        }
+      }
+      /** Clear persistent session state after an error so next call starts fresh */
+      clearPersistentSession() {
+        this._sessionId = void 0;
+      }
+      emitSessionInfo(sessionId) {
+        const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+        const transcriptPath = home ? `${home}/.claude/projects/.session/sessions/${sessionId}/conversation.jsonl` : void 0;
+        return { type: "session_info", sessionId, transcriptPath, backend: "claude" };
+      }
+      buildQueryOptions(signal) {
+        const ac = new AbortController();
+        signal.addEventListener("abort", () => ac.abort(), { once: true });
+        const opts = {
+          abortController: ac,
+          model: this.config.model,
+          maxTurns: this.options.maxTurns,
+          cwd: this.options.workingDirectory,
+          pathToClaudeCodeExecutable: this.options.cliPath,
+          persistSession: this.isPersistent,
+          includePartialMessages: true,
+          canUseTool: this.canUseTool
+        };
+        if (this.isPersistent && this._sessionId) {
+          opts.resume = this._sessionId;
+        }
+        if (this.config.systemPrompt) {
+          opts.systemPrompt = this.config.systemPrompt;
+        }
+        if (this.options.oauthToken || this.options.env) {
+          opts.env = {
+            ...process.env,
+            ...this.options.env ?? {},
+            ...this.options.oauthToken ? { CLAUDE_CODE_OAUTH_TOKEN: this.options.oauthToken } : {}
+          };
+        }
+        if (opts.canUseTool && !opts.permissionMode) {
+          opts.permissionMode = "default";
+        }
+        if (this.config.availableTools) {
+          opts.tools = [...this.config.availableTools];
+        }
+        return opts;
+      }
+      async buildMcpConfig(opts, toolResultCapture) {
+        if (this.tools.length === 0) return opts;
+        const sdk = await loadSDK2();
+        const mcpServer = buildMcpServer(sdk, this.tools, toolResultCapture);
+        if (mcpServer) {
+          opts.mcpServers = {
+            [MCP_SERVER_NAME]: mcpServer
+          };
+          const mcpToolNames = this.tools.map((t) => mcpToolName(t.name));
+          opts.allowedTools = [...opts.allowedTools ?? [], ...mcpToolNames];
+        }
+        return opts;
+      }
+      // ─── executeRun ─────────────────────────────────────────────────
+      async executeRun(messages, _options, signal) {
+        this.checkAbort(signal);
+        const sdk = await loadSDK2();
+        const isResuming = this.isPersistent && this._sessionId !== void 0;
+        const prompt = isResuming ? extractLastUserPrompt2(messages) : buildContextualPrompt2(messages);
+        let opts = this.buildQueryOptions(signal);
+        const toolResultCapture = /* @__PURE__ */ new Map();
+        opts = await this.buildMcpConfig(opts, toolResultCapture);
+        const q = sdk.query({ prompt, options: opts });
+        this.activeQuery = q;
+        const toolCalls = [];
+        let output = null;
+        let usage;
+        try {
+          for await (const msg of q) {
+            if (msg.type === "assistant") {
+              const betaMessage = msg.message;
+              if (betaMessage?.content) {
+                for (const block of betaMessage.content) {
+                  if (block.type === "tool_use") {
+                    const toolName = stripMcpPrefix(block.name ?? "unknown");
+                    toolCalls.push({
+                      toolName,
+                      args: block.input ?? {},
+                      result: toolResultCapture.get(toolName) ?? null,
+                      approved: true
+                    });
+                  }
+                }
+              }
+            }
+            if (msg.type === "tool_use_summary" || msg.type === "result") {
+              for (const tc of toolCalls) {
+                if (tc.result === null) {
+                  const captured = toolResultCapture.get(tc.toolName);
+                  if (captured !== void 0) tc.result = captured;
+                }
+              }
+            }
+            if (msg.type === "result") {
+              if (msg.subtype === "success") {
+                const r = msg;
+                output = r.result;
+                usage = aggregateUsage(r.modelUsage);
+                if (this.isPersistent && r.session_id) {
+                  this._sessionId = r.session_id;
+                }
+              } else if (msg.is_error) {
+                const r = msg;
+                throw new Error(
+                  `Claude query failed: ${r.errors?.join("; ") ?? "unknown error"}`
+                );
+              }
+            }
+          }
+        } catch (e) {
+          if (signal.aborted) throw new AbortError();
+          if (isResuming && this.isPersistent) {
+            this.clearPersistentSession();
+            const retryPrompt = buildContextualPrompt2(messages);
+            let retryOpts = this.buildQueryOptions(signal);
+            toolResultCapture.clear();
+            retryOpts = await this.buildMcpConfig(retryOpts, toolResultCapture);
+            const retryQ = sdk.query({ prompt: retryPrompt, options: retryOpts });
+            this.activeQuery = retryQ;
+            toolCalls.length = 0;
+            output = null;
+            try {
+              for await (const msg of retryQ) {
+                if (msg.type === "assistant") {
+                  const betaMessage = msg.message;
+                  if (betaMessage?.content) {
+                    for (const block of betaMessage.content) {
+                      if (block.type === "tool_use") {
+                        const toolName = stripMcpPrefix(block.name ?? "unknown");
+                        toolCalls.push({
+                          toolName,
+                          args: block.input ?? {},
+                          result: toolResultCapture.get(toolName) ?? null,
+                          approved: true
+                        });
+                      }
+                    }
+                  }
+                }
+                if (msg.type === "tool_use_summary" || msg.type === "result") {
+                  for (const tc of toolCalls) {
+                    if (tc.result === null) {
+                      const captured = toolResultCapture.get(tc.toolName);
+                      if (captured !== void 0) tc.result = captured;
+                    }
+                  }
+                }
+                if (msg.type === "result") {
+                  if (msg.subtype === "success") {
+                    const r = msg;
+                    output = r.result;
+                    usage = aggregateUsage(r.modelUsage);
+                    if (this.isPersistent && r.session_id) {
+                      this._sessionId = r.session_id;
+                    }
+                  } else if (msg.is_error) {
+                    const r = msg;
+                    throw new Error(
+                      `Claude query failed: ${r.errors?.join("; ") ?? "unknown error"}`
+                    );
+                  }
+                }
+              }
+            } catch (retryError) {
+              if (this.isPersistent) this.clearPersistentSession();
+              if (signal.aborted) throw new AbortError();
+              throw retryError;
+            } finally {
+              this.activeQuery = null;
+            }
+            return {
+              output,
+              structuredOutput: void 0,
+              toolCalls,
+              messages: [
+                ...messages,
+                ...output !== null ? [{ role: "assistant", content: output }] : []
+              ],
+              usage
+            };
+          }
+          if (this.isPersistent) this.clearPersistentSession();
+          throw e;
+        } finally {
+          this.activeQuery = null;
+        }
+        return {
+          output,
+          structuredOutput: void 0,
+          toolCalls,
+          messages: [
+            ...messages,
+            ...output !== null ? [{ role: "assistant", content: output }] : []
+          ],
+          usage
+        };
+      }
+      // ─── executeRunStructured ───────────────────────────────────────
+      async executeRunStructured(messages, schema, _options, signal) {
+        this.checkAbort(signal);
+        const sdk = await loadSDK2();
+        const isResuming = this.isPersistent && this._sessionId !== void 0;
+        const prompt = isResuming ? extractLastUserPrompt2(messages) : buildContextualPrompt2(messages);
+        let opts = this.buildQueryOptions(signal);
+        const toolResultCapture = /* @__PURE__ */ new Map();
+        opts = await this.buildMcpConfig(opts, toolResultCapture);
+        const jsonSchema = zodToJsonSchema(schema.schema);
+        opts.outputFormat = {
+          type: "json_schema",
+          schema: jsonSchema
+        };
+        const q = sdk.query({ prompt, options: opts });
+        this.activeQuery = q;
+        const toolCalls = [];
+        let output = null;
+        let structuredOutput;
+        let usage;
+        try {
+          for await (const msg of q) {
+            if (msg.type === "assistant") {
+              const betaMessage = msg.message;
+              if (betaMessage?.content) {
+                for (const block of betaMessage.content) {
+                  if (block.type === "tool_use") {
+                    const toolName = stripMcpPrefix(block.name ?? "unknown");
+                    toolCalls.push({
+                      toolName,
+                      args: block.input ?? {},
+                      result: toolResultCapture.get(toolName) ?? null,
+                      approved: true
+                    });
+                  }
+                }
+              }
+            }
+            if (msg.type === "tool_use_summary" || msg.type === "result") {
+              for (const tc of toolCalls) {
+                if (tc.result === null) {
+                  const captured = toolResultCapture.get(tc.toolName);
+                  if (captured !== void 0) tc.result = captured;
+                }
+              }
+            }
+            if (msg.type === "result" && msg.subtype === "success") {
+              const r = msg;
+              output = r.result;
+              if (r.structured_output !== void 0) {
+                try {
+                  structuredOutput = schema.schema.parse(r.structured_output);
+                } catch {
+                  try {
+                    structuredOutput = schema.schema.parse(JSON.parse(r.result));
+                  } catch {
+                  }
+                }
+              } else if (r.result) {
+                try {
+                  const jsonMatch = r.result.match(/```(?:json)?\s*([\s\S]*?)```/);
+                  const raw = jsonMatch ? jsonMatch[1].trim() : r.result.trim();
+                  structuredOutput = schema.schema.parse(JSON.parse(raw));
+                } catch {
+                }
+              }
+              usage = aggregateUsage(r.modelUsage);
+              if (this.isPersistent && r.session_id) {
+                this._sessionId = r.session_id;
+              }
+            } else if (msg.type === "result" && msg.is_error) {
+              const r = msg;
+              throw new Error(
+                `Claude query failed: ${r.errors?.join("; ") ?? "unknown error"}`
+              );
+            }
+          }
+        } catch (e) {
+          if (signal.aborted) throw new AbortError();
+          if (isResuming && this.isPersistent) {
+            this.clearPersistentSession();
+            const retryPrompt = buildContextualPrompt2(messages);
+            let retryOpts = this.buildQueryOptions(signal);
+            toolResultCapture.clear();
+            retryOpts = await this.buildMcpConfig(retryOpts, toolResultCapture);
+            retryOpts.outputFormat = {
+              type: "json_schema",
+              schema: jsonSchema
+            };
+            const retryQ = sdk.query({ prompt: retryPrompt, options: retryOpts });
+            this.activeQuery = retryQ;
+            toolCalls.length = 0;
+            output = null;
+            structuredOutput = void 0;
+            try {
+              for await (const msg of retryQ) {
+                if (msg.type === "assistant") {
+                  const betaMessage = msg.message;
+                  if (betaMessage?.content) {
+                    for (const block of betaMessage.content) {
+                      if (block.type === "tool_use") {
+                        const toolName = stripMcpPrefix(block.name ?? "unknown");
+                        toolCalls.push({
+                          toolName,
+                          args: block.input ?? {},
+                          result: toolResultCapture.get(toolName) ?? null,
+                          approved: true
+                        });
+                      }
+                    }
+                  }
+                }
+                if (msg.type === "tool_use_summary" || msg.type === "result") {
+                  for (const tc of toolCalls) {
+                    if (tc.result === null) {
+                      const captured = toolResultCapture.get(tc.toolName);
+                      if (captured !== void 0) tc.result = captured;
+                    }
+                  }
+                }
+                if (msg.type === "result" && msg.subtype === "success") {
+                  const r = msg;
+                  output = r.result;
+                  if (r.structured_output !== void 0) {
+                    try {
+                      structuredOutput = schema.schema.parse(r.structured_output);
+                    } catch {
+                      try {
+                        structuredOutput = schema.schema.parse(JSON.parse(r.result));
+                      } catch {
+                      }
+                    }
+                  } else if (r.result) {
+                    try {
+                      const jsonMatch = r.result.match(/```(?:json)?\s*([\s\S]*?)```/);
+                      const raw = jsonMatch ? jsonMatch[1].trim() : r.result.trim();
+                      structuredOutput = schema.schema.parse(JSON.parse(raw));
+                    } catch {
+                    }
+                  }
+                  usage = aggregateUsage(r.modelUsage);
+                  if (this.isPersistent && r.session_id) {
+                    this._sessionId = r.session_id;
+                  }
+                } else if (msg.type === "result" && msg.is_error) {
+                  const r = msg;
+                  throw new Error(
+                    `Claude query failed: ${r.errors?.join("; ") ?? "unknown error"}`
+                  );
+                }
+              }
+            } catch (retryError) {
+              if (this.isPersistent) this.clearPersistentSession();
+              if (signal.aborted) throw new AbortError();
+              throw retryError;
+            } finally {
+              this.activeQuery = null;
+            }
+            return {
+              output,
+              structuredOutput,
+              toolCalls,
+              messages: [
+                ...messages,
+                ...output !== null ? [{ role: "assistant", content: output }] : []
+              ],
+              usage
+            };
+          }
+          if (this.isPersistent) this.clearPersistentSession();
+          throw e;
+        } finally {
+          this.activeQuery = null;
+        }
+        return {
+          output,
+          structuredOutput,
+          toolCalls,
+          messages: [
+            ...messages,
+            ...output !== null ? [{ role: "assistant", content: output }] : []
+          ],
+          usage
+        };
+      }
+      // ─── executeStream ──────────────────────────────────────────────
+      async *executeStream(messages, _options, signal) {
+        this.checkAbort(signal);
+        const sdk = await loadSDK2();
+        const isResuming = this.isPersistent && this._sessionId !== void 0;
+        const prompt = isResuming ? extractLastUserPrompt2(messages) : buildContextualPrompt2(messages);
+        let opts = this.buildQueryOptions(signal);
+        const toolResultCapture = /* @__PURE__ */ new Map();
+        opts = await this.buildMcpConfig(opts, toolResultCapture);
+        const q = sdk.query({ prompt, options: opts });
+        this.activeQuery = q;
+        const thinkingBlockIndices = /* @__PURE__ */ new Set();
+        const toolCallTracker = new ClaudeToolCallTracker();
+        const pendingStreamToolCalls = /* @__PURE__ */ new Map();
+        try {
+          for await (const msg of q) {
+            if (signal.aborted) throw new AbortError();
+            const events = mapSDKMessage(msg, thinkingBlockIndices, toolCallTracker);
+            if (events) {
+              const mapped = Array.isArray(events) ? events : [events];
+              for (const e of mapped) {
+                if (e.type === "tool_call_start") {
+                  pendingStreamToolCalls.set(e.toolCallId, e.toolName);
+                }
+                if (e.type === "tool_call_end" && toolResultCapture.has(e.toolName)) {
+                  e.result = toolResultCapture.get(e.toolName);
+                  toolResultCapture.delete(e.toolName);
+                  pendingStreamToolCalls.delete(e.toolCallId);
+                } else if (e.type === "tool_call_end") {
+                  pendingStreamToolCalls.delete(e.toolCallId);
+                }
+                yield e;
+              }
+            }
+            if (msg.type === "result" && msg.subtype === "success") {
+              const r = msg;
+              for (const [toolCallId, toolName] of pendingStreamToolCalls) {
+                if (toolResultCapture.has(toolName)) {
+                  yield {
+                    type: "tool_call_end",
+                    toolCallId,
+                    toolName,
+                    result: toolResultCapture.get(toolName)
+                  };
+                  toolResultCapture.delete(toolName);
+                }
+              }
+              pendingStreamToolCalls.clear();
+              if (r.session_id) {
+                if (this.isPersistent) {
+                  this._sessionId = r.session_id;
+                }
+                yield this.emitSessionInfo(r.session_id);
+              }
+              yield { type: "done", finalOutput: r.result };
+            }
+          }
+        } catch (e) {
+          if (signal.aborted) throw new AbortError();
+          if (isResuming && this.isPersistent) {
+            this.clearPersistentSession();
+            const retryPrompt = buildContextualPrompt2(messages);
+            let retryOpts = this.buildQueryOptions(signal);
+            toolResultCapture.clear();
+            retryOpts = await this.buildMcpConfig(retryOpts, toolResultCapture);
+            const retryQ = sdk.query({ prompt: retryPrompt, options: retryOpts });
+            this.activeQuery = retryQ;
+            const retryThinkingBlockIndices = /* @__PURE__ */ new Set();
+            const retryToolCallTracker = new ClaudeToolCallTracker();
+            const retryPendingToolCalls = /* @__PURE__ */ new Map();
+            try {
+              for await (const msg of retryQ) {
+                if (signal.aborted) throw new AbortError();
+                const retryEvents = mapSDKMessage(msg, retryThinkingBlockIndices, retryToolCallTracker);
+                if (retryEvents) {
+                  const mapped = Array.isArray(retryEvents) ? retryEvents : [retryEvents];
+                  for (const ev of mapped) {
+                    if (ev.type === "tool_call_start") {
+                      retryPendingToolCalls.set(ev.toolCallId, ev.toolName);
+                    }
+                    if (ev.type === "tool_call_end" && toolResultCapture.has(ev.toolName)) {
+                      ev.result = toolResultCapture.get(ev.toolName);
+                      toolResultCapture.delete(ev.toolName);
+                      retryPendingToolCalls.delete(ev.toolCallId);
+                    } else if (ev.type === "tool_call_end") {
+                      retryPendingToolCalls.delete(ev.toolCallId);
+                    }
+                    yield ev;
+                  }
+                }
+                if (msg.type === "result" && msg.subtype === "success") {
+                  const r = msg;
+                  for (const [toolCallId, toolName] of retryPendingToolCalls) {
+                    if (toolResultCapture.has(toolName)) {
+                      yield {
+                        type: "tool_call_end",
+                        toolCallId,
+                        toolName,
+                        result: toolResultCapture.get(toolName)
+                      };
+                      toolResultCapture.delete(toolName);
+                    }
+                  }
+                  retryPendingToolCalls.clear();
+                  if (r.session_id) {
+                    if (this.isPersistent) {
+                      this._sessionId = r.session_id;
+                    }
+                    yield this.emitSessionInfo(r.session_id);
+                  }
+                  yield { type: "done", finalOutput: r.result };
+                }
+              }
+            } catch (retryError) {
+              if (this.isPersistent) this.clearPersistentSession();
+              if (signal.aborted) throw new AbortError();
+              throw retryError;
+            } finally {
+              this.activeQuery = null;
+            }
+            return;
+          }
+          if (this.isPersistent) this.clearPersistentSession();
+          throw e;
+        } finally {
+          this.activeQuery = null;
+        }
+      }
+      dispose() {
+        this._sessionId = void 0;
+        super.dispose();
+      }
+    };
+    ClaudeAgentService = class {
+      name = "claude";
+      disposed = false;
+      options;
+      cachedModels = null;
+      constructor(options) {
+        this.options = options;
+      }
+      createAgent(config) {
+        if (this.disposed) throw new DisposedError("ClaudeAgentService");
+        return new ClaudeAgent(config, this.options);
+      }
+      async listModels() {
+        if (this.disposed) throw new DisposedError("ClaudeAgentService");
+        if (this.cachedModels) return this.cachedModels;
+        const token = this.options.oauthToken;
+        if (!token) {
+          return [];
+        }
+        const res = await globalThis.fetch(
+          `${ANTHROPIC_MODELS_URL}?limit=100`,
+          {
+            headers: {
+              Authorization: `Bearer ${token}`,
+              "anthropic-version": ANTHROPIC_API_VERSION,
+              "anthropic-beta": ANTHROPIC_OAUTH_BETA
+            }
+          }
+        );
+        if (!res.ok) {
+          return [];
+        }
+        const body = await res.json();
+        if (!body.data || body.data.length === 0) {
+          return [];
+        }
+        this.cachedModels = body.data.map((m) => ({
+          id: m.id,
+          name: m.display_name,
+          provider: "claude"
+        }));
+        return this.cachedModels;
+      }
+      async validate() {
+        if (this.disposed) throw new DisposedError("ClaudeAgentService");
+        const errors = [];
+        try {
+          await loadSDK2();
+        } catch (e) {
+          errors.push(
+            e instanceof Error ? e.message : String(e)
+          );
+          return { valid: false, errors };
+        }
+        try {
+          const sdk = await loadSDK2();
+          const q = sdk.query({
+            prompt: "echo test",
+            options: {
+              model: "claude-sonnet-4-20250514",
+              pathToClaudeCodeExecutable: this.options.cliPath,
+              cwd: this.options.workingDirectory,
+              persistSession: false,
+              maxTurns: 1,
+              permissionMode: "plan"
+            }
+          });
+          const first = await q.next();
+          q.close();
+          if (first.done) {
+            errors.push("Claude CLI returned no messages \u2014 may not be authenticated.");
+          }
+        } catch (e) {
+          errors.push(
+            `Failed to connect to Claude CLI: ${e instanceof Error ? e.message : String(e)}`
+          );
+        }
+        return { valid: errors.length === 0, errors };
+      }
+      async dispose() {
+        if (this.disposed) return;
+        this.disposed = true;
+        this.cachedModels = null;
+      }
+    };
+  }
+});
+
+// src/backends/vercel-ai.ts
+var vercel_ai_exports = {};
+__export(vercel_ai_exports, {
+  _injectCompat: () => _injectCompat,
+  _injectSDK: () => _injectSDK3,
+  _resetSDK: () => _resetSDK3,
+  createVercelAIService: () => createVercelAIService
+});
+async function loadSDK3() {
+  if (sdkModule3) return sdkModule3;
+  try {
+    sdkModule3 = await import('ai');
+    return sdkModule3;
+  } catch {
+    throw new DependencyError("ai");
+  }
+}
+async function loadCompat() {
+  if (compatModule) return compatModule;
+  try {
+    compatModule = await import('@ai-sdk/openai-compatible');
+    return compatModule;
+  } catch {
+    throw new DependencyError("@ai-sdk/openai-compatible");
+  }
+}
+function _injectSDK3(mock) {
+  sdkModule3 = mock;
+}
+function _injectCompat(mock) {
+  compatModule = mock;
+}
+function _resetSDK3() {
+  sdkModule3 = null;
+  compatModule = null;
+}
+function mapToolsToSDK2(sdk, tools, config, sessionApprovals, permissionStore, signal) {
+  const toolMap = {};
+  const supervisor = config.supervisor;
+  for (const ourTool of tools) {
+    const jsonSchema = zodToJsonSchema(ourTool.parameters);
+    toolMap[ourTool.name] = sdk.tool({
+      description: ourTool.description,
+      inputSchema: sdk.jsonSchema(jsonSchema),
+      execute: wrapToolExecute(ourTool, supervisor, sessionApprovals, permissionStore, signal),
+      ...ourTool.needsApproval && supervisor?.onPermission ? {
+        needsApproval: async (_input) => {
+          if (permissionStore && await permissionStore.isApproved(ourTool.name)) return false;
+          if (sessionApprovals.has(ourTool.name)) return false;
+          return true;
+        }
+      } : {}
+    });
+  }
+  if (supervisor?.onAskUser) {
+    const onAskUser = supervisor.onAskUser;
+    toolMap["ask_user"] = sdk.tool({
+      description: "Ask the user a question and wait for their response",
+      inputSchema: sdk.jsonSchema({
+        type: "object",
+        properties: {
+          question: { type: "string", description: "The question to ask the user" }
+        },
+        required: ["question"]
+      }),
+      execute: async (args) => {
+        const response = await onAskUser(
+          { question: args.question, allowFreeform: true },
+          signal
+        );
+        return response.answer;
+      }
+    });
+  }
+  return toolMap;
+}
+function wrapToolExecute(ourTool, supervisor, sessionApprovals, permissionStore, signal) {
+  return async (args) => {
+    if (ourTool.needsApproval && supervisor?.onPermission) {
+      const storeApproved = permissionStore && await permissionStore.isApproved(ourTool.name);
+      if (!storeApproved && !sessionApprovals.has(ourTool.name)) {
+        const request = {
+          toolName: ourTool.name,
+          toolArgs: args ?? {}
+        };
+        const decision = await supervisor.onPermission(
+          request,
+          signal
+        );
+        if (!decision.allowed) {
+          throw new ToolExecutionError(
+            ourTool.name,
+            decision.reason ?? "Permission denied"
+          );
+        }
+        if (permissionStore && decision.scope) {
+          await permissionStore.approve(ourTool.name, decision.scope);
+        }
+        if (decision.scope === "session" || decision.scope === "always" || decision.scope === "project") {
+          sessionApprovals.add(ourTool.name);
+        }
+        if (decision.modifiedInput) {
+          args = decision.modifiedInput;
+        }
+      }
+    }
+    try {
+      const result = await ourTool.execute(args);
+      return result;
+    } catch (e) {
+      if (e instanceof ToolExecutionError) throw e;
+      throw new ToolExecutionError(
+        ourTool.name,
+        e instanceof Error ? e.message : String(e)
+      );
+    }
+  };
+}
+function messagesToSDK(messages) {
+  return messages.map((msg) => {
+    switch (msg.role) {
+      case "user":
+        return { role: "user", content: getTextContent(msg.content) };
+      case "assistant": {
+        let content = getTextContent(msg.content);
+        const thinking = msg.thinking;
+        if (thinking) {
+          content = `[reasoning: ${thinking}]
+${content}`;
+        }
+        const mapped = { role: "assistant", content };
+        if (msg.toolCalls && msg.toolCalls.length > 0) {
+          mapped.toolCalls = msg.toolCalls.map((tc) => ({
+            id: tc.id,
+            name: tc.name,
+            args: tc.args
+          }));
+        }
+        return mapped;
+      }
+      case "system":
+        return { role: "system", content: msg.content };
+      case "tool": {
+        if (msg.toolResults && msg.toolResults.length > 0) {
+          return {
+            role: "tool",
+            toolResults: msg.toolResults.map((tr) => ({
+              toolCallId: tr.toolCallId,
+              name: tr.name,
+              result: tr.result,
+              isError: tr.isError ?? false
+            }))
+          };
+        }
+        return { role: "tool", content: msg.content ?? "" };
+      }
+      default:
+        return { role: "user", content: "" };
+    }
+  });
+}
+function mapStreamPart(part) {
+  switch (part.type) {
+    case "text-delta": {
+      const p = part;
+      return { type: "text_delta", text: p.text ?? "" };
+    }
+    case "tool-call": {
+      const p = part;
+      return {
+        type: "tool_call_start",
+        toolCallId: String(p.toolCallId ?? ""),
+        toolName: p.toolName ?? "unknown",
+        args: p.input ?? {}
+      };
+    }
+    case "tool-result": {
+      const p = part;
+      return {
+        type: "tool_call_end",
+        toolCallId: String(p.toolCallId ?? ""),
+        toolName: p.toolName ?? "unknown",
+        result: p.output ?? null
+      };
+    }
+    case "tool-error": {
+      const p = part;
+      return {
+        type: "error",
+        error: p.error instanceof Error ? p.error.message : String(p.error ?? "Tool execution failed"),
+        recoverable: true
+      };
+    }
+    case "reasoning-start":
+      return { type: "thinking_start" };
+    case "reasoning-end":
+      return { type: "thinking_end" };
+    case "reasoning-delta": {
+      const p = part;
+      return { type: "thinking_delta", text: p.text ?? "" };
+    }
+    case "finish-step": {
+      const p = part;
+      return {
+        type: "usage_update",
+        promptTokens: Number(p.usage?.inputTokens ?? 0),
+        completionTokens: Number(p.usage?.outputTokens ?? 0)
+      };
+    }
+    case "error": {
+      const p = part;
+      return {
+        type: "error",
+        error: p.error instanceof Error ? p.error.message : String(p.error ?? "Unknown error"),
+        recoverable: false
+      };
+    }
+    default:
+      return null;
+  }
+}
+function createVercelAIService(options) {
+  return new VercelAIAgentService(options);
+}
+var sdkModule3, compatModule, DEFAULT_BASE_URL, DEFAULT_PROVIDER, DEFAULT_MAX_TURNS, VercelAIAgent, VercelAIAgentService;
+var init_vercel_ai = __esm({
+  "src/backends/vercel-ai.ts"() {
+    init_types();
+    init_base_agent();
+    init_errors();
+    init_schema();
+    sdkModule3 = null;
+    compatModule = null;
+    DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
+    DEFAULT_PROVIDER = "openrouter";
+    DEFAULT_MAX_TURNS = 10;
+    VercelAIAgent = class extends BaseAgent {
+      backendName = "vercel-ai";
+      backendOptions;
+      sessionApprovals = /* @__PURE__ */ new Set();
+      model = null;
+      constructor(config, backendOptions) {
+        super(config);
+        this.backendOptions = backendOptions;
+      }
+      async getModel() {
+        if (this.model) return this.model;
+        const compat = await loadCompat();
+        const provider = compat.createOpenAICompatible({
+          name: this.backendOptions.provider ?? DEFAULT_PROVIDER,
+          baseURL: this.backendOptions.baseUrl ?? DEFAULT_BASE_URL,
+          apiKey: this.backendOptions.apiKey
+        });
+        const modelId = this.config.model ?? "anthropic/claude-sonnet-4-5";
+        this.model = provider.chatModel(modelId);
+        return this.model;
+      }
+      async getSDKTools(signal) {
+        const sdk = await loadSDK3();
+        return mapToolsToSDK2(sdk, this.config.tools ?? [], this.config, this.sessionApprovals, this.config.permissionStore, signal);
+      }
+      // ─── executeRun ─────────────────────────────────────────────────
+      async executeRun(messages, _options, signal) {
+        this.checkAbort(signal);
+        const sdk = await loadSDK3();
+        const model = await this.getModel();
+        const tools = await this.getSDKTools(signal);
+        const maxTurns = this.config.maxTurns ?? DEFAULT_MAX_TURNS;
+        const sdkMessages = messagesToSDK(messages);
+        const hasTools = Object.keys(tools).length > 0;
+        const result = await sdk.generateText({
+          model,
+          system: this.config.systemPrompt,
+          messages: sdkMessages,
+          tools: hasTools ? tools : void 0,
+          stopWhen: sdk.stepCountIs(maxTurns),
+          abortSignal: signal,
+          ...this.config.modelParams?.temperature !== void 0 && {
+            temperature: this.config.modelParams.temperature
+          },
+          ...this.config.modelParams?.maxTokens !== void 0 && {
+            maxTokens: this.config.modelParams.maxTokens
+          },
+          ...this.config.modelParams?.topP !== void 0 && {
+            topP: this.config.modelParams.topP
+          },
+          ...this.config.providerOptions && {
+            providerOptions: this.config.providerOptions
+          }
+        });
+        const toolCalls = [];
+        for (const step of result.steps) {
+          for (const tc of step.toolCalls) {
+            const matchingResult = step.toolResults.find(
+              (tr) => tr.toolCallId === tc.toolCallId
+            );
+            toolCalls.push({
+              toolName: tc.toolName,
+              args: tc.input ?? {},
+              result: matchingResult?.output ?? null,
+              approved: true
+            });
+          }
+        }
+        const usage = {
+          promptTokens: Number(result.totalUsage?.inputTokens ?? 0),
+          completionTokens: Number(result.totalUsage?.outputTokens ?? 0)
+        };
+        const lastStep = result.steps.length > 0 ? result.steps[result.steps.length - 1] : null;
+        const outputText = lastStep?.text || null;
+        return {
+          output: outputText,
+          structuredOutput: void 0,
+          toolCalls,
+          messages: [
+            ...messages,
+            ...outputText ? [{ role: "assistant", content: outputText }] : []
+          ],
+          usage
+        };
+      }
+      // ─── executeRunStructured ───────────────────────────────────────
+      async executeRunStructured(messages, schema, _options, signal) {
+        this.checkAbort(signal);
+        const sdk = await loadSDK3();
+        const model = await this.getModel();
+        const sdkMessages = messagesToSDK(messages);
+        const jsonSchema = zodToJsonSchema(schema.schema);
+        const result = await sdk.generateObject({
+          model,
+          system: this.config.systemPrompt,
+          messages: sdkMessages,
+          schema: sdk.jsonSchema(jsonSchema),
+          schemaName: schema.name,
+          schemaDescription: schema.description,
+          abortSignal: signal,
+          ...this.config.modelParams?.temperature !== void 0 && {
+            temperature: this.config.modelParams.temperature
+          },
+          ...this.config.modelParams?.maxTokens !== void 0 && {
+            maxTokens: this.config.modelParams.maxTokens
+          },
+          ...this.config.providerOptions && {
+            providerOptions: this.config.providerOptions
+          }
+        });
+        let structuredOutput;
+        try {
+          structuredOutput = schema.schema.parse(result.object);
+        } catch {
+        }
+        const usage = {
+          promptTokens: Number(result.usage?.inputTokens ?? 0),
+          completionTokens: Number(result.usage?.outputTokens ?? 0)
+        };
+        return {
+          output: JSON.stringify(result.object),
+          structuredOutput,
+          toolCalls: [],
+          messages: [
+            ...messages,
+            ...result.object != null ? [{ role: "assistant", content: JSON.stringify(result.object) }] : []
+          ],
+          usage
+        };
+      }
+      // ─── executeStream ──────────────────────────────────────────────
+      async *executeStream(messages, _options, signal) {
+        this.checkAbort(signal);
+        const sdk = await loadSDK3();
+        const model = await this.getModel();
+        const tools = await this.getSDKTools(signal);
+        const maxTurns = this.config.maxTurns ?? DEFAULT_MAX_TURNS;
+        const sdkMessages = messagesToSDK(messages);
+        const hasTools = Object.keys(tools).length > 0;
+        const result = sdk.streamText({
+          model,
+          system: this.config.systemPrompt,
+          messages: sdkMessages,
+          tools: hasTools ? tools : void 0,
+          stopWhen: sdk.stepCountIs(maxTurns),
+          abortSignal: signal,
+          ...this.config.modelParams?.temperature !== void 0 && {
+            temperature: this.config.modelParams.temperature
+          },
+          ...this.config.modelParams?.maxTokens !== void 0 && {
+            maxTokens: this.config.modelParams.maxTokens
+          },
+          ...this.config.modelParams?.topP !== void 0 && {
+            topP: this.config.modelParams.topP
+          },
+          ...this.config.providerOptions && {
+            providerOptions: this.config.providerOptions
+          }
+        });
+        let finalText = "";
+        try {
+          for await (const part of result.fullStream) {
+            if (signal.aborted) throw new AbortError();
+            const event = mapStreamPart(part);
+            if (event) yield event;
+            if (part.type === "text-delta") {
+              finalText += part.text ?? "";
+            }
+            if (part.type === "finish-step") {
+              const p = part;
+              if (p.finishReason === "tool-calls") {
+                finalText = "";
+              }
+            }
+          }
+          const totalUsage = await result.totalUsage;
+          yield {
+            type: "usage_update",
+            promptTokens: Number(totalUsage?.inputTokens ?? 0),
+            completionTokens: Number(totalUsage?.outputTokens ?? 0)
+          };
+          yield {
+            type: "done",
+            finalOutput: finalText || null
+          };
+        } catch (e) {
+          if (signal.aborted) throw new AbortError();
+          throw e;
+        }
+      }
+      dispose() {
+        this.sessionApprovals.clear();
+        this.model = null;
+        super.dispose();
+      }
+    };
+    VercelAIAgentService = class {
+      name = "vercel-ai";
+      disposed = false;
+      options;
+      constructor(options) {
+        this.options = options;
+      }
+      createAgent(config) {
+        if (this.disposed) throw new DisposedError("VercelAIAgentService");
+        return new VercelAIAgent(config, this.options);
+      }
+      async listModels() {
+        if (this.disposed) throw new DisposedError("VercelAIAgentService");
+        const baseUrl = (this.options.baseUrl || "https://api.openai.com/v1").replace(/\/+$/, "");
+        try {
+          const res = await globalThis.fetch(`${baseUrl}/models`, {
+            headers: { Authorization: `Bearer ${this.options.apiKey}` }
+          });
+          if (!res.ok) {
+            return [];
+          }
+          const body = await res.json();
+          if (!body.data || body.data.length === 0) {
+            return [];
+          }
+          return body.data.map((m) => ({ id: m.id }));
+        } catch {
+          return [];
+        }
+      }
+      async validate() {
+        if (this.disposed) throw new DisposedError("VercelAIAgentService");
+        const errors = [];
+        if (!this.options.apiKey) {
+          errors.push("apiKey is required for Vercel AI backend.");
+        }
+        try {
+          await loadSDK3();
+        } catch (e) {
+          errors.push(e instanceof Error ? e.message : String(e));
+        }
+        try {
+          await loadCompat();
+        } catch (e) {
+          errors.push(e instanceof Error ? e.message : String(e));
+        }
+        return { valid: errors.length === 0, errors };
+      }
+      async dispose() {
+        if (this.disposed) return;
+        this.disposed = true;
+      }
+    };
+  }
+});
+
+// src/registry.ts
+function registerBackend(name, factory) {
+  if (registry.has(name)) {
+    throw new BackendAlreadyRegisteredError(name);
+  }
+  registry.set(name, { factory, builtin: false });
+}
+function unregisterBackend(name) {
+  return registry.delete(name);
+}
+function hasBackend(name) {
+  return registry.has(name) || isBuiltinName(name);
+}
+function listBackends() {
+  const names = new Set(registry.keys());
+  for (const builtin of BUILTIN_BACKENDS) {
+    names.add(builtin);
+  }
+  return [...names];
+}
+function resetRegistry() {
+  registry.clear();
+}
+function isBuiltinName(name) {
+  return BUILTIN_BACKENDS.has(name);
+}
+async function loadBuiltinFactory(name) {
+  switch (name) {
+    case "copilot": {
+      const mod = await Promise.resolve().then(() => (init_copilot(), copilot_exports));
+      return (opts) => mod.createCopilotService(opts);
+    }
+    case "claude": {
+      const mod = await Promise.resolve().then(() => (init_claude(), claude_exports));
+      return (opts) => mod.createClaudeService(opts);
+    }
+    case "vercel-ai": {
+      const mod = await Promise.resolve().then(() => (init_vercel_ai(), vercel_ai_exports));
+      return (opts) => mod.createVercelAIService(opts);
+    }
+  }
+}
+async function createAgentService(name, options) {
+  const entry = registry.get(name);
+  if (entry) {
+    return entry.factory(options);
+  }
+  if (isBuiltinName(name)) {
+    const factory = await loadBuiltinFactory(name);
+    registry.set(name, { factory, builtin: true });
+    return factory(options);
+  }
+  throw new BackendNotFoundError(name);
+}
+var registry, BUILTIN_BACKENDS;
+var init_registry = __esm({
+  "src/registry.ts"() {
+    init_errors();
+    registry = /* @__PURE__ */ new Map();
+    BUILTIN_BACKENDS = /* @__PURE__ */ new Set([
+      "copilot",
+      "claude",
+      "vercel-ai"
+    ]);
+  }
+});
+
+// src/utils/messages.ts
+function messagesToPrompt(messages) {
+  return messages.map((msg) => {
+    switch (msg.role) {
+      case "user":
+        return contentToText(msg.content);
+      case "assistant":
+        return contentToText(msg.content);
+      case "system":
+        return msg.content;
+      case "tool":
+        return msg.content ?? "";
+    }
+  }).filter(Boolean).join("\n\n");
+}
+function contentToText(content) {
+  return getTextContent(content);
+}
+function buildSystemPrompt(base, schemaInstruction) {
+  if (!schemaInstruction) return base;
+  return `${base}
+
+${schemaInstruction}`;
+}
+var init_messages = __esm({
+  "src/utils/messages.ts"() {
+    init_types();
+  }
+});
+function createDefaultPermissionStore(projectDir) {
+  const sessionStore = new InMemoryPermissionStore();
+  const projectPath = projectDir ? path.join(projectDir, ".agent-sdk", "permissions.json") : path.join(process.cwd(), ".agent-sdk", "permissions.json");
+  const userPath = path.join(os.homedir(), ".agent-sdk", "permissions.json");
+  const projectStore = new FilePermissionStore(projectPath);
+  const userStore = new FilePermissionStore(userPath);
+  return new CompositePermissionStore(sessionStore, projectStore, userStore);
+}
+var InMemoryPermissionStore, FilePermissionStore, CompositePermissionStore;
+var init_permission_store = __esm({
+  "src/permission-store.ts"() {
+    InMemoryPermissionStore = class {
+      approvals = /* @__PURE__ */ new Map();
+      async isApproved(toolName) {
+        return this.approvals.has(toolName);
+      }
+      async approve(toolName, scope) {
+        if (scope === "once") return;
+        this.approvals.set(toolName, scope);
+      }
+      async revoke(toolName) {
+        this.approvals.delete(toolName);
+      }
+      async clear() {
+        this.approvals.clear();
+      }
+      async dispose() {
+        this.approvals.clear();
+      }
+    };
+    FilePermissionStore = class {
+      filePath;
+      constructor(filePath) {
+        this.filePath = path.resolve(filePath);
+      }
+      async isApproved(toolName) {
+        const data = this.readFile();
+        return toolName in data.approvals;
+      }
+      async approve(toolName, scope) {
+        if (scope === "once") return;
+        const data = this.readFile();
+        data.approvals[toolName] = { scope, timestamp: Date.now() };
+        this.writeFileAtomic(data);
+      }
+      async revoke(toolName) {
+        const data = this.readFile();
+        delete data.approvals[toolName];
+        this.writeFileAtomic(data);
+      }
+      async clear() {
+        this.writeFileAtomic({ approvals: {} });
+      }
+      async dispose() {
+      }
+      readFile() {
+        try {
+          const raw = fs.readFileSync(this.filePath, "utf-8");
+          const parsed = JSON.parse(raw);
+          if (parsed && typeof parsed.approvals === "object") return parsed;
+        } catch {
+        }
+        return { approvals: {} };
+      }
+      writeFileAtomic(data) {
+        const dir = path.dirname(this.filePath);
+        fs.mkdirSync(dir, { recursive: true });
+        const tmpPath = this.filePath + `.tmp.${process.pid}.${Date.now()}`;
+        fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+        fs.renameSync(tmpPath, this.filePath);
+      }
+    };
+    CompositePermissionStore = class {
+      sessionStore;
+      projectStore;
+      userStore;
+      constructor(sessionStore, projectStore, userStore) {
+        this.sessionStore = sessionStore;
+        this.projectStore = projectStore;
+        this.userStore = userStore ?? projectStore;
+      }
+      async isApproved(toolName) {
+        return await this.sessionStore.isApproved(toolName) || await this.projectStore.isApproved(toolName) || await this.userStore.isApproved(toolName);
+      }
+      async approve(toolName, scope) {
+        if (scope === "once") return;
+        if (scope === "session") {
+          await this.sessionStore.approve(toolName, scope);
+        } else if (scope === "project") {
+          await this.projectStore.approve(toolName, scope);
+        } else {
+          await this.userStore.approve(toolName, scope);
+        }
+      }
+      async revoke(toolName) {
+        await this.sessionStore.revoke(toolName);
+        await this.projectStore.revoke(toolName);
+        await this.userStore.revoke(toolName);
+      }
+      async clear() {
+        await this.sessionStore.clear();
+        await this.projectStore.clear();
+        await this.userStore.clear();
+      }
+      async dispose() {
+        await this.sessionStore.dispose();
+        await this.projectStore.dispose();
+        if (this.userStore !== this.projectStore) {
+          await this.userStore.dispose();
+        }
+      }
+    };
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AbortError: () => AbortError,
+  AgentSDKError: () => AgentSDKError,
+  BackendAlreadyRegisteredError: () => BackendAlreadyRegisteredError,
+  BackendNotFoundError: () => BackendNotFoundError,
+  BaseAgent: () => BaseAgent,
+  CompositePermissionStore: () => CompositePermissionStore,
+  DependencyError: () => DependencyError,
+  DisposedError: () => DisposedError,
+  FilePermissionStore: () => FilePermissionStore,
+  InMemoryPermissionStore: () => InMemoryPermissionStore,
+  ReentrancyError: () => ReentrancyError,
+  StructuredOutputError: () => StructuredOutputError,
+  SubprocessError: () => SubprocessError,
+  ToolExecutionError: () => ToolExecutionError,
+  buildSystemPrompt: () => buildSystemPrompt,
+  contentToText: () => contentToText,
+  createAgentService: () => createAgentService,
+  createDefaultPermissionStore: () => createDefaultPermissionStore,
+  getTextContent: () => getTextContent,
+  hasBackend: () => hasBackend,
+  isMultiPartContent: () => isMultiPartContent,
+  isTextContent: () => isTextContent,
+  isToolDefinition: () => isToolDefinition,
+  listBackends: () => listBackends,
+  messagesToPrompt: () => messagesToPrompt,
+  registerBackend: () => registerBackend,
+  resetRegistry: () => resetRegistry,
+  unregisterBackend: () => unregisterBackend,
+  zodToJsonSchema: () => zodToJsonSchema
+});
+var init_src = __esm({
+  "src/index.ts"() {
+    init_types();
+    init_errors();
+    init_registry();
+    init_base_agent();
+    init_schema();
+    init_messages();
+    init_permission_store();
+  }
+});
+
+// src/chat/core.ts
+function createChatId() {
+  return crypto.randomUUID();
+}
+function getMessageText(message) {
+  return message.parts.filter((p) => p.type === "text").map((p) => p.text).join("");
+}
+function getMessageToolCalls(message) {
+  return message.parts.filter((p) => p.type === "tool_call");
+}
+function agentEventToChatEvent(event, messageId) {
+  switch (event.type) {
+    case "text_delta":
+      return { type: "message:delta", messageId, text: event.text };
+    case "thinking_start":
+      return { type: "thinking:start", messageId };
+    case "thinking_delta":
+      return { type: "thinking:delta", messageId, text: event.text };
+    case "thinking_end":
+      return { type: "thinking:end", messageId };
+    case "tool_call_start":
+      return {
+        type: "tool:start",
+        messageId,
+        toolCallId: event.toolCallId,
+        toolName: event.toolName,
+        args: event.args
+      };
+    case "tool_call_end":
+      return {
+        type: "tool:complete",
+        messageId,
+        toolCallId: event.toolCallId,
+        toolName: event.toolName,
+        result: event.result
+      };
+    case "permission_request":
+      return {
+        type: "permission:request",
+        messageId,
+        toolName: event.request.toolName,
+        toolArgs: event.request.toolArgs
+      };
+    case "permission_response":
+      return {
+        type: "permission:response",
+        messageId,
+        toolName: event.toolName,
+        allowed: event.decision.allowed
+      };
+    case "usage_update":
+      return {
+        type: "usage",
+        promptTokens: event.promptTokens,
+        completionTokens: event.completionTokens,
+        model: event.model
+      };
+    case "error":
+      return {
+        type: "error",
+        error: event.error,
+        recoverable: event.recoverable,
+        messageId
+      };
+    case "heartbeat":
+      return { type: "heartbeat" };
+    case "ask_user":
+    case "ask_user_response":
+    case "session_info":
+    case "done":
+      return null;
+    default:
+      return null;
+  }
+}
+async function* adaptAgentEvents(events, messageId) {
+  for await (const event of events) {
+    const chatEvent = agentEventToChatEvent(event, messageId);
+    if (chatEvent !== null) {
+      yield chatEvent;
+    }
+  }
+}
+function toAgentMessage(message) {
+  const textContent = getMessageText(message);
+  const toolCallParts = getMessageToolCalls(message);
+  switch (message.role) {
+    case "user":
+      return { role: "user", content: textContent };
+    case "assistant": {
+      const toolCalls = toolCallParts.length > 0 ? toolCallParts.map((p) => ({ id: p.toolCallId, name: p.name, args: p.args })) : void 0;
+      return {
+        role: "assistant",
+        content: textContent,
+        toolCalls
+      };
+    }
+    case "system":
+      return { role: "system", content: textContent };
+  }
+}
+
+// src/chat/errors.ts
+init_errors();
+var ChatError = class extends AgentSDKError {
+  code;
+  retryable;
+  retryAfter;
+  timestamp;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.name = "ChatError";
+    this.code = options.code;
+    this.retryable = options.retryable ?? false;
+    this.retryAfter = options.retryAfter;
+    this.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  }
+};
+
+// src/chat/backends/base.ts
+var BaseBackendAdapter = class {
+  name;
+  _agentService;
+  _agent = null;
+  _disposed = false;
+  _agentConfig;
+  _ownsService;
+  constructor(name, options) {
+    this.name = name;
+    this._agentConfig = options.agentConfig;
+    if (options.agentService) {
+      this._agentService = options.agentService;
+      this._ownsService = false;
+    } else {
+      this._agentService = this.createService();
+      this._ownsService = true;
+    }
+  }
+  get agentService() {
+    return this._agentService;
+  }
+  async sendMessage(session, message, options) {
+    this.assertNotDisposed();
+    const events = this.streamMessage(session, message, options);
+    let text = "";
+    let lastMessage;
+    for await (const event of events) {
+      if (event.type === "message:delta") {
+        text += event.text;
+      }
+      if (event.type === "message:complete") {
+        lastMessage = event.message;
+      }
+    }
+    if (lastMessage) return lastMessage;
+    const messageId = createChatId();
+    return {
+      id: messageId,
+      role: "assistant",
+      parts: [{ type: "text", text, status: "complete" }],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "complete"
+    };
+  }
+  async *streamMessage(session, message, options) {
+    this.assertNotDisposed();
+    const agent = this.getOrCreateAgent(options);
+    const messages = session.messages.map(toAgentMessage);
+    messages.push({ role: "user", content: message });
+    yield* this.streamAgentEvents(agent, messages, options);
+  }
+  /**
+   * Shared streaming helper: bridges agent events to chat events.
+   * Used by both streamMessage() and resume() to avoid duplication.
+   */
+  async *streamAgentEvents(agent, messages, options) {
+    const messageId = createChatId();
+    const agentEvents = agent.streamWithContext(messages, {
+      signal: options?.signal,
+      context: options?.context
+    });
+    yield { type: "message:start", messageId, role: "assistant" };
+    let text = "";
+    for await (const chatEvent of adaptAgentEvents(agentEvents, messageId)) {
+      if (chatEvent.type === "message:delta") {
+        text += chatEvent.text;
+      }
+      yield chatEvent;
+    }
+    this.captureSessionId(agent);
+    yield {
+      type: "message:complete",
+      messageId,
+      message: {
+        id: messageId,
+        role: "assistant",
+        parts: [{ type: "text", text, status: "complete" }],
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "complete"
+      }
+    };
+  }
+  async listModels() {
+    this.assertNotDisposed();
+    return this._agentService.listModels();
+  }
+  async validate() {
+    this.assertNotDisposed();
+    return this._agentService.validate();
+  }
+  async dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    this._agent?.dispose();
+    this._agent = null;
+    if (this._ownsService) {
+      await this._agentService.dispose();
+    }
+  }
+  /** Get or create an agent, applying model override from options */
+  getOrCreateAgent(options) {
+    const config = options?.model ? { ...this._agentConfig, model: options.model } : this._agentConfig;
+    if (this._agentConfig.sessionMode === "persistent" && this._agent) {
+      return this._agent;
+    }
+    const agent = this._agentService.createAgent(config);
+    if (this._agentConfig.sessionMode === "persistent") {
+      this._agent = agent;
+    }
+    return agent;
+  }
+  assertNotDisposed() {
+    if (this._disposed) {
+      throw new ChatError("Adapter is disposed", {
+        code: "DISPOSED" /* DISPOSED */
+      });
+    }
+  }
+};
+
+// src/chat/backends/copilot.ts
+var CopilotChatAdapter = class extends BaseBackendAdapter {
+  _backendSessionId = null;
+  _copilotOptions;
+  constructor(options) {
+    const agentConfig = {
+      ...options.agentConfig,
+      sessionMode: "persistent"
+    };
+    super("copilot", { ...options, agentConfig });
+    this._copilotOptions = options.copilotOptions;
+  }
+  createService() {
+    const { createAgentService: createAgentService2 } = (init_src(), __toCommonJS(src_exports));
+    return createAgentService2("copilot", this._copilotOptions);
+  }
+  get backendSessionId() {
+    return this._backendSessionId;
+  }
+  canResume() {
+    return this._backendSessionId !== null;
+  }
+  async *resume(session, backendSessionId, options) {
+    this.assertNotDisposed();
+    if (!backendSessionId) {
+      throw new ChatError("Backend session ID is required for resume", {
+        code: "INVALID_INPUT" /* INVALID_INPUT */
+      });
+    }
+    const agent = this.getOrCreateAgent(options);
+    const currentSessionId = agent.sessionId;
+    if (!currentSessionId) {
+      throw new ChatError(
+        `No active session to resume (requested: ${backendSessionId})`,
+        { code: "SESSION_NOT_FOUND" /* SESSION_NOT_FOUND */ }
+      );
+    }
+    if (currentSessionId !== backendSessionId) {
+      throw new ChatError(
+        `Session expired: expected ${backendSessionId}, got ${currentSessionId}`,
+        { code: "SESSION_EXPIRED" /* SESSION_EXPIRED */ }
+      );
+    }
+    const messages = session.messages.map(toAgentMessage);
+    yield* this.streamAgentEvents(agent, messages, options);
+  }
+  captureSessionId(agent) {
+    if (agent.sessionId) {
+      this._backendSessionId = agent.sessionId;
+    }
+  }
+};
+
+// src/chat/backends/claude.ts
+var ClaudeChatAdapter = class extends BaseBackendAdapter {
+  _backendSessionId = null;
+  _claudeOptions;
+  constructor(options) {
+    const agentConfig = {
+      ...options.agentConfig,
+      sessionMode: "persistent"
+    };
+    super("claude", { ...options, agentConfig });
+    this._claudeOptions = options.claudeOptions;
+  }
+  createService() {
+    const { createAgentService: createAgentService2 } = (init_src(), __toCommonJS(src_exports));
+    return createAgentService2("claude", this._claudeOptions);
+  }
+  get backendSessionId() {
+    return this._backendSessionId;
+  }
+  canResume() {
+    return this._backendSessionId !== null;
+  }
+  async *resume(session, backendSessionId, options) {
+    this.assertNotDisposed();
+    if (!backendSessionId) {
+      throw new ChatError("Backend session ID is required for resume", {
+        code: "INVALID_INPUT" /* INVALID_INPUT */
+      });
+    }
+    const agent = this.getOrCreateAgent(options);
+    const currentSessionId = agent.sessionId;
+    if (!currentSessionId) {
+      throw new ChatError(
+        `No active session to resume (requested: ${backendSessionId})`,
+        { code: "SESSION_NOT_FOUND" /* SESSION_NOT_FOUND */ }
+      );
+    }
+    if (currentSessionId !== backendSessionId) {
+      throw new ChatError(
+        `Session expired: expected ${backendSessionId}, got ${currentSessionId}`,
+        { code: "SESSION_EXPIRED" /* SESSION_EXPIRED */ }
+      );
+    }
+    const messages = session.messages.map(toAgentMessage);
+    yield* this.streamAgentEvents(agent, messages, options);
+  }
+  captureSessionId(agent) {
+    if (agent.sessionId) {
+      this._backendSessionId = agent.sessionId;
+    }
+  }
+};
+
+// src/chat/backends/vercel-ai.ts
+var VercelAIChatAdapter = class extends BaseBackendAdapter {
+  _vercelOptions;
+  constructor(options) {
+    super("vercel-ai", options);
+    this._vercelOptions = options.vercelOptions;
+  }
+  createService() {
+    const { createAgentService: createAgentService2 } = (init_src(), __toCommonJS(src_exports));
+    return createAgentService2("vercel-ai", this._vercelOptions);
+  }
+  get backendSessionId() {
+    return null;
+  }
+  canResume() {
+    return false;
+  }
+  async *resume(_session, _backendSessionId, _options) {
+    throw new ChatError(
+      "Vercel AI adapter does not support session resume (stateless)",
+      { code: "PROVIDER_ERROR" /* PROVIDER_ERROR */ }
+    );
+  }
+  captureSessionId(_agent) {
+  }
+};
+
+// src/chat/backends/transport.ts
+var SSEChatTransport = class {
+  res;
+  _open;
+  _heartbeatTimer;
+  constructor(res, options) {
+    this.res = res;
+    this._open = true;
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive",
+      "X-Accel-Buffering": "no"
+    });
+    if (options?.request) {
+      options.request.on("close", () => {
+        this._cleanup();
+      });
+    }
+    const heartbeatMs = options?.heartbeatMs;
+    if (heartbeatMs && heartbeatMs > 0) {
+      this._heartbeatTimer = setInterval(() => {
+        if (!this.isOpen) {
+          this._clearHeartbeat();
+          return;
+        }
+        this.res.write(": heartbeat\n\n");
+      }, heartbeatMs);
+    }
+  }
+  get isOpen() {
+    return this._open && !this.res.writableEnded;
+  }
+  send(event) {
+    if (!this.isOpen) return;
+    this.res.write(`data: ${JSON.stringify(event)}
+
+`);
+  }
+  close() {
+    if (!this.isOpen) return;
+    this._open = false;
+    this._clearHeartbeat();
+    this.res.write(`data: [DONE]
+
+`);
+    this.res.end();
+  }
+  error(err) {
+    if (!this.isOpen) return;
+    this._open = false;
+    this._clearHeartbeat();
+    const errorEvent = {
+      type: "error",
+      error: err.message,
+      recoverable: false
+    };
+    this.res.write(`data: ${JSON.stringify(errorEvent)}
+
+`);
+    this.res.end();
+  }
+  _cleanup() {
+    this._open = false;
+    this._clearHeartbeat();
+  }
+  _clearHeartbeat() {
+    if (this._heartbeatTimer !== void 0) {
+      clearInterval(this._heartbeatTimer);
+      this._heartbeatTimer = void 0;
+    }
+  }
+};
+async function streamToTransport(events, transport) {
+  try {
+    let accumulatedText = "";
+    for await (const event of events) {
+      if (!transport.isOpen) break;
+      transport.send(event);
+      if (event.type === "message:delta") {
+        accumulatedText += event.text;
+      }
+    }
+    if (transport.isOpen) {
+      transport.send({ type: "done", finalOutput: accumulatedText || void 0 });
+    }
+    transport.close();
+  } catch (err) {
+    transport.error(err instanceof Error ? err : new Error(String(err)));
+  }
+}
+
+// src/chat/backends/ws-transport.ts
+var WS_READY_STATE = {
+  CONNECTING: 0,
+  OPEN: 1,
+  CLOSING: 2,
+  CLOSED: 3
+};
+var WsChatTransport = class {
+  ws;
+  serialize;
+  _open;
+  _heartbeatTimer;
+  constructor(ws, options) {
+    this.ws = ws;
+    this.serialize = options?.serialize ?? JSON.stringify;
+    this._open = ws.readyState === WS_READY_STATE.OPEN;
+    ws.addEventListener("close", () => {
+      this._cleanup();
+    });
+    ws.addEventListener("error", () => {
+      this._cleanup();
+    });
+    const heartbeatMs = options?.heartbeatMs;
+    if (heartbeatMs && heartbeatMs > 0) {
+      this._heartbeatTimer = setInterval(() => {
+        if (!this.isOpen) {
+          this._clearHeartbeat();
+          return;
+        }
+        this.ws.send(this.serialize({ type: "heartbeat" }));
+      }, heartbeatMs);
+    }
+  }
+  get isOpen() {
+    return this._open && this.ws.readyState === WS_READY_STATE.OPEN;
+  }
+  send(event) {
+    if (!this.isOpen) return;
+    this.ws.send(this.serialize(event));
+  }
+  close() {
+    if (!this.isOpen) return;
+    this._open = false;
+    this._clearHeartbeat();
+    this.ws.send(this.serialize({ type: "done" }));
+    this.ws.close(1e3, "stream complete");
+  }
+  error(err) {
+    if (!this.isOpen) return;
+    this._open = false;
+    this._clearHeartbeat();
+    const errorEvent = {
+      type: "error",
+      error: err.message,
+      recoverable: false
+    };
+    this.ws.send(this.serialize(errorEvent));
+    this.ws.close(1011, err.message);
+  }
+  _cleanup() {
+    this._open = false;
+    this._clearHeartbeat();
+  }
+  _clearHeartbeat() {
+    if (this._heartbeatTimer !== void 0) {
+      clearInterval(this._heartbeatTimer);
+      this._heartbeatTimer = void 0;
+    }
+  }
+};
+
+// src/chat/backends/in-process-transport.ts
+var InProcessChatTransport = class {
+  _open = true;
+  _buffer = [];
+  _resolve = null;
+  _error = null;
+  get isOpen() {
+    return this._open;
+  }
+  send(event) {
+    if (!this._open) return;
+    if (this._resolve) {
+      const resolve2 = this._resolve;
+      this._resolve = null;
+      resolve2({ value: event, done: false });
+    } else {
+      this._buffer.push(event);
+    }
+  }
+  close() {
+    if (!this._open) return;
+    this._open = false;
+    if (this._resolve) {
+      const resolve2 = this._resolve;
+      this._resolve = null;
+      resolve2({ value: void 0, done: true });
+    }
+  }
+  error(err) {
+    if (!this._open) return;
+    this._open = false;
+    const errorEvent = {
+      type: "error",
+      error: err.message,
+      recoverable: false
+    };
+    if (this._resolve) {
+      const resolve2 = this._resolve;
+      this._resolve = null;
+      resolve2({ value: errorEvent, done: false });
+    } else {
+      this._error = err;
+    }
+  }
+  // ─── AsyncIterable protocol ────────────────────────────────
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this._buffer.length > 0) {
+          return Promise.resolve({ value: this._buffer.shift(), done: false });
+        }
+        if (this._error) {
+          const err = this._error;
+          this._error = null;
+          const errorEvent = {
+            type: "error",
+            error: err.message,
+            recoverable: false
+          };
+          return Promise.resolve({ value: errorEvent, done: false });
+        }
+        if (!this._open) {
+          return Promise.resolve({ value: void 0, done: true });
+        }
+        return new Promise((resolve2) => {
+          this._resolve = resolve2;
+        });
+      }
+    };
+  }
+};
+
+// src/chat/backends/interceptors.ts
+var InterceptedTransport = class {
+  _inner;
+  _interceptors;
+  constructor(inner, interceptors) {
+    this._inner = inner;
+    this._interceptors = interceptors;
+  }
+  get isOpen() {
+    return this._inner.isOpen;
+  }
+  send(event) {
+    if (!this.isOpen) return;
+    let current = event;
+    for (const interceptor of this._interceptors) {
+      if (!interceptor.beforeSend) continue;
+      current = interceptor.beforeSend(current, this._inner);
+      if (current === null) return;
+    }
+    this._inner.send(current);
+    for (const interceptor of this._interceptors) {
+      if (interceptor.afterSend) {
+        interceptor.afterSend(current, this._inner);
+      }
+    }
+  }
+  close() {
+    for (const interceptor of this._interceptors) {
+      if (interceptor.beforeClose) {
+        interceptor.beforeClose(this._inner);
+      }
+    }
+    this._inner.close();
+  }
+  error(err) {
+    for (const interceptor of this._interceptors) {
+      if (interceptor.onError) {
+        interceptor.onError(err, this._inner);
+      }
+    }
+    this._inner.error(err);
+  }
+};
+function withInterceptors(transport, interceptors) {
+  if (interceptors.length === 0) return transport;
+  return new InterceptedTransport(transport, interceptors);
+}
+
+export { BaseBackendAdapter, ClaudeChatAdapter, CopilotChatAdapter, InProcessChatTransport, SSEChatTransport, VercelAIChatAdapter, WS_READY_STATE, WsChatTransport, streamToTransport, withInterceptors };
+//# sourceMappingURL=backends.js.map
+//# sourceMappingURL=backends.js.map