@witqq/agent-sdk 0.8.0 → 0.9.0

package/dist/chat/backends.d.cts

@@ -1,14 +1,14 @@
-import { a as ChatEvent } from '../types-DRgd_9R7.cjs';
-export { B as BackendAdapterOptions, I as IChatBackend, d as IResumableBackend, i as isResumableBackend } from '../types-DRgd_9R7.cjs';
-export { B as BaseBackendAdapter, C as ClaudeChatAdapter, a as ClaudeChatAdapterOptions, b as CopilotChatAdapter, c as CopilotChatAdapterOptions, I as InProcessChatTransport, V as VercelAIChatAdapter, d as VercelAIChatAdapterOptions, W as WS_READY_STATE, e as WebSocketLike, f as WsChatTransport, g as WsTransportOptions } from '../in-process-transport-C7DSqPyX.cjs';
-import { I as IChatTransport } from '../transport-Cdh3M0tS.cjs';
-export { C as CloseDetectable, S as SSEChatTransport, a as SSETransportOptions, W as WritableResponse, s as streamToTransport } from '../transport-Cdh3M0tS.cjs';
-import '../agent-DxY68NZL.cjs';
+import { a as ChatEvent } from '../types-DkSXALKg.cjs';
+export { B as BackendAdapterOptions, I as IChatBackend, d as IResumableBackend, i as isResumableBackend } from '../types-DkSXALKg.cjs';
+export { B as BaseBackendAdapter, C as ClaudeChatAdapter, a as ClaudeChatAdapterOptions, b as CopilotChatAdapter, c as CopilotChatAdapterOptions, I as InProcessChatTransport, M as MockLLMChatAdapter, d as MockLLMChatAdapterOptions, R as ResumableChatAdapter, V as VercelAIChatAdapter, e as VercelAIChatAdapterOptions, W as WS_READY_STATE, f as WebSocketLike, g as WsChatTransport, h as WsTransportOptions } from '../in-process-transport-Ct9YcX8I.cjs';
+import { I as IChatTransport } from '../transport-DLWCN18G.cjs';
+export { C as CloseDetectable, S as SSEChatTransport, a as SSETransportOptions, W as WritableResponse, s as streamToTransport } from '../transport-DLWCN18G.cjs';
+import '../agent-C6H2CgJA.cjs';
 import 'zod';
 import '../errors-C-so0M4t.cjs';
 import '../types-4vbcmPTp.cjs';
 import '../errors-CmVvczxZ.cjs';
