@witqq/agent-sdk 0.7.0 → 0.9.0

package/dist/chat/backends.js

@@ -1,7 +1,3 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -23,16 +19,69 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/errors.ts
-var AgentSDKError, ReentrancyError, DisposedError, BackendNotFoundError, BackendAlreadyRegisteredError, SubprocessError, DependencyError, AbortError, ToolExecutionError, StructuredOutputError;
+// 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) {
@@ -41,83 +90,84 @@ var init_errors = __esm({
     };
     ReentrancyError = class extends AgentSDKError {
       constructor() {
-        super("Agent is already running. Await the current run before starting another.");
+        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.`);
+        super(`${entity} has been disposed and cannot be used.`, {
+          code: "DISPOSED" /* DISPOSED */
+        });
         this.name = "DisposedError";
       }
     };
-    BackendNotFoundError = class extends AgentSDKError {
-      constructor(backend) {
-        super(
-          `Unknown backend: "${backend}". Built-in: copilot, claude, vercel-ai. Custom: use registerBackend() first.`
-        );
-        this.name = "BackendNotFoundError";
-      }
-    };
-    BackendAlreadyRegisteredError = class extends AgentSDKError {
-      constructor(backend) {
-        super(`Backend "${backend}" is already registered. Use a different name or unregister first.`);
-        this.name = "BackendAlreadyRegisteredError";
-      }
-    };
     SubprocessError = class extends AgentSDKError {
       constructor(message, options) {
-        super(message, options);
+        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}`);
+        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.");
+        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);
+        super(`Tool "${toolName}" failed: ${message}`, { ...options, code: "TOOL_EXECUTION" /* TOOL_EXECUTION */ });
         this.name = "ToolExecutionError";
         this.toolName = toolName;
       }
     };
-    StructuredOutputError = class extends AgentSDKError {
-      constructor(message, options) {
-        super(`Structured output error: ${message}`, options);
-        this.name = "StructuredOutputError";
+    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.ts
-function isToolDefinition(tool) {
-  return "execute" in tool && typeof tool.execute === "function";
-}
-function isTextContent(content) {
-  return typeof content === "string";
-}
-function isMultiPartContent(content) {
-  return Array.isArray(content);
-}
+// 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();
   }
 });
 
