@witqq/agent-sdk 0.8.0 → 0.9.0

package/dist/chat/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var fs = require('fs');
+var promises = require('fs/promises');
 var path = require('path');
 
 var __defProp = Object.defineProperty;
@@ -758,17 +759,6 @@ function convertParameters(params) {
   }
   return params;
 }
-async function mapToolsToSDKAsync(tools) {
-  return tools.map((tool) => ({
-    name: tool.name,
-    description: tool.description,
-    parameters: convertParameters(tool.parameters),
-    handler: async (args) => {
-      const result = await tool.execute(args);
-      return typeof result === "string" ? result : JSON.stringify(result);
-    }
-  }));
-}
 function buildPermissionHandler(config) {
   const onPermission = config.supervisor?.onPermission;
   if (!onPermission) {
@@ -1006,15 +996,15 @@ var init_copilot = __esm({
           },
           onPermissionRequest: buildPermissionHandler(config),
           onUserInputRequest: buildUserInputHandler(config),
-          ...config.availableTools?.length ? { availableTools: config.availableTools } : {}
+          ...config.availableTools ? { availableTools: config.availableTools } : {}
         };
         this._toolsReady = this._initToolsAsync(config);
         this._resumeSessionId = resumeSessionId;
       }
-      /** Pre-convert Zod schemas to JSON Schema asynchronously.
+      /** Pre-convert Zod schemas to JSON Schema.
        *  Updates sdkTools and sessionConfig.tools before first session creation. */
       async _initToolsAsync(config) {
-        this.sdkTools = await mapToolsToSDKAsync(config.tools ?? []);
+        this.sdkTools = mapToolsToSDK(config.tools ?? []);
         this.sessionConfig.tools = this.sdkTools;
       }
       get sessionId() {
@@ -1305,7 +1295,11 @@ You MUST respond with ONLY valid JSON matching this schema:
               githubToken: this.options.githubToken,
               useLoggedInUser: this.options.useLoggedInUser ?? !this.options.githubToken,
               ...this.options.cliArgs ? { cliArgs: this.options.cliArgs } : {},
-              ...this.options.env ? { env: { ...process.env, ...this.options.env } } : {}
+              env: {
+                ...process.env,
+                ...this.options.githubToken ? { GITHUB_TOKEN: this.options.githubToken } : {},
+                ...this.options.env
+              }
             });
             const startupTimeout = this.options.startupTimeoutMs ?? 3e4;
             await withTimeout(client.start(), startupTimeout, "CLI startup timed out");
@@ -2725,6 +2719,7 @@ var init_vercel_ai = __esm({
           }
         });
         let finalText = "";
