@witqq/agent-sdk 0.7.0 → 0.9.0

package/dist/chat/index.js

@@ -1,8 +1,6 @@
-import * as fs from 'fs';
-import { existsSync, readdirSync, unlinkSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import * as path from 'path';
+import { existsSync, mkdirSync } from 'fs';
+import { readdir, unlink, mkdir, access, readFile, writeFile } from 'fs/promises';
 import { join } from 'path';
-import * as os from 'os';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -25,16 +23,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 */;
+}
+var ErrorCode, RECOVERABLE_CODES;
 var init_errors = __esm({
+  "src/types/errors.ts"() {
+    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;
+    })(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) {
@@ -43,83 +125,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();
   }
 });
 
@@ -127,12 +210,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;
@@ -148,8 +234,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();
@@ -161,8 +250,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();
@@ -175,13 +267,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();
@@ -194,8 +284,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();
         }
@@ -206,12 +298,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();
@@ -234,26 +351,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);
@@ -289,9 +489,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 {
@@ -299,8 +499,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 })
@@ -323,6 +523,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") {
@@ -427,6 +656,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, {
@@ -435,10 +724,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"
@@ -446,10 +734,10 @@ async function loadSDK() {
   }
 }
 function _injectSDK(mock) {
-  sdkModule = mock;
+  _sdkMock = mock;
 }
 function _resetSDK() {
-  sdkModule = null;
+  _sdkMock = null;
 }
 function mapToolsToSDK(tools) {
   return tools.map((tool) => ({
@@ -469,17 +757,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) {
@@ -494,6 +771,7 @@ function buildPermissionHandler(config) {
     const unifiedRequest = {
       toolName,
       toolArgs: { ...request },
+      toolCallId: request.toolCallId,
       rawSDKRequest: request
     };
     const ac = new AbortController();
@@ -598,15 +876,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];
@@ -617,66 +901,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);
@@ -688,14 +919,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) {
@@ -743,6 +975,7 @@ var init_copilot = __esm({
       isPersistent;
       persistentSession = null;
       _sessionId;
+      _persistentModel;
       activeSession = null;
       _resumeSessionId;
       _toolsReady = null;
@@ -761,15 +994,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() {
@@ -793,47 +1026,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();
@@ -930,9 +1179,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);
@@ -949,8 +1198,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);
@@ -1044,7 +1293,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");
@@ -1078,7 +1331,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() {
@@ -1131,10 +1387,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"
@@ -1142,13 +1397,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);
@@ -1172,6 +1446,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",
@@ -1221,6 +1528,7 @@ function buildCanUseTool(config) {
     const unifiedRequest = {
       toolName,
       toolArgs: input,
+      toolCallId: options.toolUseID,
       suggestedScope: extractSuggestedScope(options.suggestions),
       rawSDKRequest: { toolName, input, ...options }
     };
@@ -1273,6 +1581,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);
           }
@@ -1296,6 +1605,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) {
@@ -1349,10 +1659,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;
@@ -1361,72 +1674,21 @@ function mapSDKMessage(msg, thinkingBlockIndices, toolCallTracker) {
       return null;
   }
 }
-function extractLastUserPrompt2(messages) {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.role === "user") {
-      return getTextContent(msg.content);
-    }
-  }
-  return "";
-}
-function serializeToolCall2(tc) {
-  const args = typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args);
-  return `  Tool call: ${tc.name}(${args})`;
-}
-function serializeToolResult2(tr) {
-  const result = typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result);
-  const prefix = tr.isError ? "[ERROR] " : "";
-  return `  ${tr.name} \u2192 ${prefix}${result}`;
+function createClaudeService(options) {
+  return new ClaudeAgentService(options);
 }
