@assistant-ui/react 0.5.35 → 0.5.37

package/dist/{chunk-LX7F2T2K.mjs → chunk-5ZTUOAPH.mjs}

@@ -165,6 +165,74 @@ var toLanguageModelTools = (tools) => {
   }));
 };
 
+// src/runtimes/edge/streams/assistantEncoderStream.ts
+function assistantEncoderStream() {
+  const toolCalls = /* @__PURE__ */ new Set();
+  return new TransformStream({
+    transform(chunk, controller) {
+      const chunkType = chunk.type;
+      switch (chunkType) {
+        case "text-delta": {
+          controller.enqueue({
+            type: "0" /* TextDelta */,
+            value: chunk.textDelta
+          });
+          break;
+        }
+        case "tool-call-delta": {
+          if (!toolCalls.has(chunk.toolCallId)) {
+            toolCalls.add(chunk.toolCallId);
+            controller.enqueue({
+              type: "1" /* ToolCallBegin */,
+              value: {
+                id: chunk.toolCallId,
+                name: chunk.toolName
+              }
+            });
+          }
+          controller.enqueue({
+            type: "2" /* ToolCallArgsTextDelta */,
+            value: chunk.argsTextDelta
+          });
+          break;
+        }
+        // ignore
+        case "tool-call":
+          break;
+        case "tool-result": {
+          controller.enqueue({
+            type: "3" /* ToolCallResult */,
+            value: {
+              id: chunk.toolCallId,
+              result: chunk.result
+            }
+          });
+          break;
+        }
+        case "finish": {
+          const { type, ...rest } = chunk;
+          controller.enqueue({
+            type: "F" /* Finish */,
+            value: rest
+          });
+          break;
+        }
+        case "error": {
+          controller.enqueue({
+            type: "E" /* Error */,
+            value: chunk.error
+          });
+          break;
+        }
+        default: {
+          const unhandledType = chunkType;
+          throw new Error(`Unhandled chunk type: ${unhandledType}`);
+        }
+      }
+    }
+  });
+}
+
 // src/types/ModelConfigTypes.ts
 import { z as z2 } from "zod";
 var LanguageModelV1CallSettingsSchema = z2.object({
@@ -220,39 +288,145 @@ ${config.system}`;
   }, {});
 };
 
-// src/runtimes/edge/streams/utils/PipeableTransformStream.ts
-var PipeableTransformStream = class extends TransformStream {
-  constructor(transform) {
-    super();
-    const readable = transform(super.readable);
-    Object.defineProperty(this, "readable", {
-      value: readable,
-      writable: false
-    });
-  }
-};
+// src/runtimes/edge/EdgeRuntimeRequestOptions.ts
+import { z as z3 } from "zod";
+var LanguageModelV1FunctionToolSchema = z3.object({
+  type: z3.literal("function"),
+  name: z3.string(),
+  description: z3.string().optional(),
+  parameters: z3.custom(
+    (val) => typeof val === "object" && val !== null
+  )
+});
+var TextContentPartSchema = z3.object({
+  type: z3.literal("text"),
+  text: z3.string()
+});
+var ImageContentPartSchema = z3.object({
+  type: z3.literal("image"),
+  image: z3.string()
+});
+var CoreToolCallContentPartSchema = z3.object({
+  type: z3.literal("tool-call"),
+  toolCallId: z3.string(),
+  toolName: z3.string(),
+  args: z3.record(z3.unknown()),
+  result: z3.unknown().optional(),
+  isError: z3.boolean().optional()
+});
+var CoreUserMessageSchema = z3.object({
+  role: z3.literal("user"),
+  content: z3.array(
+    z3.discriminatedUnion("type", [
+      TextContentPartSchema,
+      ImageContentPartSchema
+    ])
+  ).min(1)
+});
+var CoreAssistantMessageSchema = z3.object({
+  role: z3.literal("assistant"),
+  content: z3.array(
+    z3.discriminatedUnion("type", [
+      TextContentPartSchema,
+      CoreToolCallContentPartSchema
+    ])
+  ).min(1)
+});
+var CoreSystemMessageSchema = z3.object({
+  role: z3.literal("system"),
+  content: z3.tuple([TextContentPartSchema])
+});
+var CoreMessageSchema = z3.discriminatedUnion("role", [
+  CoreSystemMessageSchema,
+  CoreUserMessageSchema,
+  CoreAssistantMessageSchema
+]);
+var EdgeRuntimeRequestOptionsSchema = z3.object({
+  system: z3.string().optional(),
+  messages: z3.array(CoreMessageSchema).min(1),
+  tools: z3.array(LanguageModelV1FunctionToolSchema).optional()
+}).merge(LanguageModelV1CallSettingsSchema).merge(LanguageModelConfigSchema);
 
-// src/runtimes/edge/streams/utils/streamPartEncoderStream.ts
-function encodeStreamPart({
-  type,
-  value
-}) {
-  return `${type}:${JSON.stringify(value)}
-`;
-}
-function streamPartEncoderStream() {
-  const encodeStream = new TransformStream({
+// src/runtimes/edge/streams/toolResultStream.ts
+import { z as z4 } from "zod";
+import sjson from "secure-json-parse";
+function toolResultStream(tools, abortSignal) {
+  const toolCallExecutions = /* @__PURE__ */ new Map();
+  return new TransformStream({
     transform(chunk, controller) {
-      controller.enqueue(encodeStreamPart(chunk));
+      controller.enqueue(chunk);
+      const chunkType = chunk.type;
+      switch (chunkType) {
+        case "tool-call": {
+          const { toolCallId, toolCallType, toolName, args: argsText } = chunk;
+          const tool = tools?.[toolName];
+          if (!tool || !tool.execute) return;
+          const args = sjson.parse(argsText);
+          if (tool.parameters instanceof z4.ZodType) {
+            const result = tool.parameters.safeParse(args);
+            if (!result.success) {
+              controller.enqueue({
+                type: "tool-result",
+                toolCallType,
+                toolCallId,
+                toolName,
+                result: "Function parameter validation failed. " + JSON.stringify(result.error.issues),
+                isError: true
+              });
+              return;
+            } else {
+              toolCallExecutions.set(
+                toolCallId,
+                (async () => {
+                  if (!tool.execute) return;
+                  try {
+                    const result2 = await tool.execute(args, { abortSignal });
+                    controller.enqueue({
+                      type: "tool-result",
+                      toolCallType,
+                      toolCallId,
+                      toolName,
+                      result: result2
+                    });
+                  } catch (error) {
+                    controller.enqueue({
+                      type: "tool-result",
+                      toolCallType,
+                      toolCallId,
+                      toolName,
+                      result: "Error: " + error,
+                      isError: true
+                    });
+                  } finally {
+                    toolCallExecutions.delete(toolCallId);
+                  }
+                })()
+              );
+            }
+          }
+          break;
+        }
+        // ignore other parts
+        case "text-delta":
+        case "tool-call-delta":
+        case "tool-result":
+        case "finish":
+        case "error":
+          break;
+        default: {
+          const unhandledType = chunkType;
+          throw new Error(`Unhandled chunk type: ${unhandledType}`);
+        }
+      }
+    },
+    async flush() {
+      await Promise.all(toolCallExecutions.values());
     }
   });
-  return new PipeableTransformStream((readable) => {
-    return readable.pipeThrough(encodeStream).pipeThrough(new TextEncoderStream());
-  });
 }
 
 // src/runtimes/edge/partial-json/parse-partial-json.ts
-import sjson from "secure-json-parse";
+import sjson2 from "secure-json-parse";
 
 // src/runtimes/edge/partial-json/fix-json.ts
 function fixJson(input) {
@@ -575,10 +749,10 @@ function fixJson(input) {
 // src/runtimes/edge/partial-json/parse-partial-json.ts
 var parsePartialJson = (json) => {
   try {
-    return sjson.parse(json);
+    return sjson2.parse(json);
   } catch {
     try {
-      return sjson.parse(fixJson(json));
+      return sjson2.parse(fixJson(json));
     } catch {
       return void 0;
     }
@@ -760,87 +934,182 @@ var appendOrUpdateCancel = (message) => {
   };
 };
 
-// src/runtimes/edge/streams/toolResultStream.ts
-import { z as z3 } from "zod";
-import sjson2 from "secure-json-parse";
-function toolResultStream(tools, abortSignal) {
-  const toolCallExecutions = /* @__PURE__ */ new Map();
-  return new TransformStream({
+// src/runtimes/edge/streams/utils/PipeableTransformStream.ts
+var PipeableTransformStream = class extends TransformStream {
+  constructor(transform) {
+    super();
+    const readable = transform(super.readable);
+    Object.defineProperty(this, "readable", {
+      value: readable,
+      writable: false
+    });
+  }
+};
+
+// src/runtimes/edge/streams/utils/streamPartEncoderStream.ts
+function encodeStreamPart({
+  type,
+  value
+}) {
+  return `${type}:${JSON.stringify(value)}
+`;
+}
+function streamPartEncoderStream() {
+  const encodeStream = new TransformStream({
     transform(chunk, controller) {
-      controller.enqueue(chunk);
-      const chunkType = chunk.type;
-      switch (chunkType) {
-        case "tool-call": {
-          const { toolCallId, toolCallType, toolName, args: argsText } = chunk;
-          const tool = tools?.[toolName];
-          if (!tool || !tool.execute) return;
-          const args = sjson2.parse(argsText);
-          if (tool.parameters instanceof z3.ZodType) {
-            const result = tool.parameters.safeParse(args);
-            if (!result.success) {
-              controller.enqueue({
-                type: "tool-result",
-                toolCallType,
-                toolCallId,
-                toolName,
-                result: "Function parameter validation failed. " + JSON.stringify(result.error.issues),
-                isError: true
-              });
+      controller.enqueue(encodeStreamPart(chunk));
+    }
+  });
+  return new PipeableTransformStream((readable) => {
+    return readable.pipeThrough(encodeStream).pipeThrough(new TextEncoderStream());
+  });
+}
+
+// src/runtimes/edge/createEdgeRuntimeAPI.ts
+var voidStream = () => {
+  return new WritableStream({
+    abort(reason) {
+      console.error("Server stream processing aborted:", reason);
+    }
+  });
+};
+var getEdgeRuntimeStream = async ({
+  abortSignal,
+  requestData: unsafeRequest,
+  options: {
+    model: modelOrCreator,
+    system: serverSystem,
+    tools: serverTools = {},
+    toolChoice,
+    onFinish,
+    ...unsafeSettings
+  }
+}) => {
+  const settings = LanguageModelV1CallSettingsSchema.parse(unsafeSettings);
+  const lmServerTools = toLanguageModelTools(serverTools);
+  const hasServerTools = Object.values(serverTools).some((v) => !!v.execute);
+  const {
+    system: clientSystem,
+    tools: clientTools = [],
+    messages,
+    apiKey,
+    baseUrl,
+    modelName,
+    ...callSettings
+  } = EdgeRuntimeRequestOptionsSchema.parse(unsafeRequest);
+  const systemMessages = [];
+  if (serverSystem) systemMessages.push(serverSystem);
+  if (clientSystem) systemMessages.push(clientSystem);
+  const system = systemMessages.join("\n\n");
+  for (const clientTool of clientTools) {
+    if (serverTools?.[clientTool.name]) {
+      throw new Error(
+        `Tool ${clientTool.name} was defined in both the client and server tools. This is not allowed.`
+      );
+    }
+  }
+  let model;
+  model = typeof modelOrCreator === "function" ? await modelOrCreator({ apiKey, baseUrl, modelName }) : modelOrCreator;
+  let stream;
+  const streamResult = await streamMessage({
+    ...settings,
+    ...callSettings,
+    model,
+    abortSignal,
+    ...!!system ? { system } : void 0,
+    messages,
+    tools: lmServerTools.concat(clientTools),
+    ...toolChoice ? { toolChoice } : void 0
+  });
+  stream = streamResult.stream;
+  const canExecuteTools = hasServerTools && toolChoice?.type !== "none";
+  if (canExecuteTools) {
+    stream = stream.pipeThrough(toolResultStream(serverTools, abortSignal));
+  }
+  if (canExecuteTools || onFinish) {
+    const tees = stream.tee();
+    stream = tees[0];
+    let serverStream = tees[1];
+    if (onFinish) {
+      let lastChunk;
+      serverStream = serverStream.pipeThrough(runResultStream()).pipeThrough(
+        new TransformStream({
+          transform(chunk) {
+            lastChunk = chunk;
+          },
+          flush() {
+            if (!lastChunk?.status || lastChunk.status.type === "running")
               return;
-            } else {
-              toolCallExecutions.set(
-                toolCallId,
-                (async () => {
-                  if (!tool.execute) return;
-                  try {
-                    const result2 = await tool.execute(args, { abortSignal });
-                    controller.enqueue({
-                      type: "tool-result",
-                      toolCallType,
-                      toolCallId,
-                      toolName,
-                      result: result2
-                    });
-                  } catch (error) {
-                    controller.enqueue({
-                      type: "tool-result",
-                      toolCallType,
-                      toolCallId,
-                      toolName,
-                      result: "Error: " + error,
-                      isError: true
-                    });
-                  } finally {
-                    toolCallExecutions.delete(toolCallId);
-                  }
-                })()
-              );
-            }
+            const resultingMessages = [
+              ...messages,
+              toCoreMessage({
+                role: "assistant",
+                content: lastChunk.content
+              })
+            ];
+            onFinish({
+              messages: resultingMessages,
+              metadata: {
+                roundtrips: lastChunk.metadata?.roundtrips
+              }
+            });
           }
-          break;
-        }
-        // ignore other parts
-        case "text-delta":
-        case "tool-call-delta":
-        case "tool-result":
-        case "finish":
-        case "error":
-          break;
-        default: {
-          const unhandledType = chunkType;
-          throw new Error(`Unhandled chunk type: ${unhandledType}`);
-        }
+        })
+      );
+    }
+    serverStream.pipeTo(voidStream()).catch((e) => {
+      console.error("Server stream processing error:", e);
+    });
+  }
+  return stream;
+};
+var getEdgeRuntimeResponse = async (options) => {
+  const stream = await getEdgeRuntimeStream(options);
+  return new Response(
+    stream.pipeThrough(assistantEncoderStream()).pipeThrough(streamPartEncoderStream()),
+    {
+      headers: {
+        "Content-Type": "text/plain; charset=utf-8"
       }
-    },
-    async flush() {
-      await Promise.all(toolCallExecutions.values());
     }
+  );
+};
+var createEdgeRuntimeAPI = (options) => ({
+  POST: async (request) => getEdgeRuntimeResponse({
+    abortSignal: request.signal,
+    requestData: await request.json(),
+    options
+  })
+});
+async function streamMessage({
+  model,
+  system,
+  messages,
+  tools,
+  toolChoice,
+  ...options
+}) {
+  return model.doStream({
+    inputFormat: "messages",
+    mode: {
+      type: "regular",
+      ...tools ? { tools } : void 0,
+      ...toolChoice ? { toolChoice } : void 0
+    },
+    prompt: convertToLanguageModelPrompt(system, messages),
+    ...options
   });
 }
+function convertToLanguageModelPrompt(system, messages) {
+  const languageModelMessages = [];
+  if (system != null) {
+    languageModelMessages.push({ role: "system", content: system });
+  }
+  languageModelMessages.push(...toLanguageModelMessages(messages));
+  return languageModelMessages;
+}
 
 export {
-  LanguageModelV1CallSettingsSchema,
-  LanguageModelConfigSchema,
   mergeModelConfigs,
   toLanguageModelMessages,
   toCoreMessages,
@@ -849,6 +1118,9 @@ export {
   PipeableTransformStream,
   streamPartEncoderStream,
   runResultStream,
-  toolResultStream
+  toolResultStream,
+  getEdgeRuntimeStream,
+  getEdgeRuntimeResponse,
+  createEdgeRuntimeAPI
 };
-//# sourceMappingURL=chunk-LX7F2T2K.mjs.map
+//# sourceMappingURL=chunk-5ZTUOAPH.mjs.map