+        let lastFinishReason;
         try {
           for await (const part of result.fullStream) {
             if (signal.aborted) throw new AbortError();
@@ -2735,10 +2730,15 @@ var init_vercel_ai = __esm({
             }
             if (part.type === "finish-step") {
               const p = part;
+              lastFinishReason = p.finishReason;
               if (p.finishReason === "tool-calls") {
                 finalText = "";
               }
             }
+            if (part.type === "finish") {
+              const p = part;
+              lastFinishReason = p.finishReason;
+            }
           }
           const totalUsage = await result.totalUsage;
           yield {
@@ -2750,7 +2750,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();
@@ -2912,30 +2913,30 @@ 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
@@ -2999,8 +3000,9 @@ function agentEventToChatEvent(event, messageId) {
     case "ask_user":
     case "ask_user_response":
     case "session_info":
-    case "done":
       return null;
+    case "done":
+      return { type: "done", finalOutput: event.finalOutput ?? void 0, finishReason: event.finishReason };
     default:
       return null;
   }
@@ -3046,21 +3048,29 @@ function chatEventToAgentEvent(event) {
 
 // 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) {
@@ -3106,6 +3116,14 @@ function fromAgentMessage(message, id) {
     status: "complete"
   };
 }
+function extractToolResults(message) {
+  return getMessageToolCalls(message).filter((p) => p.result !== void 0).map((p) => ({
+    toolCallId: p.toolCallId,
+    name: p.name,
+    result: p.result,
+    isError: p.status === "error" ? true : void 0
+  }));
+}
 
 // src/chat/context.ts
 function estimateTokens(message, options) {
@@ -3938,6 +3956,7 @@ var ChatRuntime = class {
   _backends;
   _sessionStore;
   _contextConfig;
+  _ctxManager;
   _middleware;
   _tools = /* @__PURE__ */ new Map();
   _retryConfig;
@@ -3957,6 +3976,9 @@ var ChatRuntime = class {
     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;
@@ -4137,8 +4159,8 @@ var ChatRuntime = class {
   }
   /** Stage 5: Auto-trim context window if configured. Returns session snapshot for adapter. */
   async trimSessionContext(cid, session, model) {
-    if (!this._contextConfig) return session;
-    const ctxManager = new ContextWindowManager(this._contextConfig);
+    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) {
@@ -4554,25 +4576,25 @@ var FileStorage = class {
   constructor(options) {
     this.directory = options.directory;
     this.extension = options.extension ?? ".json";
-    this.ensureDirectory();
+    this.ensureDirectorySync();
   }
   /** @inheritdoc */
   async get(key) {
     const filePath = this.keyToPath(key);
-    if (!fs.existsSync(filePath)) {
+    if (!await this.fileExists(filePath)) {
       return null;
     }
-    return this.readFile(filePath);
+    return this.readJsonFile(filePath);
   }
   /** @inheritdoc */
   async list(options) {
-    this.ensureDirectory();
-    const files = fs.readdirSync(this.directory).filter(
+    await this.ensureDirectoryAsync();
+    const files = (await promises.readdir(this.directory)).filter(
       (f) => f.endsWith(this.extension)
     );
     let items = [];
     for (const file of files) {
-      const item = this.readFile(path.join(this.directory, file));
+      const item = await this.readJsonFile(path.join(this.directory, file));
       items.push(item);
     }
     if (options?.filter) {
@@ -4592,55 +4614,55 @@ var FileStorage = class {
   /** @inheritdoc */
   async create(key, item) {
     const filePath = this.keyToPath(key);
-    if (fs.existsSync(filePath)) {
+    if (await this.fileExists(filePath)) {
       throw new StorageError(
         `Item with key "${key}" already exists`,
         "STORAGE_DUPLICATE_KEY" /* STORAGE_DUPLICATE_KEY */
       );
     }
-    this.writeFile(filePath, item);
+    await this.writeJsonFile(filePath, item);
   }
   /** @inheritdoc */
   async update(key, item) {
     const filePath = this.keyToPath(key);
-    if (!fs.existsSync(filePath)) {
+    if (!await this.fileExists(filePath)) {
       throw new StorageError(
         `Item with key "${key}" not found`,
         "STORAGE_NOT_FOUND" /* STORAGE_NOT_FOUND */
       );
     }
-    this.writeFile(filePath, item);
+    await this.writeJsonFile(filePath, item);
   }
   /** @inheritdoc */
   async delete(key) {
     const filePath = this.keyToPath(key);
-    if (!fs.existsSync(filePath)) {
+    if (!await this.fileExists(filePath)) {
       throw new StorageError(
         `Item with key "${key}" not found`,
         "STORAGE_NOT_FOUND" /* STORAGE_NOT_FOUND */
       );
     }
-    fs.unlinkSync(filePath);
+    await promises.unlink(filePath);
   }
   /** @inheritdoc */
   async has(key) {
-    return fs.existsSync(this.keyToPath(key));
+    return this.fileExists(this.keyToPath(key));
   }
   /** @inheritdoc */
   async count() {
-    this.ensureDirectory();
-    return fs.readdirSync(this.directory).filter(
+    await this.ensureDirectoryAsync();
+    return (await promises.readdir(this.directory)).filter(
       (f) => f.endsWith(this.extension)
     ).length;
   }
   /** @inheritdoc */
   async clear() {
-    this.ensureDirectory();
-    const files = fs.readdirSync(this.directory).filter(
+    await this.ensureDirectoryAsync();
+    const files = (await promises.readdir(this.directory)).filter(
       (f) => f.endsWith(this.extension)
     );
     for (const file of files) {
-      fs.unlinkSync(path.join(this.directory, file));
+      await promises.unlink(path.join(this.directory, file));
     }
   }
   keyToPath(key) {
@@ -4650,14 +4672,29 @@ var FileStorage = class {
     );
     return path.join(this.directory, `${safeKey}${this.extension}`);
   }
-  ensureDirectory() {
+  /** Sync directory init — used only in constructor (one-time). */
+  ensureDirectorySync() {
     if (!fs.existsSync(this.directory)) {
       fs.mkdirSync(this.directory, { recursive: true });
     }
   }
-  readFile(filePath) {
+  /** Async directory init — used in operations. */
+  async ensureDirectoryAsync() {
+    if (!await this.fileExists(this.directory)) {
+      await promises.mkdir(this.directory, { recursive: true });
+    }
+  }
+  async fileExists(filePath) {
+    try {
+      await promises.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async readJsonFile(filePath) {
     try {
-      const content = fs.readFileSync(filePath, "utf-8");
+      const content = await promises.readFile(filePath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       if (error instanceof SyntaxError) {
@@ -4672,10 +4709,10 @@ var FileStorage = class {
       );
     }
   }
-  writeFile(filePath, item) {
+  async writeJsonFile(filePath, item) {
     try {
       const content = JSON.stringify(item, null, 2);
-      fs.writeFileSync(filePath, content, "utf-8");
+      await promises.writeFile(filePath, content, "utf-8");
     } catch {
       throw new StorageError(
         `Failed to write file: ${filePath}`,
@@ -4894,7 +4931,7 @@ var BaseBackendAdapter = class {
   async *streamMessage(session, message, options) {
     this.assertNotDisposed();
     const agent = this.getOrCreateAgent(options);
-    const messages = session.messages.map(toAgentMessage);
+    const messages = session.messages.flatMap(toAgentMessages);
     messages.push({ role: "user", content: message });
     yield* this.streamAgentEvents(agent, messages, options);
   }
@@ -4971,7 +5008,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 };
@@ -4986,21 +5024,15 @@ var BaseBackendAdapter = class {
   }
 };
 
-// src/chat/backends/copilot.ts
-var CopilotChatAdapter = class extends BaseBackendAdapter {
+// src/chat/backends/resumable.ts
+var ResumableChatAdapter = class extends BaseBackendAdapter {
   _backendSessionId = null;
-  _copilotOptions;
-  constructor(options) {
+  constructor(name, options) {
     const agentConfig = {
       ...options.agentConfig,
       sessionMode: "persistent"
     };
-    super("copilot", { ...options, agentConfig });
-    this._copilotOptions = options.copilotOptions;
-  }
-  createService() {
-    const { createCopilotService: createCopilotService2 } = (init_copilot(), __toCommonJS(copilot_exports));
-    return createCopilotService2(this._copilotOptions || {});
+    super(name, { ...options, agentConfig });
   }
   get backendSessionId() {
     return this._backendSessionId;
@@ -5029,7 +5061,7 @@ var CopilotChatAdapter = class extends BaseBackendAdapter {
         { code: "SESSION_EXPIRED" /* SESSION_EXPIRED */ }
       );
     }
-    const messages = session.messages.map(toAgentMessage);
+    const messages = session.messages.flatMap(toAgentMessages);
     yield* this.streamAgentEvents(agent, messages, options);
   }
   captureSessionId(agent) {
@@ -5039,69 +5071,325 @@ var CopilotChatAdapter = class extends BaseBackendAdapter {
   }
 };
 
+// src/chat/backends/copilot.ts
+var CopilotChatAdapter = class extends ResumableChatAdapter {
+  _copilotOptions;
+  constructor(options) {
+    super("copilot", options);
+    this._copilotOptions = options.copilotOptions;
+  }
+  createService() {
+    const { createCopilotService: createCopilotService2 } = (init_copilot(), __toCommonJS(copilot_exports));
+    return createCopilotService2(this._copilotOptions || {});
+  }
+};
+
 // src/chat/backends/claude.ts
-var ClaudeChatAdapter = class extends BaseBackendAdapter {
-  _backendSessionId = null;
+var ClaudeChatAdapter = class extends ResumableChatAdapter {
   _claudeOptions;
   constructor(options) {
-    const agentConfig = {
-      ...options.agentConfig,
-      sessionMode: "persistent"
-    };
-    super("claude", { ...options, agentConfig });
+    super("claude", options);
     this._claudeOptions = options.claudeOptions;
   }
   createService() {
     const { 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) {
   }
@@ -5182,16 +5470,22 @@ var SSEChatTransport = class {
 };
 async function streamToTransport(events, transport) {
   try {
-    let accumulatedText = "";
+    const textChunks = [];
+    let finishReason;
     for await (const event of events) {
       if (!transport.isOpen) break;
+      if (event.type === "done") {
+        finishReason = event.finishReason;
+        continue;
+      }
       transport.send(event);
       if (event.type === "message:delta") {
-        accumulatedText += event.text;
+        textChunks.push(event.text);
       }
     }
     if (transport.isOpen) {
-      transport.send({ type: "done", finalOutput: accumulatedText || void 0 });
+      const finalOutput = textChunks.length > 0 ? textChunks.join("") : void 0;
+      transport.send({ type: "done", finalOutput, finishReason });
     }
     transport.close();
   } catch (err) {
@@ -5514,6 +5808,7 @@ exports.InMemorySessionStore = InMemorySessionStore;
 exports.InProcessChatTransport = InProcessChatTransport;
 exports.ListenerSet = ListenerSet;
 exports.MessageAccumulator = MessageAccumulator;
+exports.MockLLMChatAdapter = MockLLMChatAdapter;
 exports.SSEChatTransport = SSEChatTransport;
 exports.TypedEventEmitter = TypedEventEmitter;
 exports.VercelAIChatAdapter = VercelAIChatAdapter;
@@ -5543,6 +5838,7 @@ exports.isTextPart = isTextPart;
 exports.isToolCallPart = isToolCallPart;
 exports.streamToTransport = streamToTransport;
 exports.toAgentMessage = toAgentMessage;
+exports.toAgentMessages = toAgentMessages;
 exports.toChatId = toChatId;
 exports.withRetry = withRetry;
 exports.withStreamWatchdog = withStreamWatchdog;