-function buildContextualPrompt2(messages) {
-  if (messages.length <= 1) {
-    return extractLastUserPrompt2(messages);
-  }
-  const history = messages.slice(0, -1).map((msg) => {
-    if (msg.role === "user") {
-      return `User: ${msg.content ? getTextContent(msg.content) : ""}`;
-    }
-    if (msg.role === "tool" && msg.toolResults) {
-      const results = msg.toolResults.map(serializeToolResult2).join("\n");
-      return `Tool results:
-${results}`;
-    }
-    if (msg.role === "assistant") {
-      const parts = [];
-      const thinking = msg.thinking;
-      if (thinking) {
-        parts.push(`[reasoning: ${thinking}]`);
-      }
-      const text2 = msg.content ? getTextContent(msg.content) : "";
-      if (text2) parts.push(text2);
-      if (msg.toolCalls && msg.toolCalls.length > 0) {
-        parts.push(msg.toolCalls.map(serializeToolCall2).join("\n"));
-      }
-      return `Assistant: ${parts.join("\n")}`;
-    }
-    const text = msg.content ? getTextContent(msg.content) : "";
-    return `${msg.role}: ${text}`;
-  }).join("\n");
-  const lastPrompt = extractLastUserPrompt2(messages);
-  return `Conversation history:
-${history}
-
-User: ${lastPrompt}`;
-}
-function createClaudeService(options) {
-  return new ClaudeAgentService(options);
-}
-var MCP_SERVER_NAME, MCP_TOOL_PREFIX, sdkModule2, ANTHROPIC_MODELS_URL, ANTHROPIC_API_VERSION, ANTHROPIC_OAUTH_BETA, ClaudeToolCallTracker, ClaudeAgent, ClaudeAgentService;
+var MCP_SERVER_NAME, MCP_TOOL_PREFIX, CLAUDE_INTERNAL_TOOL_NAMES, _sdkMock2, ANTHROPIC_MODELS_URL, ANTHROPIC_API_VERSION, ANTHROPIC_OAUTH_BETA, ClaudeToolCallTracker, ClaudeAgent, ClaudeAgentService;
 var init_claude = __esm({
   "src/backends/claude.ts"() {
-    init_types();
+    init_types2();
     init_base_agent();
-    init_errors();
+    init_errors2();
     init_schema();
+    init_shared();
     MCP_SERVER_NAME = "agent-sdk-tools";
     MCP_TOOL_PREFIX = `mcp__${MCP_SERVER_NAME}__`;
-    sdkModule2 = null;
+    CLAUDE_INTERNAL_TOOL_NAMES = /* @__PURE__ */ new Set(["AskUserQuestion"]);
+    _sdkMock2 = null;
     ANTHROPIC_MODELS_URL = "https://api.anthropic.com/v1/models";
     ANTHROPIC_API_VERSION = "2023-06-01";
     ANTHROPIC_OAUTH_BETA = "oauth-2025-04-20";
@@ -1471,11 +1733,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;
@@ -1499,12 +1756,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,
@@ -1534,25 +1791,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 });
@@ -1562,30 +1879,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;
@@ -1605,41 +1900,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;
@@ -1656,23 +1923,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;
@@ -1691,12 +1952,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);
@@ -1712,30 +1973,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;
@@ -1770,46 +2009,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;
@@ -1841,23 +2057,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;
@@ -1876,12 +2086,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 });
@@ -1889,6 +2099,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();
@@ -1906,6 +2117,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;
               }
             }
@@ -1929,22 +2141,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();
@@ -1962,6 +2173,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;
                   }
                 }
@@ -1985,7 +2197,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) {
@@ -2047,7 +2263,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;
       }