-import '../backends-BSrsBYFn.cjs';
+import '../backends-Cno0gZjy.cjs';
 
 /**
  * @witqq/agent-sdk - Transport Interceptors

package/dist/chat/backends.d.ts

@@ -1,14 +1,14 @@
-import { a as ChatEvent } from '../types-ajANVzf7.js';
-export { B as BackendAdapterOptions, I as IChatBackend, d as IResumableBackend, i as isResumableBackend } from '../types-ajANVzf7.js';
-export { B as BaseBackendAdapter, C as ClaudeChatAdapter, a as ClaudeChatAdapterOptions, b as CopilotChatAdapter, c as CopilotChatAdapterOptions, I as InProcessChatTransport, V as VercelAIChatAdapter, d as VercelAIChatAdapterOptions, W as WS_READY_STATE, e as WebSocketLike, f as WsChatTransport, g as WsTransportOptions } from '../in-process-transport-C1JnJGVR.js';
-import { I as IChatTransport } from '../transport-Ciap4PWK.js';
-export { C as CloseDetectable, S as SSEChatTransport, a as SSETransportOptions, W as WritableResponse, s as streamToTransport } from '../transport-Ciap4PWK.js';
-import '../agent-CW9XbmG_.js';
+import { a as ChatEvent } from '../types-DgtI1hzh.js';
+export { B as BackendAdapterOptions, I as IChatBackend, d as IResumableBackend, i as isResumableBackend } from '../types-DgtI1hzh.js';
+export { B as BaseBackendAdapter, C as ClaudeChatAdapter, a as ClaudeChatAdapterOptions, b as CopilotChatAdapter, c as CopilotChatAdapterOptions, I as InProcessChatTransport, M as MockLLMChatAdapter, d as MockLLMChatAdapterOptions, R as ResumableChatAdapter, V as VercelAIChatAdapter, e as VercelAIChatAdapterOptions, W as WS_READY_STATE, f as WebSocketLike, g as WsChatTransport, h as WsTransportOptions } from '../in-process-transport-7EIit9Xk.js';
+import { I as IChatTransport } from '../transport-DsuS-GeM.js';
+export { C as CloseDetectable, S as SSEChatTransport, a as SSETransportOptions, W as WritableResponse, s as streamToTransport } from '../transport-DsuS-GeM.js';
+import '../agent-F7oB6eKp.js';
 import 'zod';
 import '../errors-C-so0M4t.js';
 import '../types-BxggH0Yh.js';
 import '../errors-CmVvczxZ.js';
-import '../backends-BSrsBYFn.js';
+import '../backends-Cno0gZjy.js';
 
 /**
  * @witqq/agent-sdk - Transport Interceptors

package/dist/chat/backends.js

@@ -722,17 +722,6 @@ function convertParameters(params) {
   }
   return params;
 }
-async function mapToolsToSDKAsync(tools) {
-  return tools.map((tool) => ({
-    name: tool.name,
-    description: tool.description,
-    parameters: convertParameters(tool.parameters),
-    handler: async (args) => {
-      const result = await tool.execute(args);
-      return typeof result === "string" ? result : JSON.stringify(result);
-    }
-  }));
-}
 function buildPermissionHandler(config) {
   const onPermission = config.supervisor?.onPermission;
   if (!onPermission) {
@@ -970,15 +959,15 @@ var init_copilot = __esm({
           },
           onPermissionRequest: buildPermissionHandler(config),
           onUserInputRequest: buildUserInputHandler(config),
-          ...config.availableTools?.length ? { availableTools: config.availableTools } : {}
+          ...config.availableTools ? { availableTools: config.availableTools } : {}
         };
         this._toolsReady = this._initToolsAsync(config);
         this._resumeSessionId = resumeSessionId;
       }
-      /** Pre-convert Zod schemas to JSON Schema asynchronously.
+      /** Pre-convert Zod schemas to JSON Schema.
        *  Updates sdkTools and sessionConfig.tools before first session creation. */
       async _initToolsAsync(config) {
-        this.sdkTools = await mapToolsToSDKAsync(config.tools ?? []);
+        this.sdkTools = mapToolsToSDK(config.tools ?? []);
         this.sessionConfig.tools = this.sdkTools;
       }
       get sessionId() {
@@ -1269,7 +1258,11 @@ You MUST respond with ONLY valid JSON matching this schema:
               githubToken: this.options.githubToken,
               useLoggedInUser: this.options.useLoggedInUser ?? !this.options.githubToken,
               ...this.options.cliArgs ? { cliArgs: this.options.cliArgs } : {},
-              ...this.options.env ? { env: { ...process.env, ...this.options.env } } : {}
+              env: {
+                ...process.env,
+                ...this.options.githubToken ? { GITHUB_TOKEN: this.options.githubToken } : {},
+                ...this.options.env
+              }
             });
             const startupTimeout = this.options.startupTimeoutMs ?? 3e4;
             await withTimeout(client.start(), startupTimeout, "CLI startup timed out");
@@ -2689,6 +2682,7 @@ var init_vercel_ai = __esm({
           }
         });
         let finalText = "";
