@witqq/agent-sdk 0.6.1 → 0.8.0

package/dist/chat/backends.cjs

@@ -0,0 +1,3524 @@
+'use strict';
+
+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/types/errors.ts
+function isRecoverableErrorCode(code) {
+  return RECOVERABLE_CODES.has(code);
+}
+function classifyAgentError(error) {
+  const msg = (error instanceof Error ? error.message : error).toLowerCase();
+  if (msg.includes("timeout") || msg.includes("timed out") || msg.includes("timedout") || msg.includes("etimedout")) {
+    return "TIMEOUT" /* TIMEOUT */;
+  }
+  if (msg.includes("rate limit") || msg.includes("rate_limit") || msg.includes("429") || msg.includes("too many requests")) {
+    return "RATE_LIMIT" /* RATE_LIMIT */;
+  }
+  if (msg.includes("unauthorized") || msg.includes("401") || msg.includes("auth") && (msg.includes("expired") || msg.includes("invalid") || msg.includes("denied") || msg.includes("failed"))) {
+    return "AUTH_EXPIRED" /* AUTH_EXPIRED */;
+  }
+  if (msg.includes("econnrefused") || msg.includes("econnreset") || msg.includes("enotfound") || msg.includes("network") || msg.includes("fetch failed") || msg.includes("socket hang up")) {
+    return "NETWORK" /* NETWORK */;
+  }
+  if (msg.includes("subprocess") || msg.includes("process exited") || msg.includes("spawn") || msg.includes("enoent") || msg.includes("killed")) {
+    return "DEPENDENCY_MISSING" /* DEPENDENCY_MISSING */;
+  }
+  if (msg.includes("abort") || msg.includes("cancel")) {
+    return "ABORTED" /* ABORTED */;
+  }
+  if (msg.includes("500") || msg.includes("502") || msg.includes("503") || msg.includes("internal server error") || msg.includes("service unavailable") || msg.includes("bad gateway") || msg.includes("overloaded")) {
+    return "PROVIDER_ERROR" /* PROVIDER_ERROR */;
+  }
+  return "PROVIDER_ERROR" /* PROVIDER_ERROR */;
+}
+var RECOVERABLE_CODES;
+var init_errors = __esm({
+  "src/types/errors.ts"() {
+    RECOVERABLE_CODES = /* @__PURE__ */ new Set([
+      "TIMEOUT" /* TIMEOUT */,
+      "RATE_LIMIT" /* RATE_LIMIT */,
+      "NETWORK" /* NETWORK */,
+      "TOOL_EXECUTION" /* TOOL_EXECUTION */,
+      "MODEL_OVERLOADED" /* MODEL_OVERLOADED */,
+      "PROVIDER_ERROR" /* PROVIDER_ERROR */
+    ]);
+  }
+});
+
+// src/errors.ts
+var AgentSDKError, ReentrancyError, DisposedError, SubprocessError, DependencyError, AbortError, ToolExecutionError, ActivityTimeoutError;
+var init_errors2 = __esm({
+  "src/errors.ts"() {
+    init_errors();
+    AgentSDKError = class extends Error {
+      /** @internal Marker for cross-bundle identity checks */
+      _agentSDKError = true;
+      /** Machine-readable error code. Prefer values from the ErrorCode enum. */
+      code;
+      /** Whether this error is safe to retry */
+      retryable;
+      /** HTTP status code hint for error classification */
+      httpStatus;
+      constructor(message, options) {
+        super(message, options);
+        this.name = "AgentSDKError";
+        this.code = options?.code;
+        this.retryable = options?.retryable ?? false;
+        this.httpStatus = options?.httpStatus;
+      }
+      /** 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.", {
+          code: "REENTRANCY" /* REENTRANCY */
+        });
+        this.name = "ReentrancyError";
+      }
+    };
+    DisposedError = class extends AgentSDKError {
+      constructor(entity) {
+        super(`${entity} has been disposed and cannot be used.`, {
+          code: "DISPOSED" /* DISPOSED */
+        });
+        this.name = "DisposedError";
+      }
+    };
+    SubprocessError = class extends AgentSDKError {
+      constructor(message, options) {
+        super(message, { ...options, code: "DEPENDENCY_MISSING" /* DEPENDENCY_MISSING */ });
+        this.name = "SubprocessError";
+      }
+    };
+    DependencyError = class extends AgentSDKError {
+      packageName;
+      constructor(packageName) {
+        super(`${packageName} is not installed. Install it: npm install ${packageName}`, {
+          code: "DEPENDENCY_MISSING" /* DEPENDENCY_MISSING */
+        });
+        this.name = "DependencyError";
+        this.packageName = packageName;
+      }
+    };
+    AbortError = class extends AgentSDKError {
+      constructor() {
+        super("Agent run was aborted.", { code: "ABORTED" /* ABORTED */ });
+        this.name = "AbortError";
+      }
+    };
+    ToolExecutionError = class extends AgentSDKError {
+      toolName;
+      constructor(toolName, message, options) {
+        super(`Tool "${toolName}" failed: ${message}`, { ...options, code: "TOOL_EXECUTION" /* TOOL_EXECUTION */ });
+        this.name = "ToolExecutionError";
+        this.toolName = toolName;
+      }
+    };
+    ActivityTimeoutError = class extends AgentSDKError {
+      constructor(timeoutMs) {
+        super(`Stream activity timeout: no event received within ${timeoutMs}ms.`, {
+          code: "TIMEOUT" /* TIMEOUT */,
+          retryable: true
+        });
+        this.name = "ActivityTimeoutError";
+      }
+    };
+  }
+});
+
+// src/types/guards.ts
+function getTextContent(content) {
+  if (typeof content === "string") return content;
+  return content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+}
+var init_guards = __esm({
+  "src/types/guards.ts"() {
+  }
+});
+
+// src/types/index.ts
+var init_types = __esm({
+  "src/types/index.ts"() {
+    init_errors();
+    init_guards();
+  }
+});
+
+// src/types.ts
+var init_types2 = __esm({
+  "src/types.ts"() {
+    init_types();
+  }
+});
+
+// src/base-agent.ts
+var BaseAgent;
+var init_base_agent = __esm({
+  "src/base-agent.ts"() {
+    init_errors2();
+    init_errors2();
+    init_errors();
+    BaseAgent = class {
+      state = "idle";
+      abortController = null;
+      config;
+      _cleanupExternalSignal = null;
+      _streamMiddleware = [];
+      /** 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.withRetry(
+            () => this.executeRun(messages, options, ac.signal),
+            options
+          );
+          this.enrichAndNotifyUsage(result, options);
+          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.withRetry(
+            () => this.executeRun(messages, options, ac.signal),
+            options
+          );
+          this.enrichAndNotifyUsage(result, options);
+          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.withRetry(
+            () => this.executeRunStructured(messages, schema, options, ac.signal),
+            options
+          );
+          this.enrichAndNotifyUsage(result, options);
+          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 }];
+          yield* this.streamWithRetry(
+            () => this.applyStreamPipeline(this.executeStream(messages, options, ac.signal), options, ac),
+            options
+          );
+        } finally {
+          this.cleanupRun();
+        }
+      }
+      async *streamWithContext(messages, options) {
+        this.guardReentrancy();
+        this.guardDisposed();
+        const ac = this.createAbortController(options?.signal);
+        this.state = "streaming";
+        try {
+          yield* this.streamWithRetry(
+            () => this.applyStreamPipeline(this.executeStream(messages, options, ac.signal), options, ac),
+            options
+          );
+        } finally {
+          this.cleanupRun();
+        }
+      }
+      /** Register a stream middleware. Applied in registration order after built-in transforms. */
+      addStreamMiddleware(middleware) {
+        this.guardDisposed();
+        this._streamMiddleware.push(middleware);
+      }
+      /** Apply built-in transforms (enrich→timeout→heartbeat) then custom middleware */
+      async *applyStreamPipeline(source, options, ac) {
+        let stream = this.enrichStream(source, options);
+        stream = this.activityTimeoutStream(stream, options?.activityTimeoutMs, ac);
+        stream = this.heartbeatStream(stream);
+        if (this._streamMiddleware.length > 0) {
+          const ctx = {
+            model: options.model,
+            backend: this.backendName,
+            abortController: ac,
+            config: Object.freeze({ ...this.config })
+          };
+          for (const mw of this._streamMiddleware) {
+            stream = mw(stream, ctx);
+          }
+        }
+        yield* stream;
+      }
+      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";
+      }
+      // ─── Retry Logic ─────────────────────────────────────────────
+      /** Check if an error should be retried given the retry configuration. */
+      isRetryableError(error, retry) {
+        if (error instanceof AbortError || error instanceof ReentrancyError || error instanceof DisposedError) {
+          return false;
+        }
+        if (AgentSDKError.is(error)) {
+          if (retry.retryableErrors && retry.retryableErrors.length > 0 && error.code) {
+            return retry.retryableErrors.includes(error.code);
+          }
+          if (error.retryable) return true;
+          if (error.code) return isRecoverableErrorCode(error.code);
+        }
+        return false;
+      }
+      /** Execute a function with retry logic per RetryConfig. */
+      async withRetry(fn, options) {
+        const retry = options?.retry;
+        if (!retry || !retry.maxRetries || retry.maxRetries <= 0) {
+          return fn();
+        }
+        const maxRetries = retry.maxRetries;
+        const initialDelay = retry.initialDelayMs ?? 1e3;
+        const multiplier = retry.backoffMultiplier ?? 2;
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+          try {
+            return await fn();
+          } catch (err) {
+            lastError = err;
+            if (attempt >= maxRetries || !this.isRetryableError(err, retry)) {
+              throw err;
+            }
+            const delay = initialDelay * Math.pow(multiplier, attempt);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            if (options?.signal?.aborted || this.abortController?.signal.aborted) {
+              throw err;
+            }
+          }
+        }
+        throw lastError;
+      }
+      /** Execute a stream factory with pre-stream retry: retries until first event, then committed. */
+      async *streamWithRetry(factory, options) {
+        const retry = options?.retry;
+        if (!retry || !retry.maxRetries || retry.maxRetries <= 0) {
+          yield* factory();
+          return;
+        }
+        const maxRetries = retry.maxRetries;
+        const initialDelay = retry.initialDelayMs ?? 1e3;
+        const multiplier = retry.backoffMultiplier ?? 2;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+          try {
+            const stream = factory();
+            const iterator = stream[Symbol.asyncIterator]();
+            const first = await iterator.next();
+            if (first.done) return;
+            yield first.value;
+            while (true) {
+              const next = await iterator.next();
+              if (next.done) break;
+              yield next.value;
+            }
+            return;
+          } catch (err) {
+            if (attempt >= maxRetries || !this.isRetryableError(err, retry)) {
+              throw err;
+            }
+            const delay = initialDelay * Math.pow(multiplier, attempt);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            if (options?.signal?.aborted || this.abortController?.signal.aborted) {
+              throw err;
+            }
+          }
+        }
+      }
+      // ─── CallOptions Resolution ──────────────────────────────────
+      /** Resolve tools to use for this call (per-call override > config default) */
+      resolveTools(options) {
+        return options?.tools ?? this.config.tools ?? [];
+      }
+      // ─── Usage Enrichment ───────────────────────────────────────────
+      /** Enrich result usage with model/backend and fire onUsage callback */
+      enrichAndNotifyUsage(result, options) {
+        if (result.usage) {
+          result.usage = {
+            ...result.usage,
+            model: options.model,
+            backend: this.backendName
+          };
+          this.callOnUsage(result.usage);
+        }
+      }
+      /** Wrap a stream to enrich usage_update events and fire onUsage callback */
+      async *enrichStream(source, options) {
+        const model = options.model;
+        for await (const event of source) {
+          if (event.type === "usage_update") {
+            const usage = {
+              promptTokens: event.promptTokens,
+              completionTokens: event.completionTokens,
+              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 resolve = heartbeatResolve;
+            heartbeatResolve = null;
+            resolve();
+          }
+        }, interval);
+        try {
+          while (true) {
+            if (!pendingEvent) {
+              pendingEvent = iterator.next();
+            }
+            const heartbeatPromise = new Promise((resolve) => {
+              heartbeatResolve = resolve;
+            });
+            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;
+        }
+      }
+      // ─── Activity Timeout ────────────────────────────────────────
+      /** Wrap a stream to abort on inactivity. Resets timer on every event.
+       *  When timeoutMs is not set, passes through directly. */
+      async *activityTimeoutStream(source, timeoutMs, ac) {
+        if (!timeoutMs || timeoutMs <= 0) {
+          yield* source;
+          return;
+        }
+        const iterator = source[Symbol.asyncIterator]();
+        let timerId;
+        try {
+          while (true) {
+            const timeoutPromise = new Promise((_, reject) => {
+              timerId = setTimeout(() => reject(new ActivityTimeoutError(timeoutMs)), timeoutMs);
+            });
+            const result = await Promise.race([iterator.next(), timeoutPromise]);
+            clearTimeout(timerId);
+            if (result.done) break;
+            yield result.value;
+          }
+        } catch (err) {
+          if (err instanceof ActivityTimeoutError) {
+            ac.abort(err);
+          }
+          throw err;
+        } finally {
+          clearTimeout(timerId);
+        }
+      }
+      // ─── 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/shared.ts
+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}`;
+}
+var init_shared = __esm({
+  "src/backends/shared.ts"() {
+    init_types2();
+  }
+});
+
+// src/backends/copilot.ts
+var copilot_exports = {};
+__export(copilot_exports, {
+  _injectSDK: () => _injectSDK,
+  _resetSDK: () => _resetSDK,
+  createCopilotService: () => createCopilotService
+});
+async function loadSDK() {
+  if (_sdkMock) return _sdkMock;
+  try {
+    return await import('@github/copilot-sdk');
+  } catch {
+    throw new SubprocessError(
+      "@github/copilot-sdk is not installed. Install it: npm install @github/copilot-sdk"
+    );
+  }
+}
+function _injectSDK(mock) {
+  _sdkMock = mock;
+}
+function _resetSDK() {
+  _sdkMock = 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 },
+      toolCallId: request.toolCallId,
+      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));
+      {
+        const errorMsg = String(data.message ?? "Unknown error");
+        const code = classifyAgentError(errorMsg);
+        return {
+          type: "error",
+          error: errorMsg,
+          recoverable: isRecoverableErrorCode(code),
+          code
+        };
+      }
+    case "assistant.message": {
+      const doneEvent = {
+        type: "done",
+        finalOutput: null,
+        streamed: true
+      };
+      if (thinkingTracker.endThinking()) {
+        return [{ type: "thinking_end" }, doneEvent];
+      }
+      return doneEvent;
+    }
+    default:
+      return null;
+  }
+}
+function withTimeout(promise, ms, message) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new SubprocessError(message)), ms);
+    promise.then(
+      (val) => {
+        clearTimeout(timer);
+        resolve(val);
+      },
+      (err) => {
+        clearTimeout(timer);
+        reject(err);
+      }
+    );
+  });
+}
+function createCopilotService(options) {
+  return new CopilotAgentService(options);
+}
+var _sdkMock, ToolCallTracker, ThinkingTracker, CopilotAgent, CopilotAgentService;
+var init_copilot = __esm({
+  "src/backends/copilot.ts"() {
+    init_types2();
+    init_base_agent();
+    init_errors2();
+    init_schema();
+    init_shared();
+    _sdkMock = 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;
+      _persistentModel;
+      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;
+          this._persistentModel = void 0;
+        }
+      }
+      async getOrCreateSession(streaming, options) {
+        if (this.isPersistent && this.persistentSession) {
+          if (options.model !== this._persistentModel) {
+            this.persistentSession.destroy().catch(() => {
+            });
+            this.persistentSession = null;
+            this._sessionId = void 0;
+          } else {
+            return { session: this.persistentSession, isNew: false };
+          }
+        }
+        if (this._toolsReady) {
+          await this._toolsReady;
+          this._toolsReady = null;
+        }
+        const sessionConfig = { ...this.sessionConfig };
+        sessionConfig.model = options.model;
+        const resolvedTools = this.resolveTools(options);
+        if (options?.tools) {
+          sessionConfig.tools = mapToolsToSDK(resolvedTools);
+        }
+        const client = await this.getClient();
+        if (this._resumeSessionId) {
+          const storedId = this._resumeSessionId;
+          this._resumeSessionId = void 0;
+          try {
+            const session2 = await client.resumeSession(storedId, {
+              ...sessionConfig,
+              streaming: this.isPersistent ? true : streaming
+            });
+            if (this.isPersistent) {
+              this.persistentSession = session2;
+              this._sessionId = session2.sessionId;
+              this._persistentModel = options.model;
+            }
+            return { session: session2, isNew: false };
+          } catch {
+          }
+        }
+        const session = await client.createSession({
+          ...sessionConfig,
+          streaming: this.isPersistent ? true : streaming
+        });
+        if (this.isPersistent) {
+          this.persistentSession = session;
+          this._sessionId = session.sessionId;
+          this._persistentModel = options.model;
+        }
+        return { session, isNew: true };
+      }
+      // ─── executeRun ─────────────────────────────────────────────────
+      async executeRun(messages, options, signal) {
+        this.checkAbort(signal);
+        const { session, isNew: isNewSession } = await this.getOrCreateSession(false, options);
+        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, options);
+        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((resolve) => {
+          notify = resolve;
+        });
+        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",
+          ...m.capabilities?.limits?.max_context_window_tokens != null && {
+            contextWindow: m.capabilities.limits.max_context_window_tokens
+          }
+        }));
+      }
+      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 (_sdkMock2) return _sdkMock2;
+  try {
+    return await import('@anthropic-ai/claude-agent-sdk');
+  } catch {
+    throw new SubprocessError(
+      "@anthropic-ai/claude-agent-sdk is not installed. Install it: npm install @anthropic-ai/claude-agent-sdk"
+    );
+  }
+}
+function _injectSDK2(mock) {
+  _sdkMock2 = mock;
+}
+function _resetSDK2() {
+  _sdkMock2 = null;
+}
+function normalizeAskUserInput(args) {
+  if (typeof args.question === "string") {
+    return {
+      question: args.question,
+      choices: Array.isArray(args.choices) ? args.choices : void 0,
+      allowFreeform: args.allowFreeform !== false
+    };
+  }
+  const questions = args.questions;
+  if (questions && questions.length > 0) {
+    const first = questions[0];
+    return {
+      question: first.question,
+      choices: first.options?.map((o) => o.label),
+      allowFreeform: true
+    };
+  }
+  return { question: JSON.stringify(args), allowFreeform: true };
+}
+function buildMcpServer(sdk, tools, toolResultCapture, onAskUser) {
+  if (tools.length === 0 && !onAskUser) 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)
+            }
+          ]
+        };
+      }
+    );
+  });
+  if (onAskUser) {
+    const askUserTool = sdk.tool(
+      "ask_user",
+      "Ask the user a question and wait for their response",
+      {
+        question: { type: "string", description: "The question to ask the user" },
+        choices: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional list of choices for multiple choice"
+        },
+        questions: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              question: { type: "string" },
+              options: { type: "array", items: { type: "object", properties: { label: { type: "string" } } } }
+            }
+          },
+          description: "Alternative nested question format"
+        }
+      },
+      async (args) => {
+        const normalized = normalizeAskUserInput(args);
+        const response = await onAskUser(normalized, AbortSignal.timeout(3e5));
+        return {
+          content: [{ type: "text", text: response.answer }]
+        };
+      }
+    );
+    mcpTools.push(askUserTool);
+  }
+  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,
+      toolCallId: options.toolUseID,
+      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 (CLAUDE_INTERNAL_TOOL_NAMES.has(toolName)) continue;
+          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");
+      if (CLAUDE_INTERNAL_TOOL_NAMES.has(toolName)) return null;
+      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;
+        const errorMsg = r.errors?.join("; ") ?? "Unknown error";
+        const code = classifyAgentError(errorMsg);
+        return {
+          type: "error",
+          error: errorMsg,
+          recoverable: isRecoverableErrorCode(code),
+          code
+        };
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+function createClaudeService(options) {
+  return new ClaudeAgentService(options);
+}
+var MCP_SERVER_NAME, MCP_TOOL_PREFIX, CLAUDE_INTERNAL_TOOL_NAMES, _sdkMock2, ANTHROPIC_MODELS_URL, ANTHROPIC_API_VERSION, ANTHROPIC_OAUTH_BETA, ClaudeToolCallTracker, ClaudeAgent, ClaudeAgentService;
+var init_claude = __esm({
+  "src/backends/claude.ts"() {
+    init_types2();
+    init_base_agent();
+    init_errors2();
+    init_schema();
+    init_shared();
+    MCP_SERVER_NAME = "agent-sdk-tools";
+    MCP_TOOL_PREFIX = `mcp__${MCP_SERVER_NAME}__`;
+    CLAUDE_INTERNAL_TOOL_NAMES = /* @__PURE__ */ new Set(["AskUserQuestion"]);
+    _sdkMock2 = 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;
+        }
+      }
+      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, options) {
+        const ac = new AbortController();
+        signal.addEventListener("abort", () => ac.abort(), { once: true });
+        const opts = {
+          abortController: ac,
+          model: options.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) {
+        const onAskUser = this.config.supervisor?.onAskUser;
+        if (this.tools.length === 0 && !onAskUser) return opts;
+        const sdk = await loadSDK2();
+        const mcpServer = buildMcpServer(sdk, this.tools, toolResultCapture, onAskUser);
+        if (mcpServer) {
+          opts.mcpServers = {
+            [MCP_SERVER_NAME]: mcpServer
+          };
+          const mcpToolNames = this.tools.map((t) => mcpToolName(t.name));
+          if (onAskUser) {
+            mcpToolNames.push(mcpToolName("ask_user"));
+          }
+          opts.allowedTools = [...opts.allowedTools ?? [], ...mcpToolNames];
+        }
+        if (onAskUser) {
+          opts.disallowedTools = [...opts.disallowedTools ?? [], "AskUserQuestion"];
+        }
+        return opts;
+      }
+      // ─── Retry Helpers (shared across executeRun/RunStructured/Stream) ──
+      /** Setup a retry query: clear session, rebuild with full history */
+      async prepareRetryQuery(sdk, messages, signal, options, toolResultCapture, modifyOpts) {
+        this.clearPersistentSession();
+        const retryPrompt = buildContextualPrompt(messages);
+        let retryOpts = this.buildQueryOptions(signal, options);
+        toolResultCapture.clear();
+        retryOpts = await this.buildMcpConfig(retryOpts, toolResultCapture);
+        modifyOpts?.(retryOpts);
+        const retryQ = sdk.query({ prompt: retryPrompt, options: retryOpts });
+        this.activeQuery = retryQ;
+        return retryQ;
+      }
+      /** Extract tool_use blocks from an assistant SDK message into toolCalls array */
+      collectToolCallsFromMessage(msg, toolCalls, toolResultCapture) {
+        if (msg.type !== "assistant") return;
+        const betaMessage = msg.message;
+        if (!betaMessage?.content) return;
+        for (const block of betaMessage.content) {
+          if (block.type === "tool_use") {
+            const toolName = stripMcpPrefix(block.name ?? "unknown");
+            if (CLAUDE_INTERNAL_TOOL_NAMES.has(toolName)) continue;
+            toolCalls.push({
+              toolName,
+              args: block.input ?? {},
+              result: toolResultCapture.get(toolName) ?? null,
+              approved: true
+            });
+          }
+        }
+      }
+      /** Back-fill tool results from capture map on summary/result messages */
+      backfillToolResults(msg, toolCalls, toolResultCapture) {
+        if (msg.type !== "tool_use_summary" && msg.type !== "result") return;
+        for (const tc of toolCalls) {
+          if (tc.result === null) {
+            const captured = toolResultCapture.get(tc.toolName);
+            if (captured !== void 0) tc.result = captured;
+          }
+        }
+      }
+      /** Wrap retry inner loop with shared error handling */
+      async withRetryErrorHandling(signal, fn) {
+        try {
+          return await fn();
+        } catch (retryError) {
+          if (this.isPersistent) this.clearPersistentSession();
+          if (signal.aborted) throw new AbortError();
+          throw retryError;
+        } finally {
+          this.activeQuery = null;
+        }
+      }
+      // ─── executeRun ─────────────────────────────────────────────────
+      async executeRun(messages, options, signal) {
+        this.checkAbort(signal);
+        const sdk = await loadSDK2();
+        const isResuming = this.isPersistent && this._sessionId !== void 0;
+        const prompt = isResuming ? extractLastUserPrompt(messages) : buildContextualPrompt(messages);
+        let opts = this.buildQueryOptions(signal, options);
+        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) {
+            this.collectToolCallsFromMessage(msg, toolCalls, toolResultCapture);
+            this.backfillToolResults(msg, toolCalls, toolResultCapture);
+            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) {
+            const retryQ = await this.prepareRetryQuery(sdk, messages, signal, options, toolResultCapture);
+            toolCalls.length = 0;
+            output = null;
+            return this.withRetryErrorHandling(signal, async () => {
+              for await (const msg of retryQ) {
+                this.collectToolCallsFromMessage(msg, toolCalls, toolResultCapture);
+                this.backfillToolResults(msg, toolCalls, toolResultCapture);
+                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"}`
+                    );
+                  }
+                }
+              }
+              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 ? extractLastUserPrompt(messages) : buildContextualPrompt(messages);
+        let opts = this.buildQueryOptions(signal, options);
+        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) {
+            this.collectToolCallsFromMessage(msg, toolCalls, toolResultCapture);
+            this.backfillToolResults(msg, toolCalls, toolResultCapture);
+            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) {
+            const retryQ = await this.prepareRetryQuery(
+              sdk,
+              messages,
+              signal,
+              options,
+              toolResultCapture,
+              (opts2) => {
+                opts2.outputFormat = { type: "json_schema", schema: jsonSchema };
+              }
+            );
+            toolCalls.length = 0;
+            output = null;
+            structuredOutput = void 0;
+            return this.withRetryErrorHandling(signal, async () => {
+              for await (const msg of retryQ) {
+                this.collectToolCallsFromMessage(msg, toolCalls, toolResultCapture);
+                this.backfillToolResults(msg, toolCalls, toolResultCapture);
+                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"}`
+                  );
+                }
+              }
+              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 ? extractLastUserPrompt(messages) : buildContextualPrompt(messages);
+        let opts = this.buildQueryOptions(signal, options);
+        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();
+        let hasStreamedText = false;
+        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);
+                }
+                if (e.type === "text_delta") hasStreamedText = true;
+                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: hasStreamedText ? null : r.result,
+                ...hasStreamedText ? { streamed: true } : {}
+              };
+            }
+          }
+        } catch (e) {
+          if (signal.aborted) throw new AbortError();
+          if (isResuming && this.isPersistent) {
+            const retryQ = await this.prepareRetryQuery(sdk, messages, signal, options, toolResultCapture);
+            const retryThinkingBlockIndices = /* @__PURE__ */ new Set();
+            const retryToolCallTracker = new ClaudeToolCallTracker();
+            const retryPendingToolCalls = /* @__PURE__ */ new Map();
+            let retryHasStreamedText = false;
+            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);
+                    }
+                    if (ev.type === "text_delta") retryHasStreamedText = true;
+                    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: retryHasStreamedText ? null : r.result,
+                    ...retryHasStreamedText ? { streamed: true } : {}
+                  };
+                }
+              }
+            } 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",
+          ...m.max_input_tokens != null && { contextWindow: m.max_input_tokens }
+        }));
+        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 (_sdkMock3) return _sdkMock3;
+  try {
+    return await import('ai');
+  } catch {
+    throw new DependencyError("ai");
+  }
+}
+async function loadCompat() {
+  if (_compatMock) return _compatMock;
+  try {
+    return await import('@ai-sdk/openai-compatible');
+  } catch {
+    throw new DependencyError("@ai-sdk/openai-compatible");
+  }
+}
+function _injectSDK3(mock) {
+  _sdkMock3 = mock;
+}
+function _injectCompat(mock) {
+  _compatMock = mock;
+}
+function _resetSDK3() {
+  _sdkMock3 = null;
+  _compatMock = 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, options) => {
+    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 ?? {},
+          toolCallId: options?.toolCallId
+        };
+        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,
+        code: "TOOL_EXECUTION" /* TOOL_EXECUTION */
+      };
+    }
+    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;
+      const errorMsg = p.error instanceof Error ? p.error.message : String(p.error ?? "Unknown error");
+      const code = classifyAgentError(errorMsg);
+      return {
+        type: "error",
+        error: errorMsg,
+        recoverable: isRecoverableErrorCode(code),
+        code
+      };
+    }
+    default:
+      return null;
+  }
+}
+function createVercelAIService(options) {
+  return new VercelAIAgentService(options);
+}
+var _sdkMock3, _compatMock, DEFAULT_BASE_URL, DEFAULT_PROVIDER, DEFAULT_MAX_TURNS, VercelAIAgent, VercelAIAgentService;
+var init_vercel_ai = __esm({
+  "src/backends/vercel-ai.ts"() {
+    init_types2();
+    init_base_agent();
+    init_errors2();
+    init_schema();
+    _sdkMock3 = null;
+    _compatMock = 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(options) {
+        const requestedModel = options.model;
+        const defaultModel = this.config.model;
+        if (requestedModel === defaultModel && 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 model = provider.chatModel(requestedModel);
+        if (requestedModel === defaultModel) {
+          this.model = model;
+        }
+        return model;
+      }
+      async getSDKTools(signal, options) {
+        const sdk = await loadSDK3();
+        const tools = this.resolveTools(options);
+        return mapToolsToSDK2(sdk, 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(options);
+        const tools = await this.getSDKTools(signal, options);
+        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(options);
+        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(options);
+        const tools = await this.getSDKTools(signal, options);
+        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)
+          };
+          const hasStreamed = finalText.length > 0;
+          yield {
+            type: "done",
+            finalOutput: hasStreamed ? null : finalText || null,
+            ...hasStreamed ? { streamed: true } : {}
+          };
+        } 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}`,
+              // OpenRouter requires HTTP-Referer for API access
+              "HTTP-Referer": "https://github.com/nicepkg/agent-sdk"
+            }
+          });
+          if (!res.ok) {
+            return [];
+          }
+          const body = await res.json();
+          if (body.data && Array.isArray(body.data)) {
+            return body.data.filter((m) => typeof m.id === "string").map((m) => ({
+              id: m.id,
+              ...typeof m.name === "string" && { name: m.name },
+              ...typeof m.description === "string" && { description: m.description },
+              ...typeof m.context_length === "number" && { contextWindow: m.context_length }
+            }));
+          }
+          if (Array.isArray(body)) {
+            return body.filter((m) => typeof m.id === "string").map((m) => ({
+              id: m.id,
+              ...typeof m.name === "string" && { name: m.name },
+              ...typeof m.description === "string" && { description: m.description },
+              ...typeof m.context_length === "number" && { contextWindow: m.context_length }
+            }));
+          }
+          return [];
+        } 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/chat/backends/types.ts
+function isResumableBackend(adapter) {
+  return "canResume" in adapter && typeof adapter.canResume === "function";
+}
+
+// src/chat/types.ts
+function createChatId() {
+  return crypto.randomUUID();
+}
+
+// src/chat/chat-utils.ts
+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");
+}
+
+// src/chat/bridge.ts
+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,
+        code: event.code,
+        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;
+    }
+  }
+}
+
+// src/chat/conversion.ts
+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_errors2();
+init_errors();
+var ChatError = class extends AgentSDKError {
+  code;
+  retryable;
+  retryAfter;
+  timestamp;
+  constructor(message, options) {
+    super(message, {
+      cause: options.cause,
+      code: options.code,
+      retryable: options.retryable
+    });
+    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 = null;
+  _agentServiceFactory = null;
+  _disposed = false;
+  _agentConfig;
+  _ownsService;
+  // Agent lifecycle: tracks current agent and the model it was created with.
+  // For persistent sessions, reused across calls when model matches.
+  // For non-persistent, recreated every call.
+  _currentAgent = null;
+  constructor(name, options) {
+    this.name = name;
+    this._agentConfig = options.agentConfig;
+    if (options.agentService) {
+      this._agentService = options.agentService;
+      this._ownsService = false;
+    } else if (options.agentServiceFactory) {
+      this._agentServiceFactory = options.agentServiceFactory;
+      this._ownsService = true;
+    } else {
+      this._agentService = this.createService();
+      this._ownsService = true;
+    }
+  }
+  get agentService() {
+    if (!this._agentService) {
+      if (this._agentServiceFactory) {
+        this._agentService = this._agentServiceFactory();
+        this._agentServiceFactory = null;
+      } else {
+        throw new ChatError("Agent service not available", {
+          code: "BACKEND_NOT_INSTALLED" /* BACKEND_NOT_INSTALLED */
+        });
+      }
+    }
+    return this._agentService;
+  }
+  get currentModel() {
+    return this._agentConfig.model;
+  }
+  /**
+   * @deprecated No-op. Tools are passed per-call via SendMessageOptions.tools.
+   * Kept for backward compatibility with code that calls setTools() directly.
+   */
+  setTools() {
+  }
+  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 model = options?.model ?? this._agentConfig.model ?? "";
+    const agentEvents = agent.streamWithContext(messages, {
+      model,
+      signal: options?.signal,
+      context: options?.context,
+      tools: options?.tools,
+      ...options?.systemPrompt ? { systemMessage: options.systemPrompt } : {}
+    });
+    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;
+    if (this._currentAgent) {
+      this._currentAgent.instance.dispose();
+      this._currentAgent = null;
+    }
+    if (this._ownsService && this._agentService && typeof this._agentService.dispose === "function") {
+      await this._agentService.dispose();
+    }
+  }
+  /** Get or create an agent. Model is passed per-call via RunOptions.
+   *  Tools are passed per-call via SendMessageOptions — not baked into config.
+   *  For persistent sessions, reuses agent when model matches. */
+  getOrCreateAgent(options) {
+    const model = options?.model ?? this._agentConfig.model;
+    if (this._agentConfig.sessionMode === "persistent" && this._currentAgent) {
+      if (this._currentAgent.model === model) {
+        return this._currentAgent.instance;
+      }
+      this._currentAgent.instance.dispose();
+      this._currentAgent = null;
+    }
+    if (this._currentAgent) {
+      this._currentAgent.instance.dispose();
+      this._currentAgent = null;
+    }
+    const config = {
+      ...this._agentConfig,
+      ...model !== void 0 && { model }
+    };
+    const agent = this.agentService.createAgent(config);
+    this._currentAgent = { instance: agent, model };
+    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 { createCopilotService: createCopilotService2 } = (init_copilot(), __toCommonJS(copilot_exports));
+    return createCopilotService2(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 { createClaudeService: createClaudeService2 } = (init_claude(), __toCommonJS(claude_exports));
+    return createClaudeService2(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 { createVercelAIService: createVercelAIService2 } = (init_vercel_ai(), __toCommonJS(vercel_ai_exports));
+    return createVercelAIService2(this._vercelOptions || {});
+  }
+  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 resolve = this._resolve;
+      this._resolve = null;
+      resolve({ value: event, done: false });
+    } else {
+      this._buffer.push(event);
+    }
+  }
+  close() {
+    if (!this._open) return;
+    this._open = false;
+    if (this._resolve) {
+      const resolve = this._resolve;
+      this._resolve = null;
+      resolve({ 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 resolve = this._resolve;
+      this._resolve = null;
+      resolve({ 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((resolve) => {
+          this._resolve = resolve;
+        });
+      }
+    };
+  }
+};
+
+// 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);
+}
+
+exports.BaseBackendAdapter = BaseBackendAdapter;
+exports.ClaudeChatAdapter = ClaudeChatAdapter;
+exports.CopilotChatAdapter = CopilotChatAdapter;
+exports.InProcessChatTransport = InProcessChatTransport;
+exports.SSEChatTransport = SSEChatTransport;
+exports.VercelAIChatAdapter = VercelAIChatAdapter;
+exports.WS_READY_STATE = WS_READY_STATE;
+exports.WsChatTransport = WsChatTransport;
+exports.isResumableBackend = isResumableBackend;
+exports.streamToTransport = streamToTransport;
+exports.withInterceptors = withInterceptors;
+//# sourceMappingURL=backends.cjs.map
+//# sourceMappingURL=backends.cjs.map