@@ -2105,32 +2322,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 = {};
@@ -2173,13 +2388,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,
@@ -2286,7 +2502,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":
@@ -2307,10 +2524,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:
@@ -2320,15 +2540,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;
@@ -2341,28 +2561,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;
@@ -2418,10 +2643,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({
@@ -2463,11 +2688,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;
@@ -2492,6 +2717,7 @@ var init_vercel_ai = __esm({
           }
         });
         let finalText = "";
+        let lastFinishReason;
         try {
           for await (const part of result.fullStream) {
             if (signal.aborted) throw new AbortError();
@@ -2502,10 +2728,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 {
@@ -2513,9 +2744,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();
@@ -2544,16 +2778,33 @@ var init_vercel_ai = __esm({
         const baseUrl = (this.options.baseUrl || "https://api.openai.com/v1").replace(/\/+$/, "");
         try {
           const res = await globalThis.fetch(`${baseUrl}/models`, {
-            headers: { Authorization: `Bearer ${this.options.apiKey}` }
+            headers: {
+              Authorization: `Bearer ${this.options.apiKey}`,
+              // OpenRouter requires HTTP-Referer for API access
+              "HTTP-Referer": "https://github.com/nicepkg/agent-sdk"
+            }
           });
           if (!res.ok) {
             return [];
           }
           const body = await res.json();
-          if (!body.data || body.data.length === 0) {
-            return [];
+          if (body.data && Array.isArray(body.data)) {
+            return body.data.filter((m) => typeof m.id === "string").map((m) => ({
+              id: m.id,
+              ...typeof m.name === "string" && { name: m.name },
+              ...typeof m.description === "string" && { description: m.description },
+              ...typeof m.context_length === "number" && { contextWindow: m.context_length }
+            }));
+          }
+          if (Array.isArray(body)) {
+            return body.filter((m) => typeof m.id === "string").map((m) => ({
+              id: m.id,
+              ...typeof m.name === "string" && { name: m.name },
+              ...typeof m.description === "string" && { description: m.description },
+              ...typeof m.context_length === "number" && { contextWindow: m.context_length }
+            }));
           }
-          return body.data.map((m) => ({ id: m.id }));
+          return [];
         } catch {
           return [];
         }
@@ -2584,263 +2835,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.join(projectDir, ".agent-sdk", "permissions.json") : path.join(process.cwd(), ".agent-sdk", "permissions.json");
-  const userPath = path.join(os.homedir(), ".agent-sdk", "permissions.json");
-  const projectStore = new FilePermissionStore(projectPath);
-  const userStore = new FilePermissionStore(userPath);
-  return new CompositePermissionStore(sessionStore, projectStore, userStore);
-}
-var InMemoryPermissionStore, FilePermissionStore, CompositePermissionStore;
-var init_permission_store = __esm({
-  "src/permission-store.ts"() {
-    InMemoryPermissionStore = class {
-      approvals = /* @__PURE__ */ new Map();
-      async isApproved(toolName) {
-        return this.approvals.has(toolName);
-      }
-      async approve(toolName, scope) {
-        if (scope === "once") return;
-        this.approvals.set(toolName, scope);
-      }
-      async revoke(toolName) {
-        this.approvals.delete(toolName);
-      }
-      async clear() {
-        this.approvals.clear();
-      }
-      async dispose() {
-        this.approvals.clear();
-      }
-    };
-    FilePermissionStore = class {
-      filePath;
-      constructor(filePath) {
-        this.filePath = path.resolve(filePath);
-      }
-      async isApproved(toolName) {
-        const data = this.readFile();
-        return toolName in data.approvals;
-      }
-      async approve(toolName, scope) {
-        if (scope === "once") return;
-        const data = this.readFile();
-        data.approvals[toolName] = { scope, timestamp: Date.now() };
-        this.writeFileAtomic(data);
-      }
-      async revoke(toolName) {
-        const data = this.readFile();
-        delete data.approvals[toolName];
-        this.writeFileAtomic(data);
-      }
-      async clear() {
-        this.writeFileAtomic({ approvals: {} });
-      }
-      async dispose() {
-      }
-      readFile() {
-        try {
-          const raw = fs.readFileSync(this.filePath, "utf-8");
-          const parsed = JSON.parse(raw);
-          if (parsed && typeof parsed.approvals === "object") return parsed;
-        } catch {
-        }
-        return { approvals: {} };
-      }
-      writeFileAtomic(data) {
-        const dir = path.dirname(this.filePath);
-        fs.mkdirSync(dir, { recursive: true });
-        const tmpPath = this.filePath + `.tmp.${process.pid}.${Date.now()}`;
-        fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2), "utf-8");
-        fs.renameSync(tmpPath, this.filePath);
-      }
-    };
-    CompositePermissionStore = class {
-      sessionStore;
-      projectStore;
-      userStore;
-      constructor(sessionStore, projectStore, userStore) {
-        this.sessionStore = sessionStore;
-        this.projectStore = projectStore;
-        this.userStore = userStore ?? projectStore;
-      }
-      async isApproved(toolName) {
-        return await this.sessionStore.isApproved(toolName) || await this.projectStore.isApproved(toolName) || await this.userStore.isApproved(toolName);
-      }
-      async approve(toolName, scope) {
-        if (scope === "once") return;
-        if (scope === "session") {
-          await this.sessionStore.approve(toolName, scope);
-        } else if (scope === "project") {
-          await this.projectStore.approve(toolName, scope);
-        } else {
-          await this.userStore.approve(toolName, scope);
-        }
-      }
-      async revoke(toolName) {
-        await this.sessionStore.revoke(toolName);
-        await this.projectStore.revoke(toolName);
-        await this.userStore.revoke(toolName);
-      }
-      async clear() {
-        await this.sessionStore.clear();
-        await this.projectStore.clear();
-        await this.userStore.clear();
-      }
-      async dispose() {
-        await this.sessionStore.dispose();
-        await this.projectStore.dispose();
-        if (this.userStore !== this.projectStore) {
-          await this.userStore.dispose();
-        }
-      }
-    };
-  }
-});
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  AbortError: () => AbortError,
-  AgentSDKError: () => AgentSDKError,
-  BackendAlreadyRegisteredError: () => BackendAlreadyRegisteredError,
-  BackendNotFoundError: () => BackendNotFoundError,
-  BaseAgent: () => BaseAgent,
-  CompositePermissionStore: () => CompositePermissionStore,
-  DependencyError: () => DependencyError,
-  DisposedError: () => DisposedError,
-  FilePermissionStore: () => FilePermissionStore,
-  InMemoryPermissionStore: () => InMemoryPermissionStore,
-  ReentrancyError: () => ReentrancyError,
-  StructuredOutputError: () => StructuredOutputError,
-  SubprocessError: () => SubprocessError,
-  ToolExecutionError: () => ToolExecutionError,
-  buildSystemPrompt: () => buildSystemPrompt,
-  contentToText: () => contentToText,
-  createAgentService: () => createAgentService,
-  createDefaultPermissionStore: () => createDefaultPermissionStore,
-  getTextContent: () => getTextContent,
-  hasBackend: () => hasBackend,
-  isMultiPartContent: () => isMultiPartContent,
-  isTextContent: () => isTextContent,
-  isToolDefinition: () => isToolDefinition,
-  listBackends: () => listBackends,
-  messagesToPrompt: () => messagesToPrompt,
-  registerBackend: () => registerBackend,
-  resetRegistry: () => resetRegistry,
-  unregisterBackend: () => unregisterBackend,
-  zodToJsonSchema: () => zodToJsonSchema
-});
-var init_src = __esm({
-  "src/index.ts"() {
-    init_types();
-    init_errors();
-    init_registry();
-    init_base_agent();
-    init_schema();
-    init_messages();
-    init_permission_store();
-  }
-});
-
-// src/chat/core.ts
+// src/chat/types.ts
 function createChatId() {
   return crypto.randomUUID();
 }
@@ -2851,6 +2846,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("");
 }
@@ -2860,6 +2869,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;
@@ -2900,31 +2911,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":
@@ -2977,6 +2990,7 @@ function agentEventToChatEvent(event, messageId) {
         type: "error",
         error: event.error,
         recoverable: event.recoverable,
+        code: event.code,
         messageId
       };
     case "heartbeat":
@@ -2984,8 +2998,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;
   }
