@assistant-ui/react 0.5.35 → 0.5.36

package/dist/{chunk-JKRONBQK.js → chunk-BQ3MRWUV.js}

@@ -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
 
 var LanguageModelV1CallSettingsSchema = _zod.z.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
 
-// src/runtimes/edge/streams/utils/streamPartEncoderStream.ts
-function encodeStreamPart({
-  type,
-  value
-}) {
-  return `${type}:${JSON.stringify(value)}
-`;
-}
-function streamPartEncoderStream() {
-  const encodeStream = new TransformStream({
+var LanguageModelV1FunctionToolSchema = _zod.z.object({
+  type: _zod.z.literal("function"),
+  name: _zod.z.string(),
+  description: _zod.z.string().optional(),
+  parameters: _zod.z.custom(
+    (val) => typeof val === "object" && val !== null
+  )
+});
+var TextContentPartSchema = _zod.z.object({
+  type: _zod.z.literal("text"),
+  text: _zod.z.string()
+});
+var ImageContentPartSchema = _zod.z.object({
+  type: _zod.z.literal("image"),
+  image: _zod.z.string()
+});
+var CoreToolCallContentPartSchema = _zod.z.object({
+  type: _zod.z.literal("tool-call"),
+  toolCallId: _zod.z.string(),
+  toolName: _zod.z.string(),
+  args: _zod.z.record(_zod.z.unknown()),
+  result: _zod.z.unknown().optional(),
+  isError: _zod.z.boolean().optional()
+});
+var CoreUserMessageSchema = _zod.z.object({
+  role: _zod.z.literal("user"),
+  content: _zod.z.array(
+    _zod.z.discriminatedUnion("type", [
+      TextContentPartSchema,
+      ImageContentPartSchema
+    ])
+  ).min(1)
+});
+var CoreAssistantMessageSchema = _zod.z.object({
+  role: _zod.z.literal("assistant"),
+  content: _zod.z.array(
+    _zod.z.discriminatedUnion("type", [
+      TextContentPartSchema,
+      CoreToolCallContentPartSchema
+    ])
+  ).min(1)
+});
+var CoreSystemMessageSchema = _zod.z.object({
+  role: _zod.z.literal("system"),
+  content: _zod.z.tuple([TextContentPartSchema])
+});
+var CoreMessageSchema = _zod.z.discriminatedUnion("role", [
+  CoreSystemMessageSchema,
+  CoreUserMessageSchema,
+  CoreAssistantMessageSchema
+]);
+var EdgeRuntimeRequestOptionsSchema = _zod.z.object({
+  system: _zod.z.string().optional(),
+  messages: _zod.z.array(CoreMessageSchema).min(1),
+  tools: _zod.z.array(LanguageModelV1FunctionToolSchema).optional()
+}).merge(LanguageModelV1CallSettingsSchema).merge(LanguageModelConfigSchema);
+
+// src/runtimes/edge/streams/toolResultStream.ts
+
+var _securejsonparse = require('secure-json-parse'); var _securejsonparse2 = _interopRequireDefault(_securejsonparse);
+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 = _optionalChain([tools, 'optionalAccess', _3 => _3[toolName]]);
+          if (!tool || !tool.execute) return;
+          const args = _securejsonparse2.default.parse(argsText);
+          if (tool.parameters instanceof _zod.z.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
-var _securejsonparse = require('secure-json-parse'); var _securejsonparse2 = _interopRequireDefault(_securejsonparse);
+
 
 // src/runtimes/edge/partial-json/fix-json.ts
 function fixJson(input) {
@@ -576,10 +750,10 @@ function fixJson(input) {
 var parsePartialJson = (json) => {
   try {
     return _securejsonparse2.default.parse(json);
-  } catch (e) {
+  } catch (e2) {
     try {
       return _securejsonparse2.default.parse(fixJson(json));
-    } catch (e2) {
+    } catch (e3) {
       return void 0;
     }
   }
@@ -655,8 +829,8 @@ function runResultStream() {
 }
 var appendOrUpdateText = (message, textDelta) => {
   let contentParts = _nullishCoalesce(message.content, () => ( []));
-  let contentPart = _optionalChain([message, 'access', _3 => _3.content, 'optionalAccess', _4 => _4.at, 'call', _5 => _5(-1)]);
-  if (_optionalChain([contentPart, 'optionalAccess', _6 => _6.type]) !== "text") {
+  let contentPart = _optionalChain([message, 'access', _4 => _4.content, 'optionalAccess', _5 => _5.at, 'call', _6 => _6(-1)]);
+  if (_optionalChain([contentPart, 'optionalAccess', _7 => _7.type]) !== "text") {
     contentPart = { type: "text", text: textDelta };
   } else {
     contentParts = contentParts.slice(0, -1);
@@ -669,8 +843,8 @@ var appendOrUpdateText = (message, textDelta) => {
 };
 var appendOrUpdateToolCall = (message, toolCallId, toolName, argsText) => {
   let contentParts = _nullishCoalesce(message.content, () => ( []));
-  let contentPart = _optionalChain([message, 'access', _7 => _7.content, 'optionalAccess', _8 => _8.at, 'call', _9 => _9(-1)]);
-  if (_optionalChain([contentPart, 'optionalAccess', _10 => _10.type]) !== "tool-call" || contentPart.toolCallId !== toolCallId) {
+  let contentPart = _optionalChain([message, 'access', _8 => _8.content, 'optionalAccess', _9 => _9.at, 'call', _10 => _10(-1)]);
+  if (_optionalChain([contentPart, 'optionalAccess', _11 => _11.type]) !== "tool-call" || contentPart.toolCallId !== toolCallId) {
     contentPart = {
       type: "tool-call",
       toolCallId,
@@ -693,7 +867,7 @@ var appendOrUpdateToolCall = (message, toolCallId, toolName, argsText) => {
 };
 var appendOrUpdateToolResult = (message, toolCallId, toolName, result) => {
   let found = false;
-  const newContentParts = _optionalChain([message, 'access', _11 => _11.content, 'optionalAccess', _12 => _12.map, 'call', _13 => _13((part) => {
+  const newContentParts = _optionalChain([message, 'access', _12 => _12.content, 'optionalAccess', _13 => _13.map, 'call', _14 => _14((part) => {
     if (part.type !== "tool-call" || part.toolCallId !== toolCallId)
       return part;
     found = true;
@@ -723,7 +897,7 @@ var appendOrUpdateFinish = (message, chunk) => {
     metadata: {
       ...message.metadata,
       roundtrips: [
-        ..._nullishCoalesce(_optionalChain([message, 'access', _14 => _14.metadata, 'optionalAccess', _15 => _15.roundtrips]), () => ( [])),
+        ..._nullishCoalesce(_optionalChain([message, 'access', _15 => _15.metadata, 'optionalAccess', _16 => _16.roundtrips]), () => ( [])),
         {
           logprobs: rest.logprobs,
           usage: rest.usage
@@ -760,83 +934,181 @@ var appendOrUpdateCancel = (message) => {
   };
 };
 
-// src/runtimes/edge/streams/toolResultStream.ts
-
+// 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
+    });
+  }
+};
 
-function toolResultStream(tools, abortSignal) {
-  const toolCallExecutions = /* @__PURE__ */ new Map();
-  return new TransformStream({
+// 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 = _optionalChain([tools, 'optionalAccess', _16 => _16[toolName]]);
-          if (!tool || !tool.execute) return;
-          const args = _securejsonparse2.default.parse(argsText);
-          if (tool.parameters instanceof _zod.z.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 (_optionalChain([serverTools, 'optionalAccess', _17 => _17[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 && _optionalChain([toolChoice, 'optionalAccess', _18 => _18.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 (!_optionalChain([lastChunk, 'optionalAccess', _19 => _19.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: _optionalChain([lastChunk, 'access', _20 => _20.metadata, 'optionalAccess', _21 => _21.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;
+}
+
 
 
 
@@ -850,5 +1122,5 @@ function toolResultStream(tools, abortSignal) {
 
 
 
-exports.LanguageModelV1CallSettingsSchema = LanguageModelV1CallSettingsSchema; exports.LanguageModelConfigSchema = LanguageModelConfigSchema; exports.mergeModelConfigs = mergeModelConfigs; exports.toLanguageModelMessages = toLanguageModelMessages; exports.toCoreMessages = toCoreMessages; exports.toCoreMessage = toCoreMessage; exports.toLanguageModelTools = toLanguageModelTools; exports.PipeableTransformStream = PipeableTransformStream; exports.streamPartEncoderStream = streamPartEncoderStream; exports.runResultStream = runResultStream; exports.toolResultStream = toolResultStream;
-//# sourceMappingURL=chunk-JKRONBQK.js.map
+exports.mergeModelConfigs = mergeModelConfigs; exports.toLanguageModelMessages = toLanguageModelMessages; exports.toCoreMessages = toCoreMessages; exports.toCoreMessage = toCoreMessage; exports.toLanguageModelTools = toLanguageModelTools; exports.PipeableTransformStream = PipeableTransformStream; exports.streamPartEncoderStream = streamPartEncoderStream; exports.runResultStream = runResultStream; exports.toolResultStream = toolResultStream; exports.getEdgeRuntimeStream = getEdgeRuntimeStream; exports.getEdgeRuntimeResponse = getEdgeRuntimeResponse; exports.createEdgeRuntimeAPI = createEdgeRuntimeAPI;
+//# sourceMappingURL=chunk-BQ3MRWUV.js.map