@dudousxd/nestjs-agent-react 0.3.2 → 0.3.3

package/dist/index.cjs

@@ -147,18 +147,26 @@ var AgentChatTransport = class {
     this.options.onMeta?.(meta);
   }
   /**
-  * Parse the backend's SSE byte stream and synthesize a valid v7
-  * UI-message chunk stream. Recognized backend frames:
-  *  - `event: meta`  `data: {"runId","threadId"}`  → records identity
-  *  - `data: {"delta":"..."}`                       → `text-delta`
-  *  - `event: done`  `data: {}`                     → terminates
+  * Parse the backend's SSE byte stream and re-emit it as a valid v7 UI-message chunk stream.
+  * Recognized frames:
+  *  - `event: meta`  `data: {"runId","threadId"}`   → records identity
+  *  - `data: <AgentStreamEvent JSON>`                → mapped to UI chunks (text / reasoning / tool)
+  *  - `event: done`  `data: {}`                      → terminates
+  *  - `event: error` `data: {code,message}`          → error chunk
+  *
+  * A run is ONE UI message with N steps. Each `step-start`/`step-finish` pair brackets a model
+  * call plus its tool execution; text and reasoning open lazily and close at the step boundary, so
+  * tool-call cards (input streaming → output) render live between the prose.
   */
   toChunkStream(source) {
     const reader = source.getReader();
     const decoder = new TextDecoder();
-    const textId = `txt-${Math.random().toString(36).slice(2)}`;
     let buffer = "";
     let started = false;
+    let stepOpen = false;
+    let stepIndex = 0;
+    let textId = null;
+    let reasoningId = null;
     const record = /* @__PURE__ */ __name((meta) => this.recordMeta(meta), "record");
     return new ReadableStream({
       async pull(controller) {
@@ -168,24 +176,133 @@ var AgentChatTransport = class {
           controller.enqueue({
             type: "start"
           });
-          controller.enqueue({
-            type: "start-step"
-          });
-          controller.enqueue({
-            type: "text-start",
-            id: textId
-          });
         }
         __name(ensureStarted, "ensureStarted");
-        function finish() {
+        function openStep() {
           ensureStarted();
+          if (stepOpen) closeStep();
+          stepOpen = true;
+          stepIndex += 1;
+          textId = null;
+          reasoningId = null;
           controller.enqueue({
-            type: "text-end",
-            id: textId
+            type: "start-step"
           });
+        }
+        __name(openStep, "openStep");
+        function ensureStep() {
+          if (!stepOpen) openStep();
+        }
+        __name(ensureStep, "ensureStep");
+        function closeStep() {
+          if (!stepOpen) return;
+          if (textId !== null) {
+            controller.enqueue({
+              type: "text-end",
+              id: textId
+            });
+            textId = null;
+          }
+          if (reasoningId !== null) {
+            controller.enqueue({
+              type: "reasoning-end",
+              id: reasoningId
+            });
+            reasoningId = null;
+          }
           controller.enqueue({
             type: "finish-step"
           });
+          stepOpen = false;
+        }
+        __name(closeStep, "closeStep");
+        function emit(event) {
+          switch (event.kind) {
+            case "step-start":
+              openStep();
+              break;
+            case "step-finish":
+              closeStep();
+              break;
+            case "text":
+              ensureStep();
+              if (textId === null) {
+                textId = `txt-${stepIndex}`;
+                controller.enqueue({
+                  type: "text-start",
+                  id: textId
+                });
+              }
+              controller.enqueue({
+                type: "text-delta",
+                id: textId,
+                delta: event.text
+              });
+              break;
+            case "reasoning":
+              ensureStep();
+              if (reasoningId === null) {
+                reasoningId = `rsn-${stepIndex}`;
+                controller.enqueue({
+                  type: "reasoning-start",
+                  id: reasoningId
+                });
+              }
+              controller.enqueue({
+                type: "reasoning-delta",
+                id: reasoningId,
+                delta: event.text
+              });
+              break;
+            case "tool-input-start":
+              ensureStep();
+              controller.enqueue({
+                type: "tool-input-start",
+                toolCallId: event.id,
+                toolName: event.name
+              });
+              break;
+            case "tool-input-delta":
+              ensureStep();
+              controller.enqueue({
+                type: "tool-input-delta",
+                toolCallId: event.id,
+                inputTextDelta: event.delta
+              });
+              break;
+            case "tool-input-available":
+              ensureStep();
+              controller.enqueue({
+                type: "tool-input-available",
+                toolCallId: event.id,
+                toolName: event.name,
+                input: event.input
+              });
+              break;
+            case "tool-output":
+              ensureStep();
+              controller.enqueue({
+                type: "tool-output-available",
+                toolCallId: event.id,
+                output: event.output
+              });
+              break;
+            case "tool-output-error":
+              ensureStep();
+              controller.enqueue({
+                type: "tool-output-error",
+                toolCallId: event.id,
+                errorText: event.error
+              });
+              break;
+            default:
+              break;
+          }
+        }
+        __name(emit, "emit");
+        function finish() {
+          ensureStarted();
+          closeStep();
           controller.enqueue({
             type: "finish"
           });
@@ -224,15 +341,8 @@ var AgentChatTransport = class {
                 const meta = parseMeta(frame.data);
                 if (meta) record(meta);
               } else if (frame.data) {
-                const delta = parseDelta(frame.data);
-                if (delta) {
-                  ensureStarted();
-                  controller.enqueue({
-                    type: "text-delta",
-                    id: textId,
-                    delta
-                  });
-                }
+                const event = parseEvent(frame.data);
+                if (event) emit(event);
               }
               separator = buffer.indexOf("\n\n");
             }
@@ -294,17 +404,17 @@ function parseErrorText(data) {
   return "Agent run failed";
 }
 __name(parseErrorText, "parseErrorText");
-function parseDelta(data) {
+function parseEvent(data) {
   try {
     const parsed = JSON.parse(data);
-    if (parsed !== null && typeof parsed === "object" && "delta" in parsed && typeof parsed.delta === "string") {
-      return parsed.delta;
+    if (parsed !== null && typeof parsed === "object" && "kind" in parsed) {
+      return parsed;
     }
   } catch {
   }
   return null;
 }
-__name(parseDelta, "parseDelta");
+__name(parseEvent, "parseEvent");
 function extractText(message) {
   let text = "";
   for (const part of message.parts ?? []) {
@@ -411,6 +521,7 @@ function useAgentChat(options) {
   const runIdRef = (0, import_react2.useRef)(runId);
   runIdRef.current = runId;
   const regenerateNext = (0, import_react2.useRef)(false);
+  const createdThreadId = (0, import_react2.useRef)(void 0);
   const client = (0, import_react2.useMemo)(() => {
     if (options.client) return options.client;
     return new AgentClient({
@@ -429,6 +540,10 @@ function useAgentChat(options) {
   const transport = (0, import_react2.useMemo)(() => {
     function onMeta(meta) {
       setRunId(meta.runId);
+      if (latest.current.threadId === void 0 && meta.threadId && createdThreadId.current !== meta.threadId) {
+        createdThreadId.current = meta.threadId;
+        latest.current.onThreadCreated?.(meta.threadId);
+      }
     }
     __name(onMeta, "onMeta");
     return new AgentChatTransport({
@@ -450,9 +565,10 @@ function useAgentChat(options) {
         const pageContext = current.getPageContext?.() ?? null;
         const regenerate2 = regenerateNext.current;
         regenerateNext.current = false;
+        const threadId = current.threadId ?? createdThreadId.current;
         return {
-          ...current.threadId !== void 0 ? {
-            threadId: current.threadId
+          ...threadId !== void 0 ? {
+            threadId
           } : {},
           ...pageContext ? {
             pageContext