@witqq/agent-sdk 0.7.0 → 0.9.0

package/dist/chat/runtime.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-// src/chat/core.ts
+// src/chat/types.ts
 function createChatId() {
   return crypto.randomUUID();
 }
@@ -11,6 +11,8 @@ function toChatId(value) {
   }
   return value;
 }
+
+// src/chat/bridge.ts
 function chatEventToAgentEvent(event) {
   switch (event.type) {
     case "message:delta":
@@ -36,7 +38,7 @@ 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;
   }
@@ -150,6 +152,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.
@@ -270,9 +322,18 @@ var ContextWindowManager = class {
 var 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) {
@@ -287,7 +348,11 @@ var ChatError = class extends AgentSDKError {
   retryAfter;
   timestamp;
   constructor(message, options) {
-    super(message, { cause: options.cause });
+    super(message, {
+      cause: options.cause,
+      code: options.code,
+      retryable: options.retryable
+    });
     this.name = "ChatError";
     this.code = options.code;
     this.retryable = options.retryable ?? false;
@@ -608,6 +673,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;
@@ -615,26 +709,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;
@@ -645,6 +742,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() {
@@ -656,24 +758,23 @@ var ChatRuntime = class {
     this._abortController?.dispose();
     this._abortController = null;
     this._state.transition("disposed");
-    if (this._activeAdapter) {
-      await this._activeAdapter.dispose();
-      this._activeAdapter = null;
+    for (const adapter of this._adapterPool.values()) {
+      try {
+        await adapter.dispose();
+      } catch {
+      }
     }
+    this._adapterPool.clear();
   }
   // ── Sessions ───────────────────────────────────────────────
-  get activeSessionId() {
-    return this._activeSessionId;
-  }
   async createSession(options) {
     this.assertNotDisposed();
     const config = {
-      model: options.config?.model ?? this._currentModel ?? "",
-      backend: options.config?.backend ?? this._currentBackend,
+      model: options.config?.model ?? "",
+      backend: options.config?.backend ?? this._defaultBackend,
       ...options.config
     };
     const session = await this._sessionStore.createSession({ ...options, config });
-    this._activeSessionId = session.id;
     this._notifySessionChange();
     return session;
   }
@@ -693,36 +794,12 @@ var ChatRuntime = class {
     if (!session) return;
     await this._sessionStore.deleteSession(cid);
     this._contextStats.delete(cid);
-    if (this._activeSessionId === cid) {
-      this._activeSessionId = null;
-    }
+    this._sessionUsage.delete(cid);
     this._notifySessionChange();
   }
-  async archiveSession(id) {
-    this.assertNotDisposed();
-    const cid = toChatId(id);
-    await this._sessionStore.archiveSession(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);
@@ -731,150 +808,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(
-        `Backend "${name}" not found in backends map`,
+        "options.model is required \u2014 caller must specify which model to use",
         { code: "INVALID_INPUT" /* INVALID_INPUT */ }
       );
     }
-    if (this._activeAdapter) {
-      await this._activeAdapter.dispose();
-      this._activeAdapter = null;
+    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(
+        "options.credentials is required \u2014 caller must provide authentication credentials",
+        { code: "INVALID_INPUT" /* INVALID_INPUT */ }
+      );
     }
-    this._currentBackend = name;
   }
-  switchModel(model) {
+  /** Stage 2: Load session from store. */
+  async loadSession(cid) {
+    const session = await this._sessionStore.getSession(cid);
+    if (!session) {
+      throw new ChatError(
+        `Session "${cid}" not found`,
+        { code: "SESSION_NOT_FOUND" /* SESSION_NOT_FOUND */ }
+      );
+    }
+    return session;
+  }
+  /** Stage 3: Apply onBeforeSend middleware pipeline. Returns null if middleware rejected the send. */
+  async applyBeforeSendMiddleware(userMessage, ctx) {
+    let msg = userMessage;
+    for (const mw of this._middleware) {
+      if (mw.onBeforeSend && msg) {
+        msg = await mw.onBeforeSend(msg, ctx);
+        if (msg === null) return null;
+      }
+    }
+    return msg;
+  }
+  /** Stage 4: Persist user message and reload session with full history. */
+  async persistAndReload(cid, userMessage) {
+    await this._sessionStore.appendMessage(cid, userMessage);
+    return await this._sessionStore.getSession(cid);
+  }
+  /** Stage 5: Auto-trim context window if configured. Returns session snapshot for adapter. */
+  async trimSessionContext(cid, session, model) {
+    if (!this._ctxManager) return session;
+    const ctxManager = this._ctxManager;
+    const lastUsage = this._sessionUsage.get(cid);
+    const modelContextWindow = model ? this._modelContextWindows.get(model) : void 0;
+    if (lastUsage && modelContextWindow) {
+      const result2 = ctxManager.fitMessagesWithUsage(
+        session.messages,
+        lastUsage.promptTokens,
+        modelContextWindow
+      );
+      this._contextStats.set(cid, {
+        totalTokens: result2.totalTokens,
+        removedCount: result2.removedCount,
+        wasTruncated: result2.wasTruncated,
+        availableBudget: Math.max(0, modelContextWindow - result2.totalTokens),
+        realPromptTokens: lastUsage.promptTokens,
+        realCompletionTokens: lastUsage.completionTokens,
+        modelContextWindow
+      });
+      if (result2.wasTruncated && this._onContextTrimmed) {
+        const keptIds = new Set(result2.messages.map((m) => m.id));
+        const removed = session.messages.filter((m) => !keptIds.has(m.id));
+        if (removed.length > 0) {
+          try {
+            this._onContextTrimmed(cid, removed);
+          } catch {
+          }
+        }
+      }
+      return { ...session, messages: result2.messages };
+    }
+    const result = await ctxManager.fitMessagesAsync(session.messages);
+    this._contextStats.set(cid, {
+      totalTokens: result.totalTokens,
+      removedCount: result.removedCount,
+      wasTruncated: result.wasTruncated,
+      availableBudget: ctxManager.availableBudget,
+      modelContextWindow
+    });
+    if (result.wasTruncated && this._onContextTrimmed) {
+      const keptIds = new Set(result.messages.map((m) => m.id));
+      const removed = session.messages.filter((m) => !keptIds.has(m.id));
+      if (removed.length > 0) {
+        try {
+          this._onContextTrimmed(cid, removed);
+        } catch {
+        }
+      }
+    }
+    return { ...session, messages: result.messages };
+  }
+  /** Update context stats with real usage data from a usage event. */
+  updateContextStatsWithUsage(cid, promptTokens, completionTokens, options) {
+    const modelContextWindow = options.model ? this._modelContextWindows.get(options.model) : void 0;
+    const existing = this._contextStats.get(cid);
+    this._contextStats.set(cid, {
+      totalTokens: promptTokens,
+      removedCount: existing?.removedCount ?? 0,
+      wasTruncated: existing?.wasTruncated ?? false,
+      availableBudget: modelContextWindow ? Math.max(0, modelContextWindow - promptTokens) : existing?.availableBudget ?? 0,
+      realPromptTokens: promptTokens,
+      realCompletionTokens: completionTokens,
+      modelContextWindow
+    });
+  }
+  /** Stage 6: Prepare event stream — adapter with retry, tool injection. */
+  async prepareEventStream(cid, sessionForAdapter, fullSession, message, options) {
+    const adapter = await this.getOrCreateAdapterWithRetry(options.backend, options.credentials);
+    const runtimeTools = this._tools.size > 0 ? this.injectToolContext([...this._tools.values()], {
+      sessionId: cid,
+      custom: fullSession.metadata?.custom
+    }) : void 0;
+    const streamOptions = {
+      signal: this._abortController.signal,
+      model: options.model,
+      systemPrompt: options.systemPrompt,
+      tools: runtimeTools
+    };
+    return this.createStreamWithRetry(
+      adapter,
+      sessionForAdapter,
+      message,
+      streamOptions,
+      options.backend,
+      options.credentials
+    );
+  }
+  /** Stage 7: Apply onEvent middleware pipeline (sequential transform/suppress). */
+  async applyOnEventMiddleware(event, ctx) {
+    let processed = event;
+    for (const mw of this._middleware) {
+      if (mw.onEvent && processed) {
+        processed = await mw.onEvent(processed, ctx);
+      }
+    }
+    return processed;
+  }
+  /** Stage 8: Finalize accumulator, apply afterReceive middleware, persist assistant message. */
+  async finalizeAssistantMessage(cid, accumulator, ctx) {
+    let assistantMessage = accumulator.finalize();
+    for (const mw of this._middleware) {
+      if (mw.onAfterReceive) {
+        assistantMessage = await mw.onAfterReceive(assistantMessage, ctx);
+      }
+    }
+    await this._sessionStore.appendMessage(cid, assistantMessage);
+    this._notifySessionChange();
+  }
+  /** Stage 9: Error handling — apply onError middleware, transition state. Returns null if suppressed. */
+  async handleSendError(error, cid) {
+    let processedError = error instanceof Error ? error : new Error(String(error));
+    const ctx = {
+      sessionId: cid,
+      signal: this._abortController?.signal ?? new AbortController().signal
+    };
+    for (const mw of this._middleware) {
+      if (mw.onError) {
+        const result = await mw.onError(processedError, ctx);
+        if (result === null) {
+          if (this._state.canTransition("idle")) {
+            this._state.transition("idle");
+          }
+          return null;
+        }
+        processedError = result;
+      }
+    }
+    if (this._state.canTransition("error")) {
+      this._state.transition("error");
+    }
+    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() {
@@ -899,37 +1100,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) {
@@ -961,17 +1171,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);
         }
       }
@@ -984,7 +1202,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;
@@ -1005,13 +1223,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);
         }
       }
     }