@@ -3023,27 +3038,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) {
@@ -3089,6 +3114,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) {
@@ -3198,6 +3231,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.
@@ -3315,37 +3398,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;
@@ -3524,12 +3589,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",
       () => {
@@ -3853,6 +3918,35 @@ var CancellableTimeout = class {
   }
 };
 
+// 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;
@@ -3860,26 +3954,29 @@ var ChatRuntime = class {
   _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;
@@ -3890,6 +3987,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() {
@@ -3901,24 +4003,23 @@ var ChatRuntime = class {
     this._abortController?.dispose();
     this._abortController = null;
     this._state.transition("disposed");
-    if (this._activeAdapter) {
-      await this._activeAdapter.dispose();
-      this._activeAdapter = null;
-    }
-  }
-  // ── Sessions ───────────────────────────────────────────────
-  get activeSessionId() {
-    return this._activeSessionId;
+    for (const adapter of this._adapterPool.values()) {
+      try {
+        await adapter.dispose();
+      } catch {
+      }
+    }
+    this._adapterPool.clear();
   }
+  // ── Sessions ───────────────────────────────────────────────
   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;
   }
@@ -3938,36 +4039,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);
@@ -3976,150 +4053,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(
+        "options.backend is required \u2014 caller must specify which backend to use",
+        { code: "INVALID_INPUT" /* INVALID_INPUT */ }
+      );
+    }
+    if (!options.credentials) {
       throw new ChatError(
-        `Backend "${name}" not found in backends map`,
+        "options.credentials is required \u2014 caller must provide authentication credentials",
         { code: "INVALID_INPUT" /* INVALID_INPUT */ }
       );
     }
