@dudousxd/nestjs-agent-react 0.3.2 → 0.4.0

package/dist/index.js

@@ -101,18 +101,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) {
@@ -122,24 +130,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"
           });
@@ -178,15 +316,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");
             }
@@ -248,17 +379,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 ?? []) {
@@ -302,10 +433,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`);
   }
@@ -345,6 +505,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);
     }
@@ -355,16 +518,66 @@ 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
 import { useChat } from "@ai-sdk/react";
-import { useCallback, useMemo, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 function useAgentChat(options) {
   const latest = useRef(options);
   latest.current = options;
   const [runId, setRunId] = useState(options.resumeRunId);
   const runIdRef = useRef(runId);
   runIdRef.current = runId;
+  const autoResumeRunIdRef = useRef(void 0);
+  const [autoResume, setAutoResume] = useState(false);
+  const [activeRunId, setActiveRunId] = useState(null);
   const regenerateNext = useRef(false);
+  const createdThreadId = useRef(void 0);
   const client = useMemo(() => {
     if (options.client) return options.client;
     return new AgentClient({
@@ -380,9 +593,33 @@ function useAgentChat(options) {
       getHeaders: /* @__PURE__ */ __name(async () => mergeHeaders(latest.current), "getHeaders")
     });
   }, []);
+  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 = 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({
@@ -404,9 +641,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
@@ -416,13 +654,13 @@ function useAgentChat(options) {
           } : {}
         };
       }, "getBody"),
-      getResumeRunId: /* @__PURE__ */ __name(() => latest.current.resumeRunId, "getResumeRunId"),
+      getResumeRunId: /* @__PURE__ */ __name(() => latest.current.resumeRunId ?? autoResumeRunIdRef.current, "getResumeRunId"),
       onMeta
     });
   }, []);
   const chat = useChat({
     transport,
-    resume: options.resumeRunId !== void 0,
+    resume: options.resumeRunId !== void 0 || autoResume,
     ...options.threadId !== void 0 ? {
       id: options.threadId
     } : {},
@@ -489,10 +727,10 @@ function useAgentChat(options) {
   ]);
   const cancel = 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 {
       }
     }
@@ -524,6 +762,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,
@@ -552,10 +792,10 @@ async function mergeHeaders(options) {
 __name(mergeHeaders, "mergeHeaders");
 
 // src/components/chat-input.tsx
-import React, { useEffect as useEffect2, useState as useState3 } from "react";
+import React, { useEffect as useEffect3, useState as useState3 } from "react";
 
 // src/components/use-speech-recognition.ts
-import { useCallback as useCallback2, useEffect, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
 function getRecognitionCtor() {
   if (typeof window === "undefined") return null;
   const scope = window;
@@ -571,7 +811,7 @@ function useSpeechRecognition({ lang = "en-US", onFinalTranscript, onInterimTran
   const interimRef = useRef2(onInterimTranscript);
   finalRef.current = onFinalTranscript;
   interimRef.current = onInterimTranscript;
-  useEffect(() => {
+  useEffect2(() => {
     if (!ctor) return;
     const recognition = new ctor();
     recognition.lang = lang;
@@ -651,7 +891,7 @@ function ChatInput({ onSubmit, disabled, placeholder, rows = 2, enableSpeech = t
     }, "onFinalTranscript"),
     onInterimTranscript: /* @__PURE__ */ __name((text) => setInterim(text), "onInterimTranscript")
   });
-  useEffect2(() => {
+  useEffect3(() => {
     if (!speech.isListening) setInterim("");
   }, [
     speech.isListening
@@ -710,7 +950,7 @@ __name(ChatInput, "ChatInput");
 
 // src/components/message-item.tsx
 import { isTextUIPart, isToolUIPart } from "ai";
-import React2, { useEffect as useEffect3, useRef as useRef3, useState as useState4 } from "react";
+import React2, { useEffect as useEffect4, useRef as useRef3, useState as useState4 } from "react";
 function MessageItem({ message, renderToolPart, renderToolGroup, renderText, classNames, isStreaming = false, editable, onEditSubmit, regeneratable, onRegenerate, onFork, usage, createdAt }) {
   const isUser = message.role === "user";
   const parts = message.parts ?? [];
@@ -814,7 +1054,7 @@ function EditableUserBubble({ message, onSubmit, renderText, classNames, actions
   const [isEditing, setIsEditing] = useState4(false);
   const [draft, setDraft] = useState4(initialText);
   const textareaRef = useRef3(null);
-  useEffect3(() => {
+  useEffect4(() => {
     if (isEditing && textareaRef.current) {
       const el = textareaRef.current;
       el.focus();
@@ -1132,6 +1372,7 @@ export {
   formatRelativeTime,
   loadStoredSpeechLang,
   persistSpeechLang,
+  storedMessageToUiMessage,
   useAgentChat,
   useSpeechRecognition
 };