@firtoz/chat-agent 2.0.0 → 2.1.0

package/dist/chunk-G5P5JXRF.js

@@ -0,0 +1,1068 @@
+import { safeParseClientMessage, isAssistantMessage } from './chunk-OEX3D4WL.js';
+import { exhaustiveGuard } from '@firtoz/maybe-error';
+import { OpenRouter } from '@openrouter/sdk';
+import { Agent } from 'agents';
+
+var DEFAULT_SYSTEM_PROMPT = "You are a helpful AI assistant.";
+var CHUNK_BUFFER_SIZE = 10;
+var CHUNK_BUFFER_MAX_SIZE = 100;
+var STREAM_STALE_THRESHOLD_MS = 5 * 60 * 1e3;
+var CLEANUP_INTERVAL_MS = 10 * 60 * 1e3;
+var CLEANUP_AGE_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_MAX_TOOL_CONTENT_CHARS = 2e5;
+var STREAM_TOOL_TOP_KEYS = /* @__PURE__ */ new Set(["index", "id", "type", "function"]);
+function getRawToolCallDeltaEntry(chunk, index) {
+  const c = chunk;
+  const delta = c.choices?.[0]?.delta;
+  if (!delta) {
+    return void 0;
+  }
+  const list = delta.tool_calls ?? delta.toolCalls;
+  if (!Array.isArray(list) || index < 0 || index >= list.length) {
+    return void 0;
+  }
+  const raw = list[index];
+  if (!raw || typeof raw !== "object") {
+    return void 0;
+  }
+  return raw;
+}
+function extractProviderMetadataFromRawToolPart(raw) {
+  const meta = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (STREAM_TOOL_TOP_KEYS.has(k)) {
+      continue;
+    }
+    meta[k] = v;
+  }
+  const fn = raw.function;
+  if (fn && typeof fn === "object" && !Array.isArray(fn)) {
+    const f = fn;
+    const fnExtra = {};
+    for (const [k, v] of Object.entries(f)) {
+      if (k === "name" || k === "arguments") {
+        continue;
+      }
+      fnExtra[k] = v;
+    }
+    if (Object.keys(fnExtra).length > 0) {
+      meta.function = fnExtra;
+    }
+  }
+  return Object.keys(meta).length > 0 ? meta : void 0;
+}
+var ChatAgentBase = class extends Agent {
+  // ============================================================================
+  // Constructor - Following @cloudflare/ai-chat pattern
+  // ============================================================================
+  constructor(ctx, env) {
+    super(ctx, env);
+    /** In-memory cache of messages */
+    this.messages = [];
+    /** Map of message IDs to AbortControllers for request cancellation */
+    this._abortControllers = /* @__PURE__ */ new Map();
+    /** Currently active stream ID */
+    this._activeStreamId = null;
+    /** Message ID being streamed */
+    this._activeMessageId = null;
+    /** True only while the OpenRouter async iterator for the active stream is running */
+    this._openRouterStreamLive = false;
+    /** Current chunk index for active stream */
+    this._streamChunkIndex = 0;
+    /** Buffer for chunks pending write */
+    this._chunkBuffer = [];
+    /** Lock for flush operations */
+    this._isFlushingChunks = false;
+    /** Last cleanup timestamp */
+    this._lastCleanupTime = 0;
+    /** Client-registered tools (tools defined at runtime from frontend) */
+    this._clientTools = /* @__PURE__ */ new Map();
+    /** FIFO serialization of chat turns (user sends, tool continuations, etc.) */
+    this._turnTail = Promise.resolve();
+    /** Bumped by {@link resetTurnState} to ignore stale async work */
+    this._turnGeneration = 0;
+    /** Connection id that last queued an auto-continue after client tools (for multi-tab hints) */
+    this._continuationOriginConnectionId = null;
+    this._pendingClientToolAutoContinue = [];
+    this._clientToolAutoContinueFlushScheduled = false;
+    /** Human-in-the-loop: server tools awaiting `toolApprovalResponse` (not queued — avoids deadlock). */
+    this._pendingToolApprovals = /* @__PURE__ */ new Map();
+    this.dbInitialize();
+    this.messages = this.dbLoadMessages();
+    this._restoreActiveStream();
+    this._openRouterStreamLive = false;
+    const _onConnect = this.onConnect.bind(this);
+    this.onConnect = async (connection, connCtx) => {
+      if (this._activeStreamId && this._activeMessageId) {
+        this._notifyStreamResuming(connection);
+      }
+      return _onConnect(connection, connCtx);
+    };
+  }
+  // ============================================================================
+  // Persistence hooks (override in subclasses)
+  // ============================================================================
+  /**
+   * Transform a message immediately before it is written to storage.
+   * Default: return the message unchanged.
+   */
+  sanitizeMessageForPersistence(msg) {
+    return msg;
+  }
+  // ============================================================================
+  // Turn coordination (subclasses / host code)
+  // ============================================================================
+  /**
+   * Resolves after all queued turns have finished and no OpenRouter stream is active.
+   */
+  waitUntilStable() {
+    return this._turnTail.then(async () => {
+      while (this._openRouterStreamLive) {
+        await new Promise((r) => queueMicrotask(r));
+      }
+    });
+  }
+  /**
+   * Abort in-flight generation, clear pending client tool auto-continue batch, and invalidate queued async work.
+   * Call from custom clear handlers; {@link clearHistory} path also resets state.
+   */
+  resetTurnState() {
+    this._turnGeneration++;
+    this._pendingClientToolAutoContinue = [];
+    this._clientToolAutoContinueFlushScheduled = false;
+    this._continuationOriginConnectionId = null;
+    for (const p of this._pendingToolApprovals.values()) {
+      p.resolve(false);
+    }
+    this._pendingToolApprovals.clear();
+    for (const id of [...this._abortControllers.keys()]) {
+      this._cancelRequest(id);
+    }
+  }
+  /**
+   * True when the last assistant message still has tool calls without matching tool role replies.
+   */
+  hasPendingInteraction() {
+    if (this._pendingToolApprovals.size > 0) {
+      return true;
+    }
+    const last = this.messages[this.messages.length - 1];
+    if (!last || last.role !== "assistant") {
+      return false;
+    }
+    if (!last.toolCalls?.length) {
+      return false;
+    }
+    const pending = new Set(last.toolCalls.map((t) => t.id));
+    for (const m of this.messages) {
+      if (m.role === "tool" && pending.has(m.toolCallId)) {
+        pending.delete(m.toolCallId);
+      }
+    }
+    return pending.size > 0;
+  }
+  // ============================================================================
+  // Message Persistence
+  // ============================================================================
+  _persistMessage(msg) {
+    const sanitized = this.sanitizeMessageForPersistence(msg);
+    const stored = this._maybeTruncateToolMessageContent(sanitized);
+    this.dbSaveMessage(stored);
+    const max = this.maxPersistedMessages;
+    if (typeof max === "number" && max > 0) {
+      this.dbTrimMessagesToMax(max);
+      this.messages = this.dbLoadMessages();
+    }
+  }
+  _maybeTruncateToolMessageContent(msg) {
+    if (msg.role !== "tool") {
+      return msg;
+    }
+    const content = msg.content;
+    if (content.length <= DEFAULT_MAX_TOOL_CONTENT_CHARS) {
+      return msg;
+    }
+    const truncated = content.slice(0, DEFAULT_MAX_TOOL_CONTENT_CHARS) + `
+\u2026 [truncated ${content.length - DEFAULT_MAX_TOOL_CONTENT_CHARS} chars for storage]`;
+    return { ...msg, content: truncated };
+  }
+  _clearMessages() {
+    this.resetTurnState();
+    this.dbClearAll();
+    this._activeStreamId = null;
+    this._activeMessageId = null;
+    this._streamChunkIndex = 0;
+    this._chunkBuffer = [];
+    this.messages = [];
+  }
+  // ============================================================================
+  // Stream Restoration (following @cloudflare/ai-chat pattern)
+  // ============================================================================
+  /**
+   * Restore active stream state if the agent was restarted during streaming.
+   * Called during construction to recover any interrupted streams.
+   */
+  _restoreActiveStream() {
+    const stream = this.dbFindActiveStream();
+    if (!stream) {
+      return;
+    }
+    const streamAge = Date.now() - stream.createdAt.getTime();
+    if (streamAge > STREAM_STALE_THRESHOLD_MS) {
+      this.dbDeleteStreamWithChunks(stream.id);
+      console.warn(
+        `[ChatAgent] Deleted stale stream ${stream.id} (age: ${Math.round(streamAge / 1e3)}s)`
+      );
+      return;
+    }
+    this._activeStreamId = stream.id;
+    this._activeMessageId = stream.messageId;
+    const maxIndex = this.dbFindMaxChunkIndex(stream.id);
+    this._streamChunkIndex = maxIndex != null ? maxIndex + 1 : 0;
+  }
+  /**
+   * Notify a connection about an active stream that can be resumed.
+   */
+  _notifyStreamResuming(connection) {
+    if (!this._activeStreamId || !this._activeMessageId) {
+      return;
+    }
+    this._sendTo(connection, {
+      type: "streamResuming",
+      id: this._activeMessageId,
+      streamId: this._activeStreamId
+    });
+  }
+  // ============================================================================
+  // Stream Chunk Management
+  // ============================================================================
+  _storeChunk(streamId, content) {
+    if (this._chunkBuffer.length >= CHUNK_BUFFER_MAX_SIZE) {
+      this._flushChunkBuffer();
+    }
+    this._chunkBuffer.push({
+      streamId,
+      content,
+      index: this._streamChunkIndex++
+    });
+    if (this._chunkBuffer.length >= CHUNK_BUFFER_SIZE) {
+      this._flushChunkBuffer();
+    }
+  }
+  _flushChunkBuffer() {
+    if (this._isFlushingChunks || this._chunkBuffer.length === 0) {
+      return;
+    }
+    this._isFlushingChunks = true;
+    try {
+      const chunks = this._chunkBuffer;
+      this._chunkBuffer = [];
+      const chunksToInsert = chunks.map((chunk) => ({
+        id: crypto.randomUUID(),
+        streamId: chunk.streamId,
+        content: chunk.content,
+        chunkIndex: chunk.index
+      }));
+      this.dbInsertChunks(chunksToInsert);
+    } finally {
+      this._isFlushingChunks = false;
+    }
+  }
+  _startStream(messageId) {
+    this._flushChunkBuffer();
+    const streamId = crypto.randomUUID();
+    this._activeStreamId = streamId;
+    this._activeMessageId = messageId;
+    this._streamChunkIndex = 0;
+    this.dbInsertStreamMetadata(streamId, messageId);
+    return streamId;
+  }
+  /**
+   * Complete stream with a full message (supports tool calls)
+   */
+  _completeStreamWithMessage(streamId, message) {
+    this._flushChunkBuffer();
+    this.dbUpdateStreamStatus(streamId, "completed");
+    this._persistMessage(message);
+    if (typeof this.maxPersistedMessages !== "number") {
+      this.messages.push(message);
+    }
+    this.dbDeleteChunks(streamId);
+    this._activeStreamId = null;
+    this._activeMessageId = null;
+    this._streamChunkIndex = 0;
+    this._maybeCleanupOldStreams();
+  }
+  _markStreamError(streamId) {
+    this._flushChunkBuffer();
+    this.dbUpdateStreamStatus(streamId, "error");
+    this._activeStreamId = null;
+    this._activeMessageId = null;
+    this._streamChunkIndex = 0;
+  }
+  /**
+   * Clean up old completed streams periodically.
+   */
+  _maybeCleanupOldStreams() {
+    const now = Date.now();
+    if (now - this._lastCleanupTime < CLEANUP_INTERVAL_MS) {
+      return;
+    }
+    this._lastCleanupTime = now;
+    const cutoffMs = now - CLEANUP_AGE_THRESHOLD_MS;
+    this.dbDeleteOldCompletedStreams(cutoffMs);
+  }
+  _getStreamChunks(streamId) {
+    this._flushChunkBuffer();
+    return this.dbGetChunks(streamId);
+  }
+  /**
+   * Finalize a stream that has buffered chunks but no live OpenRouter reader (e.g. after DO restart).
+   */
+  _finalizeOrphanedStreamFromChunks(streamId) {
+    if (this._activeStreamId !== streamId || !this._activeMessageId) {
+      return;
+    }
+    const messageId = this._activeMessageId;
+    const chunks = this._getStreamChunks(streamId);
+    const text = chunks.join("");
+    const assistantMessage = {
+      id: messageId,
+      role: "assistant",
+      content: text.length > 0 ? text : null,
+      createdAt: Date.now()
+    };
+    this._completeStreamWithMessage(streamId, assistantMessage);
+    this._broadcast({
+      type: "messageEnd",
+      id: messageId,
+      createdAt: assistantMessage.createdAt
+    });
+  }
+  // ============================================================================
+  // Abort Controller Management
+  // ============================================================================
+  _getAbortSignal(id) {
+    let controller = this._abortControllers.get(id);
+    if (!controller) {
+      controller = new AbortController();
+      this._abortControllers.set(id, controller);
+    }
+    return controller.signal;
+  }
+  _cancelRequest(id) {
+    const controller = this._abortControllers.get(id);
+    if (controller) {
+      controller.abort();
+      this._abortControllers.delete(id);
+    }
+  }
+  _removeAbortController(id) {
+    this._abortControllers.delete(id);
+  }
+  // ============================================================================
+  // Broadcasting
+  // ============================================================================
+  _broadcast(msg) {
+    this.broadcast(JSON.stringify(msg));
+  }
+  _sendTo(connection, msg) {
+    connection.send(JSON.stringify(msg));
+  }
+  _enqueueTurn(fn) {
+    const run = this._turnTail.then(fn);
+    this._turnTail = run.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    return run;
+  }
+  _resolveToolApproval(approvalId, approved) {
+    const pending = this._pendingToolApprovals.get(approvalId);
+    if (!pending) {
+      return;
+    }
+    this._pendingToolApprovals.delete(approvalId);
+    pending.resolve(approved);
+  }
+  _mergeProviderMetadata(a, b) {
+    if (!a && !b) {
+      return void 0;
+    }
+    return { ...a ?? {}, ...b ?? {} };
+  }
+  _replaceMessagesFromClient(messages) {
+    this.resetTurnState();
+    this._flushChunkBuffer();
+    if (this._activeStreamId) {
+      this.dbDeleteStreamWithChunks(this._activeStreamId);
+    }
+    this._activeStreamId = null;
+    this._activeMessageId = null;
+    this._streamChunkIndex = 0;
+    this._chunkBuffer = [];
+    this.dbReplaceAllMessages([...messages]);
+    this.messages = [...messages];
+  }
+  // ============================================================================
+  // OpenRouter Integration
+  // ============================================================================
+  _getOpenRouter() {
+    const envWithGateway = this.env;
+    const serverURL = envWithGateway.CLOUDFLARE_ACCOUNT_ID && envWithGateway.AI_GATEWAY_NAME ? `https://gateway.ai.cloudflare.com/v1/${envWithGateway.CLOUDFLARE_ACCOUNT_ID}/${envWithGateway.AI_GATEWAY_NAME}/openrouter` : void 0;
+    return new OpenRouter({
+      apiKey: this.env.OPENROUTER_API_KEY,
+      ...serverURL && { serverURL }
+    });
+  }
+  // ============================================================================
+  // WebSocket Handlers
+  // ============================================================================
+  async onConnect(connection, _ctx) {
+    this._sendTo(connection, { type: "history", messages: this.messages });
+  }
+  async onClose(connection, _code, _reason, _wasClean) {
+    if (this._continuationOriginConnectionId === connection.id) {
+      this._continuationOriginConnectionId = null;
+    }
+  }
+  async onMessage(connection, message) {
+    const data = safeParseClientMessage(message);
+    if (!data) {
+      console.error("Invalid client message:", message);
+      this._sendTo(connection, {
+        type: "error",
+        message: "Invalid message format"
+      });
+      return;
+    }
+    try {
+      switch (data.type) {
+        case "getHistory":
+          this._sendTo(connection, {
+            type: "history",
+            messages: this.messages
+          });
+          break;
+        case "clearHistory":
+          await this._enqueueTurn(async () => {
+            this._clearMessages();
+            this._broadcast({ type: "history", messages: [] });
+          });
+          break;
+        case "sendMessage":
+          await this._enqueueTurn(async () => {
+            this._continuationOriginConnectionId = connection.id;
+            await this._handleSendMessagePayload(data);
+          });
+          break;
+        case "toolApprovalResponse":
+          this._resolveToolApproval(data.approvalId, data.approved);
+          break;
+        case "resumeStream":
+          this._handleResumeStream(data.streamId);
+          break;
+        case "cancelRequest":
+          this._cancelRequest(data.id);
+          break;
+        case "toolResult":
+          await this._handleToolResultMessage(
+            connection,
+            data.toolCallId,
+            data.toolName,
+            data.output,
+            data.autoContinue ?? false
+          );
+          break;
+        case "registerTools":
+          await this._enqueueTurn(async () => {
+            this._registerClientTools(
+              connection,
+              data.tools
+            );
+          });
+          break;
+        default:
+          exhaustiveGuard(data);
+      }
+    } catch (err) {
+      console.error("Error processing message:", err);
+      this._broadcast({
+        type: "error",
+        message: "Failed to process message"
+      });
+    }
+  }
+  // ============================================================================
+  // Chat Message Handling
+  // ============================================================================
+  /**
+   * Get the system prompt for the AI
+   * Override this method to customize the AI's behavior
+   */
+  getSystemPrompt() {
+    return DEFAULT_SYSTEM_PROMPT;
+  }
+  /**
+   * Get the AI model to use
+   * Override this method to use a different model
+   */
+  getModel() {
+    return "anthropic/claude-sonnet-4.5";
+  }
+  /**
+   * Get available tools for the AI
+   * Override this method to provide custom tools
+   */
+  getTools() {
+    return [];
+  }
+  async _handleSendMessagePayload(data) {
+    const trigger = data.trigger ?? "submit-message";
+    if (trigger === "regenerate-message") {
+      this._replaceMessagesFromClient(data.messages ?? []);
+      await this._generateAIResponse();
+      return;
+    }
+    if (data.messages && data.messages.length > 0) {
+      this._replaceMessagesFromClient(data.messages);
+    }
+    const content = data.content;
+    if (content !== void 0 && content !== "") {
+      const userMessage = {
+        id: crypto.randomUUID(),
+        role: "user",
+        content,
+        createdAt: Date.now()
+      };
+      this._persistMessage(userMessage);
+      if (typeof this.maxPersistedMessages !== "number") {
+        this.messages.push(userMessage);
+      }
+    }
+    const last = this.messages[this.messages.length - 1];
+    if (!last || last.role !== "user") {
+      this._broadcast({
+        type: "error",
+        message: "Cannot generate: conversation must end with a user message (sync `messages` and/or send `content`)."
+      });
+      return;
+    }
+    await this._generateAIResponse();
+  }
+  async _handleToolResultMessage(connection, toolCallId, toolName, output, autoContinue) {
+    if (!autoContinue) {
+      await this._enqueueTurn(async () => {
+        await this._applyClientToolResult(connection, toolCallId, output);
+      });
+      return;
+    }
+    this._pendingClientToolAutoContinue.push({
+      connection,
+      toolCallId,
+      toolName,
+      output
+    });
+    this._scheduleClientToolAutoContinueFlush();
+  }
+  _scheduleClientToolAutoContinueFlush() {
+    if (this._clientToolAutoContinueFlushScheduled) {
+      return;
+    }
+    this._clientToolAutoContinueFlushScheduled = true;
+    queueMicrotask(() => {
+      this._clientToolAutoContinueFlushScheduled = false;
+      const batch = this._pendingClientToolAutoContinue.splice(0);
+      if (batch.length === 0) {
+        return;
+      }
+      void this._enqueueTurn(async () => {
+        const origin = batch[0]?.connection;
+        if (origin) {
+          this._continuationOriginConnectionId = origin.id;
+        }
+        for (const item of batch) {
+          await this._applyClientToolResult(
+            item.connection,
+            item.toolCallId,
+            item.output
+          );
+        }
+        await this._generateAIResponse();
+      });
+    });
+  }
+  async _applyClientToolResult(_connection, toolCallId, output) {
+    const assistantMsg = this.messages.find(
+      (m) => isAssistantMessage(m) && m.toolCalls?.some((tc) => tc.id === toolCallId)
+    );
+    if (!assistantMsg) {
+      console.warn(
+        `[ChatAgent] Tool result for unknown tool call: ${toolCallId}`
+      );
+      this._broadcast({ type: "error", message: "Tool call not found" });
+      return;
+    }
+    const toolMessage = {
+      id: crypto.randomUUID(),
+      role: "tool",
+      toolCallId,
+      content: JSON.stringify(output),
+      createdAt: Date.now()
+    };
+    this._persistMessage(toolMessage);
+    if (typeof this.maxPersistedMessages !== "number") {
+      this.messages.push(toolMessage);
+    }
+    this._broadcast({ type: "messageUpdated", message: toolMessage });
+  }
+  /**
+   * Generate AI response (can be called for initial message or after tool results)
+   */
+  async _generateAIResponse() {
+    const generation = this._turnGeneration;
+    const assistantId = crypto.randomUUID();
+    const streamId = this._startStream(assistantId);
+    const abortSignal = this._getAbortSignal(assistantId);
+    this._broadcast({ type: "messageStart", id: assistantId, streamId });
+    const runStream = async () => {
+      let fullContent = "";
+      let usage;
+      const toolCallsInProgress = /* @__PURE__ */ new Map();
+      const openRouter = this._getOpenRouter();
+      const toolsMap = this._getToolsMap();
+      const tools = Array.from(toolsMap.values());
+      const apiMessages = this._buildApiMessages();
+      const envWithGateway = this.env;
+      const headers = envWithGateway.AI_GATEWAY_TOKEN ? {
+        "cf-aig-authorization": `Bearer ${envWithGateway.AI_GATEWAY_TOKEN}`
+      } : void 0;
+      const stream = await openRouter.chat.send(
+        {
+          model: this.getModel(),
+          messages: apiMessages,
+          stream: true,
+          ...tools.length > 0 && { tools }
+        },
+        {
+          ...headers && { headers },
+          signal: abortSignal
+        }
+      );
+      this._openRouterStreamLive = true;
+      try {
+        for await (const chunk of stream) {
+          if (generation !== this._turnGeneration) {
+            return;
+          }
+          if (abortSignal.aborted) {
+            throw new Error("Request cancelled");
+          }
+          const delta = chunk.choices?.[0]?.delta;
+          if (delta?.content) {
+            fullContent += delta.content;
+            this._storeChunk(streamId, delta.content);
+            this._broadcast({
+              type: "messageChunk",
+              id: assistantId,
+              chunk: delta.content
+            });
+          }
+          if (delta?.toolCalls) {
+            for (const toolCallDelta of delta.toolCalls) {
+              const index = toolCallDelta.index;
+              if (!toolCallsInProgress.has(index)) {
+                toolCallsInProgress.set(index, {
+                  id: toolCallDelta.id || "",
+                  name: toolCallDelta.function?.name || "",
+                  arguments: ""
+                });
+              }
+              const tcRow = toolCallsInProgress.get(index);
+              if (tcRow) {
+                if (toolCallDelta.id) {
+                  tcRow.id = toolCallDelta.id;
+                }
+                if (toolCallDelta.function?.name) {
+                  tcRow.name = toolCallDelta.function.name;
+                }
+                if (toolCallDelta.function?.arguments) {
+                  tcRow.arguments += toolCallDelta.function.arguments;
+                }
+                const rawEntry = getRawToolCallDeltaEntry(chunk, index);
+                const extra = rawEntry ? extractProviderMetadataFromRawToolPart(rawEntry) : void 0;
+                if (extra) {
+                  tcRow.providerMetadata = this._mergeProviderMetadata(
+                    tcRow.providerMetadata,
+                    extra
+                  );
+                }
+              }
+              const deltaMsg = {
+                index: toolCallDelta.index,
+                id: toolCallDelta.id,
+                type: toolCallDelta.type,
+                function: toolCallDelta.function ? {
+                  name: toolCallDelta.function.name,
+                  arguments: toolCallDelta.function.arguments
+                } : void 0,
+                ...tcRow?.providerMetadata && Object.keys(tcRow.providerMetadata).length > 0 && {
+                  providerMetadata: tcRow.providerMetadata
+                }
+              };
+              this._broadcast({
+                type: "toolCallDelta",
+                id: assistantId,
+                delta: deltaMsg
+              });
+            }
+          }
+          if (chunk.usage) {
+            usage = {
+              prompt_tokens: chunk.usage.promptTokens ?? 0,
+              completion_tokens: chunk.usage.completionTokens ?? 0,
+              total_tokens: chunk.usage.totalTokens ?? 0
+            };
+          }
+        }
+        const finalToolCalls = [];
+        for (const [, tc] of toolCallsInProgress) {
+          if (tc.id && tc.name) {
+            const toolCall = {
+              id: tc.id,
+              type: "function",
+              function: {
+                name: tc.name,
+                arguments: tc.arguments
+              },
+              ...tc.providerMetadata && Object.keys(tc.providerMetadata).length > 0 && {
+                providerMetadata: tc.providerMetadata
+              }
+            };
+            finalToolCalls.push(toolCall);
+            this._broadcast({
+              type: "toolCall",
+              id: assistantId,
+              toolCall
+            });
+          }
+        }
+        const assistantMessage = {
+          id: assistantId,
+          role: "assistant",
+          content: fullContent || null,
+          toolCalls: finalToolCalls.length > 0 ? finalToolCalls : void 0,
+          createdAt: Date.now()
+        };
+        this._completeStreamWithMessage(streamId, assistantMessage);
+        this._removeAbortController(assistantId);
+        this._broadcast({
+          type: "messageEnd",
+          id: assistantId,
+          toolCalls: finalToolCalls.length > 0 ? finalToolCalls : void 0,
+          createdAt: assistantMessage.createdAt,
+          ...usage && { usage }
+        });
+        if (finalToolCalls.length > 0) {
+          const hasServerTools = await this._executeServerSideTools(finalToolCalls);
+          if (hasServerTools) {
+            return;
+          }
+        }
+      } catch (err) {
+        console.error("OpenRouter error:", err);
+        this._markStreamError(streamId);
+        this._removeAbortController(assistantId);
+        this._broadcast({
+          type: "error",
+          message: err instanceof Error ? err.message : "Failed to get AI response"
+        });
+      } finally {
+        this._openRouterStreamLive = false;
+      }
+    };
+    await this.experimental_waitUntil(runStream);
+  }
+  /**
+   * Build API messages from our message history
+   */
+  _buildApiMessages() {
+    const result = [
+      { role: "system", content: this.getSystemPrompt() }
+    ];
+    for (const msg of this.messages) {
+      switch (msg.role) {
+        case "user":
+          result.push({ role: "user", content: msg.content });
+          break;
+        case "assistant": {
+          const assistantMsg = msg;
+          const orMsg = {
+            role: "assistant",
+            content: assistantMsg.content,
+            ...assistantMsg.toolCalls && {
+              toolCalls: assistantMsg.toolCalls.map((tc) => {
+                const call = {
+                  id: tc.id,
+                  type: "function",
+                  function: {
+                    name: tc.function.name,
+                    arguments: tc.function.arguments
+                  }
+                };
+                const meta = tc.providerMetadata;
+                if (meta) {
+                  const {
+                    id: _i,
+                    type: _t,
+                    function: _fn,
+                    ...rest
+                  } = meta;
+                  Object.assign(call, rest);
+                }
+                return call;
+              })
+            }
+          };
+          result.push(orMsg);
+          break;
+        }
+        case "tool": {
+          const toolMsg = msg;
+          result.push({
+            role: "tool",
+            content: toolMsg.content,
+            toolCallId: toolMsg.toolCallId
+          });
+          break;
+        }
+        default:
+          exhaustiveGuard(msg);
+      }
+    }
+    return result;
+  }
+  /**
+   * Build a map of tool definitions by name for quick lookup
+   */
+  _getToolsMap() {
+    const tools = this.getTools();
+    const map = new Map(tools.map((t) => [t.function.name, t]));
+    for (const [name, tool] of this._clientTools) {
+      if (!map.has(name)) {
+        const toolDef = {
+          type: "function",
+          function: {
+            name: tool.name
+          }
+        };
+        if (tool.description !== void 0) {
+          toolDef.function.description = tool.description;
+        }
+        if (tool.parameters !== void 0) {
+          toolDef.function.parameters = tool.parameters;
+        }
+        map.set(name, toolDef);
+      }
+    }
+    return map;
+  }
+  /**
+   * Register tools from the client at runtime
+   */
+  _registerClientTools(_connection, tools) {
+    for (const tool of tools) {
+      const entry = {
+        name: tool.name
+      };
+      if (tool.description !== void 0) {
+        entry.description = tool.description;
+      }
+      if (tool.parameters !== void 0) {
+        entry.parameters = tool.parameters;
+      }
+      this._clientTools.set(tool.name, entry);
+      console.log(`[ChatAgent] Registered client tool: ${tool.name}`);
+    }
+    this._broadcast({
+      type: "history",
+      messages: this.messages
+    });
+  }
+  /**
+   * Execute server-side tools and continue the conversation
+   */
+  async _executeServerSideTools(toolCalls) {
+    const toolsMap = this._getToolsMap();
+    let executedServerTools = false;
+    for (const toolCall of toolCalls) {
+      const toolDef = toolsMap.get(toolCall.function.name);
+      if (!toolDef) {
+        this._broadcast({
+          type: "toolError",
+          errorType: "not_found",
+          toolCallId: toolCall.id,
+          toolName: toolCall.function.name,
+          message: `Tool "${toolCall.function.name}" not found`
+        });
+        continue;
+      }
+      if (!toolDef.execute) {
+        continue;
+      }
+      executedServerTools = true;
+      try {
+        let args;
+        try {
+          args = toolCall.function.arguments ? JSON.parse(toolCall.function.arguments) : {};
+        } catch (parseErr) {
+          this._broadcast({
+            type: "toolError",
+            errorType: "input",
+            toolCallId: toolCall.id,
+            toolName: toolCall.function.name,
+            message: `Invalid JSON arguments: ${parseErr instanceof Error ? parseErr.message : "Parse error"}`
+          });
+          continue;
+        }
+        if (toolDef.needsApproval) {
+          const needApproval = await toolDef.needsApproval(args);
+          if (needApproval) {
+            const approvalId = crypto.randomUUID();
+            const approved = await new Promise((resolve) => {
+              this._pendingToolApprovals.set(approvalId, { resolve });
+              this._broadcast({
+                type: "toolApprovalRequest",
+                approvalId,
+                toolCallId: toolCall.id,
+                toolName: toolCall.function.name,
+                arguments: toolCall.function.arguments
+              });
+            });
+            if (!approved) {
+              const errorMsg = "Tool execution rejected by user";
+              this._broadcast({
+                type: "toolError",
+                errorType: "output",
+                toolCallId: toolCall.id,
+                toolName: toolCall.function.name,
+                message: errorMsg
+              });
+              const rejectedMessage = {
+                id: crypto.randomUUID(),
+                role: "tool",
+                toolCallId: toolCall.id,
+                content: JSON.stringify({
+                  error: errorMsg,
+                  rejected: true
+                }),
+                createdAt: Date.now()
+              };
+              this._persistMessage(rejectedMessage);
+              if (typeof this.maxPersistedMessages !== "number") {
+                this.messages.push(rejectedMessage);
+              }
+              this._broadcast({
+                type: "messageUpdated",
+                message: rejectedMessage
+              });
+              continue;
+            }
+          }
+        }
+        console.log(
+          `[ChatAgent] Executing server tool: ${toolCall.function.name}`,
+          args
+        );
+        const result = await toolDef.execute(args);
+        const toolMessage = {
+          id: crypto.randomUUID(),
+          role: "tool",
+          toolCallId: toolCall.id,
+          content: JSON.stringify(result),
+          createdAt: Date.now()
+        };
+        this._persistMessage(toolMessage);
+        if (typeof this.maxPersistedMessages !== "number") {
+          this.messages.push(toolMessage);
+        }
+        this._broadcast({ type: "messageUpdated", message: toolMessage });
+        console.log(
+          `[ChatAgent] Server tool completed: ${toolCall.function.name}`,
+          result
+        );
+      } catch (err) {
+        console.error(
+          `[ChatAgent] Server tool error: ${toolCall.function.name}`,
+          err
+        );
+        const errorMsg = err instanceof Error ? err.message : "Tool execution failed";
+        this._broadcast({
+          type: "toolError",
+          errorType: "output",
+          toolCallId: toolCall.id,
+          toolName: toolCall.function.name,
+          message: errorMsg
+        });
+        const errorMessage = {
+          id: crypto.randomUUID(),
+          role: "tool",
+          toolCallId: toolCall.id,
+          content: JSON.stringify({ error: errorMsg }),
+          createdAt: Date.now()
+        };
+        this._persistMessage(errorMessage);
+        if (typeof this.maxPersistedMessages !== "number") {
+          this.messages.push(errorMessage);
+        }
+        this._broadcast({
+          type: "messageUpdated",
+          message: errorMessage
+        });
+      }
+    }
+    if (executedServerTools) {
+      await this._generateAIResponse();
+    }
+    return executedServerTools;
+  }
+  _handleResumeStream(streamId) {
+    if (!this.dbIsStreamKnown(streamId)) {
+      this._broadcast({
+        type: "streamResume",
+        streamId,
+        chunks: [],
+        done: true
+      });
+      return;
+    }
+    const chunks = this._getStreamChunks(streamId);
+    const isLive = this._openRouterStreamLive && this._activeStreamId === streamId;
+    this._broadcast({
+      type: "streamResume",
+      streamId,
+      chunks,
+      done: !isLive
+    });
+    if (!isLive && this._activeStreamId === streamId) {
+      this._finalizeOrphanedStreamFromChunks(streamId);
+    }
+  }
+  // ============================================================================
+  // Cleanup
+  // ============================================================================
+  async destroy() {
+    for (const controller of this._abortControllers.values()) {
+      controller.abort();
+    }
+    this._abortControllers.clear();
+    this._flushChunkBuffer();
+    await super.destroy();
+  }
+};
+
+export { ChatAgentBase };
+//# sourceMappingURL=chunk-G5P5JXRF.js.map
+//# sourceMappingURL=chunk-G5P5JXRF.js.map