@witqq/agent-sdk 0.7.0 → 0.9.0

package/dist/chat/index.cjs

@@ -1,30 +1,8 @@
 'use strict';
 
 var fs = require('fs');
+var promises = require('fs/promises');
 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;
@@ -47,16 +25,100 @@ 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 */;
+}
+exports.ErrorCode = void 0; var RECOVERABLE_CODES;
 var init_errors = __esm({
+  "src/types/errors.ts"() {
+    exports.ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+      ErrorCode2["AUTH_EXPIRED"] = "AUTH_EXPIRED";
+      ErrorCode2["AUTH_INVALID"] = "AUTH_INVALID";
+      ErrorCode2["RATE_LIMIT"] = "RATE_LIMIT";
+      ErrorCode2["NETWORK"] = "NETWORK";
+      ErrorCode2["TIMEOUT"] = "TIMEOUT";
+      ErrorCode2["PROVIDER_ERROR"] = "PROVIDER_ERROR";
+      ErrorCode2["MODEL_NOT_FOUND"] = "MODEL_NOT_FOUND";
+      ErrorCode2["MODEL_OVERLOADED"] = "MODEL_OVERLOADED";
+      ErrorCode2["CONTEXT_OVERFLOW"] = "CONTEXT_OVERFLOW";
+      ErrorCode2["INVALID_INPUT"] = "INVALID_INPUT";
+      ErrorCode2["INVALID_RESPONSE"] = "INVALID_RESPONSE";
+      ErrorCode2["REENTRANCY"] = "REENTRANCY";
+      ErrorCode2["DISPOSED"] = "DISPOSED";
+      ErrorCode2["ABORTED"] = "ABORTED";
+      ErrorCode2["INVALID_TRANSITION"] = "INVALID_TRANSITION";
+      ErrorCode2["DEPENDENCY_MISSING"] = "DEPENDENCY_MISSING";
+      ErrorCode2["BACKEND_NOT_INSTALLED"] = "BACKEND_NOT_INSTALLED";
+      ErrorCode2["TOOL_EXECUTION"] = "TOOL_EXECUTION";
+      ErrorCode2["PERMISSION_DENIED"] = "PERMISSION_DENIED";
+      ErrorCode2["SESSION_NOT_FOUND"] = "SESSION_NOT_FOUND";
+      ErrorCode2["SESSION_EXPIRED"] = "SESSION_EXPIRED";
+      ErrorCode2["PROVIDER_NOT_FOUND"] = "PROVIDER_NOT_FOUND";
+      ErrorCode2["AUTH_REQUIRED"] = "AUTH_REQUIRED";
+      ErrorCode2["STORAGE_ERROR"] = "STORAGE_ERROR";
+      ErrorCode2["STORAGE_NOT_FOUND"] = "STORAGE_NOT_FOUND";
+      ErrorCode2["STORAGE_DUPLICATE_KEY"] = "STORAGE_DUPLICATE_KEY";
+      ErrorCode2["STORAGE_IO_ERROR"] = "STORAGE_IO_ERROR";
+      ErrorCode2["STORAGE_SERIALIZATION_ERROR"] = "STORAGE_SERIALIZATION_ERROR";
+      return ErrorCode2;
+    })(exports.ErrorCode || {});
+    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 +127,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 +212,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 +236,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 +252,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 +269,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 +286,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 +300,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 +353,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 delay2 = initialDelay * Math.pow(multiplier, attempt);
+            await new Promise((resolve) => setTimeout(resolve, delay2));
+            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 delay2 = initialDelay * Math.pow(multiplier, attempt);
+            await new Promise((resolve) => setTimeout(resolve, delay2));
+            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 +491,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 +501,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 +525,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 +658,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 +726,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 +736,10 @@ async function loadSDK() {
   }
 }
 function _injectSDK(mock) {
-  sdkModule = mock;
+  _sdkMock = mock;
 }
 function _resetSDK() {
-  sdkModule = null;
+  _sdkMock = null;
 }
 function mapToolsToSDK(tools) {
   return tools.map((tool) => ({
@@ -491,17 +759,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) {
@@ -516,6 +773,7 @@ function buildPermissionHandler(config) {
     const unifiedRequest = {
       toolName,
       toolArgs: { ...request },
+      toolCallId: request.toolCallId,
       rawSDKRequest: request
     };
     const ac = new AbortController();
@@ -620,15 +878,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 +903,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 +921,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 +977,7 @@ var init_copilot = __esm({
       isPersistent;
       persistentSession = null;
       _sessionId;
+      _persistentModel;
       activeSession = null;
       _resumeSessionId;
       _toolsReady = null;
@@ -783,15 +996,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() {
@@ -815,47 +1028,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 +1181,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 +1200,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);
@@ -1066,7 +1295,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");
@@ -1100,7 +1333,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 +1389,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 +1399,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 +1448,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 +1530,7 @@ function buildCanUseTool(config) {
     const unifiedRequest = {
       toolName,
       toolArgs: input,
+      toolCallId: options.toolUseID,
       suggestedScope: extractSuggestedScope(options.suggestions),
       rawSDKRequest: { toolName, input, ...options }
     };
@@ -1295,6 +1583,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 +1607,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 +1661,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 +1676,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 createClaudeService(options) {
+  return new ClaudeAgentService(options);
 }
-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 +1735,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 +1758,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 +1793,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 +1881,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 +1902,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 +1925,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 +1954,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 +1975,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 +2011,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 +2059,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 +2088,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 +2101,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 +2119,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 +2143,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 +2175,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 +2199,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 +2265,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 +2324,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 +2390,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 +2504,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 +2526,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 +2542,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 +2563,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 +2645,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 +2690,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;
@@ -2514,6 +2719,7 @@ var init_vercel_ai = __esm({
           }
         });
         let finalText = "";
+        let lastFinishReason;
         try {
           for await (const part of result.fullStream) {
             if (signal.aborted) throw new AbortError();
@@ -2524,10 +2730,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 {
@@ -2535,9 +2746,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();
@@ -2566,16 +2780,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 [];
         }
@@ -2606,263 +2837,7 @@ 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);
-}
-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();
 }
@@ -2873,6 +2848,20 @@ function toChatId(value) {
   }
   return value;
 }
+function createTextMessage(text, role = "user") {
+  return {
+    id: createChatId(),
+    role,
+    parts: [{ type: "text", text, status: "complete" }],
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "complete"
+  };
+}
+function isObservableSession(session) {
+  return "subscribe" in session && typeof session.subscribe === "function" && "getSnapshot" in session && typeof session.getSnapshot === "function";
+}
+
+// src/chat/chat-utils.ts
 function getMessageText(message) {
   return message.parts.filter((p) => p.type === "text").map((p) => p.text).join("");
 }
@@ -2882,6 +2871,8 @@ function getMessageToolCalls(message) {
 function getMessageReasoning(message) {
   return message.parts.filter((p) => p.type === "reasoning").map((p) => p.text).join("");
 }
+
+// src/chat/guards.ts
 function isChatMessage(value) {
   if (typeof value !== "object" || value === null) return false;
   const obj = value;
@@ -2922,31 +2913,33 @@ function isFilePart(value) {
   const obj = value;
   return obj.type === "file" && typeof obj.name === "string" && typeof obj.mimeType === "string";
 }
+var VALID_CHAT_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "message:start",
+  "message:delta",
+  "message:complete",
+  "tool:start",
+  "tool:complete",
+  "thinking:start",
+  "thinking:delta",
+  "thinking:end",
+  "permission:request",
+  "permission:response",
+  "usage",
+  "session:created",
+  "session:updated",
+  "error",
+  "typing:start",
+  "typing:end",
+  "heartbeat",
+  "done"
+]);
 function isChatEvent(value) {
   if (typeof value !== "object" || value === null) return false;
   const obj = value;
-  const validTypes = [
-    "message:start",
-    "message:delta",
-    "message:complete",
-    "tool:start",
-    "tool:complete",
-    "thinking:start",
-    "thinking:delta",
-    "thinking:end",
-    "permission:request",
-    "permission:response",
-    "usage",
-    "session:created",
-    "session:updated",
-    "error",
-    "typing:start",
-    "typing:end",
-    "heartbeat",
-    "done"
-  ];
-  return validTypes.includes(obj.type);
+  return VALID_CHAT_EVENT_TYPES.has(obj.type);
 }
+
+// src/chat/bridge.ts
 function agentEventToChatEvent(event, messageId) {
   switch (event.type) {
     case "text_delta":
@@ -2999,6 +2992,7 @@ function agentEventToChatEvent(event, messageId) {
         type: "error",
         error: event.error,
         recoverable: event.recoverable,
+        code: event.code,
         messageId
       };
     case "heartbeat":
@@ -3006,8 +3000,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;
   }
@@ -3045,27 +3040,37 @@ function chatEventToAgentEvent(event) {
         result: event.result
       };
     case "error":
-      return { type: "error", error: event.error, recoverable: event.recoverable };
+      return { type: "error", error: event.error, recoverable: event.recoverable, code: event.code };
     default:
       return null;
   }
 }
+
+// src/chat/conversion.ts
 function toAgentMessage(message) {
+  return toAgentMessages(message)[0];
+}
+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 fromAgentMessage(message, id) {
@@ -3111,6 +3116,14 @@ function fromAgentMessage(message, id) {
     status: "complete"
   };
 }
+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/context.ts
 function estimateTokens(message, options) {
@@ -3220,6 +3233,56 @@ var ContextWindowManager = class {
     });
     return { ...result, messages: updatedMessages };
   }
+  /**
+   * Trim messages using real token usage data from the previous API call.
+   * Uses average-based algorithm: `avgTokensPerMessage = lastPromptTokens / messageCount`.
+   * Removes oldest non-system messages until freed budget brings usage under modelContextWindow.
+   *
+   * @param messages - All messages in the session
+   * @param lastPromptTokens - Real prompt tokens from the last API response
+   * @param modelContextWindow - Model's total context window size in tokens
+   * @returns Result with fitted messages and metadata
+   */
+  fitMessagesWithUsage(messages, lastPromptTokens, modelContextWindow) {
+    if (messages.length === 0) {
+      return { messages: [], totalTokens: 0, removedCount: 0, wasTruncated: false };
+    }
+    const budget = modelContextWindow - this.config.reservedTokens;
+    if (budget <= 0 || lastPromptTokens <= budget) {
+      return {
+        messages: [...messages],
+        totalTokens: lastPromptTokens,
+        removedCount: 0,
+        wasTruncated: false
+      };
+    }
+    const avgTokensPerMessage = lastPromptTokens / messages.length;
+    const tokensToFree = lastPromptTokens - budget;
+    const messagesToRemove = Math.ceil(tokensToFree / avgTokensPerMessage);
+    const nonSystemIndices = [];
+    for (let i = 0; i < messages.length; i++) {
+      if (messages[i].role === "system") ; else {
+        nonSystemIndices.push(i);
+      }
+    }
+    const removableCount = Math.min(messagesToRemove, nonSystemIndices.length);
+    const removedIndices = new Set(nonSystemIndices.slice(0, removableCount));
+    const result = [];
+    for (let i = 0; i < messages.length; i++) {
+      if (!removedIndices.has(i)) {
+        result.push(messages[i]);
+      }
+    }
+    const estimatedTokens = Math.round(
+      lastPromptTokens * (result.length / messages.length)
+    );
+    return {
+      messages: result,
+      totalTokens: estimatedTokens,
+      removedCount: removableCount,
+      wasTruncated: removableCount > 0
+    };
+  }
   /**
    * Truncate oldest: keeps system messages, removes oldest non-system messages first.
    * Always keeps the most recent user message.
@@ -3337,37 +3400,19 @@ var ContextWindowManager = class {
 };
 
 // src/chat/errors.ts
+init_errors2();
 init_errors();
-var ChatErrorCode = /* @__PURE__ */ ((ChatErrorCode2) => {
-  ChatErrorCode2["NETWORK"] = "NETWORK";
-  ChatErrorCode2["TIMEOUT"] = "TIMEOUT";
-  ChatErrorCode2["AUTH_EXPIRED"] = "AUTH_EXPIRED";
-  ChatErrorCode2["AUTH_INVALID"] = "AUTH_INVALID";
-  ChatErrorCode2["RATE_LIMIT"] = "RATE_LIMIT";
-  ChatErrorCode2["PROVIDER_ERROR"] = "PROVIDER_ERROR";
-  ChatErrorCode2["MODEL_NOT_FOUND"] = "MODEL_NOT_FOUND";
-  ChatErrorCode2["MODEL_OVERLOADED"] = "MODEL_OVERLOADED";
-  ChatErrorCode2["CONTEXT_OVERFLOW"] = "CONTEXT_OVERFLOW";
-  ChatErrorCode2["INVALID_INPUT"] = "INVALID_INPUT";
-  ChatErrorCode2["INVALID_RESPONSE"] = "INVALID_RESPONSE";
-  ChatErrorCode2["PERMISSION_DENIED"] = "PERMISSION_DENIED";
-  ChatErrorCode2["BACKEND_NOT_INSTALLED"] = "BACKEND_NOT_INSTALLED";
-  ChatErrorCode2["SESSION_NOT_FOUND"] = "SESSION_NOT_FOUND";
-  ChatErrorCode2["STORAGE_ERROR"] = "STORAGE_ERROR";
-  ChatErrorCode2["SESSION_EXPIRED"] = "SESSION_EXPIRED";
-  ChatErrorCode2["DISPOSED"] = "DISPOSED";
-  ChatErrorCode2["ABORTED"] = "ABORTED";
-  ChatErrorCode2["INVALID_TRANSITION"] = "INVALID_TRANSITION";
-  ChatErrorCode2["REENTRANCY"] = "REENTRANCY";
-  return ChatErrorCode2;
-})(ChatErrorCode || {});
 var ChatError = class extends AgentSDKError {
   code;
   retryable;
   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;
@@ -3546,12 +3591,12 @@ function isRetryable(error) {
   return classified.retryable;
 }
 function sleep(ms, signal) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     if (signal?.aborted) {
       reject(new ChatError("Retry aborted", { code: "ABORTED" /* ABORTED */ }));
       return;
     }
-    const timer = setTimeout(resolve2, ms);
+    const timer = setTimeout(resolve, ms);
     signal?.addEventListener(
       "abort",
       () => {
@@ -3875,33 +3920,65 @@ var CancellableTimeout = class {
   }
 };
 
-// src/chat/runtime.ts
-var ChatRuntime = class {
-  _state;
-  _guard;
-  _backends;
-  _sessionStore;
-  _contextConfig;
-  _middleware;
-  _tools = /* @__PURE__ */ new Map();
-  _retryConfig;
+// src/chat/listener-set.ts
+var ListenerSet = class {
+  _listeners = /* @__PURE__ */ new Set();
+  /** Add a listener. Returns an unsubscribe function. */
+  add(callback) {
+    this._listeners.add(callback);
+    return () => {
+      this._listeners.delete(callback);
+    };
+  }
+  /** Notify all listeners with the given arguments. Errors are isolated per listener. */
+  notify(...args) {
+    for (const cb of this._listeners) {
+      try {
+        cb(...args);
+      } catch {
+      }
+    }
+  }
+  /** Remove all listeners. */
+  clear() {
+    this._listeners.clear();
+  }
+  /** Current number of listeners. */
+  get size() {
+    return this._listeners.size;
+  }
+};
+
+// src/chat/runtime.ts
+var ChatRuntime = class {
+  _state;
+  _guard;
+  _backends;
+  _sessionStore;
+  _contextConfig;
+  _ctxManager;
+  _middleware;
+  _tools = /* @__PURE__ */ new Map();
+  _retryConfig;
   _contextStats = /* @__PURE__ */ new Map();
+  _sessionUsage = /* @__PURE__ */ new Map();
+  _modelContextWindows = /* @__PURE__ */ new Map();
   _onContextTrimmed;
   _streamTimeoutMs;
-  _sessionListeners = /* @__PURE__ */ new Set();
-  _activeAdapter = null;
-  _currentBackend;
-  _currentModel;
-  _activeSessionId = null;
+  _sessionListeners = new ListenerSet();
+  _adapterPool = /* @__PURE__ */ new Map();
+  _defaultBackend;
   _abortController = null;
   constructor(options) {
     this._state = new StateMachine("idle", RUNTIME_TRANSITIONS);
     this._guard = new ChatReentrancyGuard();
     this._backends = options.backends;
-    this._currentBackend = options.defaultBackend;
-    this._currentModel = options.defaultModel;
+    this._defaultBackend = options.defaultBackend;
     this._sessionStore = options.sessionStore;
     this._contextConfig = options.context;
+    if (this._contextConfig) {
+      this._ctxManager = new ContextWindowManager(this._contextConfig);
+    }
     this._middleware = [...options.middleware ?? []];
     this._retryConfig = options.retryConfig;
     this._onContextTrimmed = options.onContextTrimmed;
@@ -3912,6 +3989,11 @@ var ChatRuntime = class {
         { code: "INVALID_INPUT" /* INVALID_INPUT */ }
       );
     }
+    if (options.tools) {
+      for (const tool of options.tools) {
+        this._tools.set(tool.name, tool);
+      }
+    }
   }
   // ── Lifecycle ──────────────────────────────────────────────
   get status() {
@@ -3923,24 +4005,23 @@ var ChatRuntime = class {
     this._abortController?.dispose();
     this._abortController = null;
     this._state.transition("disposed");
-    if (this._activeAdapter) {
-      await this._activeAdapter.dispose();
-      this._activeAdapter = null;
+    for (const adapter of this._adapterPool.values()) {
+      try {
+        await adapter.dispose();
+      } catch {
+      }
     }
+    this._adapterPool.clear();
   }
   // ── Sessions ───────────────────────────────────────────────
-  get activeSessionId() {
-    return this._activeSessionId;
-  }
   async createSession(options) {
     this.assertNotDisposed();
     const config = {
-      model: options.config?.model ?? this._currentModel ?? "",
-      backend: options.config?.backend ?? this._currentBackend,
+      model: options.config?.model ?? "",
+      backend: options.config?.backend ?? this._defaultBackend,
       ...options.config
     };
     const session = await this._sessionStore.createSession({ ...options, config });
-    this._activeSessionId = session.id;
     this._notifySessionChange();
     return session;
   }
@@ -3960,36 +4041,12 @@ var ChatRuntime = class {
     if (!session) return;
     await this._sessionStore.deleteSession(cid);
     this._contextStats.delete(cid);
-    if (this._activeSessionId === cid) {
-      this._activeSessionId = null;
-    }
-    this._notifySessionChange();
-  }
-  async archiveSession(id) {
-    this.assertNotDisposed();
-    const cid = toChatId(id);
-    await this._sessionStore.archiveSession(cid);
+    this._sessionUsage.delete(cid);
     this._notifySessionChange();
   }
-  async switchSession(id) {
-    this.assertNotDisposed();
-    const cid = toChatId(id);
-    const session = await this._sessionStore.getSession(cid);
-    if (!session) {
-      throw new ChatError(
-        `Session "${id}" not found`,
-        { code: "SESSION_NOT_FOUND" /* SESSION_NOT_FOUND */ }
-      );
-    }
-    this._activeSessionId = session.id;
-    return session;
-  }
   // ── Messaging ──────────────────────────────────────────────
   async *send(sessionId, message, options) {
-    this.assertNotDisposed();
-    if (!message || message.trim().length === 0) {
-      throw new ChatError("Message cannot be empty", { code: "INVALID_INPUT" /* INVALID_INPUT */ });
-    }
+    this.validateSendInput(message, options);
     this._guard.acquire();
     const cid = toChatId(sessionId);
     this._abortController = new ChatAbortController(options?.signal);
@@ -3998,150 +4055,274 @@ var ChatRuntime = class {
         this._state.transition("idle");
       }
       this._state.transition("streaming");
-      const session = await this._sessionStore.getSession(cid);
-      if (!session) {
-        throw new ChatError(
-          `Session "${cid}" not found`,
-          { code: "SESSION_NOT_FOUND" /* SESSION_NOT_FOUND */ }
-        );
-      }
-      const middlewareContext = {
+      await this.loadSession(cid);
+      const mwCtx = {
         sessionId: cid,
         signal: this._abortController.signal
       };
-      let userMessage = this.createUserMessage(message);
-      for (const mw of this._middleware) {
-        if (mw.onBeforeSend) {
-          userMessage = await mw.onBeforeSend(userMessage, middlewareContext);
-        }
-      }
-      await this._sessionStore.appendMessage(cid, userMessage);
-      const updatedSession = await this._sessionStore.getSession(cid);
-      let messagesToSend = updatedSession.messages;
-      if (this._contextConfig) {
-        const ctxManager = new ContextWindowManager(this._contextConfig);
-        const result = await ctxManager.fitMessagesAsync(messagesToSend);
-        this._contextStats.set(cid, {
-          totalTokens: result.totalTokens,
-          removedCount: result.removedCount,
-          wasTruncated: result.wasTruncated,
-          availableBudget: ctxManager.availableBudget
-        });
-        if (result.wasTruncated && this._onContextTrimmed) {
-          const keptIds = new Set(result.messages.map((m) => m.id));
-          const removed = messagesToSend.filter((m) => !keptIds.has(m.id));
-          if (removed.length > 0) {
-            try {
-              this._onContextTrimmed(cid, removed);
-            } catch {
-            }
-          }
-        }
-        messagesToSend = result.messages;
+      const userMessage = await this.applyBeforeSendMiddleware(
+        this.createUserMessage(message),
+        mwCtx
+      );
+      if (userMessage === null) {
+        this._state.transition("idle");
+        return;
       }
-      const sessionForAdapter = {
-        ...updatedSession,
-        messages: messagesToSend
-      };
-      const adapter = await this.getOrCreateAdapterWithRetry();
+      const updatedSession = await this.persistAndReload(cid, userMessage);
+      const sessionForAdapter = await this.trimSessionContext(cid, updatedSession, options.model);
+      const stream = await this.prepareEventStream(
+        cid,
+        sessionForAdapter,
+        updatedSession,
+        message,
+        options
+      );
       const accumulator = new MessageAccumulator();
-      const runtimeTools = this._tools.size > 0 ? this.injectToolContext([...this._tools.values()], {
-        sessionId: cid,
-        custom: updatedSession.metadata?.custom
-      }) : void 0;
-      const streamOptions = {
-        ...options,
-        signal: this._abortController.signal,
-        model: options?.model ?? this._currentModel,
-        tools: runtimeTools
-      };
-      const stream = await this.createStreamWithRetry(adapter, sessionForAdapter, message, streamOptions);
       const eventSource = this._streamTimeoutMs ? withStreamWatchdog(stream, { timeoutMs: this._streamTimeoutMs, signal: this._abortController.signal }) : stream;
       for await (const event of eventSource) {
         if (this._abortController.isAborted) break;
         this.feedAccumulator(accumulator, event);
-        let processedEvent = event;
-        for (const mw of this._middleware) {
-          if (mw.onEvent && processedEvent) {
-            processedEvent = await mw.onEvent(processedEvent, middlewareContext);
-          }
-        }
-        if (processedEvent) {
-          yield processedEvent;
-        }
-      }
-      if (this._state.current === "disposed") {
-        return;
-      }
-      let assistantMessage = accumulator.finalize();
-      for (const mw of this._middleware) {
-        if (mw.onAfterReceive) {
-          assistantMessage = await mw.onAfterReceive(assistantMessage, middlewareContext);
+        if (event.type === "usage") {
+          this._sessionUsage.set(cid, {
+            promptTokens: event.promptTokens,
+            completionTokens: event.completionTokens
+          });
+          this.updateContextStatsWithUsage(cid, event.promptTokens, event.completionTokens, options);
         }
+        const processed = await this.applyOnEventMiddleware(event, mwCtx);
+        if (processed) yield processed;
       }
-      await this._sessionStore.appendMessage(cid, assistantMessage);
-      this._notifySessionChange();
+      if (this._state.current === "disposed") return;
+      await this.finalizeAssistantMessage(cid, accumulator, mwCtx);
       this._state.transition("idle");
     } catch (error) {
-      let processedError = error instanceof Error ? error : new Error(String(error));
-      const middlewareContext = {
-        sessionId: cid,
-        signal: this._abortController?.signal ?? new AbortController().signal
-      };
-      for (const mw of this._middleware) {
-        if (mw.onError) {
-          const result = await mw.onError(processedError, middlewareContext);
-          if (result === null) {
-            if (this._state.canTransition("idle")) {
-              this._state.transition("idle");
-            }
-            return;
-          }
-          processedError = result;
-        }
-      }
-      if (this._state.canTransition("error")) {
-        this._state.transition("error");
-      }
-      throw processedError;
+      const result = await this.handleSendError(error, cid);
+      if (result !== null) throw result;
     } finally {
       this._guard.release();
       this._abortController?.dispose();
       this._abortController = null;
     }
   }
-  abort() {
-    this._abortController?.abort("User abort");
-  }
-  // ── Backend / Model ────────────────────────────────────────
-  get currentBackend() {
-    return this._currentBackend;
-  }
-  get currentModel() {
-    return this._currentModel;
-  }
-  async switchBackend(name) {
+  // ── Send Pipeline Stages ──────────────────────────────────────
+  /** Stage 1: Validate send inputs (message content + required fields). */
+  validateSendInput(message, options) {
     this.assertNotDisposed();
-    if (!this._backends[name]) {
+    if (!message || message.trim().length === 0) {
+      throw new ChatError("Message cannot be empty", { code: "INVALID_INPUT" /* INVALID_INPUT */ });
+    }
+    if (!options.model) {
+      throw new ChatError(
+        "options.model is required \u2014 caller must specify which model to use",
+        { code: "INVALID_INPUT" /* INVALID_INPUT */ }
+      );
+    }
+    if (!options.backend) {
       throw new ChatError(
-        `Backend "${name}" not found in backends map`,
+        "options.backend is required \u2014 caller must specify which backend to use",
         { code: "INVALID_INPUT" /* INVALID_INPUT */ }
       );
     }
-    if (this._activeAdapter) {
-      await this._activeAdapter.dispose();
-      this._activeAdapter = null;
+    if (!options.credentials) {
+      throw new ChatError(
+        "options.credentials is required \u2014 caller must provide authentication credentials",
+        { code: "INVALID_INPUT" /* INVALID_INPUT */ }
+      );
+    }
+  }
+  /** Stage 2: Load session from store. */
+  async loadSession(cid) {
+    const session = await this._sessionStore.getSession(cid);
+    if (!session) {
+      throw new ChatError(
+        `Session "${cid}" not found`,
+        { code: "SESSION_NOT_FOUND" /* SESSION_NOT_FOUND */ }
+      );
+    }
+    return session;
+  }
+  /** Stage 3: Apply onBeforeSend middleware pipeline. Returns null if middleware rejected the send. */
+  async applyBeforeSendMiddleware(userMessage, ctx) {
+    let msg = userMessage;
+    for (const mw of this._middleware) {
+      if (mw.onBeforeSend && msg) {
+        msg = await mw.onBeforeSend(msg, ctx);
+        if (msg === null) return null;
+      }
+    }
+    return msg;
+  }
+  /** Stage 4: Persist user message and reload session with full history. */
+  async persistAndReload(cid, userMessage) {
+    await this._sessionStore.appendMessage(cid, userMessage);
+    return await this._sessionStore.getSession(cid);
+  }
+  /** Stage 5: Auto-trim context window if configured. Returns session snapshot for adapter. */
+  async trimSessionContext(cid, session, model) {
+    if (!this._ctxManager) return session;
+    const ctxManager = this._ctxManager;
+    const lastUsage = this._sessionUsage.get(cid);
+    const modelContextWindow = model ? this._modelContextWindows.get(model) : void 0;
+    if (lastUsage && modelContextWindow) {
+      const result2 = ctxManager.fitMessagesWithUsage(
+        session.messages,
+        lastUsage.promptTokens,
+        modelContextWindow
+      );
+      this._contextStats.set(cid, {
+        totalTokens: result2.totalTokens,
+        removedCount: result2.removedCount,
+        wasTruncated: result2.wasTruncated,
+        availableBudget: Math.max(0, modelContextWindow - result2.totalTokens),
+        realPromptTokens: lastUsage.promptTokens,
+        realCompletionTokens: lastUsage.completionTokens,
+        modelContextWindow
+      });
+      if (result2.wasTruncated && this._onContextTrimmed) {
+        const keptIds = new Set(result2.messages.map((m) => m.id));
+        const removed = session.messages.filter((m) => !keptIds.has(m.id));
+        if (removed.length > 0) {
+          try {
+            this._onContextTrimmed(cid, removed);
+          } catch {
+          }
+        }
+      }
+      return { ...session, messages: result2.messages };
+    }
+    const result = await ctxManager.fitMessagesAsync(session.messages);
+    this._contextStats.set(cid, {
+      totalTokens: result.totalTokens,
+      removedCount: result.removedCount,
+      wasTruncated: result.wasTruncated,
+      availableBudget: ctxManager.availableBudget,
+      modelContextWindow
+    });
+    if (result.wasTruncated && this._onContextTrimmed) {
+      const keptIds = new Set(result.messages.map((m) => m.id));
+      const removed = session.messages.filter((m) => !keptIds.has(m.id));
+      if (removed.length > 0) {
+        try {
+          this._onContextTrimmed(cid, removed);
+        } catch {
+        }
+      }
+    }
+    return { ...session, messages: result.messages };
+  }
+  /** Update context stats with real usage data from a usage event. */
+  updateContextStatsWithUsage(cid, promptTokens, completionTokens, options) {
+    const modelContextWindow = options.model ? this._modelContextWindows.get(options.model) : void 0;
+    const existing = this._contextStats.get(cid);
+    this._contextStats.set(cid, {
+      totalTokens: promptTokens,
+      removedCount: existing?.removedCount ?? 0,
+      wasTruncated: existing?.wasTruncated ?? false,
+      availableBudget: modelContextWindow ? Math.max(0, modelContextWindow - promptTokens) : existing?.availableBudget ?? 0,
+      realPromptTokens: promptTokens,
+      realCompletionTokens: completionTokens,
+      modelContextWindow
+    });
+  }
+  /** Stage 6: Prepare event stream — adapter with retry, tool injection. */
+  async prepareEventStream(cid, sessionForAdapter, fullSession, message, options) {
+    const adapter = await this.getOrCreateAdapterWithRetry(options.backend, options.credentials);
+    const runtimeTools = this._tools.size > 0 ? this.injectToolContext([...this._tools.values()], {
+      sessionId: cid,
+      custom: fullSession.metadata?.custom
+    }) : void 0;
+    const streamOptions = {
+      signal: this._abortController.signal,
+      model: options.model,
+      systemPrompt: options.systemPrompt,
+      tools: runtimeTools
+    };
+    return this.createStreamWithRetry(
+      adapter,
+      sessionForAdapter,
+      message,
+      streamOptions,
+      options.backend,
+      options.credentials
+    );
+  }
+  /** Stage 7: Apply onEvent middleware pipeline (sequential transform/suppress). */
+  async applyOnEventMiddleware(event, ctx) {
+    let processed = event;
+    for (const mw of this._middleware) {
+      if (mw.onEvent && processed) {
+        processed = await mw.onEvent(processed, ctx);
+      }
+    }
+    return processed;
+  }
+  /** Stage 8: Finalize accumulator, apply afterReceive middleware, persist assistant message. */
+  async finalizeAssistantMessage(cid, accumulator, ctx) {
+    let assistantMessage = accumulator.finalize();
+    for (const mw of this._middleware) {
+      if (mw.onAfterReceive) {
+        assistantMessage = await mw.onAfterReceive(assistantMessage, ctx);
+      }
+    }
+    await this._sessionStore.appendMessage(cid, assistantMessage);
+    this._notifySessionChange();
+  }
+  /** Stage 9: Error handling — apply onError middleware, transition state. Returns null if suppressed. */
+  async handleSendError(error, cid) {
+    let processedError = error instanceof Error ? error : new Error(String(error));
+    const ctx = {
+      sessionId: cid,
+      signal: this._abortController?.signal ?? new AbortController().signal
+    };
+    for (const mw of this._middleware) {
+      if (mw.onError) {
+        const result = await mw.onError(processedError, ctx);
+        if (result === null) {
+          if (this._state.canTransition("idle")) {
+            this._state.transition("idle");
+          }
+          return null;
+        }
+        processedError = result;
+      }
+    }
+    if (this._state.canTransition("error")) {
+      this._state.transition("error");
     }
-    this._currentBackend = name;
+    return processedError;
   }
-  switchModel(model) {
+  abort() {
+    this._abortController?.abort("User abort");
+  }
+  // ── Backend / Model ────────────────────────────────────────
+  async listModels(options) {
     this.assertNotDisposed();
-    this._currentModel = model;
+    let models = [];
+    const firstAdapter = [...this._adapterPool.values()][0];
+    if (firstAdapter) {
+      try {
+        models = await firstAdapter.listModels();
+      } catch {
+        return [];
+      }
+    } else if (options?.backend && options?.credentials) {
+      try {
+        const adapter = await this.getOrCreateAdapter(options.backend, options.credentials);
+        models = await adapter.listModels();
+      } catch {
+        return [];
+      }
+    }
+    for (const model of models) {
+      if (model.contextWindow != null) {
+        this._modelContextWindows.set(model.id, model.contextWindow);
+      }
+    }
+    return models;
   }
-  async listModels() {
+  async listBackends() {
     this.assertNotDisposed();
-    const adapter = await this.getOrCreateAdapter();
-    return adapter.listModels();
+    return Object.keys(this._backends).map((name) => ({ name }));
   }
   // ── Tools ──────────────────────────────────────────────────
   get registeredTools() {
@@ -4166,37 +4347,46 @@ var ChatRuntime = class {
     if (idx >= 0) this._middleware.splice(idx, 1);
   }
   // ── Context Stats ─────────────────────────────────────────
-  getContextStats(sessionId) {
+  async getContextStats(sessionId) {
     const cid = toChatId(sessionId);
     return this._contextStats.get(cid) ?? null;
   }
   // ── Session Subscription ──────────────────────────────────
   onSessionChange(callback) {
-    this._sessionListeners.add(callback);
-    return () => {
-      this._sessionListeners.delete(callback);
-    };
+    return this._sessionListeners.add(callback);
   }
   _notifySessionChange() {
-    for (const cb of this._sessionListeners) {
-      try {
-        cb();
-      } catch {
-      }
-    }
+    this._sessionListeners.notify();
   }
   // ── Private Helpers ────────────────────────────────────────
-  async getOrCreateAdapter() {
-    if (this._activeAdapter) return this._activeAdapter;
-    const factory = this._backends[this._currentBackend];
+  async getOrCreateAdapter(backend, credentials) {
+    const key = this.getPoolKey(backend, credentials);
+    const existing = this._adapterPool.get(key);
+    if (existing) return existing;
+    for (const [oldKey, oldAdapter] of this._adapterPool) {
+      if (oldKey.startsWith(backend + ":")) {
+        try {
+          await oldAdapter.dispose();
+        } catch {
+        }
+        this._adapterPool.delete(oldKey);
+      }
+    }
+    const factory = this._backends[backend];
     if (!factory) {
       throw new ChatError(
-        `Backend "${this._currentBackend}" not found`,
+        `Backend "${backend}" not found`,
         { code: "INVALID_INPUT" /* INVALID_INPUT */ }
       );
     }
-    this._activeAdapter = await factory();
-    return this._activeAdapter;
+    const adapter = await factory(credentials);
+    this._adapterPool.set(key, adapter);
+    return adapter;
+  }
+  getPoolKey(backend, credentials) {
+    const token = credentials.accessToken;
+    const hash = token.length > 16 ? token.slice(0, 8) + token.slice(-8) : token;
+    return `${backend}:${hash}`;
   }
   /** Wrap each tool's execute to inject ToolContext as 2nd argument */
   injectToolContext(tools, context) {
@@ -4228,17 +4418,25 @@ var ChatRuntime = class {
     }
   }
   /** Get or create adapter with retry on connection errors */
-  async getOrCreateAdapterWithRetry() {
+  async getOrCreateAdapterWithRetry(backend, credentials) {
     const maxAttempts = this._retryConfig?.maxAttempts ?? 1;
     const delayMs = this._retryConfig?.delayMs ?? 0;
     let lastError;
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
       try {
-        return await this.getOrCreateAdapter();
+        return await this.getOrCreateAdapter(backend, credentials);
       } catch (err) {
         lastError = err instanceof Error ? err : new Error(String(err));
         if (attempt < maxAttempts) {
-          this._activeAdapter = null;
+          const key = this.getPoolKey(backend, credentials);
+          const old = this._adapterPool.get(key);
+          if (old) {
+            try {
+              await old.dispose();
+            } catch {
+            }
+          }
+          this._adapterPool.delete(key);
           await delay(delayMs);
         }
       }
@@ -4251,7 +4449,7 @@ var ChatRuntime = class {
    * retries with a fresh adapter. Once first event is received,
    * the stream is committed (no more retries).
    */
-  async createStreamWithRetry(adapter, session, message, options) {
+  async createStreamWithRetry(adapter, session, message, options, backend, credentials) {
     const maxAttempts = this._retryConfig?.maxAttempts ?? 1;
     const delayMs = this._retryConfig?.delayMs ?? 0;
     let lastError;
@@ -4272,13 +4470,14 @@ var ChatRuntime = class {
       } catch (err) {
         lastError = err instanceof Error ? err : new Error(String(err));
         if (attempt < maxAttempts) {
-          if (this._activeAdapter) {
-            await this._activeAdapter.dispose().catch(() => {
-            });
+          try {
+            await currentAdapter.dispose();
+          } catch {
           }
-          this._activeAdapter = null;
+          const key = this.getPoolKey(backend, credentials);
+          this._adapterPool.delete(key);
           await delay(delayMs);
-          currentAdapter = await this.getOrCreateAdapter();
+          currentAdapter = await this.getOrCreateAdapter(backend, credentials);
         }
       }
     }
@@ -4286,16 +4485,17 @@ var ChatRuntime = class {
   }
 };
 function delay(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function createChatRuntime(options) {
   return new ChatRuntime(options);
 }
 
 // src/chat/storage.ts
+init_errors2();
 init_errors();
 var StorageError = class extends AgentSDKError {
-  /** Machine-readable error code */
+  /** Machine-readable error code from the unified ErrorCode enum */
   code;
   constructor(message, code) {
     super(message);
@@ -4332,7 +4532,7 @@ var InMemoryStorage = class {
     if (this.data.has(key)) {
       throw new StorageError(
         `Item with key "${key}" already exists`,
-        "DUPLICATE_KEY"
+        "STORAGE_DUPLICATE_KEY" /* STORAGE_DUPLICATE_KEY */
       );
     }
     this.data.set(key, structuredClone(item));
@@ -4342,7 +4542,7 @@ var InMemoryStorage = class {
     if (!this.data.has(key)) {
       throw new StorageError(
         `Item with key "${key}" not found`,
-        "NOT_FOUND"
+        "STORAGE_NOT_FOUND" /* STORAGE_NOT_FOUND */
       );
     }
     this.data.set(key, structuredClone(item));
@@ -4352,7 +4552,7 @@ var InMemoryStorage = class {
     if (!this.data.has(key)) {
       throw new StorageError(
         `Item with key "${key}" not found`,
-        "NOT_FOUND"
+        "STORAGE_NOT_FOUND" /* STORAGE_NOT_FOUND */
       );
     }
     this.data.delete(key);
@@ -4376,25 +4576,25 @@ var FileStorage = class {
   constructor(options) {
     this.directory = options.directory;
     this.extension = options.extension ?? ".json";
-    this.ensureDirectory();
+    this.ensureDirectorySync();
   }
   /** @inheritdoc */
   async get(key) {
     const filePath = this.keyToPath(key);
-    if (!fs.existsSync(filePath)) {
+    if (!await this.fileExists(filePath)) {
       return null;
     }
-    return this.readFile(filePath);
+    return this.readJsonFile(filePath);
   }
   /** @inheritdoc */
   async list(options) {
-    this.ensureDirectory();
-    const files = fs.readdirSync(this.directory).filter(
+    await this.ensureDirectoryAsync();
+    const files = (await promises.readdir(this.directory)).filter(
       (f) => f.endsWith(this.extension)
     );
     let items = [];
     for (const file of files) {
-      const item = this.readFile(path.join(this.directory, file));
+      const item = await this.readJsonFile(path.join(this.directory, file));
       items.push(item);
     }
     if (options?.filter) {
@@ -4414,55 +4614,55 @@ var FileStorage = class {
   /** @inheritdoc */
   async create(key, item) {
     const filePath = this.keyToPath(key);
-    if (fs.existsSync(filePath)) {
+    if (await this.fileExists(filePath)) {
       throw new StorageError(
         `Item with key "${key}" already exists`,
-        "DUPLICATE_KEY"
+        "STORAGE_DUPLICATE_KEY" /* STORAGE_DUPLICATE_KEY */
       );
     }
-    this.writeFile(filePath, item);
+    await this.writeJsonFile(filePath, item);
   }
   /** @inheritdoc */
   async update(key, item) {
     const filePath = this.keyToPath(key);
-    if (!fs.existsSync(filePath)) {
+    if (!await this.fileExists(filePath)) {
       throw new StorageError(
         `Item with key "${key}" not found`,
-        "NOT_FOUND"
+        "STORAGE_NOT_FOUND" /* STORAGE_NOT_FOUND */
       );
     }
-    this.writeFile(filePath, item);
+    await this.writeJsonFile(filePath, item);
   }
   /** @inheritdoc */
   async delete(key) {
     const filePath = this.keyToPath(key);
-    if (!fs.existsSync(filePath)) {
+    if (!await this.fileExists(filePath)) {
       throw new StorageError(
         `Item with key "${key}" not found`,
-        "NOT_FOUND"
+        "STORAGE_NOT_FOUND" /* STORAGE_NOT_FOUND */
       );
     }
-    fs.unlinkSync(filePath);
+    await promises.unlink(filePath);
   }
   /** @inheritdoc */
   async has(key) {
-    return fs.existsSync(this.keyToPath(key));
+    return this.fileExists(this.keyToPath(key));
   }
   /** @inheritdoc */
   async count() {
-    this.ensureDirectory();
-    return fs.readdirSync(this.directory).filter(
+    await this.ensureDirectoryAsync();
+    return (await promises.readdir(this.directory)).filter(
       (f) => f.endsWith(this.extension)
     ).length;
   }
   /** @inheritdoc */
   async clear() {
-    this.ensureDirectory();
-    const files = fs.readdirSync(this.directory).filter(
+    await this.ensureDirectoryAsync();
+    const files = (await promises.readdir(this.directory)).filter(
       (f) => f.endsWith(this.extension)
     );
     for (const file of files) {
-      fs.unlinkSync(path.join(this.directory, file));
+      await promises.unlink(path.join(this.directory, file));
     }
   }
   keyToPath(key) {
@@ -4472,42 +4672,58 @@ var FileStorage = class {
     );
     return path.join(this.directory, `${safeKey}${this.extension}`);
   }
-  ensureDirectory() {
+  /** Sync directory init — used only in constructor (one-time). */
+  ensureDirectorySync() {
     if (!fs.existsSync(this.directory)) {
       fs.mkdirSync(this.directory, { recursive: true });
     }
   }
-  readFile(filePath) {
+  /** Async directory init — used in operations. */
+  async ensureDirectoryAsync() {
+    if (!await this.fileExists(this.directory)) {
+      await promises.mkdir(this.directory, { recursive: true });
+    }
+  }
+  async fileExists(filePath) {
+    try {
+      await promises.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async readJsonFile(filePath) {
     try {
-      const content = fs.readFileSync(filePath, "utf-8");
+      const content = await promises.readFile(filePath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       if (error instanceof SyntaxError) {
         throw new StorageError(
           `Failed to parse file: ${filePath}`,
-          "SERIALIZATION_ERROR"
+          "STORAGE_SERIALIZATION_ERROR" /* STORAGE_SERIALIZATION_ERROR */
         );
       }
       throw new StorageError(
         `Failed to read file: ${filePath}`,
-        "IO_ERROR"
+        "STORAGE_IO_ERROR" /* STORAGE_IO_ERROR */
       );
     }
   }
-  writeFile(filePath, item) {
+  async writeJsonFile(filePath, item) {
     try {
       const content = JSON.stringify(item, null, 2);
-      fs.writeFileSync(filePath, content, "utf-8");
+      await promises.writeFile(filePath, content, "utf-8");
     } catch {
       throw new StorageError(
         `Failed to write file: ${filePath}`,
-        "IO_ERROR"
+        "STORAGE_IO_ERROR" /* STORAGE_IO_ERROR */
       );
     }
   }
 };
 
 // src/chat/sessions.ts
+init_errors();
 var BaseSessionStore = class {
   constructor(adapter) {
     this.adapter = adapter;
@@ -4546,7 +4762,7 @@ var BaseSessionStore = class {
   async updateTitle(id, title) {
     const session = await this.adapter.get(id);
     if (!session) {
-      throw new StorageError(`Session "${id}" not found`, "NOT_FOUND");
+      throw new StorageError(`Session "${id}" not found`, "STORAGE_NOT_FOUND" /* STORAGE_NOT_FOUND */);
     }
     session.title = title;
     session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -4555,7 +4771,7 @@ var BaseSessionStore = class {
   async updateConfig(id, config) {
     const session = await this.adapter.get(id);
     if (!session) {
-      throw new StorageError(`Session "${id}" not found`, "NOT_FOUND");
+      throw new StorageError(`Session "${id}" not found`, "STORAGE_NOT_FOUND" /* STORAGE_NOT_FOUND */);
     }
     session.config = { ...session.config, ...config };
     session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -4567,7 +4783,7 @@ var BaseSessionStore = class {
   async appendMessage(sessionId, message) {
     const session = await this.adapter.get(sessionId);
     if (!session) {
-      throw new StorageError(`Session "${sessionId}" not found`, "NOT_FOUND");
+      throw new StorageError(`Session "${sessionId}" not found`, "STORAGE_NOT_FOUND" /* STORAGE_NOT_FOUND */);
     }
     session.messages.push(structuredClone(message));
     session.metadata.messageCount = session.messages.length;
@@ -4578,7 +4794,7 @@ var BaseSessionStore = class {
     if (messages.length === 0) return;
     const session = await this.adapter.get(sessionId);
     if (!session) {
-      throw new StorageError(`Session "${sessionId}" not found`, "NOT_FOUND");
+      throw new StorageError(`Session "${sessionId}" not found`, "STORAGE_NOT_FOUND" /* STORAGE_NOT_FOUND */);
     }
     for (const msg of messages) {
       session.messages.push(structuredClone(msg));
@@ -4590,7 +4806,7 @@ var BaseSessionStore = class {
   async loadMessages(sessionId, options) {
     const session = await this.adapter.get(sessionId);
     if (!session) {
-      throw new StorageError(`Session "${sessionId}" not found`, "NOT_FOUND");
+      throw new StorageError(`Session "${sessionId}" not found`, "STORAGE_NOT_FOUND" /* STORAGE_NOT_FOUND */);
     }
     const total = session.messages.length;
     const offset = options?.offset ?? 0;
@@ -4602,24 +4818,6 @@ var BaseSessionStore = class {
       hasMore: offset + limit < total
     };
   }
-  async archiveSession(id) {
-    const session = await this.adapter.get(id);
-    if (!session) {
-      throw new StorageError(`Session "${id}" not found`, "NOT_FOUND");
-    }
-    session.status = "archived";
-    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await this.adapter.update(id, session);
-  }
-  async unarchiveSession(id) {
-    const session = await this.adapter.get(id);
-    if (!session) {
-      throw new StorageError(`Session "${id}" not found`, "NOT_FOUND");
-    }
-    session.status = "active";
-    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await this.adapter.update(id, session);
-  }
   async searchSessions(options) {
     const query = options.query.toLowerCase();
     const limit = options.limit ?? 20;
@@ -4641,15 +4839,6 @@ var BaseSessionStore = class {
   async clear() {
     return this.adapter.clear();
   }
-  // ── Deprecated Aliases ──────────────────────────────────────
-  /** @deprecated Use `appendMessage()` instead */
-  async addMessage(sessionId, message) {
-    return this.appendMessage(sessionId, message);
-  }
-  /** @deprecated Use `loadMessages()` instead */
-  async getMessages(sessionId, options) {
-    return this.loadMessages(sessionId, options);
-  }
 };
 var InMemorySessionStore = class extends BaseSessionStore {
   constructor() {
@@ -4662,28 +4851,59 @@ var FileSessionStore = class extends BaseSessionStore {
   }
 };
 
+// src/chat/backends/types.ts
+function isResumableBackend(adapter) {
+  return "canResume" in adapter && typeof adapter.canResume === "function";
+}
+
 // 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);
@@ -4711,7 +4931,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);
   }
@@ -4721,9 +4941,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 = "";
@@ -4749,31 +4973,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 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 },
+      ...options?.tools?.length ? { tools: options.tools } : {}
+    };
+    const agent = this.agentService.createAgent(config);
+    this._currentAgent = { instance: agent, model };
     return agent;
   }
   assertNotDisposed() {
@@ -4785,21 +5024,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;
@@ -4828,7 +5061,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) {
@@ -4838,81 +5071,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
+    }));
   }
-  createService() {
-    const { createAgentService: createAgentService2 } = (init_src(), __toCommonJS(src_exports));
-    return createAgentService2("vercel-ai", this._vercelOptions);
+  createAgent(config) {
+    return new MockLLMAgent(config, this.options);
   }
-  get backendSessionId() {
-    return null;
+  async listModels() {
+    return this.models;
   }
-  canResume() {
-    return false;
+  async validate() {
+    return { valid: true, errors: [] };
   }
-  async *resume(_session, _backendSessionId, _options) {
-    throw new ChatError(
-      "Vercel AI adapter does not support session resume (stateless)",
-      { code: "PROVIDER_ERROR" /* PROVIDER_ERROR */ }
-    );
+  async dispose() {
+  }
+};
+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) {
   }
@@ -4993,16 +5470,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) {
@@ -5089,9 +5572,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);
     }
@@ -5100,9 +5583,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) {
@@ -5114,9 +5597,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;
     }
@@ -5141,8 +5624,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;
         });
       }
     };
@@ -5315,9 +5798,7 @@ var ChatEventBus = class extends TypedEventEmitter {
 
 exports.BaseBackendAdapter = BaseBackendAdapter;
 exports.ChatError = ChatError;
-exports.ChatErrorCode = ChatErrorCode;
 exports.ChatEventBus = ChatEventBus;
-exports.ChatSDKError = ChatError;
 exports.ClaudeChatAdapter = ClaudeChatAdapter;
 exports.ContextWindowManager = ContextWindowManager;
 exports.CopilotChatAdapter = CopilotChatAdapter;
@@ -5325,7 +5806,9 @@ exports.ExponentialBackoffStrategy = ExponentialBackoffStrategy;
 exports.FileSessionStore = FileSessionStore;
 exports.InMemorySessionStore = InMemorySessionStore;
 exports.InProcessChatTransport = InProcessChatTransport;
+exports.ListenerSet = ListenerSet;
 exports.MessageAccumulator = MessageAccumulator;
+exports.MockLLMChatAdapter = MockLLMChatAdapter;
 exports.SSEChatTransport = SSEChatTransport;
 exports.TypedEventEmitter = TypedEventEmitter;
 exports.VercelAIChatAdapter = VercelAIChatAdapter;
@@ -5335,6 +5818,7 @@ exports.agentEventToChatEvent = agentEventToChatEvent;
 exports.classifyError = classifyError;
 exports.createChatId = createChatId;
 exports.createChatRuntime = createChatRuntime;
+exports.createTextMessage = createTextMessage;
 exports.estimateTokens = estimateTokens;
 exports.fromAgentMessage = fromAgentMessage;
 exports.getMessageReasoning = getMessageReasoning;
@@ -5345,13 +5829,16 @@ exports.isChatMessage = isChatMessage;
 exports.isChatSession = isChatSession;
 exports.isFilePart = isFilePart;
 exports.isMessagePart = isMessagePart;
+exports.isObservableSession = isObservableSession;
 exports.isReasoningPart = isReasoningPart;
+exports.isResumableBackend = isResumableBackend;
 exports.isRetryable = isRetryable;
 exports.isSourcePart = isSourcePart;
 exports.isTextPart = isTextPart;
 exports.isToolCallPart = isToolCallPart;
 exports.streamToTransport = streamToTransport;
 exports.toAgentMessage = toAgentMessage;
+exports.toAgentMessages = toAgentMessages;
 exports.toChatId = toChatId;
 exports.withRetry = withRetry;
 exports.withStreamWatchdog = withStreamWatchdog;