+        let lastFinishReason;
         try {
           for await (const part of result.fullStream) {
             if (signal.aborted) throw new AbortError();
@@ -2699,10 +2693,15 @@ var init_vercel_ai = __esm({
             }
             if (part.type === "finish-step") {
               const p = part;
+              lastFinishReason = p.finishReason;
               if (p.finishReason === "tool-calls") {
                 finalText = "";
               }
             }
+            if (part.type === "finish") {
+              const p = part;
+              lastFinishReason = p.finishReason;
+            }
           }
           const totalUsage = await result.totalUsage;
           yield {
@@ -2714,7 +2713,8 @@ var init_vercel_ai = __esm({
           yield {
             type: "done",
             finalOutput: hasStreamed ? null : finalText || null,
-            ...hasStreamed ? { streamed: true } : {}
+            ...hasStreamed ? { streamed: true } : {},
+            ...lastFinishReason ? { finishReason: lastFinishReason } : {}
           };
         } catch (e) {
           if (signal.aborted) throw new AbortError();
@@ -2879,8 +2879,9 @@ function agentEventToChatEvent(event, messageId) {
     case "ask_user":
     case "ask_user_response":
     case "session_info":
-    case "done":
       return null;
+    case "done":
+      return { type: "done", finalOutput: event.finalOutput ?? void 0, finishReason: event.finishReason };
     default:
       return null;
   }
@@ -2895,24 +2896,37 @@ async function* adaptAgentEvents(events, messageId) {
 }
 
 // src/chat/conversion.ts
-function toAgentMessage(message) {
+function toAgentMessages(message) {
   const textContent = getMessageText(message);
   const toolCallParts = getMessageToolCalls(message);
   switch (message.role) {
     case "user":
-      return { role: "user", content: textContent };
+      return [{ role: "user", content: textContent }];
     case "assistant": {
       const toolCalls = toolCallParts.length > 0 ? toolCallParts.map((p) => ({ id: p.toolCallId, name: p.name, args: p.args })) : void 0;
-      return {
+      const assistantMsg = {
         role: "assistant",
         content: textContent,
         toolCalls
       };
+      const toolResults = extractToolResults(message);
+      if (toolResults.length > 0) {
+        return [assistantMsg, { role: "tool", toolResults }];
+      }
+      return [assistantMsg];
     }
     case "system":
-      return { role: "system", content: textContent };
+      return [{ role: "system", content: textContent }];
   }
 }
+function extractToolResults(message) {
+  return getMessageToolCalls(message).filter((p) => p.result !== void 0).map((p) => ({
+    toolCallId: p.toolCallId,
+    name: p.name,
+    result: p.result,
+    isError: p.status === "error" ? true : void 0
+  }));
+}
 
 // src/chat/errors.ts
 init_errors2();
@@ -3011,7 +3025,7 @@ var BaseBackendAdapter = class {
   async *streamMessage(session, message, options) {
     this.assertNotDisposed();
     const agent = this.getOrCreateAgent(options);
-    const messages = session.messages.map(toAgentMessage);
+    const messages = session.messages.flatMap(toAgentMessages);
     messages.push({ role: "user", content: message });
     yield* this.streamAgentEvents(agent, messages, options);
   }
@@ -3088,7 +3102,8 @@ var BaseBackendAdapter = class {
     }
     const config = {
       ...this._agentConfig,
-      ...model !== void 0 && { model }
+      ...model !== void 0 && { model },
+      ...options?.tools?.length ? { tools: options.tools } : {}
     };
     const agent = this.agentService.createAgent(config);
     this._currentAgent = { instance: agent, model };
@@ -3103,21 +3118,15 @@ var BaseBackendAdapter = class {
   }
 };
 
-// src/chat/backends/copilot.ts
-var CopilotChatAdapter = class extends BaseBackendAdapter {
+// src/chat/backends/resumable.ts
+var ResumableChatAdapter = class extends BaseBackendAdapter {
   _backendSessionId = null;
-  _copilotOptions;
-  constructor(options) {
+  constructor(name, options) {
     const agentConfig = {
       ...options.agentConfig,
       sessionMode: "persistent"
     };
-    super("copilot", { ...options, agentConfig });
-    this._copilotOptions = options.copilotOptions;
-  }
-  createService() {
-    const { createCopilotService: createCopilotService2 } = (init_copilot(), __toCommonJS(copilot_exports));
-    return createCopilotService2(this._copilotOptions || {});
+    super(name, { ...options, agentConfig });
   }
   get backendSessionId() {
     return this._backendSessionId;
@@ -3146,7 +3155,7 @@ var CopilotChatAdapter = class extends BaseBackendAdapter {
         { code: "SESSION_EXPIRED" /* SESSION_EXPIRED */ }
       );
     }
-    const messages = session.messages.map(toAgentMessage);
+    const messages = session.messages.flatMap(toAgentMessages);
     yield* this.streamAgentEvents(agent, messages, options);
   }
   captureSessionId(agent) {
@@ -3156,69 +3165,325 @@ var CopilotChatAdapter = class extends BaseBackendAdapter {
   }
 };
 
+// src/chat/backends/copilot.ts
+var CopilotChatAdapter = class extends ResumableChatAdapter {
+  _copilotOptions;
+  constructor(options) {
+    super("copilot", options);
+    this._copilotOptions = options.copilotOptions;
+  }
+  createService() {
+    const { createCopilotService: createCopilotService2 } = (init_copilot(), __toCommonJS(copilot_exports));
+    return createCopilotService2(this._copilotOptions || {});
+  }
+};
+
 // src/chat/backends/claude.ts
-var ClaudeChatAdapter = class extends BaseBackendAdapter {
-  _backendSessionId = null;
+var ClaudeChatAdapter = class extends ResumableChatAdapter {
   _claudeOptions;
   constructor(options) {
-    const agentConfig = {
-      ...options.agentConfig,
-      sessionMode: "persistent"
-    };
-    super("claude", { ...options, agentConfig });
+    super("claude", options);
     this._claudeOptions = options.claudeOptions;
   }
   createService() {
     const { 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" }
+          };
+        }
+      }
     }
   }
 };
+var MockLLMService = class {
+  name = "mock-llm";
+  options;
+  models;
+  constructor(options = {}) {
+    this.options = options;
+    this.models = (options.models ?? [
+      { id: "mock-fast", name: "Mock Fast" },
+      { id: "mock-quality", name: "Mock Quality" }
+    ]).map((m) => ({
+      id: m.id,
+      name: m.name,
+      description: m.description
+    }));
+  }
+  createAgent(config) {
+    return new MockLLMAgent(config, this.options);
+  }
+  async listModels() {
+    return this.models;
+  }
+  async validate() {
+    return { valid: true, errors: [] };
+  }
+  async dispose() {
+  }
+};
+function createMockLLMService(options = {}) {
+  return new MockLLMService(options);
+}
 
-// src/chat/backends/vercel-ai.ts
-var VercelAIChatAdapter = class extends BaseBackendAdapter {
-  _vercelOptions;
+// src/chat/backends/mock-llm.ts
+var MockLLMChatAdapter = class extends BaseBackendAdapter {
   constructor(options) {
-    super("vercel-ai", options);
-    this._vercelOptions = options.vercelOptions;
+    const mockOpts = options.mockOptions;
+    super("mock-llm", {
+      ...options,
+      agentServiceFactory: () => createMockLLMService(mockOpts || {})
+    });
   }
   createService() {
-    const { createVercelAIService: createVercelAIService2 } = (init_vercel_ai(), __toCommonJS(vercel_ai_exports));
-    return createVercelAIService2(this._vercelOptions || {});
+    return createMockLLMService({});
   }
   captureSessionId(_agent) {
   }
@@ -3299,16 +3564,22 @@ var SSEChatTransport = class {
 };
 async function streamToTransport(events, transport) {
   try {
-    let accumulatedText = "";
+    const textChunks = [];
+    let finishReason;
     for await (const event of events) {
       if (!transport.isOpen) break;
+      if (event.type === "done") {
+        finishReason = event.finishReason;
+        continue;
+      }
       transport.send(event);
       if (event.type === "message:delta") {
-        accumulatedText += event.text;
+        textChunks.push(event.text);
       }
     }
     if (transport.isOpen) {
-      transport.send({ type: "done", finalOutput: accumulatedText || void 0 });
+      const finalOutput = textChunks.length > 0 ? textChunks.join("") : void 0;
+      transport.send({ type: "done", finalOutput, finishReason });
     }
     transport.close();
   } catch (err) {
@@ -3507,6 +3778,6 @@ function withInterceptors(transport, interceptors) {
   return new InterceptedTransport(transport, interceptors);
 }
 
-export { BaseBackendAdapter, ClaudeChatAdapter, CopilotChatAdapter, InProcessChatTransport, SSEChatTransport, VercelAIChatAdapter, WS_READY_STATE, WsChatTransport, isResumableBackend, streamToTransport, withInterceptors };
+export { BaseBackendAdapter, ClaudeChatAdapter, CopilotChatAdapter, InProcessChatTransport, MockLLMChatAdapter, ResumableChatAdapter, SSEChatTransport, VercelAIChatAdapter, WS_READY_STATE, WsChatTransport, isResumableBackend, streamToTransport, withInterceptors };
 //# sourceMappingURL=backends.js.map
 //# sourceMappingURL=backends.js.map