@witqq/agent-sdk 0.7.0 → 0.8.0

package/dist/chat/backends.cjs

@@ -1,31 +1,5 @@
 'use strict';
 
-var fs = require('fs');
-var path = require('path');
-var os = require('os');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var os__namespace = /*#__PURE__*/_interopNamespace(os);
-
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -47,16 +21,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) {
@@ -65,83 +92,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();
   }
 });
 
@@ -149,12 +177,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;
@@ -170,8 +201,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();
@@ -183,8 +217,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();
@@ -197,13 +234,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();
@@ -216,8 +251,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();
         }
@@ -228,12 +265,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();
@@ -256,26 +318,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);
@@ -311,9 +456,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 {
@@ -321,8 +466,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 })
@@ -345,6 +490,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") {
@@ -449,6 +623,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, {
@@ -457,10 +691,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"
@@ -468,10 +701,10 @@ async function loadSDK() {
   }
 }
 function _injectSDK(mock) {
-  sdkModule = mock;
+  _sdkMock = mock;
 }
 function _resetSDK() {
-  sdkModule = null;
+  _sdkMock = null;
 }
 function mapToolsToSDK(tools) {
   return tools.map((tool) => ({
@@ -516,6 +749,7 @@ function buildPermissionHandler(config) {
     const unifiedRequest = {
       toolName,
       toolArgs: { ...request },
+      toolCallId: request.toolCallId,
       rawSDKRequest: request
     };
     const ac = new AbortController();
@@ -620,15 +854,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];
@@ -639,66 +879,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);
@@ -710,14 +897,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) {
@@ -765,6 +953,7 @@ var init_copilot = __esm({
       isPersistent;
       persistentSession = null;
       _sessionId;
+      _persistentModel;
       activeSession = null;
       _resumeSessionId;
       _toolsReady = null;
@@ -815,47 +1004,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();
@@ -952,9 +1157,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);
@@ -971,8 +1176,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);
@@ -1100,7 +1305,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() {
@@ -1153,10 +1361,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"
@@ -1164,13 +1371,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);
@@ -1194,6 +1420,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",
@@ -1243,6 +1502,7 @@ function buildCanUseTool(config) {
     const unifiedRequest = {
       toolName,
       toolArgs: input,
+      toolCallId: options.toolUseID,
       suggestedScope: extractSuggestedScope(options.suggestions),
       rawSDKRequest: { toolName, input, ...options }
     };
@@ -1295,6 +1555,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);
           }
@@ -1318,6 +1579,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) {
@@ -1371,10 +1633,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;
@@ -1383,72 +1648,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 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";
@@ -1493,11 +1707,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;
@@ -1521,12 +1730,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,
@@ -1556,25 +1765,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 });
@@ -1584,30 +1853,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;
@@ -1627,41 +1874,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;
@@ -1678,23 +1897,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;
@@ -1713,12 +1926,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);
@@ -1734,30 +1947,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;
@@ -1792,46 +1983,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;
@@ -1863,23 +2031,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;
@@ -1898,12 +2060,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 });
@@ -1911,6 +2073,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();
@@ -1928,6 +2091,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;
               }
             }
@@ -1951,22 +2115,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();
@@ -1984,6 +2147,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;
                   }
                 }
@@ -2007,7 +2171,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) {
@@ -2069,7 +2237,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;
       }
@@ -2127,32 +2296,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 = {};
@@ -2195,13 +2362,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,
@@ -2308,7 +2476,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":
@@ -2329,10 +2498,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:
@@ -2342,15 +2514,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;
@@ -2363,28 +2535,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;
@@ -2440,10 +2617,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({
@@ -2485,11 +2662,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;
@@ -2535,9 +2712,11 @@ 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 } : {}
           };
         } catch (e) {
           if (signal.aborted) throw new AbortError();
@@ -2566,16 +2745,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 }
+            }));
+          }
+          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 body.data.map((m) => ({ id: m.id }));
+          return [];
         } catch {
           return [];
         }
@@ -2606,272 +2802,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);
+// src/chat/backends/types.ts
+function isResumableBackend(adapter) {
+  return "canResume" in adapter && typeof adapter.canResume === "function";
 }
