@copilotz/chat-adapter 0.3.9 → 0.4.1

package/README.md

@@ -107,6 +107,19 @@ Messages stream token-by-token with a thinking indicator while waiting for the f
 <CopilotzChat userId="user-123" />
 ```
 
+### Live Stream Contract
+
+From `0.4.0` onward, the adapter treats the Copilotz live stream as a lifecycle-native contract:
+
+- `TOKEN` streams partial assistant text and reasoning
+- `TOOL_CALL` starts or updates the tool execution UI
+- `TOOL_RESULT` completes the tool execution UI
+- `LLM_RESULT` finalizes the active assistant turn
+- `ASSET_CREATED` remains an optional live artifact event
+- `NEW_MESSAGE` is treated as a history/artifact event, not the primary live completion signal
+
+If you stream Copilotz events through a custom bridge, keep those event names intact.
+
 ### Tool Calls with Live Status
 
 When your agent calls tools, the UI shows real-time status updates:

package/dist/index.js

@@ -337,6 +337,8 @@ async function runCopilotzStream(options) {
   const threadName = mergedThreadMetadata.name ?? null;
   const { name: _threadName, ...restThreadMetadata } = mergedThreadMetadata;
   const resolvedParticipants = Array.isArray(participants) && participants.length > 0 ? participants : [selectedAgent || "assistant"];
+  const resolvedTarget = targetAgent?.trim() || null;
+  const toolCallSenderId = selectedAgent || resolvedParticipants[0] || "assistant";
   const threadPayload = threadId || threadExternalId || threadName || Object.keys(restThreadMetadata).length > 0 ? {
     id: threadId ?? null,
     externalId: threadExternalId ?? null,
@@ -379,14 +381,13 @@ async function runCopilotzStream(options) {
     if (parts.length === 1 && parts[0].type === "text") return parts[0].text;
     return parts;
   })();
-  const resolvedTarget = targetAgent?.trim() || null;
   const payload = {
     content: contentParts,
     sender: {
       type: normalizedToolCalls.length > 0 ? "agent" : "user",
-      externalId: user.externalId,
-      id: normalizedToolCalls.length > 0 ? "assistant" : void 0,
-      name: normalizedToolCalls.length > 0 ? "assistant" : user.name ?? null,
+      externalId: normalizedToolCalls.length > 0 ? toolCallSenderId : user.externalId,
+      id: normalizedToolCalls.length > 0 ? toolCallSenderId : void 0,
+      name: normalizedToolCalls.length > 0 ? toolCallSenderId : user.name ?? null,
       metadata: Object.keys(senderMetadata).length > 0 ? senderMetadata : null
     },
     metadata: messageMetadata ?? null,
@@ -475,15 +476,11 @@ async function runCopilotzStream(options) {
         }
         break;
       }
-      case "MESSAGE": {
+      case "NEW_MESSAGE": {
         hadNonReasoningContent = true;
         lastTokenWasReasoning = false;
         collectedMessages.push(payload2);
         onMessageEvent?.(payload2);
-        const senderType = payload2?.payload?.senderType ?? payload2?.payload?.sender?.type;
-        if (senderType === "agent" && typeof payload2?.payload?.content === "string") {
-          aggregatedText = payload2.payload.content;
-        }
         break;
       }
       case "TOOL_CALL": {
@@ -492,6 +489,13 @@ async function runCopilotzStream(options) {
         onMessageEvent?.(payload2);
         break;
       }
+      case "TOOL_RESULT":
+      case "LLM_RESULT": {
+        hadNonReasoningContent = true;
+        lastTokenWasReasoning = false;
+        onMessageEvent?.(payload2);
+        break;
+      }
       case "ASSET_CREATED": {
         const assetPayload = payload2 && typeof payload2 === "object" && "payload" in payload2 ? payload2.payload : payload2;
         if (assetPayload?.dataUrl) {
@@ -504,8 +508,15 @@ async function runCopilotzStream(options) {
       }
       case "ERROR":
         throw new Error(payload2?.error || "Copilotz stream error");
-      default:
-        onMessageEvent?.({ type: eventType, payload: payload2 });
+      default: {
+        const hasEnvelope = payload2 && typeof payload2 === "object" && "type" in payload2;
+        if (hasEnvelope) {
+          onMessageEvent?.(payload2);
+        } else {
+          onMessageEvent?.({ type: eventType, payload: payload2 });
+        }
+        break;
+      }
     }
   };
   while (true) {
@@ -661,7 +672,8 @@ async function getAssetDataUrl(refOrId) {
     const text = await res.text().catch(() => res.statusText);
     throw new Error(text || `Failed to fetch asset ${refOrId}`);
   }
-  const data = await res.json();
+  const body = await res.json();
+  const data = body?.data ?? body;
   if (!data?.dataUrl) {
     throw new Error(data?.error || `Asset ${refOrId} has no dataUrl`);
   }
@@ -858,6 +870,67 @@ var parseToolArguments = (value) => {
   }
   return {};
 };
+var matchesToolResultUpdate = (target, update) => {
+  if (update.id && target.id) {
+    return update.id === target.id;
+  }
+  return Boolean(update.name && target.name && update.name === target.name);
+};
+var findMatchingToolCallIndex = (toolCalls, update) => toolCalls.findIndex((toolCall) => matchesToolResultUpdate(
+  { id: toolCall.id, name: toolCall.name },
+  update
+) && (toolCall.status === "pending" || toolCall.status === "running" || typeof toolCall.result === "undefined"));
+var applyToolResultUpdateToMessages = (messages, update, assistantPatch) => {
+  const nextMessages = [...messages];
+  for (let i = nextMessages.length - 1; i >= 0; i--) {
+    const message = nextMessages[i];
+    if (message.role !== "assistant" || !Array.isArray(message.toolCalls) || message.toolCalls.length === 0) {
+      continue;
+    }
+    const toolCallIndex = findMatchingToolCallIndex(message.toolCalls, update);
+    if (toolCallIndex === -1) continue;
+    const updatedToolCalls = [...message.toolCalls];
+    const current = updatedToolCalls[toolCallIndex];
+    updatedToolCalls[toolCallIndex] = {
+      ...current,
+      status: update.status,
+      ...update.result !== void 0 ? { result: update.result } : {},
+      endTime: update.endTime
+    };
+    nextMessages[i] = {
+      ...message,
+      toolCalls: updatedToolCalls,
+      ...assistantPatch ?? {}
+    };
+    return { messages: nextMessages, matched: true };
+  }
+  return { messages, matched: false };
+};
+var extractLiveToolCall = (payload) => {
+  const toolCall = payload?.toolCall;
+  if (!toolCall) return null;
+  const tool = toolCall.tool;
+  const name = typeof tool?.name === "string" ? tool.name : typeof tool?.id === "string" ? tool.id : "tool";
+  const result = toolCall.output !== void 0 ? toolCall.output : void 0;
+  return {
+    ...typeof toolCall.id === "string" ? { id: toolCall.id } : {},
+    name,
+    arguments: parseToolArguments(toolCall.args),
+    status: normalizeToolStatus(toolCall.status ?? payload?.status ?? "running"),
+    ...result !== void 0 ? { result } : {}
+  };
+};
+var extractLiveToolResultUpdate = (payload) => {
+  const tool = payload?.tool;
+  const result = payload?.projectedOutput !== void 0 ? payload.projectedOutput : payload?.output !== void 0 ? payload.output : payload?.content;
+  return {
+    ...typeof payload?.toolCallId === "string" ? { id: payload.toolCallId } : {},
+    ...typeof tool?.name === "string" ? { name: tool.name } : typeof tool?.id === "string" ? { name: tool.id } : {},
+    status: normalizeToolStatus(payload?.status),
+    ...result !== void 0 ? { result } : {},
+    endTime: nowTs()
+  };
+};
 var extractToolCallsFromServerMessage = (msg) => {
   const metadata = msg.metadata ?? void 0;
   const topLevelToolCalls = Array.isArray(msg.toolCalls) ? msg.toolCalls || [] : [];
@@ -924,33 +997,9 @@ var extractToolResultUpdateFromMessage = (msg) => {
 };
 var mergePersistedToolResults = (messages, updates) => {
   if (updates.length === 0) return messages;
-  const nextMessages = [...messages];
+  let nextMessages = messages;
   for (const update of updates) {
-    for (let i = nextMessages.length - 1; i >= 0; i--) {
-      const message = nextMessages[i];
-      if (message.role !== "assistant" || !Array.isArray(message.toolCalls) || message.toolCalls.length === 0) {
-        continue;
-      }
-      const toolCalls = message.toolCalls;
-      let toolCallIndex = update.id ? toolCalls.findIndex((toolCall) => toolCall.id === update.id) : -1;
-      if (toolCallIndex === -1 && update.name) {
-        toolCallIndex = toolCalls.findIndex((toolCall) => toolCall.name === update.name && (toolCall.status === "pending" || toolCall.status === "running" || typeof toolCall.result === "undefined"));
-      }
-      if (toolCallIndex === -1) continue;
-      const updatedToolCalls = [...toolCalls];
-      const current = updatedToolCalls[toolCallIndex];
-      updatedToolCalls[toolCallIndex] = {
-        ...current,
-        status: update.status,
-        ...update.result !== void 0 ? { result: update.result } : {},
-        endTime: update.endTime
-      };
-      nextMessages[i] = {
-        ...message,
-        toolCalls: updatedToolCalls
-      };
-      break;
-    }
+    nextMessages = applyToolResultUpdateToMessages(nextMessages, update).messages;
   }
   return nextMessages;
 };
@@ -1070,6 +1119,7 @@ function useCopilotz({
   const messagePageInfoRef = useRef2(messagePageInfo);
   const isLoadingOlderMessagesRef = useRef2(isLoadingOlderMessages);
   const persistedToolUpdatesRef = useRef2([]);
+  const liveToolUpdatesRef = useRef2([]);
   threadsRef.current = threads;
   threadMetadataMapRef.current = threadMetadataMap;
   threadExternalIdMapRef.current = threadExternalIdMap;
@@ -1133,87 +1183,46 @@ function useCopilotz({
       return;
     }
     const senderType = getEventSenderType(payload);
-    if (senderType === "tool") {
-      const metadata = payload.metadata ?? event.metadata ?? {};
-      const output = metadata?.output ?? metadata;
-      if (output) processToolOutput(output);
-      const toolName = metadata?.toolName || metadata?.tool || "tool";
-      let argsObj = {};
-      try {
-        const argStr = metadata?.arguments ?? "{}";
-        argsObj = typeof argStr === "string" ? JSON.parse(argStr) : argStr;
-      } catch (_) {
-      }
-      const resultObj = metadata?.output;
-      const callId = payload.toolCallId || generateId();
-      setMessages((prev) => {
-        const next = [...prev];
-        for (let i = next.length - 1; i >= 0; i--) {
-          const m = next[i];
-          if (m.role === "assistant") {
-            const existing = Array.isArray(m.toolCalls) ? m.toolCalls : [];
-            next[i] = {
-              ...m,
-              toolCalls: [
-                ...existing,
-                {
-                  id: callId,
-                  name: toolName,
-                  arguments: argsObj,
-                  result: resultObj,
-                  status: "completed",
-                  endTime: Date.now()
-                }
-              ]
-            };
-            break;
-          }
-        }
-        return next;
-      });
-      return;
-    }
-    if (senderType === "agent" && typeof payload.content === "string") {
-      const agentSenderId = payload.senderId ?? payload.sender?.id ?? payload.sender?.name ?? void 0;
-      const agentSenderName = payload.sender?.name ?? payload.senderId ?? void 0;
-      const incomingAgentKey = agentSenderId ?? agentSenderName ?? null;
-      setMessages((prev) => {
-        const next = [...prev];
-        for (let i = next.length - 1; i >= 0; i--) {
-          const m = next[i];
-          if (m.role === "assistant" && m.isStreaming && (!incomingAgentKey || messageAgentKey(m) === incomingAgentKey)) {
-            next[i] = {
-              ...m,
-              content: payload.content,
-              isStreaming: false,
-              isComplete: true,
-              ...agentSenderId ? { senderAgentId: agentSenderId } : {},
-              ...agentSenderName ? { senderName: agentSenderName } : {}
-            };
-            return next;
-          }
-        }
-        const trimmedContent = payload.content.trim();
-        if (!trimmedContent) {
-          return prev;
-        }
-        return [
-          ...next,
-          {
-            id: generateId(),
-            role: "assistant",
+    if (senderType !== "agent" || typeof payload.content !== "string") return;
+    const agentSenderId = payload.senderId ?? payload.sender?.id ?? payload.sender?.name ?? void 0;
+    const agentSenderName = payload.sender?.name ?? payload.senderId ?? void 0;
+    const incomingAgentKey = agentSenderId ?? agentSenderName ?? null;
+    setMessages((prev) => {
+      const next = [...prev];
+      for (let i = next.length - 1; i >= 0; i--) {
+        const m = next[i];
+        if (m.role === "assistant" && m.isStreaming && (!incomingAgentKey || messageAgentKey(m) === incomingAgentKey)) {
+          next[i] = {
+            ...m,
             content: payload.content,
-            timestamp: nowTs(),
             isStreaming: false,
             isComplete: true,
-            metadata: liveMetadata,
             ...agentSenderId ? { senderAgentId: agentSenderId } : {},
             ...agentSenderName ? { senderName: agentSenderName } : {}
-          }
-        ];
-      });
-    }
-  }, [processToolOutput]);
+          };
+          return next;
+        }
+      }
+      const trimmedContent = payload.content.trim();
+      if (!trimmedContent) {
+        return prev;
+      }
+      return [
+        ...next,
+        {
+          id: generateId(),
+          role: "assistant",
+          content: payload.content,
+          timestamp: nowTs(),
+          isStreaming: false,
+          isComplete: true,
+          metadata: liveMetadata,
+          ...agentSenderId ? { senderAgentId: agentSenderId } : {},
+          ...agentSenderName ? { senderName: agentSenderName } : {}
+        }
+      ];
+    });
+  }, []);
   const updateThreadsState = useCallback2((rawThreads, preferredExternalId) => {
     const metadataMap = {};
     const externalMap = {};
@@ -1302,6 +1311,7 @@ function useCopilotz({
     setIsLoadingOlderMessages(false);
     setMessagePageInfo(createEmptyMessagePageInfo());
     persistedToolUpdatesRef.current = [];
+    liveToolUpdatesRef.current = [];
     try {
       const page = await fetchThreadMessagesPage(
         threadId,
@@ -1597,78 +1607,70 @@ function useCopilotz({
       });
     };
     const curThreadId = currentThreadIdRef.current;
+    const applyLiveToolResultUpdate = (update) => {
+      let matched = false;
+      setMessages((prev) => {
+        const next = applyToolResultUpdateToMessages(prev, update, {
+          isStreaming: true,
+          isComplete: false
+        });
+        matched = next.matched;
+        return next.matched ? next.messages : prev;
+      });
+      if (!matched) {
+        liveToolUpdatesRef.current.push(update);
+      }
+    };
+    const finalizeActiveAssistantTurn = (finalAnswer) => {
+      setMessages((prev) => {
+        const currentIdx = prev.findIndex((message2) => message2.id === currentAssistantId && message2.role === "assistant");
+        const fallbackIdx = currentIdx >= 0 ? currentIdx : (() => {
+          for (let i = prev.length - 1; i >= 0; i--) {
+            if (prev[i].role === "assistant" && prev[i].isStreaming) {
+              return i;
+            }
+          }
+          return -1;
+        })();
+        if (fallbackIdx < 0) return prev;
+        const message = prev[fallbackIdx];
+        const nextMessage = {
+          ...message,
+          ...typeof finalAnswer === "string" && finalAnswer.length > 0 ? { content: finalAnswer } : {},
+          isStreaming: false,
+          isComplete: true,
+          ...message.reasoning ? { isReasoningStreaming: false } : {}
+        };
+        if (message.content === nextMessage.content && message.isStreaming === nextMessage.isStreaming && message.isComplete === nextMessage.isComplete && message.isReasoningStreaming === nextMessage.isReasoningStreaming) {
+          return prev;
+        }
+        const updated = [...prev];
+        updated[fallbackIdx] = nextMessage;
+        currentAssistantId = nextMessage.id;
+        return updated;
+      });
+    };
     const toServerMessageFromEvent = async (event) => {
       if (!event) return null;
       const type = event?.type || "";
       const payload = event?.payload ?? event;
       if (type === "TOOL_CALL") {
-        const metadata = payload?.metadata ?? {};
-        const tc = payload?.toolCall ?? void 0;
-        const tcTool = tc?.tool ?? void 0;
-        const call = payload?.call ?? metadata?.call;
-        const func = call?.function ?? payload?.function;
-        const toolName = tcTool?.name || func?.name || payload?.name || call?.name || metadata.toolName || metadata.tool || "tool";
-        let argsObj = {};
-        const possibleArgs = [
-          tc?.args,
-          func?.arguments,
-          payload?.args,
-          call?.arguments,
-          metadata?.args,
-          metadata?.arguments
-        ];
-        for (const candidate of possibleArgs) {
-          if (candidate === void 0 || candidate === null) continue;
-          try {
-            if (typeof candidate === "string") {
-              argsObj = JSON.parse(candidate);
-              break;
-            }
-            if (typeof candidate === "object") {
-              argsObj = candidate;
-              break;
-            }
-          } catch {
-          }
-        }
-        const output = (tc?.output !== void 0 ? tc.output : void 0) ?? (metadata?.output !== void 0 ? metadata.output : void 0) ?? (payload?.output !== void 0 ? payload.output : void 0);
-        const callId = tc?.id || call?.id || func?.id || payload?.id || generateId();
-        const statusVal = tc?.status || payload?.status || event?.status || "pending";
+        const parsedToolCall = extractLiveToolCall(payload);
+        if (!parsedToolCall) return null;
         return {
           id: generateId(),
           threadId: curThreadId ?? "",
           senderType: "tool",
           content: "",
           toolCalls: [{
-            id: callId,
-            name: toolName,
-            args: argsObj,
-            output,
-            status: statusVal
+            id: parsedToolCall.id ?? generateId(),
+            name: parsedToolCall.name,
+            args: parsedToolCall.arguments,
+            ...parsedToolCall.result !== void 0 ? { output: parsedToolCall.result } : {},
+            status: parsedToolCall.status
           }]
         };
       }
-      if (type === "MESSAGE" || type === "NEW_MESSAGE") {
-        const senderType = payload?.senderType || payload?.sender?.type;
-        const liveMetadata = event?.metadata && typeof event.metadata === "object" ? event.metadata : payload?.metadata;
-        if (isInternalMessageMetadata(liveMetadata)) {
-          return null;
-        }
-        if (senderType !== "agent") {
-          return null;
-        }
-        const content = typeof payload?.content === "string" ? payload.content : "";
-        if (!content.trim()) {
-          return null;
-        }
-        return {
-          id: generateId(),
-          threadId: curThreadId ?? "",
-          senderType: "agent",
-          content,
-          metadata: liveMetadata ?? {}
-        };
-      }
       if (type === "ASSET_CREATED") {
         const by = payload?.by || "";
         if (by && by !== "tool") return null;
@@ -1694,6 +1696,7 @@ function useCopilotz({
     abortControllerRef.current?.abort();
     abortControllerRef.current = abortController;
     setIsStreaming(true);
+    liveToolUpdatesRef.current = [];
     try {
       const normalizedUserMetadata = params.userMetadata ? JSON.parse(JSON.stringify(params.userMetadata)) : void 0;
       const contextSeed = userContextSeedRef.current;
@@ -1739,68 +1742,38 @@ function useCopilotz({
           }
           const type = event?.type || "";
           const payload = getEventPayload(event);
+          if (type === "TOOL_RESULT") {
+            processToolOutput(payload ?? {});
+            applyLiveToolResultUpdate(extractLiveToolResultUpdate(
+              payload ?? {}
+            ));
+            return;
+          }
+          if (type === "LLM_RESULT") {
+            const finalAnswer = typeof payload?.answer === "string" ? payload.answer : void 0;
+            finalizeActiveAssistantTurn(finalAnswer);
+            pendingStartNewAssistantBubble = true;
+            return;
+          }
           if (type === "MESSAGE" || type === "NEW_MESSAGE") {
-            const senderType = getEventSenderType(payload);
-            if (senderType === "tool") {
-              const metadata = payload?.metadata ?? {};
-              const toolCallsArray = metadata?.toolCalls;
-              const toolCallData = toolCallsArray && toolCallsArray.length > 0 ? toolCallsArray[0] : void 0;
-              if (!toolCallData) {
-                return;
-              }
-              processToolOutput(metadata);
-              const toolCallId = toolCallData.id;
-              const toolCallName = toolCallData.name;
-              const toolResult = toolCallData.output || payload?.content;
-              const toolStatus = toolCallData.status || "completed";
-              const isFailed = toolStatus === "failed" || toolCallData?.error;
-              setMessages((prev) => {
-                const updated = [...prev];
-                for (let i = updated.length - 1; i >= 0; i--) {
-                  if (updated[i].role === "assistant" && updated[i].toolCalls) {
-                    const toolCalls = updated[i].toolCalls;
-                    if (toolCalls) {
-                      let toolCallIndex = toolCallId ? toolCalls.findIndex((tc) => tc.id === toolCallId) : -1;
-                      if (toolCallIndex === -1 && toolCallName) {
-                        toolCallIndex = toolCalls.findIndex(
-                          (tc) => tc.name === toolCallName && (tc.status === "pending" || tc.status === "running")
-                        );
-                      }
-                      if (toolCallIndex !== -1) {
-                        const updatedToolCalls = [...toolCalls];
-                        updatedToolCalls[toolCallIndex] = {
-                          ...updatedToolCalls[toolCallIndex],
-                          status: isFailed ? "failed" : "completed",
-                          result: toolResult,
-                          endTime: Date.now()
-                        };
-                        updated[i] = {
-                          ...updated[i],
-                          toolCalls: updatedToolCalls,
-                          isStreaming: true,
-                          isComplete: false
-                        };
-                        break;
-                      }
-                    }
-                  }
-                }
-                return updated;
-              });
-              return;
-            }
-            handleStreamMessageEvent(event);
-            if (senderType === "agent") {
-              currentAssistantId = generateId();
-              pendingStartNewAssistantBubble = true;
-            }
             return;
           }
           if (type === "TOOL_CALL") {
-            const sm2 = await toServerMessageFromEvent(event);
-            const toolCalls = sm2?.toolCalls;
-            const toolCall = toolCalls && toolCalls[0];
-            if (!toolCall) return;
+            const parsedToolCall = extractLiveToolCall(
+              payload ?? {}
+            );
+            if (!parsedToolCall) return;
+            const callId = parsedToolCall.id ?? generateId();
+            const toolName = parsedToolCall.name;
+            const bufferedUpdates = liveToolUpdatesRef.current;
+            const matchingUpdateIndex = bufferedUpdates.findIndex((upd) => matchesToolResultUpdate({ id: callId, name: toolName }, upd));
+            const bufferedUpdate = matchingUpdateIndex >= 0 ? bufferedUpdates[matchingUpdateIndex] : void 0;
+            if (matchingUpdateIndex >= 0) {
+              bufferedUpdates.splice(matchingUpdateIndex, 1);
+            }
+            const initialStatus = bufferedUpdate ? bufferedUpdate.status : parsedToolCall.status;
+            const initialResult = bufferedUpdate && bufferedUpdate.result !== void 0 ? bufferedUpdate.result : parsedToolCall.result;
+            const endTime = bufferedUpdate?.endTime;
             setMessages(
               (prev) => (() => {
                 const appendToolCall = (msg) => ({
@@ -1808,12 +1781,13 @@ function useCopilotz({
                   toolCalls: [
                     ...Array.isArray(msg.toolCalls) ? msg.toolCalls : [],
                     {
-                      id: toolCall.id ?? generateId(),
-                      name: toolCall.name ?? "tool",
-                      arguments: toolCall.args ?? toolCall.arguments ?? {},
-                      result: toolCall.output,
-                      status: toolCall.status ?? "running",
-                      startTime: Date.now()
+                      id: callId,
+                      name: toolName,
+                      arguments: parsedToolCall.arguments,
+                      ...initialResult !== void 0 ? { result: initialResult } : {},
+                      status: initialStatus,
+                      startTime: Date.now(),
+                      ...endTime !== void 0 ? { endTime } : {}
                     }
                   ]
                 });