@copilotz/chat-adapter 0.9.43 → 0.9.45

package/dist/index.js

@@ -101,6 +101,38 @@ var User = createLucideIcon("user", __iconNode);
 // src/useCopilotzChat.ts
 import { useState as useState2, useCallback as useCallback2, useRef as useRef2, useEffect as useEffect2 } from "react";
 
+// src/streamEvents.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var hasValues = (value) => Array.isArray(value) && value.length > 0;
+var getStreamEventPayload = (event) => {
+  if (!isRecord(event)) return event;
+  return "payload" in event ? event.payload : event;
+};
+var getLlmAttemptId = (event) => {
+  if (!isRecord(event)) return null;
+  const metadata = isRecord(event.metadata) ? event.metadata : {};
+  if (typeof metadata.llmAttemptId === "string" && metadata.llmAttemptId.trim().length > 0) {
+    return metadata.llmAttemptId.trim();
+  }
+  if (event.subjectType === "llm_attempt" && typeof event.subjectId === "string" && event.subjectId.trim().length > 0) {
+    return event.subjectId.trim();
+  }
+  return null;
+};
+var isTerminalEmptyLlmResultEvent = (event) => {
+  if (!isRecord(event) || event.type !== "LLM_RESULT") return false;
+  const payload = getStreamEventPayload(event);
+  if (!isRecord(payload)) return false;
+  if (payload.answer !== "") return false;
+  if (payload.finishReason === "tool_calls") return false;
+  if (hasValues(payload.toolCalls)) return false;
+  const metadata = isRecord(event.metadata) ? event.metadata : {};
+  const routing = isRecord(metadata.routing) ? metadata.routing : {};
+  if ((routing.action === "ask" || routing.action === "handoff") && typeof routing.targetId === "string" && routing.targetId.trim().length > 0) return false;
+  if (hasValues(metadata.targetQueue)) return false;
+  return true;
+};
+
 // src/copilotzService.ts
 var rawBaseValue = import.meta.env?.VITE_API_URL;
 var rawBase = typeof rawBaseValue === "string" && rawBaseValue.length > 0 ? rawBaseValue : "/api";