@@ -125,12 +175,15 @@ var init_types = __esm({
 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;
@@ -146,8 +199,11 @@ var init_base_agent = __esm({
         this.state = "running";
         try {
           const messages = [{ role: "user", content: prompt }];
-          const result = await this.executeRun(messages, options, ac.signal);
-          this.enrichAndNotifyUsage(result);
+          const result = await this.withRetry(
+            () => this.executeRun(messages, options, ac.signal),
+            options
+          );
+          this.enrichAndNotifyUsage(result, options);
           return result;
         } finally {
           this.cleanupRun();
@@ -159,8 +215,11 @@ var init_base_agent = __esm({
         const ac = this.createAbortController(options?.signal);
         this.state = "running";
         try {
-          const result = await this.executeRun(messages, options, ac.signal);
-          this.enrichAndNotifyUsage(result);
+          const result = await this.withRetry(
+            () => this.executeRun(messages, options, ac.signal),
+            options
+          );
+          this.enrichAndNotifyUsage(result, options);
           return result;
         } finally {
           this.cleanupRun();
@@ -173,13 +232,11 @@ var init_base_agent = __esm({
         this.state = "running";
         try {
           const messages = [{ role: "user", content: prompt }];
-          const result = await this.executeRunStructured(
-            messages,
-            schema,
-            options,
-            ac.signal
+          const result = await this.withRetry(
+            () => this.executeRunStructured(messages, schema, options, ac.signal),
+            options
           );
-          this.enrichAndNotifyUsage(result);
+          this.enrichAndNotifyUsage(result, options);
           return result;
         } finally {
           this.cleanupRun();
@@ -192,8 +249,10 @@ var init_base_agent = __esm({
         this.state = "streaming";
         try {
           const messages = [{ role: "user", content: prompt }];
-          const enriched = this.enrichStream(this.executeStream(messages, options, ac.signal));
-          yield* this.heartbeatStream(enriched);
+          yield* this.streamWithRetry(
+            () => this.applyStreamPipeline(this.executeStream(messages, options, ac.signal), options, ac),
+            options
+          );
         } finally {
           this.cleanupRun();
         }
@@ -204,12 +263,37 @@ var init_base_agent = __esm({
         const ac = this.createAbortController(options?.signal);
         this.state = "streaming";
         try {
-          const enriched = this.enrichStream(this.executeStream(messages, options, ac.signal));
-          yield* this.heartbeatStream(enriched);
+          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();
@@ -232,26 +316,109 @@ var init_base_agent = __esm({
         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) {
+      enrichAndNotifyUsage(result, options) {
         if (result.usage) {
           result.usage = {
             ...result.usage,
-            model: this.config.model,
+            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) {
+      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: this.config.model,
+              model,
               backend: this.backendName
             };
             this.callOnUsage(usage);
@@ -287,9 +454,9 @@ var init_base_agent = __esm({
         let heartbeatResolve = null;
         const timer = setInterval(() => {
           if (heartbeatResolve) {
-            const resolve2 = heartbeatResolve;
+            const resolve = heartbeatResolve;
             heartbeatResolve = null;
-            resolve2();
+            resolve();
           }
         }, interval);
         try {
@@ -297,8 +464,8 @@ var init_base_agent = __esm({
             if (!pendingEvent) {
               pendingEvent = iterator.next();
             }
-            const heartbeatPromise = new Promise((resolve2) => {
-              heartbeatResolve = resolve2;
+            const heartbeatPromise = new Promise((resolve) => {
+              heartbeatResolve = resolve;
             });
             const eventDone = pendingEvent.then(
               (r) => ({ kind: "event", result: r })
@@ -321,6 +488,35 @@ var init_base_agent = __esm({
           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") {
@@ -425,6 +621,66 @@ var init_schema = __esm({
   }
 });
 
+// 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, {
@@ -433,10 +689,9 @@ __export(copilot_exports, {
   createCopilotService: () => createCopilotService
 });
 async function loadSDK() {
-  if (sdkModule) return sdkModule;
+  if (_sdkMock) return _sdkMock;
   try {
-    sdkModule = await import('@github/copilot-sdk');
-    return sdkModule;
+    return await import('@github/copilot-sdk');
   } catch {
     throw new SubprocessError(
       "@github/copilot-sdk is not installed. Install it: npm install @github/copilot-sdk"
@@ -444,10 +699,10 @@ async function loadSDK() {
   }
 }
 function _injectSDK(mock) {
-  sdkModule = mock;
+  _sdkMock = mock;
 }
 function _resetSDK() {
-  sdkModule = null;
+  _sdkMock = null;
 }
 function mapToolsToSDK(tools) {
   return tools.map((tool) => ({
@@ -467,17 +722,6 @@ function convertParameters(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) {
@@ -492,6 +736,7 @@ function buildPermissionHandler(config) {
     const unifiedRequest = {
       toolName,
       toolArgs: { ...request },
+      toolCallId: request.toolCallId,
       rawSDKRequest: request
     };
     const ac = new AbortController();
@@ -596,15 +841,21 @@ function mapSessionEvent(event, tracker, thinkingTracker) {
       };
     case "session.error":
       console.error("[copilot] mapSessionEvent error:", JSON.stringify(data));
-      return {
-        type: "error",
-        error: String(data.message ?? "Unknown error"),
-        recoverable: false
-      };
+      {
+        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: data.content ? String(data.content) : null
+        finalOutput: null,
+        streamed: true
       };
       if (thinkingTracker.endThinking()) {
         return [{ type: "thinking_end" }, doneEvent];
@@ -615,66 +866,13 @@ function mapSessionEvent(event, tracker, thinkingTracker) {
       return null;
   }
 }
-function extractLastUserPrompt(messages) {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.role === "user") {
-      return getTextContent(msg.content);
-    }
-  }
-  return "";
-}
-function serializeToolCall(tc) {
-  const args = typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args);
-  return `  Tool call: ${tc.name}(${args})`;
-}
-function serializeToolResult(tr) {
-  const result = typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result);
-  const prefix = tr.isError ? "[ERROR] " : "";
-  return `  ${tr.name} \u2192 ${prefix}${result}`;
-}
-function buildContextualPrompt(messages) {
-  if (messages.length <= 1) {
-    return extractLastUserPrompt(messages);
-  }
-  const history = messages.slice(0, -1).map((msg) => {
-    if (msg.role === "user") {
-      return `User: ${msg.content ? getTextContent(msg.content) : ""}`;
-    }
-    if (msg.role === "tool" && msg.toolResults) {
-      const results = msg.toolResults.map(serializeToolResult).join("\n");
-      return `Tool results:
-${results}`;
-    }
-    if (msg.role === "assistant") {
-      const parts = [];
-      const thinking = msg.thinking;
-      if (thinking) {
-        parts.push(`[reasoning: ${thinking}]`);
-      }
-      const text2 = msg.content ? getTextContent(msg.content) : "";
-      if (text2) parts.push(text2);
-      if (msg.toolCalls && msg.toolCalls.length > 0) {
-        parts.push(msg.toolCalls.map(serializeToolCall).join("\n"));
-      }
-      return `Assistant: ${parts.join("\n")}`;
-    }
-    const text = msg.content ? getTextContent(msg.content) : "";
-    return `${msg.role}: ${text}`;
-  }).join("\n");
-  const lastPrompt = extractLastUserPrompt(messages);
-  return `Conversation history:
-${history}
-
-User: ${lastPrompt}`;
-}
 function withTimeout(promise, ms, message) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const timer = setTimeout(() => reject(new SubprocessError(message)), ms);
     promise.then(
       (val) => {
         clearTimeout(timer);
-        resolve2(val);
+        resolve(val);
       },
       (err) => {
         clearTimeout(timer);
@@ -686,14 +884,15 @@ function withTimeout(promise, ms, message) {
 function createCopilotService(options) {
   return new CopilotAgentService(options);
 }
-var sdkModule, ToolCallTracker, ThinkingTracker, CopilotAgent, CopilotAgentService;
+var _sdkMock, ToolCallTracker, ThinkingTracker, CopilotAgent, CopilotAgentService;
 var init_copilot = __esm({
   "src/backends/copilot.ts"() {
-    init_types();
+    init_types2();
     init_base_agent();
-    init_errors();
+    init_errors2();
     init_schema();
-    sdkModule = null;
+    init_shared();
+    _sdkMock = null;
     ToolCallTracker = class {
       map = /* @__PURE__ */ new Map();
       trackStart(toolCallId, toolName, args) {
@@ -741,6 +940,7 @@ var init_copilot = __esm({
       isPersistent;
       persistentSession = null;
       _sessionId;
+      _persistentModel;
       activeSession = null;
       _resumeSessionId;
       _toolsReady = null;
@@ -759,15 +959,15 @@ var init_copilot = __esm({
           },
           onPermissionRequest: buildPermissionHandler(config),
           onUserInputRequest: buildUserInputHandler(config),
-          ...config.availableTools?.length ? { availableTools: config.availableTools } : {}
+          ...config.availableTools ? { availableTools: config.availableTools } : {}
         };
         this._toolsReady = this._initToolsAsync(config);
         this._resumeSessionId = resumeSessionId;
       }
-      /** Pre-convert Zod schemas to JSON Schema asynchronously.
+      /** Pre-convert Zod schemas to JSON Schema.
        *  Updates sdkTools and sessionConfig.tools before first session creation. */
       async _initToolsAsync(config) {
-        this.sdkTools = await mapToolsToSDKAsync(config.tools ?? []);
+        this.sdkTools = mapToolsToSDK(config.tools ?? []);
         this.sessionConfig.tools = this.sdkTools;
       }
       get sessionId() {
@@ -791,47 +991,63 @@ var init_copilot = __esm({
           });
           this.persistentSession = null;
           this._sessionId = void 0;
+          this._persistentModel = void 0;
         }
       }
-      async getOrCreateSession(streaming) {
+      async getOrCreateSession(streaming, options) {
         if (this.isPersistent && this.persistentSession) {
-          return { session: this.persistentSession, isNew: false };
+          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, {
-              ...this.sessionConfig,
+              ...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({
-          ...this.sessionConfig,
+          ...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) {
+      async executeRun(messages, options, signal) {
         this.checkAbort(signal);
-        const { session, isNew: isNewSession } = await this.getOrCreateSession(false);
+        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();
@@ -928,9 +1144,9 @@ You MUST respond with ONLY valid JSON matching this schema:
         };
       }
       // ─── executeStream ──────────────────────────────────────────────
-      async *executeStream(messages, _options, signal) {
+      async *executeStream(messages, options, signal) {
         this.checkAbort(signal);
-        const { session, isNew: isNewSession } = await this.getOrCreateSession(true);
+        const { session, isNew: isNewSession } = await this.getOrCreateSession(true, options);
         this.activeSession = session;
         if (isNewSession) {
           yield this.emitSessionInfo(session.sessionId);
@@ -947,8 +1163,8 @@ You MUST respond with ONLY valid JSON matching this schema:
             notify = null;
           }
         };
-        const waitForItem = () => new Promise((resolve2) => {
-          notify = resolve2;
+        const waitForItem = () => new Promise((resolve) => {
+          notify = resolve;
         });
         const unsubscribe = session.on((event) => {
           const mapped = mapSessionEvent(event, tracker, thinkingTracker);
@@ -1042,7 +1258,11 @@ You MUST respond with ONLY valid JSON matching this schema:
               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 } } : {}
+              env: {
+                ...process.env,
+                ...this.options.githubToken ? { GITHUB_TOKEN: this.options.githubToken } : {},
+                ...this.options.env
+              }
             });
             const startupTimeout = this.options.startupTimeoutMs ?? 3e4;
             await withTimeout(client.start(), startupTimeout, "CLI startup timed out");
@@ -1076,7 +1296,10 @@ You MUST respond with ONLY valid JSON matching this schema:
         return models.map((m) => ({
           id: m.id,
           name: m.name,
-          provider: "copilot"
+          provider: "copilot",
+          ...m.capabilities?.limits?.max_context_window_tokens != null && {
+            contextWindow: m.capabilities.limits.max_context_window_tokens
+          }
         }));
       }
       async validate() {
@@ -1129,10 +1352,9 @@ function stripMcpPrefix(name) {
   return name.startsWith(MCP_TOOL_PREFIX) ? name.slice(MCP_TOOL_PREFIX.length) : name;
 }
 async function loadSDK2() {
-  if (sdkModule2) return sdkModule2;
+  if (_sdkMock2) return _sdkMock2;
   try {
-    sdkModule2 = await import('@anthropic-ai/claude-agent-sdk');
-    return sdkModule2;
+    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"
@@ -1140,13 +1362,32 @@ async function loadSDK2() {
   }
 }
 function _injectSDK2(mock) {
-  sdkModule2 = mock;
+  _sdkMock2 = mock;
 }
 function _resetSDK2() {
-  sdkModule2 = null;
+  _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) {
-  if (tools.length === 0) return void 0;
+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);
@@ -1170,6 +1411,39 @@ function buildMcpServer(sdk, tools, toolResultCapture) {
       }
     );
   });
+  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",
@@ -1219,6 +1493,7 @@ function buildCanUseTool(config) {
     const unifiedRequest = {
       toolName,
       toolArgs: input,
+      toolCallId: options.toolUseID,
       suggestedScope: extractSuggestedScope(options.suggestions),
       rawSDKRequest: { toolName, input, ...options }
     };
@@ -1271,6 +1546,7 @@ function mapSDKMessage(msg, thinkingBlockIndices, toolCallTracker) {
         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);
           }
@@ -1294,6 +1570,7 @@ function mapSDKMessage(msg, thinkingBlockIndices, toolCallTracker) {
     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) {
@@ -1347,10 +1624,13 @@ function mapSDKMessage(msg, thinkingBlockIndices, toolCallTracker) {
       }
       if (msg.is_error) {
         const r = msg;
+        const errorMsg = r.errors?.join("; ") ?? "Unknown error";
+        const code = classifyAgentError(errorMsg);
         return {
           type: "error",
-          error: r.errors?.join("; ") ?? "Unknown error",
-          recoverable: false
+          error: errorMsg,
+          recoverable: isRecoverableErrorCode(code),
+          code
         };
       }
       return null;
@@ -1359,72 +1639,21 @@ function mapSDKMessage(msg, thinkingBlockIndices, toolCallTracker) {
       return null;
   }
 }
-function extractLastUserPrompt2(messages) {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.role === "user") {
-      return getTextContent(msg.content);
-    }
-  }
-  return "";
-}
-function serializeToolCall2(tc) {
-  const args = typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args);
-  return `  Tool call: ${tc.name}(${args})`;
-}
-function serializeToolResult2(tr) {
-  const result = typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result);
-  const prefix = tr.isError ? "[ERROR] " : "";
-  return `  ${tr.name} \u2192 ${prefix}${result}`;
+function createClaudeService(options) {
+  return new ClaudeAgentService(options);
 }
-function buildContextualPrompt2(messages) {
-  if (messages.length <= 1) {
-    return extractLastUserPrompt2(messages);
-  }
-  const history = messages.slice(0, -1).map((msg) => {
-    if (msg.role === "user") {
-      return `User: ${msg.content ? getTextContent(msg.content) : ""}`;
-    }
-    if (msg.role === "tool" && msg.toolResults) {
-      const results = msg.toolResults.map(serializeToolResult2).join("\n");
-      return `Tool results:
-${results}`;
-    }
-    if (msg.role === "assistant") {
-      const parts = [];
-      const thinking = msg.thinking;
-      if (thinking) {
-        parts.push(`[reasoning: ${thinking}]`);
-      }
-      const text2 = msg.content ? getTextContent(msg.content) : "";
-      if (text2) parts.push(text2);
-      if (msg.toolCalls && msg.toolCalls.length > 0) {
-        parts.push(msg.toolCalls.map(serializeToolCall2).join("\n"));
-      }
-      return `Assistant: ${parts.join("\n")}`;
-    }
-    const text = msg.content ? getTextContent(msg.content) : "";
-    return `${msg.role}: ${text}`;
-  }).join("\n");
-  const lastPrompt = extractLastUserPrompt2(messages);
-  return `Conversation history:
-${history}
-
-User: ${lastPrompt}`;
-}
-function createClaudeService(options) {
-  return new ClaudeAgentService(options);
-}
-var MCP_SERVER_NAME, MCP_TOOL_PREFIX, sdkModule2, ANTHROPIC_MODELS_URL, ANTHROPIC_API_VERSION, ANTHROPIC_OAUTH_BETA, ClaudeToolCallTracker, ClaudeAgent, ClaudeAgentService;
+var 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_types();
+    init_types2();
     init_base_agent();
-    init_errors();
+    init_errors2();
     init_schema();
+    init_shared();
     MCP_SERVER_NAME = "agent-sdk-tools";
     MCP_TOOL_PREFIX = `mcp__${MCP_SERVER_NAME}__`;
-    sdkModule2 = null;
+    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";
@@ -1469,11 +1698,6 @@ var init_claude = __esm({
         if (options.resumeSessionId) {
           this._sessionId = options.resumeSessionId;
         }
-        if (config.supervisor?.onAskUser) {
-          console.warn(
-            "[agent-sdk/claude] supervisor.onAskUser is not supported by the Claude CLI backend. User interaction requests from the model will not be forwarded."
-          );
-        }
       }
       get sessionId() {
         return this._sessionId;
@@ -1497,12 +1721,12 @@ var init_claude = __esm({
         const transcriptPath = home ? `${home}/.claude/projects/.session/sessions/${sessionId}/conversation.jsonl` : void 0;
         return { type: "session_info", sessionId, transcriptPath, backend: "claude" };
       }
-      buildQueryOptions(signal) {
+      buildQueryOptions(signal, options) {
         const ac = new AbortController();
         signal.addEventListener("abort", () => ac.abort(), { once: true });
         const opts = {
           abortController: ac,
-          model: this.config.model,
+          model: options.model,
           maxTurns: this.options.maxTurns,
           cwd: this.options.workingDirectory,
           pathToClaudeCodeExecutable: this.options.cliPath,
@@ -1532,25 +1756,85 @@ var init_claude = __esm({
         return opts;
       }
       async buildMcpConfig(opts, toolResultCapture) {
-        if (this.tools.length === 0) return opts;
+        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);
+        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) {
+      async executeRun(messages, options, signal) {
         this.checkAbort(signal);
         const sdk = await loadSDK2();
         const isResuming = this.isPersistent && this._sessionId !== void 0;
-        const prompt = isResuming ? extractLastUserPrompt2(messages) : buildContextualPrompt2(messages);
-        let opts = this.buildQueryOptions(signal);
+        const 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 });
@@ -1560,30 +1844,8 @@ var init_claude = __esm({
         let usage;
         try {
           for await (const msg of q) {
-            if (msg.type === "assistant") {
-              const betaMessage = msg.message;
-              if (betaMessage?.content) {
-                for (const block of betaMessage.content) {
-                  if (block.type === "tool_use") {
-                    const toolName = stripMcpPrefix(block.name ?? "unknown");
-                    toolCalls.push({
-                      toolName,
-                      args: block.input ?? {},
-                      result: toolResultCapture.get(toolName) ?? null,
-                      approved: true
-                    });
-                  }
-                }
-              }
-            }
-            if (msg.type === "tool_use_summary" || msg.type === "result") {
-              for (const tc of toolCalls) {
-                if (tc.result === null) {
-                  const captured = toolResultCapture.get(tc.toolName);
-                  if (captured !== void 0) tc.result = captured;
-                }
-              }
-            }
+            this.collectToolCallsFromMessage(msg, toolCalls, toolResultCapture);
+            this.backfillToolResults(msg, toolCalls, toolResultCapture);
             if (msg.type === "result") {
               if (msg.subtype === "success") {
                 const r = msg;
@@ -1603,41 +1865,13 @@ var init_claude = __esm({
         } catch (e) {
           if (signal.aborted) throw new AbortError();
           if (isResuming && this.isPersistent) {
-            this.clearPersistentSession();
-            const retryPrompt = buildContextualPrompt2(messages);
-            let retryOpts = this.buildQueryOptions(signal);
-            toolResultCapture.clear();
-            retryOpts = await this.buildMcpConfig(retryOpts, toolResultCapture);
-            const retryQ = sdk.query({ prompt: retryPrompt, options: retryOpts });
-            this.activeQuery = retryQ;
+            const retryQ = await this.prepareRetryQuery(sdk, messages, signal, options, toolResultCapture);
             toolCalls.length = 0;
             output = null;
-            try {
+            return this.withRetryErrorHandling(signal, async () => {
               for await (const msg of retryQ) {
-                if (msg.type === "assistant") {
-                  const betaMessage = msg.message;
-                  if (betaMessage?.content) {
-                    for (const block of betaMessage.content) {
-                      if (block.type === "tool_use") {
-                        const toolName = stripMcpPrefix(block.name ?? "unknown");
-                        toolCalls.push({
-                          toolName,
-                          args: block.input ?? {},
-                          result: toolResultCapture.get(toolName) ?? null,
-                          approved: true
-                        });
-                      }
-                    }
-                  }
-                }
-                if (msg.type === "tool_use_summary" || msg.type === "result") {
-                  for (const tc of toolCalls) {
-                    if (tc.result === null) {
-                      const captured = toolResultCapture.get(tc.toolName);
-                      if (captured !== void 0) tc.result = captured;
-                    }
-                  }
-                }
+                this.collectToolCallsFromMessage(msg, toolCalls, toolResultCapture);
+                this.backfillToolResults(msg, toolCalls, toolResultCapture);
                 if (msg.type === "result") {
                   if (msg.subtype === "success") {
                     const r = msg;
@@ -1654,23 +1888,17 @@ var init_claude = __esm({
                   }
                 }
               }
-            } catch (retryError) {
-              if (this.isPersistent) this.clearPersistentSession();
-              if (signal.aborted) throw new AbortError();
-              throw retryError;
-            } finally {
-              this.activeQuery = null;
-            }
-            return {
-              output,
-              structuredOutput: void 0,
-              toolCalls,
-              messages: [
-                ...messages,
-                ...output !== null ? [{ role: "assistant", content: output }] : []
-              ],
-              usage
-            };
+              return {
+                output,
+                structuredOutput: void 0,
+                toolCalls,
+                messages: [
+                  ...messages,
+                  ...output !== null ? [{ role: "assistant", content: output }] : []
+                ],
+                usage
+              };
+            });
           }
           if (this.isPersistent) this.clearPersistentSession();
           throw e;
@@ -1689,12 +1917,12 @@ var init_claude = __esm({
         };
       }
       // ─── executeRunStructured ───────────────────────────────────────
-      async executeRunStructured(messages, schema, _options, signal) {
+      async executeRunStructured(messages, schema, options, signal) {
         this.checkAbort(signal);
         const sdk = await loadSDK2();
         const isResuming = this.isPersistent && this._sessionId !== void 0;
-        const prompt = isResuming ? extractLastUserPrompt2(messages) : buildContextualPrompt2(messages);
-        let opts = this.buildQueryOptions(signal);
+        const 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);
@@ -1710,30 +1938,8 @@ var init_claude = __esm({
         let usage;
         try {
           for await (const msg of q) {
-            if (msg.type === "assistant") {
-              const betaMessage = msg.message;
-              if (betaMessage?.content) {
-                for (const block of betaMessage.content) {
-                  if (block.type === "tool_use") {
-                    const toolName = stripMcpPrefix(block.name ?? "unknown");
-                    toolCalls.push({
-                      toolName,
-                      args: block.input ?? {},
-                      result: toolResultCapture.get(toolName) ?? null,
-                      approved: true
-                    });
-                  }
-                }
-              }
-            }
-            if (msg.type === "tool_use_summary" || msg.type === "result") {
-              for (const tc of toolCalls) {
-                if (tc.result === null) {
-                  const captured = toolResultCapture.get(tc.toolName);
-                  if (captured !== void 0) tc.result = captured;
-                }
-              }
-            }
+            this.collectToolCallsFromMessage(msg, toolCalls, toolResultCapture);
+            this.backfillToolResults(msg, toolCalls, toolResultCapture);
             if (msg.type === "result" && msg.subtype === "success") {
               const r = msg;
               output = r.result;
@@ -1768,46 +1974,23 @@ var init_claude = __esm({
         } catch (e) {
           if (signal.aborted) throw new AbortError();
           if (isResuming && this.isPersistent) {
-            this.clearPersistentSession();
-            const retryPrompt = buildContextualPrompt2(messages);
-            let retryOpts = this.buildQueryOptions(signal);
-            toolResultCapture.clear();
-            retryOpts = await this.buildMcpConfig(retryOpts, toolResultCapture);
-            retryOpts.outputFormat = {
-              type: "json_schema",
-              schema: jsonSchema
-            };
-            const retryQ = sdk.query({ prompt: retryPrompt, options: retryOpts });
-            this.activeQuery = retryQ;
+            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;
-            try {
+            return this.withRetryErrorHandling(signal, async () => {
               for await (const msg of retryQ) {
-                if (msg.type === "assistant") {
-                  const betaMessage = msg.message;
-                  if (betaMessage?.content) {
-                    for (const block of betaMessage.content) {
-                      if (block.type === "tool_use") {
-                        const toolName = stripMcpPrefix(block.name ?? "unknown");
-                        toolCalls.push({
-                          toolName,
-                          args: block.input ?? {},
-                          result: toolResultCapture.get(toolName) ?? null,
-                          approved: true
-                        });
-                      }
-                    }
-                  }
-                }
-                if (msg.type === "tool_use_summary" || msg.type === "result") {
-                  for (const tc of toolCalls) {
-                    if (tc.result === null) {
-                      const captured = toolResultCapture.get(tc.toolName);
-                      if (captured !== void 0) tc.result = captured;
-                    }
-                  }
-                }
+                this.collectToolCallsFromMessage(msg, toolCalls, toolResultCapture);
+                this.backfillToolResults(msg, toolCalls, toolResultCapture);
                 if (msg.type === "result" && msg.subtype === "success") {
                   const r = msg;
                   output = r.result;
@@ -1839,23 +2022,17 @@ var init_claude = __esm({
                   );
                 }
               }
-            } catch (retryError) {
-              if (this.isPersistent) this.clearPersistentSession();
-              if (signal.aborted) throw new AbortError();
-              throw retryError;
-            } finally {
-              this.activeQuery = null;
-            }
-            return {
-              output,
-              structuredOutput,
-              toolCalls,
-              messages: [
-                ...messages,
-                ...output !== null ? [{ role: "assistant", content: output }] : []
-              ],
-              usage
-            };
+              return {
+                output,
+                structuredOutput,
+                toolCalls,
+                messages: [
+                  ...messages,
+                  ...output !== null ? [{ role: "assistant", content: output }] : []
+                ],
+                usage
+              };
+            });
           }
           if (this.isPersistent) this.clearPersistentSession();
           throw e;
@@ -1874,12 +2051,12 @@ var init_claude = __esm({
         };
       }
       // ─── executeStream ──────────────────────────────────────────────
-      async *executeStream(messages, _options, signal) {
+      async *executeStream(messages, options, signal) {
         this.checkAbort(signal);
         const sdk = await loadSDK2();
         const isResuming = this.isPersistent && this._sessionId !== void 0;
-        const prompt = isResuming ? extractLastUserPrompt2(messages) : buildContextualPrompt2(messages);
-        let opts = this.buildQueryOptions(signal);
+        const 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 });
@@ -1887,6 +2064,7 @@ var init_claude = __esm({
         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();
@@ -1904,6 +2082,7 @@ var init_claude = __esm({
                 } else if (e.type === "tool_call_end") {
                   pendingStreamToolCalls.delete(e.toolCallId);
                 }
+                if (e.type === "text_delta") hasStreamedText = true;
                 yield e;
               }
             }
@@ -1927,22 +2106,21 @@ var init_claude = __esm({
                 }
                 yield this.emitSessionInfo(r.session_id);
               }
-              yield { type: "done", finalOutput: r.result };
+              yield {
+                type: "done",
+                finalOutput: hasStreamedText ? null : r.result,
+                ...hasStreamedText ? { streamed: true } : {}
+              };
             }
           }
         } catch (e) {
           if (signal.aborted) throw new AbortError();
           if (isResuming && this.isPersistent) {
-            this.clearPersistentSession();
-            const retryPrompt = buildContextualPrompt2(messages);
-            let retryOpts = this.buildQueryOptions(signal);
-            toolResultCapture.clear();
-            retryOpts = await this.buildMcpConfig(retryOpts, toolResultCapture);
-            const retryQ = sdk.query({ prompt: retryPrompt, options: retryOpts });
-            this.activeQuery = retryQ;
+            const 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();
@@ -1960,6 +2138,7 @@ var init_claude = __esm({
                     } else if (ev.type === "tool_call_end") {
                       retryPendingToolCalls.delete(ev.toolCallId);
                     }
+                    if (ev.type === "text_delta") retryHasStreamedText = true;
                     yield ev;
                   }
                 }
@@ -1983,7 +2162,11 @@ var init_claude = __esm({
                     }
                     yield this.emitSessionInfo(r.session_id);
                   }
-                  yield { type: "done", finalOutput: r.result };
+                  yield {
+                    type: "done",
+                    finalOutput: retryHasStreamedText ? null : r.result,
+                    ...retryHasStreamedText ? { streamed: true } : {}
+                  };
                 }
               }
             } catch (retryError) {
@@ -2045,7 +2228,8 @@ var init_claude = __esm({
         this.cachedModels = body.data.map((m) => ({
           id: m.id,
           name: m.display_name,
-          provider: "claude"
+          provider: "claude",
+          ...m.max_input_tokens != null && { contextWindow: m.max_input_tokens }
         }));
         return this.cachedModels;
       }
@@ -2103,32 +2287,30 @@ __export(vercel_ai_exports, {
   createVercelAIService: () => createVercelAIService
 });
 async function loadSDK3() {
-  if (sdkModule3) return sdkModule3;
+  if (_sdkMock3) return _sdkMock3;
   try {
-    sdkModule3 = await import('ai');
-    return sdkModule3;
+    return await import('ai');
   } catch {
     throw new DependencyError("ai");
   }
 }
 async function loadCompat() {
-  if (compatModule) return compatModule;
+  if (_compatMock) return _compatMock;
   try {
-    compatModule = await import('@ai-sdk/openai-compatible');
-    return compatModule;
+    return await import('@ai-sdk/openai-compatible');
   } catch {
     throw new DependencyError("@ai-sdk/openai-compatible");
   }
 }
 function _injectSDK3(mock) {
-  sdkModule3 = mock;
+  _sdkMock3 = mock;
 }
 function _injectCompat(mock) {
-  compatModule = mock;
+  _compatMock = mock;
 }
 function _resetSDK3() {
-  sdkModule3 = null;
-  compatModule = null;
+  _sdkMock3 = null;
+  _compatMock = null;
 }
 function mapToolsToSDK2(sdk, tools, config, sessionApprovals, permissionStore, signal) {
   const toolMap = {};
@@ -2171,13 +2353,14 @@ function mapToolsToSDK2(sdk, tools, config, sessionApprovals, permissionStore, s
   return toolMap;
 }
 function wrapToolExecute(ourTool, supervisor, sessionApprovals, permissionStore, signal) {
-  return async (args) => {
+  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 ?? {}
+          toolArgs: args ?? {},
+          toolCallId: options?.toolCallId
         };
         const decision = await supervisor.onPermission(
           request,
@@ -2284,7 +2467,8 @@ function mapStreamPart(part) {
       return {
         type: "error",
         error: p.error instanceof Error ? p.error.message : String(p.error ?? "Tool execution failed"),
-        recoverable: true
+        recoverable: true,
+        code: "TOOL_EXECUTION" /* TOOL_EXECUTION */
       };
     }
     case "reasoning-start":
@@ -2305,10 +2489,13 @@ function mapStreamPart(part) {
     }
     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: p.error instanceof Error ? p.error.message : String(p.error ?? "Unknown error"),
-        recoverable: false
+        error: errorMsg,
+        recoverable: isRecoverableErrorCode(code),
+        code
       };
     }
     default:
@@ -2318,15 +2505,15 @@ function mapStreamPart(part) {
 function createVercelAIService(options) {
   return new VercelAIAgentService(options);
 }
-var sdkModule3, compatModule, DEFAULT_BASE_URL, DEFAULT_PROVIDER, DEFAULT_MAX_TURNS, VercelAIAgent, VercelAIAgentService;
+var _sdkMock3, _compatMock, DEFAULT_BASE_URL, DEFAULT_PROVIDER, DEFAULT_MAX_TURNS, VercelAIAgent, VercelAIAgentService;
 var init_vercel_ai = __esm({
   "src/backends/vercel-ai.ts"() {
-    init_types();
+    init_types2();
     init_base_agent();
-    init_errors();
+    init_errors2();
     init_schema();
-    sdkModule3 = null;
-    compatModule = null;
+    _sdkMock3 = null;
+    _compatMock = null;
     DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
     DEFAULT_PROVIDER = "openrouter";
     DEFAULT_MAX_TURNS = 10;
@@ -2339,28 +2526,33 @@ var init_vercel_ai = __esm({
         super(config);
         this.backendOptions = backendOptions;
       }
-      async getModel() {
-        if (this.model) return this.model;
+      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 modelId = this.config.model ?? "anthropic/claude-sonnet-4-5";
-        this.model = provider.chatModel(modelId);
-        return this.model;
+        const model = provider.chatModel(requestedModel);
+        if (requestedModel === defaultModel) {
+          this.model = model;
+        }
+        return model;
       }
-      async getSDKTools(signal) {
+      async getSDKTools(signal, options) {
         const sdk = await loadSDK3();
-        return mapToolsToSDK2(sdk, this.config.tools ?? [], this.config, this.sessionApprovals, this.config.permissionStore, signal);
+        const tools = this.resolveTools(options);
+        return mapToolsToSDK2(sdk, tools, this.config, this.sessionApprovals, this.config.permissionStore, signal);
       }
       // ─── executeRun ─────────────────────────────────────────────────
-      async executeRun(messages, _options, signal) {
+      async executeRun(messages, options, signal) {
         this.checkAbort(signal);
         const sdk = await loadSDK3();
-        const model = await this.getModel();
-        const tools = await this.getSDKTools(signal);
+        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;
@@ -2416,10 +2608,10 @@ var init_vercel_ai = __esm({
         };
       }
       // ─── executeRunStructured ───────────────────────────────────────
-      async executeRunStructured(messages, schema, _options, signal) {
+      async executeRunStructured(messages, schema, options, signal) {
         this.checkAbort(signal);
         const sdk = await loadSDK3();
-        const model = await this.getModel();
+        const model = await this.getModel(options);
         const sdkMessages = messagesToSDK(messages);
         const jsonSchema = zodToJsonSchema(schema.schema);
         const result = await sdk.generateObject({
@@ -2461,11 +2653,11 @@ var init_vercel_ai = __esm({
         };
       }
       // ─── executeStream ──────────────────────────────────────────────
-      async *executeStream(messages, _options, signal) {
+      async *executeStream(messages, options, signal) {
         this.checkAbort(signal);
         const sdk = await loadSDK3();
-        const model = await this.getModel();
-        const tools = await this.getSDKTools(signal);
+        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;
@@ -2490,6 +2682,7 @@ var init_vercel_ai = __esm({
           }
         });
         let finalText = "";
+        let lastFinishReason;
         try {
           for await (const part of result.fullStream) {
             if (signal.aborted) throw new AbortError();
@@ -2500,10 +2693,15 @@ var init_vercel_ai = __esm({
             }
             if (part.type === "finish-step") {
               const p = part;
+              lastFinishReason = p.finishReason;
               if (p.finishReason === "tool-calls") {
                 finalText = "";
               }
             }
+            if (part.type === "finish") {
+              const p = part;
+              lastFinishReason = p.finishReason;
+            }
           }
           const totalUsage = await result.totalUsage;
           yield {
@@ -2511,9 +2709,12 @@ var init_vercel_ai = __esm({
             promptTokens: Number(totalUsage?.inputTokens ?? 0),
             completionTokens: Number(totalUsage?.outputTokens ?? 0)
           };
+          const hasStreamed = finalText.length > 0;
           yield {
             type: "done",
-            finalOutput: finalText || null
+            finalOutput: hasStreamed ? null : finalText || null,
+            ...hasStreamed ? { streamed: true } : {},
+            ...lastFinishReason ? { finishReason: lastFinishReason } : {}
           };
         } catch (e) {
           if (signal.aborted) throw new AbortError();
@@ -2542,16 +2743,33 @@ var init_vercel_ai = __esm({
         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}` }
+            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 || body.data.length === 0) {
-            return [];
+          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 }
+            }));
           }
-          return body.data.map((m) => ({ id: m.id }));
+          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 [];
         }
@@ -2582,272 +2800,25 @@ var init_vercel_ai = __esm({
   }
 });
 
-// src/registry.ts
-function registerBackend(name, factory) {
-  if (registry.has(name)) {
-    throw new BackendAlreadyRegisteredError(name);
-  }
-  registry.set(name, { factory, builtin: false });
-}
-function unregisterBackend(name) {
-  return registry.delete(name);
-}
-function hasBackend(name) {
-  return registry.has(name) || isBuiltinName(name);
+// src/chat/backends/types.ts
+function isResumableBackend(adapter) {
+  return "canResume" in adapter && typeof adapter.canResume === "function";
 }
-function listBackends() {
-  const names = new Set(registry.keys());
-  for (const builtin of BUILTIN_BACKENDS) {
-    names.add(builtin);
-  }
-  return [...names];
-}
-function resetRegistry() {
-  registry.clear();
-}
-function isBuiltinName(name) {
-  return BUILTIN_BACKENDS.has(name);
-}
-async function loadBuiltinFactory(name) {
-  switch (name) {
-    case "copilot": {
-      const mod = await Promise.resolve().then(() => (init_copilot(), copilot_exports));
-      return (opts) => mod.createCopilotService(opts);
-    }
-    case "claude": {
-      const mod = await Promise.resolve().then(() => (init_claude(), claude_exports));
-      return (opts) => mod.createClaudeService(opts);
-    }
-    case "vercel-ai": {
-      const mod = await Promise.resolve().then(() => (init_vercel_ai(), vercel_ai_exports));
-      return (opts) => mod.createVercelAIService(opts);
-    }
-  }
-}
-async function createAgentService(name, options) {
-  const entry = registry.get(name);
-  if (entry) {
-    return entry.factory(options);
-  }
-  if (isBuiltinName(name)) {
-    const factory = await loadBuiltinFactory(name);
-    registry.set(name, { factory, builtin: true });
-    return factory(options);
-  }
-  throw new BackendNotFoundError(name);
-}
-var registry, BUILTIN_BACKENDS;
-var init_registry = __esm({
-  "src/registry.ts"() {
-    init_errors();
-    registry = /* @__PURE__ */ new Map();
-    BUILTIN_BACKENDS = /* @__PURE__ */ new Set([
-      "copilot",
-      "claude",
-      "vercel-ai"
-    ]);
-  }
-});
-
-// src/utils/messages.ts
-function messagesToPrompt(messages) {
-  return messages.map((msg) => {
-    switch (msg.role) {
-      case "user":
-        return contentToText(msg.content);
-      case "assistant":
-        return contentToText(msg.content);
-      case "system":
-        return msg.content;
-      case "tool":
-        return msg.content ?? "";
-    }
-  }).filter(Boolean).join("\n\n");
-}
-function contentToText(content) {
-  return getTextContent(content);
-}
-function buildSystemPrompt(base, schemaInstruction) {
-  if (!schemaInstruction) return base;
-  return `${base}
-
-${schemaInstruction}`;
-}
-var init_messages = __esm({
-  "src/utils/messages.ts"() {
-    init_types();
-  }
-});
-function createDefaultPermissionStore(projectDir) {
-  const sessionStore = new InMemoryPermissionStore();
-  const projectPath = projectDir ? path.join(projectDir, ".agent-sdk", "permissions.json") : path.join(process.cwd(), ".agent-sdk", "permissions.json");
-  const userPath = path.join(os.homedir(), ".agent-sdk", "permissions.json");
-  const projectStore = new FilePermissionStore(projectPath);
-  const userStore = new FilePermissionStore(userPath);
-  return new CompositePermissionStore(sessionStore, projectStore, userStore);
-}
-var InMemoryPermissionStore, FilePermissionStore, CompositePermissionStore;
-var init_permission_store = __esm({
-  "src/permission-store.ts"() {
-    InMemoryPermissionStore = class {
-      approvals = /* @__PURE__ */ new Map();
-      async isApproved(toolName) {
-        return this.approvals.has(toolName);
-      }
-      async approve(toolName, scope) {
-        if (scope === "once") return;
-        this.approvals.set(toolName, scope);
-      }
-      async revoke(toolName) {
-        this.approvals.delete(toolName);
-      }
-      async clear() {
-        this.approvals.clear();
-      }
-      async dispose() {
-        this.approvals.clear();
-      }
-    };
-    FilePermissionStore = class {
-      filePath;
-      constructor(filePath) {
-        this.filePath = path.resolve(filePath);
-      }
-      async isApproved(toolName) {
-        const data = this.readFile();
-        return toolName in data.approvals;
-      }
-      async approve(toolName, scope) {
-        if (scope === "once") return;
-        const data = this.readFile();
-        data.approvals[toolName] = { scope, timestamp: Date.now() };
-        this.writeFileAtomic(data);
-      }
-      async revoke(toolName) {
-        const data = this.readFile();
-        delete data.approvals[toolName];
-        this.writeFileAtomic(data);
-      }
-      async clear() {
-        this.writeFileAtomic({ approvals: {} });
-      }
-      async dispose() {
-      }
-      readFile() {
-        try {
-          const raw = fs.readFileSync(this.filePath, "utf-8");
-          const parsed = JSON.parse(raw);
-          if (parsed && typeof parsed.approvals === "object") return parsed;
-        } catch {
-        }
-        return { approvals: {} };
-      }
-      writeFileAtomic(data) {
-        const dir = path.dirname(this.filePath);
-        fs.mkdirSync(dir, { recursive: true });
-        const tmpPath = this.filePath + `.tmp.${process.pid}.${Date.now()}`;
-        fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2), "utf-8");
-        fs.renameSync(tmpPath, this.filePath);
-      }
-    };
-    CompositePermissionStore = class {
-      sessionStore;
-      projectStore;
-      userStore;
-      constructor(sessionStore, projectStore, userStore) {
-        this.sessionStore = sessionStore;
-        this.projectStore = projectStore;
-        this.userStore = userStore ?? projectStore;
-      }
-      async isApproved(toolName) {
-        return await this.sessionStore.isApproved(toolName) || await this.projectStore.isApproved(toolName) || await this.userStore.isApproved(toolName);
-      }
-      async approve(toolName, scope) {
-        if (scope === "once") return;
-        if (scope === "session") {
-          await this.sessionStore.approve(toolName, scope);
-        } else if (scope === "project") {
-          await this.projectStore.approve(toolName, scope);
-        } else {
-          await this.userStore.approve(toolName, scope);
-        }
-      }
-      async revoke(toolName) {
-        await this.sessionStore.revoke(toolName);
-        await this.projectStore.revoke(toolName);
-        await this.userStore.revoke(toolName);
-      }
-      async clear() {
-        await this.sessionStore.clear();
-        await this.projectStore.clear();
-        await this.userStore.clear();
-      }
-      async dispose() {
-        await this.sessionStore.dispose();
-        await this.projectStore.dispose();
-        if (this.userStore !== this.projectStore) {
-          await this.userStore.dispose();
-        }
-      }
-    };
-  }
-});
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  AbortError: () => AbortError,
-  AgentSDKError: () => AgentSDKError,
-  BackendAlreadyRegisteredError: () => BackendAlreadyRegisteredError,
-  BackendNotFoundError: () => BackendNotFoundError,
-  BaseAgent: () => BaseAgent,
-  CompositePermissionStore: () => CompositePermissionStore,
-  DependencyError: () => DependencyError,
-  DisposedError: () => DisposedError,
-  FilePermissionStore: () => FilePermissionStore,
-  InMemoryPermissionStore: () => InMemoryPermissionStore,
-  ReentrancyError: () => ReentrancyError,
-  StructuredOutputError: () => StructuredOutputError,
-  SubprocessError: () => SubprocessError,
-  ToolExecutionError: () => ToolExecutionError,
-  buildSystemPrompt: () => buildSystemPrompt,
-  contentToText: () => contentToText,
-  createAgentService: () => createAgentService,
-  createDefaultPermissionStore: () => createDefaultPermissionStore,
-  getTextContent: () => getTextContent,
-  hasBackend: () => hasBackend,
-  isMultiPartContent: () => isMultiPartContent,
-  isTextContent: () => isTextContent,
-  isToolDefinition: () => isToolDefinition,
-  listBackends: () => listBackends,
-  messagesToPrompt: () => messagesToPrompt,
-  registerBackend: () => registerBackend,
-  resetRegistry: () => resetRegistry,
-  unregisterBackend: () => unregisterBackend,
-  zodToJsonSchema: () => zodToJsonSchema
-});
-var init_src = __esm({
-  "src/index.ts"() {
-    init_types();
-    init_errors();
-    init_registry();
-    init_base_agent();
-    init_schema();
-    init_messages();
-    init_permission_store();
-  }
-});
 
-// src/chat/core.ts
+// 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":
@@ -2900,6 +2871,7 @@ function agentEventToChatEvent(event, messageId) {
         type: "error",
         error: event.error,
         recoverable: event.recoverable,
+        code: event.code,
         messageId
       };
     case "heartbeat":
@@ -2907,8 +2879,9 @@ function agentEventToChatEvent(event, messageId) {
     case "ask_user":
     case "ask_user_response":
     case "session_info":
-    case "done":
       return null;
+    case "done":
+      return { type: "done", finalOutput: event.finalOutput ?? void 0, finishReason: event.finishReason };
     default:
       return null;
   }
@@ -2921,26 +2894,42 @@ async function* adaptAgentEvents(events, messageId) {
     }
   }
 }
-function toAgentMessage(message) {
+
+// src/chat/conversion.ts
+function toAgentMessages(message) {
   const textContent = getMessageText(message);
   const toolCallParts = getMessageToolCalls(message);
   switch (message.role) {
     case "user":
-      return { role: "user", content: textContent };
+      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 {
+      const assistantMsg = {
         role: "assistant",
         content: textContent,
         toolCalls
       };
+      const toolResults = extractToolResults(message);
+      if (toolResults.length > 0) {
+        return [assistantMsg, { role: "tool", toolResults }];
+      }
+      return [assistantMsg];
     }
     case "system":
-      return { role: "system", content: textContent };
+      return [{ role: "system", content: textContent }];
   }
 }
+function extractToolResults(message) {
+  return getMessageToolCalls(message).filter((p) => p.result !== void 0).map((p) => ({
+    toolCallId: p.toolCallId,
+    name: p.name,
+    result: p.result,
+    isError: p.status === "error" ? true : void 0
+  }));
+}
 
 // src/chat/errors.ts
+init_errors2();
 init_errors();
 var ChatError = class extends AgentSDKError {
   code;
@@ -2948,7 +2937,11 @@ var ChatError = class extends AgentSDKError {
   retryAfter;
   timestamp;
   constructor(message, options) {
-    super(message, { cause: options.cause });
+    super(message, {
+      cause: options.cause,
+      code: options.code,
+      retryable: options.retryable
+    });
     this.name = "ChatError";
     this.code = options.code;
     this.retryable = options.retryable ?? false;
@@ -2960,25 +2953,51 @@ var ChatError = class extends AgentSDKError {
 // src/chat/backends/base.ts
 var BaseBackendAdapter = class {
   name;
-  _agentService;
-  _agent = null;
+  _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);
@@ -3006,7 +3025,7 @@ var BaseBackendAdapter = class {
   async *streamMessage(session, message, options) {
     this.assertNotDisposed();
     const agent = this.getOrCreateAgent(options);
-    const messages = session.messages.map(toAgentMessage);
+    const messages = session.messages.flatMap(toAgentMessages);
     messages.push({ role: "user", content: message });
     yield* this.streamAgentEvents(agent, messages, options);
   }
@@ -3016,9 +3035,13 @@ var BaseBackendAdapter = class {
    */
   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
+      context: options?.context,
+      tools: options?.tools,
+      ...options?.systemPrompt ? { systemMessage: options.systemPrompt } : {}
     });
     yield { type: "message:start", messageId, role: "assistant" };
     let text = "";
@@ -3044,31 +3067,46 @@ var BaseBackendAdapter = class {
   }
   async listModels() {
     this.assertNotDisposed();
-    return this._agentService.listModels();
+    return this.agentService.listModels();
   }
   async validate() {
     this.assertNotDisposed();
-    return this._agentService.validate();
+    return this.agentService.validate();
   }
   async dispose() {
     if (this._disposed) return;
     this._disposed = true;
-    this._agent?.dispose();
-    this._agent = null;
-    if (this._ownsService) {
+    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, applying model override from options */
+  /** 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 config = options?.model ? { ...this._agentConfig, model: options.model } : this._agentConfig;
-    if (this._agentConfig.sessionMode === "persistent" && this._agent) {
-      return this._agent;
-    }
-    const agent = this._agentService.createAgent(config);
-    if (this._agentConfig.sessionMode === "persistent") {
-      this._agent = agent;
-    }
+    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 },
+      ...options?.tools?.length ? { tools: options.tools } : {}
+    };
+    const agent = this.agentService.createAgent(config);
+    this._currentAgent = { instance: agent, model };
     return agent;
   }
   assertNotDisposed() {
@@ -3080,21 +3118,15 @@ var BaseBackendAdapter = class {
   }
 };
 
-// src/chat/backends/copilot.ts
-var CopilotChatAdapter = class extends BaseBackendAdapter {
+// src/chat/backends/resumable.ts
+var ResumableChatAdapter = class extends BaseBackendAdapter {
   _backendSessionId = null;
-  _copilotOptions;
-  constructor(options) {
+  constructor(name, options) {
     const agentConfig = {
       ...options.agentConfig,
       sessionMode: "persistent"
     };
-    super("copilot", { ...options, agentConfig });
-    this._copilotOptions = options.copilotOptions;
-  }
-  createService() {
-    const { createAgentService: createAgentService2 } = (init_src(), __toCommonJS(src_exports));
-    return createAgentService2("copilot", this._copilotOptions);
+    super(name, { ...options, agentConfig });
   }
   get backendSessionId() {
     return this._backendSessionId;
@@ -3123,7 +3155,7 @@ var CopilotChatAdapter = class extends BaseBackendAdapter {
         { code: "SESSION_EXPIRED" /* SESSION_EXPIRED */ }
       );
     }
-    const messages = session.messages.map(toAgentMessage);
+    const messages = session.messages.flatMap(toAgentMessages);
     yield* this.streamAgentEvents(agent, messages, options);
   }
   captureSessionId(agent) {
@@ -3133,81 +3165,325 @@ var CopilotChatAdapter = class extends BaseBackendAdapter {
   }
 };
 
+// src/chat/backends/copilot.ts
+var CopilotChatAdapter = class extends ResumableChatAdapter {
+  _copilotOptions;
+  constructor(options) {
+    super("copilot", options);
+    this._copilotOptions = options.copilotOptions;
+  }
+  createService() {
+    const { createCopilotService: createCopilotService2 } = (init_copilot(), __toCommonJS(copilot_exports));
+    return createCopilotService2(this._copilotOptions || {});
+  }
+};
+
 // src/chat/backends/claude.ts
-var ClaudeChatAdapter = class extends BaseBackendAdapter {
-  _backendSessionId = null;
+var ClaudeChatAdapter = class extends ResumableChatAdapter {
   _claudeOptions;
   constructor(options) {
-    const agentConfig = {
-      ...options.agentConfig,
-      sessionMode: "persistent"
-    };
-    super("claude", { ...options, agentConfig });
+    super("claude", options);
     this._claudeOptions = options.claudeOptions;
   }
   createService() {
-    const { createAgentService: createAgentService2 } = (init_src(), __toCommonJS(src_exports));
-    return createAgentService2("claude", this._claudeOptions);
+    const { createClaudeService: createClaudeService2 } = (init_claude(), __toCommonJS(claude_exports));
+    return createClaudeService2(this._claudeOptions || {});
   }
-  get backendSessionId() {
-    return this._backendSessionId;
+};
+
+// src/chat/backends/vercel-ai.ts
+var VercelAIChatAdapter = class extends BaseBackendAdapter {
+  _vercelOptions;
+  constructor(options) {
+    super("vercel-ai", options);
+    this._vercelOptions = options.vercelOptions;
   }
-  canResume() {
-    return this._backendSessionId !== null;
+  createService() {
+    const { createVercelAIService: createVercelAIService2 } = (init_vercel_ai(), __toCommonJS(vercel_ai_exports));
+    return createVercelAIService2(this._vercelOptions || {});
   }
-  async *resume(session, backendSessionId, options) {
-    this.assertNotDisposed();
-    if (!backendSessionId) {
-      throw new ChatError("Backend session ID is required for resume", {
-        code: "INVALID_INPUT" /* INVALID_INPUT */
+  captureSessionId(_agent) {
+  }
+};
+
+// src/backends/mock-llm.ts
+init_base_agent();
+init_errors2();
+function extractPrompt(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role === "user") {
+      return typeof msg.content === "string" ? msg.content : msg.content.filter((p) => p.type === "text").map((p) => p.text).join("");
+    }
+  }
+  return "";
+}
+function resolveResponse(mode, messages, callIndex) {
+  switch (mode.type) {
+    case "echo":
+      return extractPrompt(messages);
+    case "static":
+      return mode.response;
+    case "scripted": {
+      if (mode.loop) {
+        return mode.responses[callIndex % mode.responses.length];
+      }
+      if (callIndex < mode.responses.length) {
+        return mode.responses[callIndex];
+      }
+      return mode.responses[mode.responses.length - 1];
+    }
+    case "error":
+      throw new AgentSDKError(mode.error, {
+        code: mode.code ?? "backend_error",
+        retryable: mode.recoverable ?? false
       });
+  }
+}
+async function applyLatency(latency, signal) {
+  if (!latency) return;
+  const ms = latency.type === "fixed" ? latency.ms : latency.minMs + Math.random() * (latency.maxMs - latency.minMs);
+  if (ms <= 0) return;
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new Error("aborted"));
+    };
+    if (signal.aborted) {
+      clearTimeout(timer);
+      reject(new Error("aborted"));
+      return;
     }
-    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 */ }
-      );
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function chunkText(text, streaming) {
+  if (streaming?.chunkSize && streaming.chunkSize > 0) {
+    const chunks = [];
+    for (let i = 0; i < text.length; i += streaming.chunkSize) {
+      chunks.push(text.slice(i, i + streaming.chunkSize));
     }
-    if (currentSessionId !== backendSessionId) {
-      throw new ChatError(
-        `Session expired: expected ${backendSessionId}, got ${currentSessionId}`,
-        { code: "SESSION_EXPIRED" /* SESSION_EXPIRED */ }
-      );
+    return chunks;
+  }
+  return text.split(/(\s+)/).filter(Boolean);
+}
+async function chunkDelay(streaming, signal) {
+  const ms = streaming?.chunkDelayMs;
+  if (!ms || ms <= 0) return;
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new Error("aborted"));
+    };
+    if (signal.aborted) {
+      clearTimeout(timer);
+      reject(new Error("aborted"));
+      return;
     }
-    const messages = session.messages.map(toAgentMessage);
-    yield* this.streamAgentEvents(agent, messages, options);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var MockLLMAgent = class extends BaseAgent {
+  backendName = "mock-llm";
+  mode;
+  latency;
+  streaming;
+  finishReason;
+  permissions;
+  toolCallConfigs;
+  configuredStructuredOutput;
+  callIndex = 0;
+  constructor(config, options) {
+    super(config);
+    this.mode = options.mode ?? { type: "echo" };
+    this.latency = options.latency;
+    this.streaming = options.streaming;
+    this.finishReason = options.finishReason ?? "stop";
+    this.permissions = options.permissions;
+    this.toolCallConfigs = options.toolCalls ?? [];
+    this.configuredStructuredOutput = options.structuredOutput;
+  }
+  async executeRun(messages, _options, signal) {
+    this.checkAbort(signal);
+    await applyLatency(this.latency, signal);
+    this.checkAbort(signal);
+    const idx = this.callIndex++;
+    const output = resolveResponse(this.mode, messages, idx);
+    const toolCalls = this.toolCallConfigs.map((tc) => ({
+      toolName: tc.toolName,
+      args: tc.args ?? {},
+      result: tc.result ?? null,
+      approved: true
+    }));
+    return {
+      output,
+      structuredOutput: void 0,
+      toolCalls,
+      messages: [
+        ...messages,
+        { role: "assistant", content: output }
+      ],
+      usage: { promptTokens: 10, completionTokens: output.length }
+    };
   }
-  captureSessionId(agent) {
-    if (agent.sessionId) {
-      this._backendSessionId = agent.sessionId;
+  async executeRunStructured(messages, _schema, _options, signal) {
+    this.checkAbort(signal);
+    await applyLatency(this.latency, signal);
+    this.checkAbort(signal);
+    const idx = this.callIndex++;
+    const output = resolveResponse(this.mode, messages, idx);
+    let parsed;
+    if (this.configuredStructuredOutput !== void 0) {
+      parsed = this.configuredStructuredOutput;
+    } else {
+      try {
+        parsed = JSON.parse(output);
+      } catch {
+        parsed = output;
+      }
+    }
+    return {
+      output,
+      structuredOutput: parsed,
+      toolCalls: [],
+      messages: [
+        ...messages,
+        { role: "assistant", content: output }
+      ],
+      usage: { promptTokens: 10, completionTokens: output.length }
+    };
+  }
+  async *executeStream(messages, _options, signal) {
+    this.checkAbort(signal);
+    await applyLatency(this.latency, signal);
+    this.checkAbort(signal);
+    if (this.permissions) {
+      yield* this.simulatePermissions(signal);
+    }
+    if (this.toolCallConfigs.length > 0) {
+      yield* this.simulateToolCalls(signal);
+    }
+    const idx = this.callIndex++;
+    const output = resolveResponse(this.mode, messages, idx);
+    const chunks = chunkText(output, this.streaming);
+    for (let i = 0; i < chunks.length; i++) {
+      this.checkAbort(signal);
+      if (i > 0) {
+        await chunkDelay(this.streaming, signal);
+      }
+      yield { type: "text_delta", text: chunks[i] };
+    }
+    yield {
+      type: "usage_update",
+      promptTokens: 10,
+      completionTokens: output.length
+    };
+    yield {
+      type: "done",
+      finalOutput: output,
+      finishReason: this.finishReason
+    };
+  }
+  async *simulateToolCalls(signal) {
+    for (let i = 0; i < this.toolCallConfigs.length; i++) {
+      this.checkAbort(signal);
+      const tc = this.toolCallConfigs[i];
+      const toolCallId = tc.toolCallId ?? `mock-tc-${i}`;
+      yield {
+        type: "tool_call_start",
+        toolCallId,
+        toolName: tc.toolName,
+        args: tc.args ?? {}
+      };
+      yield {
+        type: "tool_call_end",
+        toolCallId,
+        toolName: tc.toolName,
+        result: tc.result ?? null
+      };
+    }
+  }
+  async *simulatePermissions(signal) {
+    const perms = this.permissions;
+    for (const toolName of perms.toolNames) {
+      this.checkAbort(signal);
+      const request = {
+        toolName,
+        toolArgs: {}
+      };
+      yield { type: "permission_request", request };
+      if (perms.denyTools?.includes(toolName)) {
+        yield {
+          type: "permission_response",
+          toolName,
+          decision: { allowed: false, reason: "Denied by mock configuration" }
+        };
+      } else if (perms.autoApprove) {
+        yield {
+          type: "permission_response",
+          toolName,
+          decision: { allowed: true, scope: "once" }
+        };
+      } else {
+        const supervisor = this.getConfig().supervisor;
+        if (supervisor?.onPermission) {
+          const decision = await supervisor.onPermission(request, signal);
+          yield { type: "permission_response", toolName, decision };
+        } else {
+          yield {
+            type: "permission_response",
+            toolName,
+            decision: { allowed: true, scope: "once" }
+          };
+        }
+      }
     }
   }
 };
-
-// src/chat/backends/vercel-ai.ts
-var VercelAIChatAdapter = class extends BaseBackendAdapter {
-  _vercelOptions;
-  constructor(options) {
-    super("vercel-ai", options);
-    this._vercelOptions = options.vercelOptions;
+var MockLLMService = class {
+  name = "mock-llm";
+  options;
+  models;
+  constructor(options = {}) {
+    this.options = options;
+    this.models = (options.models ?? [
+      { id: "mock-fast", name: "Mock Fast" },
+      { id: "mock-quality", name: "Mock Quality" }
+    ]).map((m) => ({
+      id: m.id,
+      name: m.name,
+      description: m.description
+    }));
+  }
+  createAgent(config) {
+    return new MockLLMAgent(config, this.options);
   }
-  createService() {
-    const { createAgentService: createAgentService2 } = (init_src(), __toCommonJS(src_exports));
-    return createAgentService2("vercel-ai", this._vercelOptions);
+  async listModels() {
+    return this.models;
   }
-  get backendSessionId() {
-    return null;
+  async validate() {
+    return { valid: true, errors: [] };
   }
-  canResume() {
-    return false;
+  async dispose() {
   }
-  async *resume(_session, _backendSessionId, _options) {
-    throw new ChatError(
-      "Vercel AI adapter does not support session resume (stateless)",
-      { code: "PROVIDER_ERROR" /* PROVIDER_ERROR */ }
-    );
+};
+function createMockLLMService(options = {}) {
+  return new MockLLMService(options);
+}
+
+// src/chat/backends/mock-llm.ts
+var MockLLMChatAdapter = class extends BaseBackendAdapter {
+  constructor(options) {
+    const mockOpts = options.mockOptions;
+    super("mock-llm", {
+      ...options,
+      agentServiceFactory: () => createMockLLMService(mockOpts || {})
+    });
+  }
+  createService() {
+    return createMockLLMService({});
   }
   captureSessionId(_agent) {
   }
@@ -3288,16 +3564,22 @@ var SSEChatTransport = class {
 };
 async function streamToTransport(events, transport) {
   try {
-    let accumulatedText = "";
+    const textChunks = [];
+    let finishReason;
     for await (const event of events) {
       if (!transport.isOpen) break;
+      if (event.type === "done") {
+        finishReason = event.finishReason;
+        continue;
+      }
       transport.send(event);
       if (event.type === "message:delta") {
-        accumulatedText += event.text;
+        textChunks.push(event.text);
       }
     }
     if (transport.isOpen) {
-      transport.send({ type: "done", finalOutput: accumulatedText || void 0 });
+      const finalOutput = textChunks.length > 0 ? textChunks.join("") : void 0;
+      transport.send({ type: "done", finalOutput, finishReason });
     }
     transport.close();
   } catch (err) {
@@ -3388,9 +3670,9 @@ var InProcessChatTransport = class {
   send(event) {
     if (!this._open) return;
     if (this._resolve) {
-      const resolve2 = this._resolve;
+      const resolve = this._resolve;
       this._resolve = null;
-      resolve2({ value: event, done: false });
+      resolve({ value: event, done: false });
     } else {
       this._buffer.push(event);
     }
@@ -3399,9 +3681,9 @@ var InProcessChatTransport = class {
     if (!this._open) return;
     this._open = false;
     if (this._resolve) {
-      const resolve2 = this._resolve;
+      const resolve = this._resolve;
       this._resolve = null;
-      resolve2({ value: void 0, done: true });
+      resolve({ value: void 0, done: true });
     }
   }
   error(err) {
@@ -3413,9 +3695,9 @@ var InProcessChatTransport = class {
       recoverable: false
     };
     if (this._resolve) {
-      const resolve2 = this._resolve;
+      const resolve = this._resolve;
       this._resolve = null;
-      resolve2({ value: errorEvent, done: false });
+      resolve({ value: errorEvent, done: false });
     } else {
       this._error = err;
     }
@@ -3440,8 +3722,8 @@ var InProcessChatTransport = class {
         if (!this._open) {
           return Promise.resolve({ value: void 0, done: true });
         }
-        return new Promise((resolve2) => {
-          this._resolve = resolve2;
+        return new Promise((resolve) => {
+          this._resolve = resolve;
         });
       }
     };
@@ -3496,6 +3778,6 @@ function withInterceptors(transport, interceptors) {
   return new InterceptedTransport(transport, interceptors);
 }
 
-export { BaseBackendAdapter, ClaudeChatAdapter, CopilotChatAdapter, InProcessChatTransport, SSEChatTransport, VercelAIChatAdapter, WS_READY_STATE, WsChatTransport, streamToTransport, withInterceptors };
+export { BaseBackendAdapter, ClaudeChatAdapter, CopilotChatAdapter, InProcessChatTransport, MockLLMChatAdapter, ResumableChatAdapter, SSEChatTransport, VercelAIChatAdapter, WS_READY_STATE, WsChatTransport, isResumableBackend, streamToTransport, withInterceptors };
 //# sourceMappingURL=backends.js.map
 //# sourceMappingURL=backends.js.map