-    if (this._activeAdapter) {
-      await this._activeAdapter.dispose();
-      this._activeAdapter = null;
+  }
+  /** 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 */ }
+      );
     }
-    this._currentBackend = name;
+    return session;
   }
-  switchModel(model) {
+  /** 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");
+    }
+    return processedError;
+  }
+  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() {
@@ -4144,37 +4345,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) {
@@ -4206,17 +4416,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);
         }
       }
@@ -4229,7 +4447,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;
@@ -4250,13 +4468,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);
         }
       }
     }
@@ -4264,16 +4483,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);
@@ -4310,7 +4530,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));
@@ -4320,7 +4540,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));
@@ -4330,7 +4550,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);
@@ -4354,25 +4574,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 (!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 = readdirSync(this.directory).filter(
+    await this.ensureDirectoryAsync();
+    const files = (await readdir(this.directory)).filter(
       (f) => f.endsWith(this.extension)
     );
     let items = [];
     for (const file of files) {
-      const item = this.readFile(join(this.directory, file));
+      const item = await this.readJsonFile(join(this.directory, file));
       items.push(item);
     }
     if (options?.filter) {
@@ -4392,55 +4612,55 @@ var FileStorage = class {
   /** @inheritdoc */
   async create(key, item) {
     const filePath = this.keyToPath(key);
-    if (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 (!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 (!existsSync(filePath)) {
+    if (!await this.fileExists(filePath)) {
       throw new StorageError(
         `Item with key "${key}" not found`,
-        "NOT_FOUND"
+        "STORAGE_NOT_FOUND" /* STORAGE_NOT_FOUND */
       );
     }
-    unlinkSync(filePath);
+    await unlink(filePath);
   }
   /** @inheritdoc */
   async has(key) {
-    return existsSync(this.keyToPath(key));
+    return this.fileExists(this.keyToPath(key));
   }
   /** @inheritdoc */
   async count() {
-    this.ensureDirectory();
-    return readdirSync(this.directory).filter(
+    await this.ensureDirectoryAsync();
+    return (await readdir(this.directory)).filter(
       (f) => f.endsWith(this.extension)
     ).length;
   }
   /** @inheritdoc */
   async clear() {
-    this.ensureDirectory();
-    const files = readdirSync(this.directory).filter(
+    await this.ensureDirectoryAsync();
+    const files = (await readdir(this.directory)).filter(
       (f) => f.endsWith(this.extension)
     );
     for (const file of files) {
-      unlinkSync(join(this.directory, file));
+      await unlink(join(this.directory, file));
     }
   }
   keyToPath(key) {
@@ -4450,42 +4670,58 @@ var FileStorage = class {
     );
     return join(this.directory, `${safeKey}${this.extension}`);
   }
-  ensureDirectory() {
+  /** Sync directory init — used only in constructor (one-time). */
+  ensureDirectorySync() {
     if (!existsSync(this.directory)) {
       mkdirSync(this.directory, { recursive: true });
     }
   }
-  readFile(filePath) {
+  /** Async directory init — used in operations. */
+  async ensureDirectoryAsync() {
+    if (!await this.fileExists(this.directory)) {
+      await mkdir(this.directory, { recursive: true });
+    }
+  }
+  async fileExists(filePath) {
     try {
-      const content = readFileSync(filePath, "utf-8");
+      await access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async readJsonFile(filePath) {
+    try {
+      const content = await 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);
-      writeFileSync(filePath, content, "utf-8");
+      await 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;
@@ -4524,7 +4760,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();
@@ -4533,7 +4769,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();
@@ -4545,7 +4781,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;
@@ -4556,7 +4792,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));
@@ -4568,7 +4804,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;
@@ -4580,24 +4816,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;
@@ -4619,15 +4837,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() {
@@ -4640,28 +4849,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);
@@ -4689,7 +4929,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);
   }
@@ -4699,9 +4939,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 = "";
@@ -4727,31 +4971,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() {
@@ -4763,21 +5022,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;
@@ -4806,7 +5059,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) {
@@ -4816,81 +5069,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) {
   }
@@ -4971,16 +5468,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) {
@@ -5067,9 +5570,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);
     }
@@ -5078,9 +5581,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) {
@@ -5092,9 +5595,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;
     }
@@ -5119,8 +5622,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;
         });
       }
     };
