@futurity/chat-react 0.0.2 → 0.1.0

package/dist/index.js

@@ -13,6 +13,325 @@ function parseServerMessage(data) {
   return result.data;
 }
 
+// src/stream-accumulator.ts
+import {
+  Z_DataEndSplitSchema,
+  Z_DataSplitSchema,
+  Z_DataSubagentPartSchema
+} from "@futurity/chat-protocol";
+function isTypedChunk(x) {
+  return typeof x === "object" && x !== null && "type" in x && typeof x.type === "string";
+}
+var StreamAccumulator = class {
+  parts = [];
+  textById = /* @__PURE__ */ new Map();
+  reasoningById = /* @__PURE__ */ new Map();
+  toolById = /* @__PURE__ */ new Map();
+  partialToolText = /* @__PURE__ */ new Map();
+  processedCount = 0;
+  push(part) {
+    this.parts.push(part);
+  }
+  /** Process any new raw chunks and return the full accumulated parts array. */
+  accumulate(rawParts) {
+    for (let i = this.processedCount; i < rawParts.length; i++) {
+      const chunk = rawParts[i];
+      if (!isTypedChunk(chunk)) {
+        this.parts.push(chunk);
+        continue;
+      }
+      switch (chunk.type) {
+        // --- Text accumulation ---
+        case "text-start": {
+          const part = { type: "text", text: "", state: "streaming" };
+          this.textById.set(chunk.id, part);
+          this.push(part);
+          break;
+        }
+        case "text-delta": {
+          const part = this.textById.get(chunk.id);
+          if (part) part.text += chunk.delta;
+          break;
+        }
+        case "text-end": {
+          const part = this.textById.get(chunk.id);
+          if (part) part.state = "done";
+          break;
+        }
+        // --- Reasoning accumulation ---
+        case "reasoning-start": {
+          const part = { type: "reasoning", text: "", state: "streaming" };
+          this.reasoningById.set(chunk.id, part);
+          this.push(part);
+          break;
+        }
+        case "reasoning-delta": {
+          const part = this.reasoningById.get(chunk.id);
+          if (part) part.text += chunk.delta;
+          break;
+        }
+        case "reasoning-end": {
+          const part = this.reasoningById.get(chunk.id);
+          if (part) part.state = "done";
+          break;
+        }
+        // --- Tool invocation accumulation ---
+        case "tool-input-start": {
+          const typeName = chunk.dynamic ? "dynamic-tool" : `tool-${chunk.toolName}`;
+          const part = {
+            type: typeName,
+            toolCallId: chunk.toolCallId,
+            toolName: chunk.toolName,
+            state: "input-streaming",
+            input: void 0,
+            providerExecuted: chunk.providerExecuted,
+            title: chunk.title
+          };
+          this.toolById.set(chunk.toolCallId, part);
+          this.partialToolText.set(chunk.toolCallId, "");
+          this.push(part);
+          break;
+        }
+        case "tool-input-delta": {
+          const text = (this.partialToolText.get(chunk.toolCallId) ?? "") + (chunk.inputTextDelta ?? "");
+          this.partialToolText.set(chunk.toolCallId, text);
+          const part = this.toolById.get(chunk.toolCallId);
+          if (part) {
+            try {
+              part.input = JSON.parse(text);
+            } catch {
+            }
+          }
+          break;
+        }
+        case "tool-input-available": {
+          const typeName = chunk.dynamic ? "dynamic-tool" : `tool-${chunk.toolName}`;
+          let part = this.toolById.get(chunk.toolCallId);
+          if (part) {
+            part.state = "input-available";
+            part.input = chunk.input;
+            part.providerExecuted = chunk.providerExecuted;
+          } else {
+            part = {
+              type: typeName,
+              toolCallId: chunk.toolCallId,
+              toolName: chunk.toolName,
+              state: "input-available",
+              input: chunk.input,
+              providerExecuted: chunk.providerExecuted,
+              title: chunk.title
+            };
+            this.toolById.set(chunk.toolCallId, part);
+            this.push(part);
+          }
+          break;
+        }
+        case "tool-input-error": {
+          const part = this.toolById.get(chunk.toolCallId);
+          if (part) {
+            part.state = "output-error";
+            part.errorText = chunk.errorText;
+            part.input = chunk.input;
+          }
+          break;
+        }
+        case "tool-output-available": {
+          const part = this.toolById.get(chunk.toolCallId);
+          if (part) {
+            part.state = "output-available";
+            part.output = chunk.output;
+            part.preliminary = chunk.preliminary;
+          }
+          break;
+        }
+        case "tool-output-error": {
+          const part = this.toolById.get(chunk.toolCallId);
+          if (part) {
+            part.state = "output-error";
+            part.errorText = chunk.errorText;
+          }
+          break;
+        }
+        // --- Pass-through parts ---
+        case "file":
+          this.push({
+            type: "file",
+            mediaType: chunk.mediaType,
+            url: chunk.url,
+            filename: chunk.filename
+          });
+          break;
+        case "source-url":
+          this.push({
+            type: "source-url",
+            sourceId: chunk.sourceId,
+            url: chunk.url,
+            title: chunk.title
+          });
+          break;
+        case "source-document":
+          this.push({
+            type: "source-document",
+            sourceId: chunk.sourceId,
+            mediaType: chunk.mediaType,
+            title: chunk.title,
+            filename: chunk.filename
+          });
+          break;
+        case "start-step":
+          this.push({ type: "step-start" });
+          break;
+        // --- Ignored protocol chunks ---
+        case "finish-step":
+        case "start":
+        case "finish":
+        case "error":
+          break;
+        // --- Unknown / custom data parts → pass through ---
+        default:
+          if (chunk.type.startsWith("data-")) {
+            this.push(chunk);
+          }
+          break;
+      }
+    }
+    this.processedCount = rawParts.length;
+    return this.parts;
+  }
+};
+function createPreprocessorState(messageId) {
+  return {
+    messageId: messageId ?? null,
+    scannedLength: 0,
+    claimedIndices: /* @__PURE__ */ new Set(),
+    openGroups: /* @__PURE__ */ new Map(),
+    groupsByStartIndex: /* @__PURE__ */ new Map(),
+    groupBySubAgentId: /* @__PURE__ */ new Map(),
+    accumulators: /* @__PURE__ */ new Map()
+  };
+}
+function incrementalPreprocess(state, parts) {
+  for (let i2 = state.scannedLength; i2 < parts.length; i2++) {
+    const part = parts[i2];
+    if (!isTypedChunk(part)) continue;
+    if (part.type === "data-split") {
+      const splitParse = Z_DataSplitSchema.safeParse(part);
+      if (splitParse.success && splitParse.data.data.subAgentId) {
+        const sid = splitParse.data.data.subAgentId;
+        const group = {
+          startIndex: i2,
+          title: splitParse.data.data.title,
+          subtitle: splitParse.data.data.subtitle,
+          desktopSessionId: splitParse.data.data.desktopSessionId,
+          subAgentId: sid,
+          innerParts: [],
+          endIndex: null
+        };
+        state.openGroups.set(sid, group);
+        state.groupsByStartIndex.set(i2, group);
+        state.groupBySubAgentId.set(sid, group);
+        state.claimedIndices.add(i2);
+        continue;
+      }
+    }
+    if (part.type === "data-endsplit") {
+      const endSplitParse = Z_DataEndSplitSchema.safeParse(part);
+      if (endSplitParse.success && endSplitParse.data?.data?.subAgentId) {
+        const sid = endSplitParse.data.data.subAgentId;
+        const group = state.openGroups.get(sid);
+        if (group) {
+          group.endIndex = i2;
+          group.desktopSessionId = group.desktopSessionId ?? endSplitParse.data.data.desktopSessionId;
+          state.openGroups.delete(sid);
+        }
+        state.claimedIndices.add(i2);
+        continue;
+      }
+    }
+    if (part.type === "data-subagent-part") {
+      const subagentParse = Z_DataSubagentPartSchema.safeParse(part);
+      if (subagentParse.success) {
+        const sid = subagentParse.data.data.subAgentId;
+        const group = state.openGroups.get(sid) ?? state.groupBySubAgentId.get(sid);
+        if (group) {
+          group.innerParts.push(subagentParse.data.data.part);
+        }
+        state.claimedIndices.add(i2);
+      }
+    }
+  }
+  state.scannedLength = parts.length;
+  const processed = [];
+  let i = 0;
+  while (i < parts.length) {
+    const groupAtIndex = state.groupsByStartIndex.get(i);
+    if (groupAtIndex) {
+      let acc = state.accumulators.get(groupAtIndex.startIndex);
+      if (!acc) {
+        acc = new StreamAccumulator();
+        state.accumulators.set(groupAtIndex.startIndex, acc);
+      }
+      processed.push({
+        type: "split-group",
+        title: groupAtIndex.title,
+        subtitle: groupAtIndex.subtitle,
+        // Incrementally accumulate — only processes newly added innerParts
+        parts: acc.accumulate(groupAtIndex.innerParts),
+        startIndex: groupAtIndex.startIndex,
+        endIndex: groupAtIndex.endIndex ?? parts.length,
+        desktopSessionId: groupAtIndex.desktopSessionId
+      });
+      i++;
+      continue;
+    }
+    if (state.claimedIndices.has(i)) {
+      i++;
+      continue;
+    }
+    const part = parts[i];
+    const type = isTypedChunk(part) ? part.type : void 0;
+    if (type === "data-split") {
+      const splitParse = Z_DataSplitSchema.safeParse(part);
+      if (splitParse.success && !splitParse.data.data.subAgentId) {
+        let endIndex = parts.length;
+        let desktopSessionId = splitParse.data.data.desktopSessionId;
+        for (let searchIndex = i + 1; searchIndex < parts.length; searchIndex++) {
+          if (state.claimedIndices.has(searchIndex)) continue;
+          const checkPart = parts[searchIndex];
+          const endParse = Z_DataEndSplitSchema.safeParse(checkPart);
+          if (endParse.success && !endParse.data?.data?.subAgentId) {
+            endIndex = searchIndex;
+            desktopSessionId = desktopSessionId ?? endParse.data?.data?.desktopSessionId;
+            break;
+          }
+        }
+        const groupedParts = parts.slice(i + 1, endIndex).filter((_, idx) => {
+          const absIdx = i + 1 + idx;
+          return !state.claimedIndices.has(absIdx);
+        });
+        processed.push({
+          type: "split-group",
+          title: splitParse.data.data.title,
+          subtitle: splitParse.data.data.subtitle,
+          parts: groupedParts,
+          startIndex: i,
+          endIndex,
+          desktopSessionId
+        });
+        i = endIndex < parts.length ? endIndex + 1 : endIndex;
+        continue;
+      }
+    }
+    if (type === "data-endsplit") {
+      i++;
+      continue;
+    }
+    processed.push({ type: "regular", part, originalIndex: i });
+    i++;
+  }
+  return processed;
+}
+
 // src/tree-builder.ts
 var MessageNode = class {
   id;
@@ -379,12 +698,35 @@ function useReconnectingWebSocket({
 
 // src/useStreamChat.ts
 import { useCallback as useCallback2, useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
-function transformChatHistory(rawMessages) {
+function simpleProcessedParts(parts) {
+  return parts.map((part, i) => ({
+    type: "regular",
+    part,
+    originalIndex: i
+  }));
+}
+function preprocessMessage(msg, statesMap) {
+  if (msg.role !== "assistant") {
+    return { ...msg, processedParts: simpleProcessedParts(msg.parts) };
+  }
+  let state = statesMap.get(msg.id);
+  if (!state || state.scannedLength > (msg.parts?.length ?? 0)) {
+    state = createPreprocessorState(msg.id);
+    statesMap.set(msg.id, state);
+  }
+  return {
+    ...msg,
+    processedParts: incrementalPreprocess(state, msg.parts ?? [])
+  };
+}
+function transformChatHistory(rawMessages, statesMap) {
   const parsedMessages = Z_ChatMessage.array().safeParse(rawMessages);
   if (!parsedMessages.success) {
     throw new Error("Invalid chat history");
   }
-  const messages = parsedMessages.data;
+  const messages = parsedMessages.data.map(
+    (msg) => preprocessMessage(msg, statesMap)
+  );
   const byId = /* @__PURE__ */ new Map();
   const tree = buildTree(messages, byId);
   const initialPath = findLatestPath(tree, byId);
@@ -399,8 +741,6 @@ function useStreamChat({
   chatId,
   wsUrl,
   onStart,
-  onDelta,
-  onResume,
   onFinish,
   onError,
   onHistory
@@ -416,9 +756,8 @@ function useStreamChat({
   const [job, setJob] = useState2("");
   const hasRequestedChat = useRef2(false);
   const [pendingClarify, setPendingClarify] = useState2(null);
+  const preprocessorStatesRef = useRef2(/* @__PURE__ */ new Map());
   const onStartRef = useRef2(onStart);
-  const onDeltaRef = useRef2(onDelta);
-  const onResumeRef = useRef2(onResume);
   const onFinishRef = useRef2(onFinish);
   const onErrorRef = useRef2(onError);
   const onHistoryRef = useRef2(onHistory);
@@ -426,8 +765,6 @@ function useStreamChat({
   });
   useEffect2(() => {
     onStartRef.current = onStart;
-    onDeltaRef.current = onDelta;
-    onResumeRef.current = onResume;
     onFinishRef.current = onFinish;
     onErrorRef.current = onError;
     onHistoryRef.current = onHistory;
@@ -459,14 +796,81 @@ function useStreamChat({
         }
         case "stream": {
           const messageId = message.messageId;
+          const delta = message.delta;
+          const consolidated = message.consolidated;
           setStatus("streaming");
-          onDeltaRef.current?.(messageId, message.delta, message.consolidated);
+          setMessages((prev) => {
+            const states = preprocessorStatesRef.current;
+            const exists = prev.some((m) => m.id === messageId);
+            let updated;
+            if (!exists) {
+              const newMsg = {
+                id: messageId,
+                role: "assistant",
+                parts: [delta],
+                processedParts: []
+              };
+              updated = [...prev, newMsg];
+            } else {
+              updated = prev.map((m) => {
+                if (m.id !== messageId) return m;
+                const parts = m.parts ?? [];
+                const nextParts = consolidated ? [...parts.slice(0, -1), delta] : [...parts, delta];
+                return { ...m, parts: nextParts };
+              });
+            }
+            return updated.map(
+              (m) => m.id === messageId ? preprocessMessage(m, states) : m
+            );
+          });
           break;
         }
         case "stream_resume": {
           const messageId = message.messageId;
           setStatus("streaming");
-          onResumeRef.current?.(messageId, message.parts);
+          setMessages((prev) => {
+            const states = preprocessorStatesRef.current;
+            states.delete(messageId);
+            return prev.map((m) => {
+              if (m.id !== messageId) return m;
+              const updated = { ...m, parts: message.parts };
+              return preprocessMessage(updated, states);
+            });
+          });
+          break;
+        }
+        case "inject_ack": {
+          const { new_assistant_id } = message.data;
+          setMessages((prev) => {
+            const exists = prev.some((m) => m.id === new_assistant_id);
+            if (exists) return prev;
+            return [
+              ...prev,
+              {
+                id: new_assistant_id,
+                role: "assistant",
+                parts: [],
+                processedParts: []
+              }
+            ];
+          });
+          break;
+        }
+        case "inject_split": {
+          const { new_message_id } = message.data;
+          setMessages((prev) => {
+            const exists = prev.some((m) => m.id === new_message_id);
+            if (exists) return prev;
+            return [
+              ...prev,
+              {
+                id: new_message_id,
+                role: "assistant",
+                parts: [],
+                processedParts: []
+              }
+            ];
+          });
           break;
         }
         case "done": {
@@ -481,7 +885,10 @@ function useStreamChat({
           break;
         }
         case "chat_history": {
-          const result = transformChatHistory(message.data.messages);
+          const result = transformChatHistory(
+            message.data.messages,
+            preprocessorStatesRef.current
+          );
           result.activeMessageId = message.data.activeMessageId;
           onHistoryRef.current?.(result);
           break;
@@ -535,6 +942,7 @@ function useStreamChat({
         id: crypto.randomUUID(),
         role: "user",
         parts: payload.parts,
+        processedParts: simpleProcessedParts(payload.parts),
         metadata: {
           parent_id
         }
@@ -570,12 +978,14 @@ function useStreamChat({
       const connected = await ensureConnected();
       if (!connected) return;
       const message_id = crypto.randomUUID();
+      const parts = [{ type: "text", text }];
       setMessages((prev) => [
         ...prev,
         {
           id: message_id,
           role: "user",
-          parts: [{ type: "text", text }]
+          parts,
+          processedParts: simpleProcessedParts(parts)
         }
       ]);
       send({
@@ -610,6 +1020,7 @@ function useStreamChat({
     setJob("");
     setPendingClarify(null);
     hasRequestedChat.current = false;
+    preprocessorStatesRef.current.clear();
   }, []);
   return {
     messages,
@@ -626,10 +1037,13 @@ function useStreamChat({
 }
 export {
   MessageNode,
+  StreamAccumulator,
   WebSocketConnection,
   Z_ChatMessage,
   buildTree,
+  createPreprocessorState,
   findLatestPath,
+  incrementalPreprocess,
   messageMetadataSchema,
   parseServerMessage,
   useReconnectingWebSocket,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@futurity/chat-react",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "type": "module",
   "license": "MIT",
   "sideEffects": false,
@@ -13,11 +13,15 @@
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": ["dist", "src", "README.md"],
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
   "scripts": {
     "build": "tsup",
     "check": "tsgo --noEmit",
-    "prepublishOnly": "tsup"
+    "prepublishOnly": "bunx tsup"
   },
   "dependencies": {
     "@futurity/chat-protocol": "0.1.0"

package/src/index.ts

@@ -4,6 +4,13 @@
 export type { ClientCommand } from "./chat-protocol";
 // Protocol helpers
 export { parseServerMessage } from "./chat-protocol";
+// Stream accumulator
+export type { PreprocessorState, ProcessedPart } from "./stream-accumulator";
+export {
+  createPreprocessorState,
+  incrementalPreprocess,
+  StreamAccumulator,
+} from "./stream-accumulator";
 // Tree utilities
 export { buildTree, findLatestPath, MessageNode } from "./tree-builder";
 // Types