@dudousxd/nestjs-agent-react 0.3.2 → 0.4.0

package/dist/index.cjs

@@ -42,6 +42,7 @@ __export(src_exports, {
   formatRelativeTime: () => formatRelativeTime,
   loadStoredSpeechLang: () => loadStoredSpeechLang,
   persistSpeechLang: () => persistSpeechLang,
+  storedMessageToUiMessage: () => storedMessageToUiMessage,
   useAgentChat: () => useAgentChat,
   useSpeechRecognition: () => useSpeechRecognition
 });
@@ -147,18 +148,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 +177,154 @@ 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();
+              if (event.costUsd !== void 0) {
+                controller.enqueue({
+                  type: "message-metadata",
+                  messageMetadata: {
+                    costUsd: event.costUsd
+                  }
+                });
+              }
+              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,
+                // `toolKind` is absent on older backends — omitted (not `undefined`-valued) so
+                // `toolMetadata` itself is only present when there's something to say, letting a
+                // UI gate approval affordances on `kind === 'action'` without hardcoding tool names.
+                ...event.toolKind !== void 0 ? {
+                  toolMetadata: {
+                    toolKind: event.toolKind
+                  }
+                } : {}
+              });
+              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,
+                ...event.toolKind !== void 0 ? {
+                  toolMetadata: {
+                    toolKind: event.toolKind
+                  }
+                } : {}
+              });
+              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 +363,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 +426,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 ?? []) {
@@ -348,10 +480,39 @@ var AgentClient = class {
     return this.request("POST", `/agent/threads/${encodeURIComponent(threadId)}/fork-from/${encodeURIComponent(messageId)}`);
   }
   renameThread(id, title) {
-    return this.request("PATCH", `/agent/threads/${encodeURIComponent(id)}`, {
+    return this.updateThread(id, {
       title
     });
   }
+  /** General `PATCH /agent/threads/:threadId` — title and/or the thread's pinned default agent. */
+  updateThread(id, patch) {
+    return this.request("PATCH", `/agent/threads/${encodeURIComponent(id)}`, patch);
+  }
+  /**
+  * Uploads a file (image/PDF) for a vision-capable model turn. Multipart, field name `file` —
+  * mirrors the backend's `POST /agent/attachments`. The returned {@link MessageAttachment} is
+  * what a caller then rides on `sendMessage({ text }, { body: { attachments: [...] } })`.
+  */
+  async uploadAttachment(file) {
+    const fetchImpl = this.options.fetch ?? globalThis.fetch;
+    const baseUrl = (this.options.baseUrl ?? "").replace(/\/$/, "");
+    const dynamic = await this.options.getHeaders?.() ?? {};
+    const formData = new FormData();
+    formData.append("file", file);
+    const response = await fetchImpl(`${baseUrl}/agent/attachments`, {
+      method: "POST",
+      headers: {
+        accept: "application/json",
+        ...this.options.headers,
+        ...dynamic
+      },
+      body: formData,
+      ...this.options.credentials !== void 0 ? {
+        credentials: this.options.credentials
+      } : {}
+    });
+    return this.handleResponse(response, "POST", "/agent/attachments");
+  }
   promoteThread(id) {
     return this.request("POST", `/agent/threads/${encodeURIComponent(id)}/promote`);
   }
@@ -391,6 +552,9 @@ var AgentClient = class {
         credentials: this.options.credentials
       } : {}
     });
+    return this.handleResponse(response, method, path);
+  }
+  async handleResponse(response, method, path) {
     if (!response.ok) {
       throw new AgentHttpError(response.status, method, path, response.statusText);
     }
@@ -401,6 +565,52 @@ var AgentClient = class {
   }
 };
 
