@assistant-ui/react 0.5.72 → 0.5.73

package/dist/index.mjs

@@ -10,7 +10,7 @@ import {
   toLanguageModelMessages,
   toLanguageModelTools,
   toolResultStream
-} from "./chunk-DC342I2Q.mjs";
+} from "./chunk-SNNYBBO6.mjs";
 import {
   __export
 } from "./chunk-BJPOCE4O.mjs";
@@ -3688,7 +3688,7 @@ var ThreadRuntimeImpl = class {
 };
 
 // src/runtimes/edge/converters/fromLanguageModelMessages.ts
-var fromLanguageModelMessages = (lm, { mergeRoundtrips }) => {
+var fromLanguageModelMessages = (lm, { mergeSteps }) => {
   const messages2 = [];
   for (const lmMessage of lm) {
     const role = lmMessage.role;
@@ -3751,7 +3751,7 @@ var fromLanguageModelMessages = (lm, { mergeRoundtrips }) => {
           }
           return part;
         });
-        if (mergeRoundtrips) {
+        if (mergeSteps) {
           const previousMessage = messages2[messages2.length - 1];
           if (previousMessage?.role === "assistant") {
             previousMessage.content.push(...newContent);
@@ -3862,7 +3862,7 @@ function assistantDecoderStream() {
   let currentToolCall;
   return new TransformStream({
     transform({ type, value }, controller) {
-      if (currentToolCall && type !== "2" /* ToolCallArgsTextDelta */ && type !== "E" /* Error */) {
+      if (currentToolCall && type !== "c" /* ToolCallDelta */ && type !== "3" /* Error */) {
         controller.enqueue({
           type: "tool-call",
           toolCallType: "function",
@@ -3880,48 +3880,82 @@ function assistantDecoderStream() {
           });
           break;
         }
-        case "1" /* ToolCallBegin */: {
-          const { id, name } = value;
+        case "b" /* ToolCallBegin */: {
+          const { toolCallId: id, toolName: name } = value;
           toolCallNames.set(id, name);
           currentToolCall = { id, name, argsText: "" };
           break;
         }
-        case "2" /* ToolCallArgsTextDelta */: {
-          const delta = value;
-          currentToolCall.argsText += delta;
+        case "c" /* ToolCallDelta */: {
+          const { toolCallId, argsTextDelta } = value;
+          if (currentToolCall?.id !== toolCallId) {
+            throw new Error(
+              `Received tool call delta for unknown tool call "${toolCallId}".`
+            );
+          }
+          currentToolCall.argsText += argsTextDelta;
           controller.enqueue({
             type: "tool-call-delta",
             toolCallType: "function",
             toolCallId: currentToolCall.id,
             toolName: currentToolCall.name,
-            argsTextDelta: delta
+            argsTextDelta
           });
           break;
         }
-        case "3" /* ToolCallResult */: {
+        case "a" /* ToolCallResult */: {
           controller.enqueue({
             type: "tool-result",
             toolCallType: "function",
-            toolCallId: value.id,
-            toolName: toolCallNames.get(value.id),
+            toolCallId: value.toolCallId,
+            toolName: toolCallNames.get(value.toolCallId),
             result: value.result
           });
           break;
         }
-        case "F" /* Finish */: {
+        case "d" /* Finish */: {
           controller.enqueue({
             type: "finish",
             ...value
           });
           break;
         }
-        case "E" /* Error */: {
+        case "3" /* Error */: {
           controller.enqueue({
             type: "error",
             error: value
           });
           break;
         }
+        case "9" /* ToolCall */: {
+          const { toolCallId, toolName, args } = value;
+          const argsText = JSON.stringify(args);
+          controller.enqueue({
+            type: "tool-call-delta",
+            toolCallType: "function",
+            toolCallId,
+            toolName,
+            argsTextDelta: argsText
+          });
+          controller.enqueue({
+            type: "tool-call",
+            toolCallType: "function",
+            toolCallId,
+            toolName,
+            args: argsText
+          });
+          break;
+        }
+        case "e" /* StepFinish */: {
+          controller.enqueue({
+            type: "step-finish",
+            ...value
+          });
+          break;
+        }
+        // TODO
+        case "2" /* Data */:
+          break;
         default: {
           const unhandledType = type;
           throw new Error(`Unhandled chunk type: ${unhandledType}`);
@@ -3981,9 +4015,14 @@ var EdgeChatAdapter = class {
 
 // src/runtimes/local/LocalRuntimeOptions.tsx
 var splitLocalRuntimeOptions = (options) => {
-  const { initialMessages, maxToolRoundtrips, adapters, ...rest } = options;
+  const { initialMessages, maxToolRoundtrips, maxSteps, adapters, ...rest } = options;
   return {
-    localRuntimeOptions: { initialMessages, maxToolRoundtrips, adapters },
+    localRuntimeOptions: {
+      initialMessages,
+      maxToolRoundtrips,
+      maxSteps,
+      adapters
+    },
     otherOptions: rest
   };
 };
@@ -4157,29 +4196,21 @@ var LocalThreadRuntimeCore = class {
     this.abortController?.abort();
     this.abortController = new AbortController();
     const initialContent = message.content;
-    const initialRoundtrips = message.metadata?.roundtrips;
+    const initialSteps = message.metadata?.steps;
     const initalCustom = message.metadata?.custom;
     const updateMessage = (m) => {
+      const newSteps = m.metadata?.steps || m.metadata?.roundtrips;
+      const steps2 = newSteps ? [...initialSteps ?? [], ...newSteps] : void 0;
       message = {
         ...message,
         ...m.content ? { content: [...initialContent, ...m.content ?? []] } : void 0,
         status: m.status ?? message.status,
         // TODO deprecated, remove in v0.6
-        ...m.metadata?.roundtrips ? {
-          roundtrips: [
-            ...initialRoundtrips ?? [],
-            ...m.metadata.roundtrips
-          ]
-        } : void 0,
+        ...steps2 ? { roundtrips: steps2 } : void 0,
         ...m.metadata ? {
           metadata: {
             ...message.metadata,
-            ...m.metadata.roundtrips ? {
-              roundtrips: [
-                ...initialRoundtrips ?? [],
-                ...m.metadata.roundtrips
-              ]
-            } : void 0,
+            ...steps2 ? { roundtrips: steps2, steps: steps2 } : void 0,
             ...m.metadata?.custom ? {
               custom: { ...initalCustom ?? {}, ...m.metadata.custom }
             } : void 0
@@ -4189,9 +4220,9 @@ var LocalThreadRuntimeCore = class {
       this.repository.addOrUpdateMessage(parentId, message);
       this.notifySubscribers();
     };
-    const maxToolRoundtrips = this.options.maxToolRoundtrips ?? 1;
-    const toolRoundtrips = message.metadata?.roundtrips?.length ?? 0;
-    if (toolRoundtrips > maxToolRoundtrips) {
+    const maxSteps = this.options.maxSteps ? this.options.maxSteps : (this.options.maxToolRoundtrips ?? 1) + 1;
+    const steps = message.metadata?.steps?.length ?? 0;
+    if (steps >= maxSteps) {
       updateMessage({
         status: {
           type: "incomplete",
@@ -5916,9 +5947,14 @@ var edit_composer_default = Object.assign(EditComposer, exports11);
 // src/ui/thread.tsx
 import { Fragment as Fragment6, jsx as jsx49, jsxs as jsxs13 } from "react/jsx-runtime";
 var Thread = (config) => {
-  const { components: { Composer: ComposerComponent = composer_default } = {} } = config;
+  const {
+    components: {
+      Composer: ComposerComponent = composer_default,
+      ThreadWelcome: ThreadWelcomeComponent = thread_welcome_default
+    } = {}
+  } = config;
   return /* @__PURE__ */ jsx49(ThreadRoot, { config, children: /* @__PURE__ */ jsxs13(ThreadViewport, { children: [
-    /* @__PURE__ */ jsx49(thread_welcome_default, {}),
+    /* @__PURE__ */ jsx49(ThreadWelcomeComponent, {}),
     /* @__PURE__ */ jsx49(ThreadMessages, {}),
     /* @__PURE__ */ jsx49(ThreadFollowupSuggestions, {}),
     /* @__PURE__ */ jsxs13(ThreadViewportFooter, { children: [