@tanstack/ai-devtools-core 0.0.1

package/dist/esm/store/ai-context.js

@@ -0,0 +1,1081 @@
+import { createComponent } from "solid-js/web";
+import { onMount, onCleanup, createContext, useContext, batch } from "solid-js";
+import { createStore, produce } from "solid-js/store";
+import { aiEventClient } from "@tanstack/ai/event-client";
+const AIContext = createContext();
+function useAIStore() {
+  const context = useContext(AIContext);
+  if (!context) {
+    throw new Error("useAIStore must be used within an AIProvider");
+  }
+  return context;
+}
+const AIProvider = (props) => {
+  const [state, setState] = createStore({
+    conversations: {},
+    activeConversationId: null
+  });
+  const streamToConversation = /* @__PURE__ */ new Map();
+  const requestToConversation = /* @__PURE__ */ new Map();
+  const pendingConversationChunks = /* @__PURE__ */ new Map();
+  const pendingMessageChunks = /* @__PURE__ */ new Map();
+  let batchScheduled = false;
+  function scheduleBatchFlush() {
+    if (batchScheduled) return;
+    batchScheduled = true;
+    queueMicrotask(flushPendingChunks);
+  }
+  function isMergeableChunkType(type) {
+    return type === "content" || type === "thinking";
+  }
+  function mergeChunks(existing, pending) {
+    for (const chunk of pending) {
+      const lastChunk = existing[existing.length - 1];
+      if (lastChunk && lastChunk.type === chunk.type && isMergeableChunkType(chunk.type) && lastChunk.messageId === chunk.messageId) {
+        lastChunk.content = chunk.content || lastChunk.content;
+        lastChunk.delta = chunk.delta;
+        lastChunk.chunkCount += chunk.chunkCount;
+      } else {
+        existing.push(chunk);
+      }
+    }
+  }
+  function flushPendingChunks() {
+    batchScheduled = false;
+    batch(() => {
+      for (const [conversationId, {
+        chunks,
+        newChunkCount
+      }] of pendingConversationChunks) {
+        const conv = state.conversations[conversationId];
+        if (conv) {
+          setState("conversations", conversationId, "chunks", produce((arr) => {
+            mergeChunks(arr, chunks);
+          }));
+        }
+      }
+      pendingConversationChunks.clear();
+      for (const [conversationId, messageMap] of pendingMessageChunks) {
+        const conv = state.conversations[conversationId];
+        if (!conv) continue;
+        for (const [messageIndex, {
+          chunks,
+          newChunkCount
+        }] of messageMap) {
+          const message = conv.messages[messageIndex];
+          if (message) {
+            setState("conversations", conversationId, "messages", messageIndex, "chunks", produce((arr) => {
+              if (!arr) {
+                return chunks;
+              }
+              mergeChunks(arr, chunks);
+              return arr;
+            }));
+            const currentTotal = message.totalChunkCount || 0;
+            setState("conversations", conversationId, "messages", messageIndex, "totalChunkCount", currentTotal + newChunkCount);
+          }
+        }
+      }
+      pendingMessageChunks.clear();
+    });
+  }
+  function queueChunk(conversationId, chunk) {
+    if (!pendingConversationChunks.has(conversationId)) {
+      pendingConversationChunks.set(conversationId, {
+        chunks: [],
+        newChunkCount: 0
+      });
+    }
+    const pending = pendingConversationChunks.get(conversationId);
+    const lastPending = pending.chunks[pending.chunks.length - 1];
+    if (lastPending && lastPending.type === chunk.type && isMergeableChunkType(chunk.type) && lastPending.messageId === chunk.messageId) {
+      lastPending.content = chunk.content || lastPending.content;
+      lastPending.delta = chunk.delta;
+      lastPending.chunkCount += chunk.chunkCount;
+    } else {
+      pending.chunks.push(chunk);
+    }
+    pending.newChunkCount += chunk.chunkCount;
+    scheduleBatchFlush();
+  }
+  function queueMessageChunk(conversationId, messageIndex, chunk) {
+    if (!pendingMessageChunks.has(conversationId)) {
+      pendingMessageChunks.set(conversationId, /* @__PURE__ */ new Map());
+    }
+    const messageMap = pendingMessageChunks.get(conversationId);
+    if (!messageMap.has(messageIndex)) {
+      messageMap.set(messageIndex, {
+        chunks: [],
+        newChunkCount: 0
+      });
+    }
+    const pending = messageMap.get(messageIndex);
+    const lastPending = pending.chunks[pending.chunks.length - 1];
+    if (lastPending && lastPending.type === chunk.type && isMergeableChunkType(chunk.type) && lastPending.messageId === chunk.messageId) {
+      lastPending.content = chunk.content || lastPending.content;
+      lastPending.delta = chunk.delta;
+      lastPending.chunkCount += chunk.chunkCount;
+    } else {
+      pending.chunks.push(chunk);
+    }
+    pending.newChunkCount += chunk.chunkCount;
+    scheduleBatchFlush();
+  }
+  function getOrCreateConversation(id, type, label) {
+    if (!state.conversations[id]) {
+      setState("conversations", id, {
+        id,
+        type,
+        label,
+        messages: [],
+        chunks: [],
+        status: "active",
+        startedAt: Date.now()
+      });
+      if (!state.activeConversationId) {
+        setState("activeConversationId", id);
+      }
+    }
+  }
+  function addMessage(conversationId, message) {
+    const conv = state.conversations[conversationId];
+    if (!conv) return;
+    setState("conversations", conversationId, "messages", conv.messages.length, message);
+  }
+  function addChunkToMessage(conversationId, chunk) {
+    const conv = state.conversations[conversationId];
+    if (!conv) return;
+    if (chunk.messageId) {
+      const messageIndex = conv.messages.findIndex((msg) => msg.id === chunk.messageId);
+      if (messageIndex !== -1) {
+        queueMessageChunk(conversationId, messageIndex, chunk);
+        return;
+      } else {
+        const newMessage = {
+          id: chunk.messageId,
+          role: "assistant",
+          content: "",
+          timestamp: chunk.timestamp,
+          model: conv.model,
+          chunks: [chunk]
+        };
+        setState("conversations", conversationId, "messages", conv.messages.length, newMessage);
+        return;
+      }
+    }
+    for (let i = conv.messages.length - 1; i >= 0; i--) {
+      const message = conv.messages[i];
+      if (message && message.role === "assistant") {
+        queueMessageChunk(conversationId, i, chunk);
+        return;
+      }
+    }
+  }
+  function updateMessageUsage(conversationId, messageId, cumulativeUsage) {
+    const conv = state.conversations[conversationId];
+    if (!conv) return;
+    let previousPromptTokens = 0;
+    let previousCompletionTokens = 0;
+    let targetMessageIndex = -1;
+    if (messageId) {
+      targetMessageIndex = conv.messages.findIndex((msg) => msg.id === messageId);
+    } else {
+      for (let i = conv.messages.length - 1; i >= 0; i--) {
+        if (conv.messages[i]?.role === "assistant") {
+          targetMessageIndex = i;
+          break;
+        }
+      }
+    }
+    if (targetMessageIndex === -1) return;
+    for (let i = 0; i < targetMessageIndex; i++) {
+      const msg = conv.messages[i];
+      if (msg?.role === "assistant" && msg.usage) {
+        previousPromptTokens += msg.usage.promptTokens;
+        previousCompletionTokens += msg.usage.completionTokens;
+      }
+    }
+    const deltaUsage = {
+      promptTokens: Math.max(0, cumulativeUsage.promptTokens - previousPromptTokens),
+      completionTokens: Math.max(0, cumulativeUsage.completionTokens - previousCompletionTokens),
+      totalTokens: 0
+    };
+    deltaUsage.totalTokens = deltaUsage.promptTokens + deltaUsage.completionTokens;
+    setState("conversations", conversationId, "messages", targetMessageIndex, "usage", deltaUsage);
+  }
+  function clearAllConversations() {
+    setState("conversations", {});
+    setState("activeConversationId", null);
+    streamToConversation.clear();
+    requestToConversation.clear();
+    pendingConversationChunks.clear();
+    pendingMessageChunks.clear();
+  }
+  function selectConversation(id) {
+    setState("activeConversationId", id);
+  }
+  function updateConversation(conversationId, updates) {
+    if (!state.conversations[conversationId]) return;
+    for (const [key, value] of Object.entries(updates)) {
+      setState("conversations", conversationId, key, value);
+    }
+  }
+  function updateMessage(conversationId, messageIndex, updates) {
+    const conv = state.conversations[conversationId];
+    if (!conv || !conv.messages[messageIndex]) return;
+    for (const [key, value] of Object.entries(updates)) {
+      setState("conversations", conversationId, "messages", messageIndex, key, value);
+    }
+  }
+  function updateToolCall(conversationId, messageIndex, toolCallIndex, updates) {
+    const conv = state.conversations[conversationId];
+    if (!conv?.messages[messageIndex]?.toolCalls?.[toolCallIndex]) return;
+    setState("conversations", conversationId, "messages", messageIndex, "toolCalls", toolCallIndex, produce((tc) => Object.assign(tc, updates)));
+  }
+  function setToolCalls(conversationId, messageIndex, toolCalls) {
+    if (!state.conversations[conversationId]?.messages[messageIndex]) return;
+    setState("conversations", conversationId, "messages", messageIndex, "toolCalls", toolCalls);
+  }
+  function addChunk(conversationId, chunk) {
+    if (!state.conversations[conversationId]) return;
+    queueChunk(conversationId, chunk);
+  }
+  function ensureMessageForChunk(conversationId, messageId, timestamp) {
+    if (!messageId) return;
+    const conv = state.conversations[conversationId];
+    if (!conv || conv.type === "client") return;
+    const existingMessage = conv.messages.find((m) => m.id === messageId);
+    if (existingMessage) return;
+    addMessage(conversationId, {
+      id: messageId,
+      role: "assistant",
+      content: "",
+      timestamp,
+      source: "server"
+    });
+  }
+  onMount(() => {
+    const cleanupFns = [];
+    cleanupFns.push(aiEventClient.on("client:created", (e) => {
+      const clientId = e.payload.clientId;
+      getOrCreateConversation(clientId, "client", `Client Chat (${clientId.substring(0, 8)})`);
+      updateConversation(clientId, {
+        model: void 0,
+        provider: "Client"
+      });
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("client:message-sent", (e) => {
+      const clientId = e.payload.clientId;
+      if (!state.conversations[clientId]) {
+        getOrCreateConversation(clientId, "client", `Client Chat (${clientId.substring(0, 8)})`);
+      }
+      addMessage(clientId, {
+        id: e.payload.messageId,
+        role: "user",
+        content: e.payload.content,
+        timestamp: e.payload.timestamp,
+        source: "client"
+      });
+      updateConversation(clientId, {
+        status: "active"
+      });
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("client:message-appended", (e) => {
+      const clientId = e.payload.clientId;
+      const role = e.payload.role;
+      if (role === "user") return;
+      if (!state.conversations[clientId]) return;
+      if (role === "assistant") {
+        addMessage(clientId, {
+          id: e.payload.messageId,
+          role: "assistant",
+          content: e.payload.contentPreview,
+          timestamp: e.payload.timestamp,
+          source: "client"
+        });
+      } else if (role === "tool") {
+        addMessage(clientId, {
+          id: e.payload.messageId,
+          role: "tool",
+          content: e.payload.contentPreview,
+          timestamp: e.payload.timestamp,
+          source: "client"
+        });
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("client:loading-changed", (e) => {
+      const clientId = e.payload.clientId;
+      if (state.conversations[clientId]) {
+        updateConversation(clientId, {
+          status: e.payload.isLoading ? "active" : "completed"
+        });
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("client:stopped", (e) => {
+      const clientId = e.payload.clientId;
+      if (state.conversations[clientId]) {
+        updateConversation(clientId, {
+          status: "completed",
+          completedAt: e.payload.timestamp
+        });
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("client:messages-cleared", (e) => {
+      const clientId = e.payload.clientId;
+      if (state.conversations[clientId]) {
+        updateConversation(clientId, {
+          messages: [],
+          chunks: [],
+          usage: void 0
+        });
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("client:reloaded", (e) => {
+      const clientId = e.payload.clientId;
+      const conv = state.conversations[clientId];
+      if (conv) {
+        updateConversation(clientId, {
+          messages: conv.messages.slice(0, e.payload.fromMessageIndex),
+          status: "active"
+        });
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("client:error-changed", (e) => {
+      const clientId = e.payload.clientId;
+      if (state.conversations[clientId] && e.payload.error) {
+        updateConversation(clientId, {
+          status: "error"
+        });
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("client:assistant-message-updated", (e) => {
+      const clientId = e.payload.clientId;
+      const messageId = e.payload.messageId;
+      const content = e.payload.content;
+      if (!state.conversations[clientId]) return;
+      const conv = state.conversations[clientId];
+      const messageIndex = conv.messages.findIndex((m) => m.id === messageId);
+      if (messageIndex >= 0) {
+        updateMessage(clientId, messageIndex, {
+          content,
+          model: conv.model
+        });
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("client:tool-call-updated", (e) => {
+      const {
+        clientId,
+        messageId,
+        toolCallId,
+        toolName,
+        state: toolCallState,
+        arguments: args
+      } = e.payload;
+      if (!state.conversations[clientId]) return;
+      const conv = state.conversations[clientId];
+      const messageIndex = conv.messages.findIndex((m) => m.id === messageId);
+      if (messageIndex === -1) return;
+      const message = conv.messages[messageIndex];
+      if (!message) return;
+      const toolCalls = message.toolCalls || [];
+      const existingToolIndex = toolCalls.findIndex((t) => t.id === toolCallId);
+      const toolCall = {
+        id: toolCallId,
+        name: toolName,
+        arguments: JSON.stringify(args, null, 2),
+        state: toolCallState
+      };
+      if (existingToolIndex >= 0) {
+        updateToolCall(clientId, messageIndex, existingToolIndex, toolCall);
+      } else {
+        setToolCalls(clientId, messageIndex, [...toolCalls, toolCall]);
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("client:approval-requested", (e) => {
+      const {
+        clientId,
+        messageId,
+        toolCallId,
+        approvalId
+      } = e.payload;
+      if (!state.conversations[clientId]) return;
+      const conv = state.conversations[clientId];
+      const messageIndex = conv.messages.findIndex((m) => m.id === messageId);
+      if (messageIndex === -1) return;
+      const message = conv.messages[messageIndex];
+      if (!message?.toolCalls) return;
+      const toolCallIndex = message.toolCalls.findIndex((t) => t.id === toolCallId);
+      if (toolCallIndex === -1) return;
+      updateToolCall(clientId, messageIndex, toolCallIndex, {
+        approvalRequired: true,
+        approvalId,
+        state: "approval-requested"
+      });
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("tool:result-added", (e) => {
+      const {
+        clientId,
+        toolCallId,
+        toolName,
+        output,
+        state: resultState,
+        timestamp
+      } = e.payload;
+      if (!state.conversations[clientId]) return;
+      const conv = state.conversations[clientId];
+      for (let messageIndex = conv.messages.length - 1; messageIndex >= 0; messageIndex--) {
+        const message = conv.messages[messageIndex];
+        if (!message?.toolCalls) continue;
+        const toolCallIndex = message.toolCalls.findIndex((t) => t.id === toolCallId);
+        if (toolCallIndex >= 0) {
+          updateToolCall(clientId, messageIndex, toolCallIndex, {
+            result: output,
+            state: resultState === "output-error" ? "error" : "complete"
+          });
+          const chunk = {
+            id: `chunk-tool-result-${toolCallId}-${Date.now()}`,
+            type: "tool_result",
+            messageId: message.id,
+            toolCallId,
+            toolName,
+            result: output,
+            timestamp,
+            chunkCount: 1
+          };
+          addChunkToMessage(clientId, chunk);
+          return;
+        }
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("tool:approval-responded", (e) => {
+      const {
+        clientId,
+        toolCallId,
+        approved
+      } = e.payload;
+      if (!state.conversations[clientId]) return;
+      const conv = state.conversations[clientId];
+      for (let messageIndex = conv.messages.length - 1; messageIndex >= 0; messageIndex--) {
+        const message = conv.messages[messageIndex];
+        if (!message?.toolCalls) continue;
+        const toolCallIndex = message.toolCalls.findIndex((t) => t.id === toolCallId);
+        if (toolCallIndex >= 0) {
+          updateToolCall(clientId, messageIndex, toolCallIndex, {
+            state: approved ? "approved" : "denied",
+            approvalRequired: false
+          });
+          return;
+        }
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("stream:chunk:content", (e) => {
+      const streamId = e.payload.streamId;
+      const conversationId = streamToConversation.get(streamId);
+      if (!conversationId) return;
+      const chunk = {
+        id: `chunk-${Date.now()}-${Math.random()}`,
+        type: "content",
+        messageId: e.payload.messageId,
+        content: e.payload.content,
+        delta: e.payload.delta,
+        timestamp: e.payload.timestamp,
+        chunkCount: 1
+      };
+      const conv = state.conversations[conversationId];
+      if (conv?.type === "client") {
+        addChunkToMessage(conversationId, chunk);
+      } else {
+        ensureMessageForChunk(conversationId, e.payload.messageId, e.payload.timestamp);
+        addChunk(conversationId, chunk);
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("stream:chunk:tool-call", (e) => {
+      const streamId = e.payload.streamId;
+      const conversationId = streamToConversation.get(streamId);
+      if (!conversationId) return;
+      const chunk = {
+        id: `chunk-${Date.now()}-${Math.random()}`,
+        type: "tool_call",
+        messageId: e.payload.messageId,
+        toolCallId: e.payload.toolCallId,
+        toolName: e.payload.toolName,
+        arguments: e.payload.arguments,
+        timestamp: e.payload.timestamp,
+        chunkCount: 1
+      };
+      const conv = state.conversations[conversationId];
+      if (conv?.type === "client") {
+        addChunkToMessage(conversationId, chunk);
+      } else {
+        ensureMessageForChunk(conversationId, e.payload.messageId, e.payload.timestamp);
+        addChunk(conversationId, chunk);
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("stream:chunk:tool-result", (e) => {
+      const streamId = e.payload.streamId;
+      const conversationId = streamToConversation.get(streamId);
+      if (!conversationId) return;
+      const chunk = {
+        id: `chunk-${Date.now()}-${Math.random()}`,
+        type: "tool_result",
+        messageId: e.payload.messageId,
+        toolCallId: e.payload.toolCallId,
+        content: e.payload.result,
+        timestamp: e.payload.timestamp,
+        chunkCount: 1
+      };
+      const conv = state.conversations[conversationId];
+      if (conv?.type === "client") {
+        addChunkToMessage(conversationId, chunk);
+      } else {
+        ensureMessageForChunk(conversationId, e.payload.messageId, e.payload.timestamp);
+        addChunk(conversationId, chunk);
+      }
+      if (conv && e.payload.toolCallId) {
+        for (let i = conv.messages.length - 1; i >= 0; i--) {
+          const message = conv.messages[i];
+          if (!message?.toolCalls) continue;
+          const toolCallIndex = message.toolCalls.findIndex((t) => t.id === e.payload.toolCallId);
+          if (toolCallIndex >= 0) {
+            updateToolCall(conversationId, i, toolCallIndex, {
+              result: e.payload.result,
+              state: "complete"
+            });
+            break;
+          }
+        }
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("stream:chunk:thinking", (e) => {
+      const streamId = e.payload.streamId;
+      const conversationId = streamToConversation.get(streamId);
+      if (!conversationId) return;
+      const chunk = {
+        id: `chunk-${Date.now()}-${Math.random()}`,
+        type: "thinking",
+        messageId: e.payload.messageId,
+        content: e.payload.content,
+        delta: e.payload.delta,
+        timestamp: e.payload.timestamp,
+        chunkCount: 1
+      };
+      const conv = state.conversations[conversationId];
+      if (conv?.type === "client") {
+        addChunkToMessage(conversationId, chunk);
+        if (e.payload.messageId) {
+          const messageIndex = conv.messages.findIndex((msg) => msg.id === e.payload.messageId);
+          if (messageIndex !== -1) {
+            updateMessage(conversationId, messageIndex, {
+              thinkingContent: e.payload.content
+            });
+          }
+        }
+      } else {
+        ensureMessageForChunk(conversationId, e.payload.messageId, e.payload.timestamp);
+        addChunk(conversationId, chunk);
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("stream:chunk:done", (e) => {
+      const streamId = e.payload.streamId;
+      const conversationId = streamToConversation.get(streamId);
+      if (!conversationId) return;
+      const chunk = {
+        id: `chunk-${Date.now()}-${Math.random()}`,
+        type: "done",
+        messageId: e.payload.messageId,
+        finishReason: e.payload.finishReason || void 0,
+        timestamp: e.payload.timestamp,
+        chunkCount: 1
+      };
+      if (e.payload.usage) {
+        updateConversation(conversationId, {
+          usage: e.payload.usage
+        });
+        updateMessageUsage(conversationId, e.payload.messageId, e.payload.usage);
+      }
+      const conv = state.conversations[conversationId];
+      if (conv?.type === "client") {
+        addChunkToMessage(conversationId, chunk);
+      } else {
+        ensureMessageForChunk(conversationId, e.payload.messageId, e.payload.timestamp);
+        addChunk(conversationId, chunk);
+      }
+      updateConversation(conversationId, {
+        status: "completed",
+        completedAt: e.payload.timestamp
+      });
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("stream:chunk:error", (e) => {
+      const streamId = e.payload.streamId;
+      const conversationId = streamToConversation.get(streamId);
+      if (!conversationId) return;
+      const chunk = {
+        id: `chunk-${Date.now()}-${Math.random()}`,
+        type: "error",
+        messageId: e.payload.messageId,
+        error: e.payload.error,
+        timestamp: e.payload.timestamp,
+        chunkCount: 1
+      };
+      const conv = state.conversations[conversationId];
+      if (conv?.type === "client") {
+        addChunkToMessage(conversationId, chunk);
+      } else {
+        ensureMessageForChunk(conversationId, e.payload.messageId, e.payload.timestamp);
+        addChunk(conversationId, chunk);
+      }
+      updateConversation(conversationId, {
+        status: "error",
+        completedAt: e.payload.timestamp
+      });
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("stream:ended", (e) => {
+      const streamId = e.payload.streamId;
+      const conversationId = streamToConversation.get(streamId);
+      if (!conversationId) return;
+      updateConversation(conversationId, {
+        status: "completed",
+        completedAt: e.payload.timestamp
+      });
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("stream:approval-requested", (e) => {
+      const {
+        streamId,
+        messageId,
+        toolCallId,
+        toolName,
+        input,
+        approvalId,
+        timestamp
+      } = e.payload;
+      const conversationId = streamToConversation.get(streamId);
+      if (!conversationId) return;
+      const conv = state.conversations[conversationId];
+      if (!conv) return;
+      const chunk = {
+        id: `chunk-${Date.now()}-${Math.random()}`,
+        type: "approval",
+        messageId,
+        toolCallId,
+        toolName,
+        approvalId,
+        input,
+        timestamp,
+        chunkCount: 1
+      };
+      if (conv.type === "client") {
+        addChunkToMessage(conversationId, chunk);
+      } else {
+        addChunk(conversationId, chunk);
+      }
+      for (let i = conv.messages.length - 1; i >= 0; i--) {
+        const message = conv.messages[i];
+        if (!message) continue;
+        if (message.role === "assistant" && message.toolCalls) {
+          const toolCallIndex = message.toolCalls.findIndex((t) => t.id === toolCallId);
+          if (toolCallIndex >= 0) {
+            updateToolCall(conversationId, i, toolCallIndex, {
+              approvalRequired: true,
+              approvalId,
+              state: "approval-requested"
+            });
+            return;
+          }
+        }
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("processor:text-updated", (e) => {
+      const streamId = e.payload.streamId;
+      let conversationId = streamToConversation.get(streamId);
+      if (!conversationId) {
+        const activeClients = Object.values(state.conversations).filter((c) => c.type === "client" && c.status === "active").sort((a, b) => b.startedAt - a.startedAt);
+        if (activeClients.length > 0 && activeClients[0]) {
+          conversationId = activeClients[0].id;
+          streamToConversation.set(streamId, conversationId);
+        }
+      }
+      if (!conversationId) return;
+      const conv = state.conversations[conversationId];
+      if (!conv) return;
+      const lastMessage = conv.messages[conv.messages.length - 1];
+      if (lastMessage && lastMessage.role === "assistant") {
+        updateMessage(conversationId, conv.messages.length - 1, {
+          content: e.payload.content
+        });
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("processor:tool-call-state-changed", (e) => {
+      const streamId = e.payload.streamId;
+      const conversationId = streamToConversation.get(streamId);
+      if (!conversationId || !state.conversations[conversationId]) return;
+      const conv = state.conversations[conversationId];
+      const lastMessage = conv.messages[conv.messages.length - 1];
+      if (lastMessage && lastMessage.role === "assistant") {
+        const toolCalls = lastMessage.toolCalls || [];
+        const existingToolIndex = toolCalls.findIndex((t) => t.id === e.payload.toolCallId);
+        const toolCall = {
+          id: e.payload.toolCallId,
+          name: e.payload.toolName,
+          arguments: JSON.stringify(e.payload.arguments, null, 2),
+          state: e.payload.state
+        };
+        if (existingToolIndex >= 0) {
+          updateToolCall(conversationId, conv.messages.length - 1, existingToolIndex, toolCall);
+        } else {
+          setToolCalls(conversationId, conv.messages.length - 1, [...toolCalls, toolCall]);
+        }
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("processor:tool-result-state-changed", (e) => {
+      const streamId = e.payload.streamId;
+      const conversationId = streamToConversation.get(streamId);
+      if (!conversationId || !state.conversations[conversationId]) return;
+      const conv = state.conversations[conversationId];
+      for (let i = conv.messages.length - 1; i >= 0; i--) {
+        const message = conv.messages[i];
+        if (!message?.toolCalls) continue;
+        const toolCallIndex = message.toolCalls.findIndex((t) => t.id === e.payload.toolCallId);
+        if (toolCallIndex >= 0) {
+          updateToolCall(conversationId, i, toolCallIndex, {
+            result: e.payload.content,
+            state: e.payload.error ? "error" : e.payload.state
+          });
+          return;
+        }
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("chat:started", (e) => {
+      const streamId = e.payload.streamId;
+      const model = e.payload.model;
+      e.payload.provider;
+      const clientId = e.payload.clientId;
+      if (clientId && state.conversations[clientId]) {
+        streamToConversation.set(streamId, clientId);
+        updateConversation(clientId, {
+          status: "active",
+          ...e.payload
+        });
+        return;
+      }
+      const activeClient = Object.values(state.conversations).find((c) => c.type === "client" && c.status === "active" && !c.model);
+      if (activeClient) {
+        streamToConversation.set(streamId, activeClient.id);
+        updateConversation(activeClient.id, {
+          ...e.payload
+        });
+      } else {
+        const existingServerConv = Object.values(state.conversations).find((c) => c.type === "server" && c.model === model);
+        if (existingServerConv) {
+          streamToConversation.set(streamId, existingServerConv.id);
+          updateConversation(existingServerConv.id, {
+            status: "active",
+            ...e.payload
+          });
+        } else {
+          const serverId = `server-${model}`;
+          getOrCreateConversation(serverId, "server", `${model} Server`);
+          streamToConversation.set(streamId, serverId);
+          updateConversation(serverId, {
+            ...e.payload
+          });
+        }
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("chat:completed", (e) => {
+      const {
+        requestId,
+        usage
+      } = e.payload;
+      const conversationId = requestToConversation.get(requestId);
+      if (conversationId && state.conversations[conversationId]) {
+        const updates = {
+          status: "completed",
+          completedAt: e.payload.timestamp
+        };
+        if (usage) {
+          updates.usage = usage;
+        }
+        updateConversation(conversationId, updates);
+        if (usage) {
+          updateMessageUsage(conversationId, e.payload.messageId, usage);
+        }
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("chat:iteration", (e) => {
+      const {
+        requestId,
+        iterationNumber
+      } = e.payload;
+      const conversationId = requestToConversation.get(requestId);
+      if (conversationId && state.conversations[conversationId]) {
+        updateConversation(conversationId, {
+          iterationCount: iterationNumber
+        });
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("usage:tokens", (e) => {
+      const {
+        requestId,
+        usage,
+        messageId
+      } = e.payload;
+      const conversationId = requestToConversation.get(requestId);
+      if (conversationId && state.conversations[conversationId]) {
+        updateConversation(conversationId, {
+          usage
+        });
+        updateMessageUsage(conversationId, messageId, usage);
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("tool:call-completed", (e) => {
+      const {
+        streamId,
+        toolCallId,
+        toolName,
+        result,
+        duration,
+        messageId,
+        timestamp
+      } = e.payload;
+      const conversationId = streamToConversation.get(streamId);
+      if (!conversationId || !state.conversations[conversationId]) return;
+      const conv = state.conversations[conversationId];
+      const chunk = {
+        id: `chunk-tool-result-${toolCallId}-${Date.now()}`,
+        type: "tool_result",
+        messageId,
+        toolCallId,
+        toolName,
+        result,
+        duration,
+        timestamp,
+        chunkCount: 1
+      };
+      if (conv.type === "client" && messageId) {
+        const messageIndex = conv.messages.findIndex((m) => m.id === messageId);
+        if (messageIndex !== -1) {
+          queueMessageChunk(conversationId, messageIndex, chunk);
+        } else {
+          for (let i = conv.messages.length - 1; i >= 0; i--) {
+            if (conv.messages[i]?.role === "assistant") {
+              queueMessageChunk(conversationId, i, chunk);
+              break;
+            }
+          }
+        }
+      } else {
+        addChunk(conversationId, chunk);
+      }
+      for (let i = conv.messages.length - 1; i >= 0; i--) {
+        const message = conv.messages[i];
+        if (!message?.toolCalls) continue;
+        const toolCallIndex = message.toolCalls.findIndex((t) => t.id === toolCallId);
+        if (toolCallIndex >= 0) {
+          updateToolCall(conversationId, i, toolCallIndex, {
+            duration,
+            result
+          });
+          return;
+        }
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("embedding:started", (e) => {
+      const {
+        requestId,
+        model,
+        inputCount,
+        timestamp,
+        clientId
+      } = e.payload;
+      let conversationId = clientId;
+      if (!conversationId || !state.conversations[conversationId]) {
+        const activeClients = Object.values(state.conversations).filter((c) => c.type === "client" && c.status === "active").sort((a, b) => b.startedAt - a.startedAt);
+        if (activeClients.length > 0 && activeClients[0]) {
+          conversationId = activeClients[0].id;
+        } else {
+          conversationId = `embedding-${requestId}`;
+          getOrCreateConversation(conversationId, "server", `Embedding (${model})`);
+          updateConversation(conversationId, {
+            model
+          });
+        }
+      }
+      requestToConversation.set(requestId, conversationId);
+      const embeddingOp = {
+        id: requestId,
+        model,
+        inputCount,
+        duration: 0,
+        timestamp,
+        status: "started"
+      };
+      const conv = state.conversations[conversationId];
+      if (conv) {
+        const embeddings = conv.embeddings || [];
+        setState("conversations", conversationId, "embeddings", [...embeddings, embeddingOp]);
+        setState("conversations", conversationId, "hasEmbedding", true);
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("embedding:completed", (e) => {
+      const {
+        requestId,
+        duration
+      } = e.payload;
+      const conversationId = requestToConversation.get(requestId);
+      if (!conversationId || !state.conversations[conversationId]) return;
+      const conv = state.conversations[conversationId];
+      if (!conv.embeddings) return;
+      const embeddingIndex = conv.embeddings.findIndex((op) => op.id === requestId);
+      if (embeddingIndex >= 0) {
+        setState("conversations", conversationId, "embeddings", embeddingIndex, produce((op) => {
+          op.duration = duration;
+          op.status = "completed";
+        }));
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("summarize:started", (e) => {
+      const {
+        requestId,
+        model,
+        inputLength,
+        timestamp,
+        clientId
+      } = e.payload;
+      let conversationId = clientId;
+      if (!conversationId || !state.conversations[conversationId]) {
+        const activeClients = Object.values(state.conversations).filter((c) => c.type === "client" && c.status === "active").sort((a, b) => b.startedAt - a.startedAt);
+        if (activeClients.length > 0 && activeClients[0]) {
+          conversationId = activeClients[0].id;
+        } else {
+          conversationId = `summarize-${requestId}`;
+          getOrCreateConversation(conversationId, "server", `Summarize (${model})`);
+          updateConversation(conversationId, {
+            model
+          });
+        }
+      }
+      requestToConversation.set(requestId, conversationId);
+      const summarizeOp = {
+        id: requestId,
+        model,
+        inputLength,
+        timestamp,
+        status: "started"
+      };
+      const conv = state.conversations[conversationId];
+      if (conv) {
+        const summaries = conv.summaries || [];
+        setState("conversations", conversationId, "summaries", [...summaries, summarizeOp]);
+        setState("conversations", conversationId, "hasSummarize", true);
+      }
+    }, {
+      withEventTarget: false
+    }));
+    cleanupFns.push(aiEventClient.on("summarize:completed", (e) => {
+      const {
+        requestId,
+        outputLength,
+        duration
+      } = e.payload;
+      const conversationId = requestToConversation.get(requestId);
+      if (!conversationId || !state.conversations[conversationId]) return;
+      const conv = state.conversations[conversationId];
+      if (!conv.summaries) return;
+      const summaryIndex = conv.summaries.findIndex((op) => op.id === requestId);
+      if (summaryIndex >= 0) {
+        setState("conversations", conversationId, "summaries", summaryIndex, produce((op) => {
+          op.duration = duration;
+          op.outputLength = outputLength;
+          op.status = "completed";
+        }));
+      }
+    }, {
+      withEventTarget: false
+    }));
+    onCleanup(() => {
+      for (const cleanup of cleanupFns) {
+        cleanup();
+      }
+      streamToConversation.clear();
+      requestToConversation.clear();
+    });
+  });
+  const contextValue = {
+    state,
+    clearAllConversations,
+    selectConversation
+  };
+  return createComponent(AIContext.Provider, {
+    value: contextValue,
+    get children() {
+      return props.children;
+    }
+  });
+};
+export {
+  AIProvider,
+  useAIStore
+};
+//# sourceMappingURL=ai-context.js.map