+// src/stored-message-to-ui-message.ts
+function storedMessageToUiMessage(message) {
+  const parts = [];
+  if (message.content) {
+    parts.push({
+      type: "text",
+      text: message.content
+    });
+  }
+  for (const attachment of message.attachments ?? []) {
+    parts.push({
+      type: "file",
+      mediaType: attachment.contentType,
+      filename: attachment.name,
+      url: attachment.url
+    });
+  }
+  for (const call of message.toolCalls ?? []) {
+    const result = message.toolResults?.find((candidate) => candidate.id === call.id);
+    const toolKind = call.kind;
+    parts.push({
+      type: `tool-${call.name}`,
+      toolCallId: call.id,
+      ...toolKind !== void 0 ? {
+        toolMetadata: {
+          toolKind
+        }
+      } : {},
+      ...result !== void 0 ? {
+        state: "output-available",
+        input: call.input,
+        output: result.output
+      } : {
+        state: "input-available",
+        input: call.input
+      }
+    });
+  }
+  return {
+    id: message.id,
+    role: message.role,
+    parts
+  };
+}
+__name(storedMessageToUiMessage, "storedMessageToUiMessage");
+
 // src/use-agent-chat.ts
 var import_react = require("@ai-sdk/react");
 var import_react2 = require("react");
@@ -410,7 +620,11 @@ function useAgentChat(options) {
   const [runId, setRunId] = (0, import_react2.useState)(options.resumeRunId);
   const runIdRef = (0, import_react2.useRef)(runId);
   runIdRef.current = runId;
+  const autoResumeRunIdRef = (0, import_react2.useRef)(void 0);
+  const [autoResume, setAutoResume] = (0, import_react2.useState)(false);
+  const [activeRunId, setActiveRunId] = (0, import_react2.useState)(null);
   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({
@@ -426,9 +640,33 @@ function useAgentChat(options) {
       getHeaders: /* @__PURE__ */ __name(async () => mergeHeaders(latest.current), "getHeaders")
     });
   }, []);
+  (0, import_react2.useEffect)(() => {
+    if (!options.resume || options.threadId === void 0) return;
+    let cancelled = false;
+    const threadId = options.threadId;
+    void client.getThread(threadId).then((thread) => {
+      if (cancelled) return;
+      setActiveRunId(thread.activeRunId ?? null);
+      if (thread.activeRunId != null) {
+        autoResumeRunIdRef.current = thread.activeRunId;
+        setAutoResume(true);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    client,
+    options.resume,
+    options.threadId
+  ]);
   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 +688,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
@@ -462,13 +701,13 @@ function useAgentChat(options) {
           } : {}
         };
       }, "getBody"),
-      getResumeRunId: /* @__PURE__ */ __name(() => latest.current.resumeRunId, "getResumeRunId"),
+      getResumeRunId: /* @__PURE__ */ __name(() => latest.current.resumeRunId ?? autoResumeRunIdRef.current, "getResumeRunId"),
       onMeta
     });
   }, []);
   const chat = (0, import_react.useChat)({
     transport,
-    resume: options.resumeRunId !== void 0,
+    resume: options.resumeRunId !== void 0 || autoResume,
     ...options.threadId !== void 0 ? {
       id: options.threadId
     } : {},
@@ -535,10 +774,10 @@ function useAgentChat(options) {
   ]);
   const cancel = (0, import_react2.useCallback)(async () => {
     chatRef.current.stop();
-    const activeRunId = runIdRef.current;
-    if (activeRunId) {
+    const activeRunId2 = runIdRef.current;
+    if (activeRunId2) {
       try {
-        await client.cancelStream(activeRunId);
+        await client.cancelStream(activeRunId2);
       } catch {
       }
     }
@@ -570,6 +809,8 @@ function useAgentChat(options) {
     ...chat,
     addToolResult,
     runId,
+    /** The `resume`-fetched thread's active run id, or `null` once resolved with none. */
+    activeRunId,
     client,
     threads,
     loadThreads,
@@ -1179,6 +1420,7 @@ __name(persistSpeechLang, "persistSpeechLang");
   formatRelativeTime,
   loadStoredSpeechLang,
   persistSpeechLang,
+  storedMessageToUiMessage,
   useAgentChat,
   useSpeechRecognition
 });