@@ -428,6 +460,11 @@ async function runCopilotzStream(options) {
   let lastCompletedText = "";
   let lastTokenWasReasoning = false;
   let hadNonReasoningContent = false;
+  let activeLlmAttemptId = null;
+  let activePhaseKind = null;
+  let activePhaseId = null;
+  let phaseOrdinal = -1;
+  let fallbackAttemptOrdinal = 0;
   const collectedMessages = [];
   let collectedMedia = null;
   const resetTokenAggregation = () => {
@@ -436,6 +473,30 @@ async function runCopilotzStream(options) {
     lastTokenWasReasoning = false;
     hadNonReasoningContent = false;
   };
+  const startAttempt = (event) => {
+    activeLlmAttemptId = getLlmAttemptId(event) ?? `stream-attempt:${fallbackAttemptOrdinal++}`;
+    activePhaseKind = null;
+    activePhaseId = null;
+    phaseOrdinal = -1;
+    resetTokenAggregation();
+  };
+  const getTokenContext = (isReasoning) => {
+    if (!activeLlmAttemptId) {
+      startAttempt(null);
+    }
+    const kind = isReasoning ? "reasoning" : "answer";
+    if (activePhaseKind !== kind || !activePhaseId) {
+      phaseOrdinal += 1;
+      activePhaseKind = kind;
+      activePhaseId = `${activeLlmAttemptId}:${kind}:${phaseOrdinal}`;
+    }
+    return {
+      isReasoning,
+      llmAttemptId: activeLlmAttemptId,
+      phaseId: activePhaseId,
+      phaseOrdinal
+    };
+  };
   const processEvent = async (eventChunk) => {
     if (!eventChunk.trim()) return;
     const lines = eventChunk.split("\n");
@@ -461,10 +522,16 @@ async function runCopilotzStream(options) {
       return;
     }
     switch (eventType) {
+      case "LLM_CALL": {
+        startAttempt(payload2);
+        await onMessageEvent?.(payload2);
+        break;
+      }
       case "TOKEN": {
         const inner = payload2?.payload ?? payload2;
         const chunk = typeof inner?.token === "string" ? inner.token : "";
-        const isReasoning = Boolean(inner?.isReasoning);
+        const isReasoning = typeof inner?.isReasoning === "boolean" ? inner.isReasoning : activePhaseKind === "reasoning" || lastTokenWasReasoning;
+        const tokenContext = getTokenContext(isReasoning);
         if (isReasoning && !lastTokenWasReasoning && hadNonReasoningContent) {
           aggregatedReasoning = "";
           aggregatedText = "";
@@ -482,12 +549,14 @@ async function runCopilotzStream(options) {
         const isComplete = Boolean(inner?.isComplete);
         if (chunk || isComplete) {
           const tokenText = isReasoning ? aggregatedReasoning : aggregatedText;
-          onToken?.(tokenText, isComplete, payload2, { isReasoning });
+          onToken?.(tokenText, isComplete, payload2, tokenContext);
           if (isComplete) {
             if (!isReasoning && tokenText) {
               lastCompletedText = tokenText;
             }
             resetTokenAggregation();
+            activePhaseKind = null;
+            activePhaseId = null;
           }
         }
         break;
@@ -833,8 +902,6 @@ function useUrlState(config = {}) {
 }
 
 // src/activity.ts
-var thinkingId = "thinking";
-var answeringId = "answering";
 var getItems = (message) => Array.isArray(message.activity?.items) ? message.activity.items : [];
 var setItems = (message, items) => ({
   ...message,
@@ -860,7 +927,8 @@ var upsertItem = (message, item) => {
   };
   return setItems(message, next);
 };
-var completeItems = (message, shouldComplete) => setItems(message, getItems(message).map((item) => item.status === "active" && shouldComplete(item) ? { ...item, status: "complete", completedAt: Date.now() } : item));
+var completeItems = (message, shouldComplete, completedAt = Date.now()) => setItems(message, getItems(message).map((item) => item.status === "active" && shouldComplete(item) ? { ...item, status: "complete", completedAt } : item));
+var removeItems = (message, shouldRemove) => setItems(message, getItems(message).filter((item) => !shouldRemove(item)));
 var hasVisibleAssistantOutput = (message) => {
   if (message.role !== "assistant") return false;
   if (typeof message.content === "string" && message.content.trim().length > 0) return true;
@@ -875,38 +943,40 @@ var toPublicChatMessage = (message) => {
 var updateAssistantMessageToken = (message, params) => {
   if (message.role !== "assistant") return message;
   if (params.isReasoning) {
-    return upsertItem({
+    const activityId2 = params.activityId ?? `${message.id}:thinking`;
+    return upsertItem(completeItems(removeItems({
       ...message,
       isStreaming: true,
       isComplete: false
-    }, {
-      id: thinkingId,
+    }, (item) => item.kind === "answering"), (item) => item.id !== activityId2 && (item.kind === "thinking" || item.kind === "answering"), params.at), {
+      id: activityId2,
       kind: "thinking",
       status: "active",
-      startedAt: getItems(message).find((item) => item.id === thinkingId)?.startedAt ?? Date.now(),
+      startedAt: getItems(message).find((item) => item.id === activityId2)?.startedAt ?? params.at ?? Date.now(),
       details: { reasoning: params.partial }
     });
   }
-  return upsertItem(completeItems({
+  const activityId = params.activityId ?? `${message.id}:answering`;
+  return upsertItem(completeItems(removeItems({
     ...message,
     content: params.partial,
     isStreaming: true,
     isComplete: false
-  }, (item) => item.kind === "thinking" || item.kind === "tool"), {
-    id: answeringId,
+  }, (item) => item.kind === "answering" && item.id !== activityId), (item) => item.kind === "thinking" || item.kind === "answering", params.at), {
+    id: activityId,
     kind: "answering",
     status: "active",
-    startedAt: getItems(message).find((item) => item.id === answeringId)?.startedAt ?? Date.now()
+    startedAt: getItems(message).find((item) => item.id === activityId)?.startedAt ?? params.at ?? Date.now()
   });
 };
 var appendAssistantToolCall = (message, toolCall) => {
   if (message.role !== "assistant") return message;
   const status = toolStatusToActivityStatus(toolCall.status);
-  return upsertItem({
+  return upsertItem(completeItems(removeItems({
     ...message,
     isStreaming: true,
     isComplete: false
-  }, {
+  }, (item) => item.kind === "answering"), (item) => item.kind === "thinking" || item.kind === "answering"), {
     id: toolCall.id,
     kind: "tool",
     status,
@@ -955,23 +1025,23 @@ var applyAssistantToolResult = (message, update) => {
   };
   return setItems(message, next);
 };
-var finalizeAssistantMessage = (message, finalAnswer) => {
+var finalizeAssistantMessage = (message, finalAnswer, completedAt = Date.now()) => {
   if (message.role !== "assistant") return message;
   const completed = completeItems({
     ...message,
     ...typeof finalAnswer === "string" && finalAnswer.length > 0 ? { content: finalAnswer } : {},
     isStreaming: false,
     isComplete: true
-  }, (item) => item.kind === "thinking" || item.kind === "answering");
+  }, (item) => item.kind === "thinking" || item.kind === "answering", completedAt);
   return setItems(completed, getItems(completed).filter((item) => item.kind !== "answering"));
 };
-var closeAssistantMessage = (message) => {
+var closeAssistantMessage = (message, completedAt = Date.now()) => {
   if (message.role !== "assistant") return message;
   return completeItems({
     ...message,
     isStreaming: false,
     isComplete: true
-  }, () => true);
+  }, () => true, completedAt);
 };
 
 // src/contract.ts
@@ -981,9 +1051,9 @@ var ContractViolation = class extends Error {
     this.name = "ContractViolation";
   }
 };
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var expectRecord = (value, path) => {
-  if (!isRecord(value)) throw new ContractViolation(`${path} must be an object`);
+  if (!isRecord2(value)) throw new ContractViolation(`${path} must be an object`);
   return value;
 };
 var expectString = (value, path) => {
@@ -1104,14 +1174,14 @@ var resolveLiveEventSender = (event, options = {}) => {
   const raw = expectRecord(event, "stream event");
   const payload = raw.payload === void 0 ? raw : expectRecord(raw.payload, "stream event.payload");
   const agent = payload.agent ?? raw.agent;
-  if (isRecord(agent)) {
+  if (isRecord2(agent)) {
     return resolveAgentSender({
       id: expectString(agent.id, "stream event.payload.agent.id"),
       name: expectString(agent.name, "stream event.payload.agent.name")
     }, options);
   }
   const sender = payload.sender ?? raw.sender;
-  if (!isRecord(sender)) {
+  if (!isRecord2(sender)) {
     throw new ContractViolation("stream event sender contract requires payload.agent or payload.sender");
   }
   const type = expectSenderType(sender.type ?? payload.senderType, "stream event.payload.sender.type");
@@ -1241,6 +1311,98 @@ async function resolveAssetsInMessages(messages, getRequestHeaders) {
   }));
 }
 
+// src/messageReconciliation.ts
+var CLIENT_MESSAGE_ID_METADATA_KEY = "clientMessageId";
+var LLM_ATTEMPT_ID_METADATA_KEY = "llmAttemptId";
+var stringifyForCompare = (value) => {
+  if (value === void 0) return "";
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return String(value);
+  }
+};
+var getMessageSignature = (message) => JSON.stringify({
+  id: message.id,
+  role: message.role,
+  content: message.content ?? "",
+  isStreaming: message.isStreaming === true,
+  isComplete: message.isComplete === true,
+  attachments: stringifyForCompare(message.attachments),
+  activity: stringifyForCompare(message.activity),
+  metadata: stringifyForCompare(message.metadata),
+  sender: message.sender ? {
+    id: message.sender.id,
+    type: message.sender.type,
+    name: message.sender.name,
+    agentId: message.sender.agentId
+  } : null
+});
+var getMetadataString = (message, key) => {
+  const value = message.metadata?.[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+};
+var getCorrelationKeys = (message) => {
+  const clientMessageId = getMetadataString(
+    message,
+    CLIENT_MESSAGE_ID_METADATA_KEY
+  );
+  const llmAttemptId = getMetadataString(
+    message,
+    LLM_ATTEMPT_ID_METADATA_KEY
+  );
+  return [
+    ...clientMessageId ? [`client-message:${message.role}:${clientMessageId}`] : [],
+    ...llmAttemptId ? [`llm-attempt:${message.role}:${llmAttemptId}`] : []
+  ];
+};
+var indexUniqueFreshCorrelations = (freshMessages) => {
+  const messagesByCorrelation = /* @__PURE__ */ new Map();
+  for (const message of freshMessages) {
+    for (const key of getCorrelationKeys(message)) {
+      messagesByCorrelation.set(
+        key,
+        messagesByCorrelation.has(key) ? null : message
+      );
+    }
+  }
+  return messagesByCorrelation;
+};
+var reconcileThreadMessages = (currentMessages, freshMessages) => {
+  if (freshMessages.length === 0) {
+    return { messages: currentMessages, changed: false };
+  }
+  if (currentMessages.length === 0) {
+    return { messages: freshMessages, changed: true };
+  }
+  const freshById = new Map(freshMessages.map((message) => [message.id, message]));
+  const freshByCorrelation = indexUniqueFreshCorrelations(freshMessages);
+  const seen = /* @__PURE__ */ new Set();
+  let changed = false;
+  const nextMessages = currentMessages.map((message) => {
+    const exactMatch = freshById.get(message.id);
+    const correlatedMatch = exactMatch ? null : getCorrelationKeys(message).map((key) => freshByCorrelation.get(key)).find((candidate) => candidate !== null && candidate !== void 0 && !seen.has(candidate.id));
+    const fresh = exactMatch ?? correlatedMatch;
+    if (!fresh) return message;
+    seen.add(fresh.id);
+    if (getMessageSignature(message) === getMessageSignature(fresh)) {
+      return message;
+    }
+    changed = true;
+    return fresh;
+  });
+  const appended = freshMessages.filter((message) => !seen.has(message.id));
+  if (appended.length > 0) {
+    changed = true;
+    nextMessages.push(...appended);
+    nextMessages.sort((a, b) => {
+      const timestampDelta = (a.timestamp ?? 0) - (b.timestamp ?? 0);
+      return timestampDelta !== 0 ? timestampDelta : a.id.localeCompare(b.id);
+    });
+  }
+  return changed ? { messages: nextMessages, changed } : { messages: currentMessages, changed: false };
+};
+
 // src/toolActivity.ts
 var fail = (message) => {
   throw new ContractViolation(message);
@@ -1263,7 +1425,7 @@ var formatToolError = (error) => {
   }
 };
 var expectToolArguments = (value, path) => {
-  if (isRecord(value)) return value;
+  if (isRecord2(value)) return value;
   if (typeof value === "string") {
     try {
       const parsed = JSON.parse(value);
@@ -1439,9 +1601,6 @@ var canAttachToStreamingAssistant = (message, incomingAgentKey) => {
   const currentAgentKey = messageAgentKey(message);
   return !incomingAgentKey || !currentAgentKey || currentAgentKey === incomingAgentKey;
 };
-var canAttachToCurrentStreamingAssistant = (message) => {
-  return !!message && message.role === "assistant" && message.isStreaming === true;
-};
 
 // src/messageContract.ts
 var isInternalMessageMetadata = (metadata) => metadata?.visibility === "internal";
@@ -1548,9 +1707,10 @@ var convertServerMessage = (msg, options = {}) => {
   const isToolSender = msg.senderType === "tool";
   const content = isToolSender ? "" : messageContent;
   const reasoning = typeof msg.reasoning === "string" && msg.reasoning.length > 0 ? msg.reasoning : void 0;
+  const llmAttemptId = typeof metadata?.[LLM_ATTEMPT_ID_METADATA_KEY] === "string" ? metadata[LLM_ATTEMPT_ID_METADATA_KEY].trim() : "";
   const activityItems = [
     ...reasoning ? [{
-      id: `${msg.id}:thinking`,
+      id: `${llmAttemptId || msg.id}:reasoning:0`,
       kind: "thinking",
       status: "complete",
       completedAt: timestamp,
@@ -1631,27 +1791,6 @@ var prepareHydratedMessages = async (rawMessages, options = {}) => {
   };
 };
 
-// src/streamEvents.ts
-var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var hasValues = (value) => Array.isArray(value) && value.length > 0;
-var getStreamEventPayload = (event) => {
-  if (!isRecord2(event)) return event;
-  return "payload" in event ? event.payload : event;
-};
-var isTerminalEmptyLlmResultEvent = (event) => {
-  if (!isRecord2(event) || event.type !== "LLM_RESULT") return false;
-  const payload = getStreamEventPayload(event);
-  if (!isRecord2(payload)) return false;
-  if (payload.answer !== "") return false;
-  if (payload.finishReason === "tool_calls") return false;
-  if (hasValues(payload.toolCalls)) return false;
-  const metadata = isRecord2(event.metadata) ? event.metadata : {};
-  const routing = isRecord2(metadata.routing) ? metadata.routing : {};
-  if ((routing.action === "ask" || routing.action === "handoff") && typeof routing.targetId === "string" && routing.targetId.trim().length > 0) return false;
-  if (hasValues(metadata.targetQueue)) return false;
-  return true;
-};
-
 // src/threadIdentity.ts
 var identityValues = ({ id, externalId }) => [id, externalId].filter((value) => typeof value === "string" && value.length > 0);
 var isSameThreadIdentity = (owner, current) => {
@@ -1661,12 +1800,256 @@ var isSameThreadIdentity = (owner, current) => {
   return ownerValues.some((value) => currentValues.has(value));
 };
 
+// src/liveRun.ts
+var copyState = (state) => ({
+  ...state,
+  attemptsById: new Map(state.attemptsById),
+  toolMessageByCallId: new Map(state.toolMessageByCallId),
+  pendingToolResultsByCallId: new Map(state.pendingToolResultsByCallId)
+});
+var createLiveRunState = (initialMessageId) => ({
+  initialMessageId,
+  initialMessageClaimed: false,
+  activeAttemptId: null,
+  lastAttemptId: null,
+  attemptsById: /* @__PURE__ */ new Map(),
+  toolMessageByCallId: /* @__PURE__ */ new Map(),
+  pendingToolResultsByCallId: /* @__PURE__ */ new Map()
+});
+var ensureAttempt = (state, attemptId, sender, at, options) => {
+  const existing = state.attemptsById.get(attemptId);
+  if (existing) {
+    const next2 = copyState(state);
+    const cursor2 = sender && existing.sender !== sender ? { ...existing, sender } : existing;
+    next2.attemptsById.set(attemptId, cursor2);
+    next2.activeAttemptId = attemptId;
+    next2.lastAttemptId = attemptId;
+    return { state: next2, cursor: cursor2, operations: [] };
+  }
+  const next = copyState(state);
+  const messageId = next.initialMessageClaimed ? options.createId() : next.initialMessageId;
+  const cursor = { messageId, sender };
+  next.initialMessageClaimed = true;
+  next.activeAttemptId = attemptId;
+  next.lastAttemptId = attemptId;
+  next.attemptsById.set(attemptId, cursor);
+  return {
+    state: next,
+    cursor,
+    operations: [{
+      type: "ensure-attempt",
+      messageId,
+      attemptId,
+      sender,
+      at
+    }]
+  };
+};
+var transitionLiveRun = (state, action, options) => {
+  if (action.type === "attempt-start") {
+    const ensured = ensureAttempt(
+      state,
+      action.attemptId,
+      action.sender,
+      action.at,
+      options
+    );
+    return { state: ensured.state, operations: ensured.operations };
+  }
+  if (action.type === "token") {
+    const ensured = ensureAttempt(
+      state,
+      action.attemptId,
+      action.sender,
+      action.at,
+      options
+    );
+    return {
+      state: ensured.state,
+      operations: [
+        ...ensured.operations,
+        {
+          type: "update-token",
+          messageId: ensured.cursor.messageId,
+          phaseId: action.phaseId,
+          partial: action.partial,
+          isReasoning: action.isReasoning,
+          sender: action.sender ?? ensured.cursor.sender,
+          at: action.at
+        }
+      ]
+    };
+  }
+  if (action.type === "attempt-result") {
+    const cursor = state.attemptsById.get(action.attemptId);
+    if (!cursor) return { state, operations: [] };
+    const next = copyState(state);
+    if (next.activeAttemptId === action.attemptId) {
+      next.activeAttemptId = null;
+    }
+    next.lastAttemptId = action.attemptId;
+    return {
+      state: next,
+      operations: [{
+        type: "finalize-attempt",
+        messageId: cursor.messageId,
+        answer: action.answer,
+        at: action.at
+      }]
+    };
+  }
+  if (action.type === "tool-call") {
+    if (state.toolMessageByCallId.has(action.toolCall.id)) {
+      return { state, operations: [] };
+    }
+    const attemptId = action.attemptId ?? state.activeAttemptId ?? state.lastAttemptId ?? `tool-attempt:${action.toolCall.id}`;
+    const ensured = ensureAttempt(
+      state,
+      attemptId,
+      action.sender,
+      action.at,
+      options
+    );
+    const next = copyState(ensured.state);
+    next.toolMessageByCallId.set(action.toolCall.id, ensured.cursor.messageId);
+    const pendingResult = next.pendingToolResultsByCallId.get(action.toolCall.id);
+    if (pendingResult) {
+      next.pendingToolResultsByCallId.delete(action.toolCall.id);
+    }
+    return {
+      state: next,
+      operations: [
+        ...ensured.operations,
+        {
+          type: "append-tool",
+          messageId: ensured.cursor.messageId,
+          toolCall: action.toolCall,
+          sender: action.sender ?? ensured.cursor.sender,
+          at: action.at
+        },
+        ...pendingResult ? [{
+          type: "resolve-tool",
+          messageId: ensured.cursor.messageId,
+          update: pendingResult
+        }] : []
+      ]
+    };
+  }
+  const messageId = action.update.id ? state.toolMessageByCallId.get(action.update.id) : void 0;
+  if (!messageId || !action.update.id) {
+    if (!action.update.id) return { state, operations: [] };
+    const next = copyState(state);
+    next.pendingToolResultsByCallId.set(action.update.id, action.update);
+    return { state: next, operations: [] };
+  }
+  return {
+    state,
+    operations: [{ type: "resolve-tool", messageId, update: action.update }]
+  };
+};
+var applyOperation = (messages, operation) => {
+  const index = messages.findIndex((message) => message.id === operation.messageId);
+  if (operation.type === "ensure-attempt") {
+    if (index >= 0) {
+      const current2 = messages[index];
+      const nextMessage = {
+        ...current2,
+        metadata: {
+          ...current2.metadata ?? {},
+          [LLM_ATTEMPT_ID_METADATA_KEY]: operation.attemptId
+        },
+        ...operation.sender ? { sender: operation.sender } : {}
+      };
+      if (current2.metadata?.[LLM_ATTEMPT_ID_METADATA_KEY] === operation.attemptId && (!operation.sender || current2.sender === operation.sender)) return messages;
+      const next2 = [...messages];
+      next2[index] = nextMessage;
+      return next2;
+    }
+    return [
+      ...messages,
+      {
+        id: operation.messageId,
+        role: "assistant",
+        content: "",
+        timestamp: operation.at,
+        isStreaming: true,
+        isComplete: false,
+        metadata: { [LLM_ATTEMPT_ID_METADATA_KEY]: operation.attemptId },
+        activity: {
+          items: [{
+            id: `${operation.messageId}:pending`,
+            kind: "answering",
+            status: "active",
+            startedAt: operation.at
+          }]
+        },
+        ...operation.sender ? { sender: operation.sender } : {}
+      }
+    ];
+  }
+  if (index < 0) return messages;
+  const current = messages[index];
+  let updated;
+  if (operation.type === "update-token") {
+    updated = {
+      ...updateAssistantMessageToken(current, {
+        partial: operation.partial,
+        isReasoning: operation.isReasoning,
+        activityId: operation.phaseId,
+        at: operation.at
+      }),
+      ...operation.sender ? { sender: operation.sender } : {}
+    };
+  } else if (operation.type === "finalize-attempt") {
+    updated = finalizeAssistantMessage(current, operation.answer, operation.at);
+  } else if (operation.type === "append-tool") {
+    updated = {
+      ...appendAssistantToolCall(current, {
+        ...operation.toolCall,
+        startTime: operation.toolCall.startTime ?? operation.at
+      }),
+      ...operation.sender ? { sender: operation.sender } : {}
+    };
+  } else {
+    const toolItem = current.activity?.items.find((item) => item.kind === "tool" && item.id === operation.update.id);
+    if (!toolItem) return messages;
+    updated = applyAssistantToolResult(current, {
+      ...operation.update.id ? { id: operation.update.id } : {},
+      ...operation.update.toolExecutionId ? { toolExecutionId: operation.update.toolExecutionId } : {},
+      name: operation.update.name ?? toolItem.toolName ?? toolItem.id,
+      status: operation.update.status,
+      ...operation.update.result !== void 0 ? { result: operation.update.result } : {},
+      ...operation.update.error !== void 0 ? { error: operation.update.error } : {},
+      endTime: operation.update.endTime
+    });
+    const hasActiveTool = updated.activity?.items.some((item) => item.kind === "tool" && item.status === "active") ?? false;
+    updated = {
+      ...updated,
+      isStreaming: hasActiveTool,
+      isComplete: !hasActiveTool
+    };
+  }
+  if (updated === current) return messages;
+  const next = [...messages];
+  next[index] = updated;
+  return next;
+};
+var applyLiveRunOperations = (messages, operations) => operations.reduce(applyOperation, messages);
+var getLatestLiveRunMessageId = (state) => {
+  const attemptId = state.activeAttemptId ?? state.lastAttemptId;
+  return attemptId ? state.attemptsById.get(attemptId)?.messageId ?? state.initialMessageId : state.initialMessageId;
+};
+
 // src/useCopilotzChat.ts
 var nowTs = () => Date.now();
 var generateId = () => globalThis.crypto?.randomUUID?.() ?? `id-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
 var isAbortError = (error) => error instanceof DOMException && error.name === "AbortError" || typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
 var getEventPayload = (event) => getStreamEventPayload(event);
 var getEventSenderType = (payload) => payload?.senderType || payload?.sender?.type;
+var getEventTimestamp = (event) => {
+  const timestamp = typeof event?.createdAt === "string" ? new Date(event.createdAt).getTime() : NaN;
+  return Number.isFinite(timestamp) ? timestamp : nowTs();
+};
 var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var normalizeThreadTag = (value) => {
   if (!isRecord3(value)) return null;
@@ -1695,66 +2078,11 @@ var createEmptyMessagePageInfo = () => ({
   oldestMessageId: null,
   newestMessageId: null
 });
-var stringifyForCompare = (value) => {
-  if (value === void 0) return "";
-  try {
-    return JSON.stringify(value) ?? "";
-  } catch {
-    return String(value);
-  }
-};
-var getMessageSignature = (message) => JSON.stringify({
-  id: message.id,
-  role: message.role,
-  content: message.content ?? "",
-  isStreaming: message.isStreaming === true,
-  isComplete: message.isComplete === true,
-  attachments: stringifyForCompare(message.attachments),
-  activity: stringifyForCompare(message.activity),
-  metadata: stringifyForCompare(message.metadata),
-  sender: message.sender ? {
-    id: message.sender.id,
-    type: message.sender.type,
-    name: message.sender.name,
-    agentId: message.sender.agentId
-  } : null
-});
-var reconcileThreadMessages = (currentMessages, freshMessages) => {
-  if (freshMessages.length === 0) {
-    return { messages: currentMessages, changed: false };
-  }
-  if (currentMessages.length === 0) {
-    return { messages: freshMessages, changed: true };
-  }
-  const freshById = new Map(freshMessages.map((message) => [message.id, message]));
-  const seen = /* @__PURE__ */ new Set();
-  let changed = false;
-  const nextMessages = currentMessages.map((message) => {
-    const fresh = freshById.get(message.id);
-    if (!fresh) return message;
-    seen.add(message.id);
-    if (getMessageSignature(message) === getMessageSignature(fresh)) {
-      return message;
-    }
-    changed = true;
-    return fresh;
-  });
-  const appended = freshMessages.filter((message) => !seen.has(message.id));
-  if (appended.length > 0) {
-    changed = true;
-    nextMessages.push(...appended);
-    nextMessages.sort((a, b) => {
-      const timestampDelta = (a.timestamp ?? 0) - (b.timestamp ?? 0);
-      return timestampDelta !== 0 ? timestampDelta : a.id.localeCompare(b.id);
-    });
-  }
-  return changed ? { messages: nextMessages, changed } : { messages: currentMessages, changed: false };
-};
-var createPendingAssistantActivity = () => ({
+var createPendingAssistantActivity = (messageId) => ({
   items: [
     {
-      id: "thinking",
-      kind: "thinking",
+      id: `${messageId}:pending`,
+      kind: "answering",
       status: "active",
       startedAt: nowTs()
     }
@@ -1797,7 +2125,6 @@ function useCopilotz({ userId, userName, userAvatar, assistantName, agentOptions
     assistantName
   });
   const persistedToolUpdatesRef = useRef2([]);
-  const liveToolUpdatesRef = useRef2([]);
   const stopRequestedRef = useRef2(false);
   const recoveryPollGenerationRef = useRef2(0);
   threadsRef.current = threads;
@@ -1993,7 +2320,6 @@ function useCopilotz({ userId, userName, userAvatar, assistantName, agentOptions
       setIsLoadingOlderMessages(false);
       setMessagePageInfo(createEmptyMessagePageInfo());
       persistedToolUpdatesRef.current = [];
-      liveToolUpdatesRef.current = [];
       try {
         const page = await fetchThreadMessagesPage(threadId, { limit: THREAD_MESSAGES_PAGE_SIZE }, getRequestHeaders);
         const { viewMessages, toolResultUpdates } = await prepareThreadMessages(page.data);
@@ -2353,154 +2679,26 @@ function useCopilotz({ userId, userName, userAvatar, assistantName, agentOptions
   }, []);
   const sendCopilotzMessage = useCallback2(
     async (params) => {
-      let currentAssistantId = params.assistantMessageId ?? generateId();
-      let currentAssistantSender = params.assistantSender;
+      const initialAssistantMessageId = params.assistantMessageId ?? generateId();
+      let liveRunState = createLiveRunState(initialAssistantMessageId);
       const streamOwnerThreadId = currentThreadIdRef.current;
       const streamOwnerThreadExternalId = params.threadExternalId ?? currentThreadExternalIdRef.current;
       const streamStillOwnsVisibleThread = () => isSameThreadIdentity(
         { id: streamOwnerThreadId, externalId: streamOwnerThreadExternalId },
         { id: currentThreadIdRef.current, externalId: currentThreadExternalIdRef.current }
       );
-      params.onBeforeStart?.(currentAssistantId);
+      params.onBeforeStart?.(initialAssistantMessageId);
       let hasStreamProgress = false;
-      const updateStreamingMessage = (partial, opts) => {
-        if (!streamStillOwnsVisibleThread()) return;
-        if (partial && partial.length > 0) {
-          hasStreamProgress = true;
-          setIsRecoveringStream(false);
-        }
-        const isReasoning = opts?.isReasoning ?? false;
-        const nextSender = opts?.agent ? resolveAgentSender(opts.agent, senderOptionsRef.current) : currentAssistantSender;
-        if (nextSender) {
-          currentAssistantSender = nextSender;
-        }
-        const nextAgentKey = currentAssistantSender?.agentId ?? currentAssistantSender?.id ?? null;
-        const applyUpdate = (msg) => {
-          return {
-            ...updateAssistantMessageToken(msg, {
-              partial,
-              isReasoning
-            }),
-            ...currentAssistantSender ? { sender: currentAssistantSender } : {}
-          };
-        };
-        setMessages((prev) => {
-          const idx = prev.findIndex((m) => m.id === currentAssistantId);
-          if (idx >= 0 && canAttachToCurrentStreamingAssistant(prev[idx])) {
-            const msg = prev[idx];
-            const next = applyUpdate(msg);
-            if (msg.content === next.content && msg.activity === next.activity && msg.isStreaming === next.isStreaming && msg.isComplete === next.isComplete) {
-              return prev;
-            }
-            const updated = [...prev];
-            updated[idx] = next;
-            return updated;
-          }
-          const last = prev[prev.length - 1];
-          if (canAttachToStreamingAssistant(last, nextAgentKey)) {
-            currentAssistantId = last.id;
-            const next = applyUpdate(last);
-            if (last.content === next.content && last.activity === next.activity && last.isStreaming === next.isStreaming && last.isComplete === next.isComplete) {
-              return prev;
-            }
-            const updated = [...prev];
-            updated[prev.length - 1] = next;
-            return updated;
-          }
-          const lastStreamingBelongsToDifferentAgent = Boolean(nextAgentKey) && last?.role === "assistant" && last.isStreaming && Boolean(messageAgentKey(last)) && messageAgentKey(last) !== nextAgentKey;
-          if (!prev.length || prev[prev.length - 1].role !== "assistant" || !prev[prev.length - 1].isStreaming || lastStreamingBelongsToDifferentAgent) {
-            const newId = generateId();
-            currentAssistantId = newId;
-            const base = {
-              id: newId,
-              role: "assistant",
-              content: "",
-              timestamp: nowTs(),
-              isStreaming: true,
-              isComplete: false,
-              ...currentAssistantSender ? { sender: currentAssistantSender } : {}
-            };
-            return [...prev, applyUpdate(base)];
-          }
-          return prev;
-        });
-      };
-      const finalizeCurrentAssistantBubble = () => {
-        if (!streamStillOwnsVisibleThread()) return;
-        setMessages((prev) => {
-          const idx = prev.findIndex((m) => m.id === currentAssistantId);
-          if (idx < 0) return prev;
-          const msg = prev[idx];
-          if (!msg.isStreaming && msg.isComplete) return prev;
-          const updated = [...prev];
-          updated[idx] = closeAssistantMessage(msg);
-          return updated;
-        });
-      };
-      const curThreadId = currentThreadIdRef.current;
-      const applyLiveToolResultUpdate = (update) => {
+      const dispatchLiveRunAction = (action) => {
         if (!streamStillOwnsVisibleThread()) return;
-        let matched = false;
-        setMessages((prev) => {
-          const next = applyToolResultUpdateToMessages(prev, update, {
-            isStreaming: true,
-            isComplete: false
-          });
-          matched = next.matched;
-          return next.matched ? next.messages : prev;
+        const transition = transitionLiveRun(liveRunState, action, {
+          createId: generateId
         });
-        if (!matched) {
-          liveToolUpdatesRef.current.push(update);
+        liveRunState = transition.state;
+        if (transition.operations.length > 0) {
+          setMessages((prev) => applyLiveRunOperations(prev, transition.operations));
         }
       };
-      const finalizeActiveAssistantTurn = (finalAnswer) => {
-        if (!streamStillOwnsVisibleThread()) return;
-        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 = finalizeAssistantMessage(message, finalAnswer);
-          if (message.content === nextMessage.content && message.isStreaming === nextMessage.isStreaming && message.isComplete === nextMessage.isComplete && message.activity === nextMessage.activity) {
-            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 parsedToolCall = extractLiveToolCall(payload);
-          return {
-            id: generateId(),
-            threadId: curThreadId ?? "",
-            senderType: "tool",
-            content: "",
-            toolCalls: [
-              {
-                id: parsedToolCall.id ?? generateId(),
-                name: parsedToolCall.name,
-                args: parsedToolCall.arguments,
-                ...parsedToolCall.result !== void 0 ? { output: parsedToolCall.result } : {},
-                status: parsedToolCall.status
-              }
-            ]
-          };
-        }
-        return null;
-      };
       const abortController = new AbortController();
       if (!params.preserveActiveRun) {
         abortControllerRef.current?.abort();
@@ -2511,7 +2709,6 @@ function useCopilotz({ userId, userName, userAvatar, assistantName, agentOptions
       stopRequestedRef.current = false;
       setThreadActivityStatus("running");
       setIsStreaming(true);
-      liveToolUpdatesRef.current = [];
       let streamError = null;
       const resolveActivityThreadId = async () => {
         if (params.threadId) return params.threadId;
@@ -2558,10 +2755,26 @@ function useCopilotz({ userId, userName, userAvatar, assistantName, agentOptions
           participants: participantsRef.current,
           targetAgent: targetAgentNameRef.current,
           getRequestHeaders,
-          onToken: (token, _isComplete, raw, opts) => updateStreamingMessage(token, {
-            ...opts,
-            agent: raw?.payload?.agent ?? raw?.agent ?? null
-          }),
+          onToken: (token, _isComplete, raw, opts) => {
+            const rawAgent = raw?.payload?.agent ?? raw?.agent ?? null;
+            const sender = rawAgent ? resolveAgentSender(rawAgent, senderOptionsRef.current) : params.assistantSender;
+            const attemptId = opts?.llmAttemptId ?? liveRunState.activeAttemptId ?? liveRunState.lastAttemptId ?? `stream-attempt:${initialAssistantMessageId}`;
+            const isReasoning = opts?.isReasoning ?? false;
+            const phaseId = opts?.phaseId ?? `${attemptId}:${isReasoning ? "reasoning" : "answer"}:0`;
+            if (token.length > 0) {
+              hasStreamProgress = true;
+              setIsRecoveringStream(false);
+            }
+            dispatchLiveRunAction({
+              type: "token",
+              attemptId,
+              phaseId,
+              partial: token,
+              isReasoning,
+              sender,
+              at: getEventTimestamp(raw)
+            });
+          },
           onMessageEvent: async (event) => {
             if (!streamStillOwnsVisibleThread()) return;
             const intercepted = applyEventInterceptor(event);
@@ -2570,14 +2783,37 @@ function useCopilotz({ userId, userName, userAvatar, assistantName, agentOptions
             }
             const type = event?.type || "";
             const payload = getEventPayload(event);
+            if (type === "LLM_CALL") {
+              const attemptId = getLlmAttemptId(event);
+              if (attemptId) {
+                dispatchLiveRunAction({
+                  type: "attempt-start",
+                  attemptId,
+                  sender: resolveLiveEventSender(event, senderOptionsRef.current),
+                  at: getEventTimestamp(event)
+                });
+              }
+              return;
+            }
             if (type === "TOOL_RESULT") {
               processToolOutput(payload ?? {});
-              applyLiveToolResultUpdate(extractLiveToolResultUpdate(payload ?? {}));
+              dispatchLiveRunAction({
+                type: "tool-result",
+                update: extractLiveToolResultUpdate(payload ?? {})
+              });
               return;
             }
             if (type === "LLM_RESULT") {
               const finalAnswer = typeof payload?.answer === "string" ? payload.answer : void 0;
-              finalizeActiveAssistantTurn(finalAnswer);
+              const attemptId = getLlmAttemptId(event) ?? liveRunState.activeAttemptId ?? liveRunState.lastAttemptId;
+              if (attemptId) {
+                dispatchLiveRunAction({
+                  type: "attempt-result",
+                  attemptId,
+                  answer: finalAnswer,
+                  at: getEventTimestamp(event)
+                });
+              }
               if (isTerminalEmptyLlmResultEvent(event)) {
                 finalizeStreamingPlaceholders();
               }
@@ -2589,87 +2825,22 @@ function useCopilotz({ userId, userName, userAvatar, assistantName, agentOptions
             if (type === "TOOL_CALL") {
               const parsedToolCall = extractLiveToolCall(payload ?? {});
               const eventSender = resolveLiveEventSender(event, senderOptionsRef.current);
-              currentAssistantSender = eventSender;
-              const eventAgentKey = currentAssistantSender.agentId ?? currentAssistantSender.id;
               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 canHostActivity = (message) => {
-                    if (!message) return false;
-                    return message.role === "assistant" && message.isStreaming && message.content.trim().length === 0 && !message.attachments?.length;
-                  };
-                  const appendToolCall = (msg) => ({
-                    ...appendAssistantToolCall(msg, {
-                      id: callId,
-                      name: toolName,
-                      arguments: parsedToolCall.arguments,
-                      ...initialResult !== void 0 ? { result: initialResult } : {},
-                      status: initialStatus,
-                      startTime: Date.now(),
-                      ...endTime !== void 0 ? { endTime } : {}
-                    })
-                  });
-                  const currentIdx = prev.findIndex((message) => message.id === currentAssistantId && message.role === "assistant" && message.isStreaming && canHostActivity(message));
-                  if (currentIdx >= 0) {
-                    const next = [...prev];
-                    next[currentIdx] = appendToolCall({
-                      ...next[currentIdx],
-                      isStreaming: true,
-                      isComplete: false,
-                      ...currentAssistantSender ? { sender: currentAssistantSender } : {}
-                    });
-                    return next;
-                  }
-                  const last = prev[prev.length - 1];
-                  if (canHostActivity(last) && canAttachToStreamingAssistant(last, eventAgentKey)) {
-                    currentAssistantId = last.id;
-                    const next = [...prev];
-                    next[prev.length - 1] = appendToolCall({
-                      ...last,
-                      isStreaming: true,
-                      isComplete: false,
-                      ...currentAssistantSender ? { sender: currentAssistantSender } : {}
-                    });
-                    return next;
-                  }
-                  const newId = generateId();
-                  currentAssistantId = newId;
-                  return [
-                    ...prev,
-                    appendToolCall({
-                      id: newId,
-                      role: "assistant",
-                      content: "",
-                      timestamp: nowTs(),
-                      isStreaming: true,
-                      isComplete: false,
-                      ...currentAssistantSender ? { sender: currentAssistantSender } : {}
-                    })
-                  ];
-                })()
-              );
-              hasStreamProgress = true;
-              return;
-            }
-            const sm = await toServerMessageFromEvent(event);
-            if (sm) {
-              const viewMsg = convertServerMessage(sm, {
-                senderOptions: senderOptionsRef.current,
-                createId: generateId,
-                now: nowTs
+              dispatchLiveRunAction({
+                type: "tool-call",
+                attemptId: getLlmAttemptId(event) ?? liveRunState.activeAttemptId ?? liveRunState.lastAttemptId,
+                sender: eventSender,
+                at: getEventTimestamp(event),
+                toolCall: {
+                  id: callId,
+                  name: parsedToolCall.name,
+                  arguments: parsedToolCall.arguments,
+                  status: parsedToolCall.status,
+                  ...parsedToolCall.toolExecutionId ? { toolExecutionId: parsedToolCall.toolExecutionId } : {},
+                  ...parsedToolCall.result !== void 0 ? { result: parsedToolCall.result } : {}
+                }
               });
-              finalizeCurrentAssistantBubble();
-              setMessages((prev) => [...prev, viewMsg]);
+              hasStreamProgress = true;
               return;
             }
             handleStreamMessageEvent(event);
@@ -2683,10 +2854,8 @@ function useCopilotz({ userId, userName, userAvatar, assistantName, agentOptions
             if (intercepted?.handled) {
               return;
             }
-            await (async () => {
-              if (!hasStreamProgress) return;
-              handleStreamAssetEvent(payload, currentAssistantId);
-            })();
+            if (!hasStreamProgress) return;
+            handleStreamAssetEvent(payload, getLatestLiveRunMessageId(liveRunState));
           },
           signal: abortController.signal
         });
@@ -2719,16 +2888,16 @@ function useCopilotz({ userId, userName, userAvatar, assistantName, agentOptions
         abortControllerRef.current = null;
       }
       if (!streamStillOwnsVisibleThread()) {
-        return currentAssistantId;
+        return getLatestLiveRunMessageId(liveRunState);
       }
       if (recoveryStarted) {
-        return currentAssistantId;
+        return getLatestLiveRunMessageId(liveRunState);
       }
       finalizeStreamingPlaceholders();
       if (streamError) {
         throw streamError;
       }
-      return currentAssistantId;
+      return getLatestLiveRunMessageId(liveRunState);
     },
     [applyEventInterceptor, handleStreamMessageEvent, handleStreamAssetEvent, fetchAndSetThreadsState, finalizeStreamingPlaceholders, getRequestHeaders, refreshThreadMessages, startThreadActivityRecovery]
   );
@@ -2762,13 +2931,17 @@ function useCopilotz({ userId, userName, userAvatar, assistantName, agentOptions
       );
       const currentMetadata = threadMetadataMapRef.current[conversationKey];
       const pendingTitle = currentMetadata?.pendingTitle;
+      const userMessageId = generateId();
       const userMessage = {
-        id: generateId(),
+        id: userMessageId,
         role: "user",
         content,
         timestamp,
         attachments: attachments.length > 0 ? attachments : void 0,
         isComplete: true,
+        metadata: {
+          [CLIENT_MESSAGE_ID_METADATA_KEY]: userMessageId
+        },
         sender: resolveUserSender({
           id: userId,
           name: getCurrentUserDisplayName(userName, userId)
@@ -2781,15 +2954,16 @@ function useCopilotz({ userId, userName, userAvatar, assistantName, agentOptions
         },
         senderOptionsRef.current
       ) : preferredAgentRef.current ? resolveAgentSender({ id: preferredAgentRef.current, name: preferredAgentRef.current }, senderOptionsRef.current) : resolveAssistantFallbackSender(senderOptionsRef.current);
+      const assistantMessageId = generateId();
       const assistantPlaceholder = {
-        id: generateId(),
+        id: assistantMessageId,
         role: "assistant",
         content: "",
         timestamp: timestamp + 1,
         isStreaming: true,
         isComplete: false,
         sender: assistantSender,
-        activity: createPendingAssistantActivity()
+        activity: createPendingAssistantActivity(assistantMessageId)
       };
       setMessages((prev) => [...prev, userMessage, assistantPlaceholder]);
       setSpecialState(null);
@@ -2817,6 +2991,7 @@ function useCopilotz({ userId, userName, userAvatar, assistantName, agentOptions
           userId,
           userName: getCurrentUserDisplayName(userName, userId),
           agentName: preferredAgentRef.current,
+          metadata: userMessage.metadata,
           assistantMessageId: assistantPlaceholder.id,
           assistantSender,
           preserveActiveRun,
@@ -2896,7 +3071,7 @@ function useCopilotz({ userId, userName, userAvatar, assistantName, agentOptions
           isStreaming: true,
           isComplete: false,
           sender: assistantSender,
-          activity: createPendingAssistantActivity()
+          activity: createPendingAssistantActivity(assistantMessageId)
         }
       ]);
       setMessagePageInfo(createEmptyMessagePageInfo());