@@ -5291,6 +5794,6 @@ var ChatEventBus = class extends TypedEventEmitter {
   }
 };
 
-export { BaseBackendAdapter, ChatError, ChatErrorCode, ChatEventBus, ChatError as ChatSDKError, ClaudeChatAdapter, ContextWindowManager, CopilotChatAdapter, ExponentialBackoffStrategy, FileSessionStore, InMemorySessionStore, InProcessChatTransport, MessageAccumulator, SSEChatTransport, TypedEventEmitter, VercelAIChatAdapter, WsChatTransport, adaptAgentEvents, agentEventToChatEvent, classifyError, createChatId, createChatRuntime, estimateTokens, fromAgentMessage, getMessageReasoning, getMessageText, getMessageToolCalls, isChatEvent, isChatMessage, isChatSession, isFilePart, isMessagePart, isReasoningPart, isRetryable, isSourcePart, isTextPart, isToolCallPart, streamToTransport, toAgentMessage, toChatId, withRetry, withStreamWatchdog };
+export { BaseBackendAdapter, ChatError, ChatEventBus, ClaudeChatAdapter, ContextWindowManager, CopilotChatAdapter, ErrorCode, ExponentialBackoffStrategy, FileSessionStore, InMemorySessionStore, InProcessChatTransport, ListenerSet, MessageAccumulator, MockLLMChatAdapter, SSEChatTransport, TypedEventEmitter, VercelAIChatAdapter, WsChatTransport, adaptAgentEvents, agentEventToChatEvent, classifyError, createChatId, createChatRuntime, createTextMessage, estimateTokens, fromAgentMessage, getMessageReasoning, getMessageText, getMessageToolCalls, isChatEvent, isChatMessage, isChatSession, isFilePart, isMessagePart, isObservableSession, isReasoningPart, isResumableBackend, isRetryable, isSourcePart, isTextPart, isToolCallPart, streamToTransport, toAgentMessage, toAgentMessages, toChatId, withRetry, withStreamWatchdog };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map