-function hasBackend(name) {
-  return registry.has(name) || isBuiltinName(name);
-}
-function listBackends() {
-  const names = new Set(registry.keys());
-  for (const builtin of BUILTIN_BACKENDS) {
-    names.add(builtin);
-  }
-  return [...names];
-}
-function resetRegistry() {
-  registry.clear();
-}
-function isBuiltinName(name) {
-  return BUILTIN_BACKENDS.has(name);
-}
-async function loadBuiltinFactory(name) {
-  switch (name) {
-    case "copilot": {
-      const mod = await Promise.resolve().then(() => (init_copilot(), copilot_exports));
-      return (opts) => mod.createCopilotService(opts);
-    }
-    case "claude": {
-      const mod = await Promise.resolve().then(() => (init_claude(), claude_exports));
-      return (opts) => mod.createClaudeService(opts);
-    }
-    case "vercel-ai": {
-      const mod = await Promise.resolve().then(() => (init_vercel_ai(), vercel_ai_exports));
-      return (opts) => mod.createVercelAIService(opts);
-    }
-  }
-}
-async function createAgentService(name, options) {
-  const entry = registry.get(name);
-  if (entry) {
-    return entry.factory(options);
-  }
-  if (isBuiltinName(name)) {
-    const factory = await loadBuiltinFactory(name);
-    registry.set(name, { factory, builtin: true });
-    return factory(options);
-  }
-  throw new BackendNotFoundError(name);
-}
-var registry, BUILTIN_BACKENDS;
-var init_registry = __esm({
-  "src/registry.ts"() {
-    init_errors();
-    registry = /* @__PURE__ */ new Map();
-    BUILTIN_BACKENDS = /* @__PURE__ */ new Set([
-      "copilot",
-      "claude",
-      "vercel-ai"
-    ]);
-  }
-});
-
-// src/utils/messages.ts
-function messagesToPrompt(messages) {
-  return messages.map((msg) => {
-    switch (msg.role) {
-      case "user":
-        return contentToText(msg.content);
-      case "assistant":
-        return contentToText(msg.content);
-      case "system":
-        return msg.content;
-      case "tool":
-        return msg.content ?? "";
-    }
-  }).filter(Boolean).join("\n\n");
-}
-function contentToText(content) {
-  return getTextContent(content);
-}
-function buildSystemPrompt(base, schemaInstruction) {
-  if (!schemaInstruction) return base;
-  return `${base}
 
-${schemaInstruction}`;
-}
-var init_messages = __esm({
-  "src/utils/messages.ts"() {
-    init_types();
-  }
-});
-function createDefaultPermissionStore(projectDir) {
-  const sessionStore = new InMemoryPermissionStore();
-  const projectPath = projectDir ? path__namespace.join(projectDir, ".agent-sdk", "permissions.json") : path__namespace.join(process.cwd(), ".agent-sdk", "permissions.json");
-  const userPath = path__namespace.join(os__namespace.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__namespace.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__namespace.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__namespace.dirname(this.filePath);
-        fs__namespace.mkdirSync(dir, { recursive: true });
-        const tmpPath = this.filePath + `.tmp.${process.pid}.${Date.now()}`;
-        fs__namespace.writeFileSync(tmpPath, JSON.stringify(data, null, 2), "utf-8");
-        fs__namespace.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":
@@ -2924,6 +2873,7 @@ function agentEventToChatEvent(event, messageId) {
         type: "error",
         error: event.error,
         recoverable: event.recoverable,
+        code: event.code,
         messageId
       };
     case "heartbeat":
@@ -2945,6 +2895,8 @@ async function* adaptAgentEvents(events, messageId) {
     }
   }
 }
+
+// src/chat/conversion.ts
 function toAgentMessage(message) {
   const textContent = getMessageText(message);
   const toolCallParts = getMessageToolCalls(message);
@@ -2965,6 +2917,7 @@ function toAgentMessage(message) {
 }
 
 // src/chat/errors.ts
+init_errors2();
 init_errors();
 var ChatError = class extends AgentSDKError {
   code;
@@ -2972,7 +2925,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;
@@ -2984,25 +2941,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);
@@ -3040,9 +3023,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 = "";
@@ -3068,31 +3055,45 @@ 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 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;
     }
-    const agent = this._agentService.createAgent(config);
-    if (this._agentConfig.sessionMode === "persistent") {
-      this._agent = agent;
+    if (this._currentAgent) {
+      this._currentAgent.instance.dispose();
+      this._currentAgent = null;
     }
+    const config = {
+      ...this._agentConfig,
+      ...model !== void 0 && { model }
+    };
+    const agent = this.agentService.createAgent(config);
+    this._currentAgent = { instance: agent, model };
     return agent;
   }
   assertNotDisposed() {
@@ -3117,8 +3118,8 @@ var CopilotChatAdapter = class extends BaseBackendAdapter {
     this._copilotOptions = options.copilotOptions;
   }
   createService() {
-    const { createAgentService: createAgentService2 } = (init_src(), __toCommonJS(src_exports));
-    return createAgentService2("copilot", this._copilotOptions);
+    const { createCopilotService: createCopilotService2 } = (init_copilot(), __toCommonJS(copilot_exports));
+    return createCopilotService2(this._copilotOptions || {});
   }
   get backendSessionId() {
     return this._backendSessionId;
@@ -3170,8 +3171,8 @@ var ClaudeChatAdapter = class extends BaseBackendAdapter {
     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;
@@ -3218,20 +3219,8 @@ var VercelAIChatAdapter = class extends BaseBackendAdapter {
     this._vercelOptions = options.vercelOptions;
   }
   createService() {
-    const { createAgentService: createAgentService2 } = (init_src(), __toCommonJS(src_exports));
-    return createAgentService2("vercel-ai", this._vercelOptions);
-  }
-  get backendSessionId() {
-    return null;
-  }
-  canResume() {
-    return false;
-  }
-  async *resume(_session, _backendSessionId, _options) {
-    throw new ChatError(
-      "Vercel AI adapter does not support session resume (stateless)",
-      { code: "PROVIDER_ERROR" /* PROVIDER_ERROR */ }
-    );
+    const { createVercelAIService: createVercelAIService2 } = (init_vercel_ai(), __toCommonJS(vercel_ai_exports));
+    return createVercelAIService2(this._vercelOptions || {});
   }
   captureSessionId(_agent) {
   }
@@ -3412,9 +3401,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);
     }
@@ -3423,9 +3412,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) {
@@ -3437,9 +3426,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;
     }
@@ -3464,8 +3453,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;
         });
       }
     };
@@ -3528,6 +3517,7 @@ exports.SSEChatTransport = SSEChatTransport;
 exports.VercelAIChatAdapter = VercelAIChatAdapter;
 exports.WS_READY_STATE = WS_READY_STATE;
 exports.WsChatTransport = WsChatTransport;
+exports.isResumableBackend = isResumableBackend;
 exports.streamToTransport = streamToTransport;
 exports.withInterceptors = withInterceptors;
 //# sourceMappingURL=backends.cjs.map