@assistant-ui/react 0.5.19 → 0.5.21

package/dist/edge.mjs

@@ -1,3 +1,17 @@
+"use client";
+import {
+  runResultStream,
+  toCoreMessage,
+  toLanguageModelMessages,
+  toLanguageModelTools,
+  toolResultStream
+} from "./chunk-2RKUKZSZ.mjs";
+import {
+  LanguageModelConfigSchema,
+  LanguageModelV1CallSettingsSchema
+} from "./chunk-QBS6JLLN.mjs";
+import "./chunk-BJPOCE4O.mjs";
+
 // src/runtimes/edge/streams/assistantEncoderStream.ts
 function assistantEncoderStream() {
   const toolCalls = /* @__PURE__ */ new Set();
@@ -69,829 +83,65 @@ function formatStreamPart(...[code, value]) {
 `;
 }
 
-// src/types/ModelConfigTypes.ts
-import { z } from "zod";
-var LanguageModelV1CallSettingsSchema = z.object({
-  maxTokens: z.number().int().positive().optional(),
-  temperature: z.number().optional(),
-  topP: z.number().optional(),
-  presencePenalty: z.number().optional(),
-  frequencyPenalty: z.number().optional(),
-  seed: z.number().int().optional(),
-  headers: z.record(z.string().optional()).optional()
-});
-var LanguageModelConfigSchema = z.object({
-  apiKey: z.string().optional(),
-  baseUrl: z.string().optional(),
-  modelName: z.string().optional()
-});
-
 // src/runtimes/edge/EdgeRuntimeRequestOptions.ts
-import { z as z2 } from "zod";
-var LanguageModelV1FunctionToolSchema = z2.object({
-  type: z2.literal("function"),
-  name: z2.string(),
-  description: z2.string().optional(),
-  parameters: z2.custom(
+import { z } from "zod";
+var LanguageModelV1FunctionToolSchema = z.object({
+  type: z.literal("function"),
+  name: z.string(),
+  description: z.string().optional(),
+  parameters: z.custom(
     (val) => typeof val === "object" && val !== null
   )
 });
-var TextContentPartSchema = z2.object({
-  type: z2.literal("text"),
-  text: z2.string()
+var TextContentPartSchema = z.object({
+  type: z.literal("text"),
+  text: z.string()
 });
-var ImageContentPartSchema = z2.object({
-  type: z2.literal("image"),
-  image: z2.string()
+var ImageContentPartSchema = z.object({
+  type: z.literal("image"),
+  image: z.string()
 });
-var CoreToolCallContentPartSchema = z2.object({
-  type: z2.literal("tool-call"),
-  toolCallId: z2.string(),
-  toolName: z2.string(),
-  args: z2.record(z2.unknown()),
-  result: z2.unknown().optional(),
-  isError: z2.boolean().optional()
+var CoreToolCallContentPartSchema = z.object({
+  type: z.literal("tool-call"),
+  toolCallId: z.string(),
+  toolName: z.string(),
+  args: z.record(z.unknown()),
+  result: z.unknown().optional(),
+  isError: z.boolean().optional()
 });
-var CoreUserMessageSchema = z2.object({
-  role: z2.literal("user"),
-  content: z2.array(
-    z2.discriminatedUnion("type", [
+var CoreUserMessageSchema = z.object({
+  role: z.literal("user"),
+  content: z.array(
+    z.discriminatedUnion("type", [
       TextContentPartSchema,
       ImageContentPartSchema
     ])
   ).min(1)
 });
-var CoreAssistantMessageSchema = z2.object({
-  role: z2.literal("assistant"),
-  content: z2.array(
-    z2.discriminatedUnion("type", [
+var CoreAssistantMessageSchema = z.object({
+  role: z.literal("assistant"),
+  content: z.array(
+    z.discriminatedUnion("type", [
       TextContentPartSchema,
       CoreToolCallContentPartSchema
     ])
   ).min(1)
 });
-var CoreSystemMessageSchema = z2.object({
-  role: z2.literal("system"),
-  content: z2.tuple([TextContentPartSchema])
+var CoreSystemMessageSchema = z.object({
+  role: z.literal("system"),
+  content: z.tuple([TextContentPartSchema])
 });
-var CoreMessageSchema = z2.discriminatedUnion("role", [
+var CoreMessageSchema = z.discriminatedUnion("role", [
   CoreSystemMessageSchema,
   CoreUserMessageSchema,
   CoreAssistantMessageSchema
 ]);
-var EdgeRuntimeRequestOptionsSchema = z2.object({
-  system: z2.string().optional(),
-  messages: z2.array(CoreMessageSchema).min(1),
-  tools: z2.array(LanguageModelV1FunctionToolSchema).optional()
+var EdgeRuntimeRequestOptionsSchema = z.object({
+  system: z.string().optional(),
+  messages: z.array(CoreMessageSchema).min(1),
+  tools: z.array(LanguageModelV1FunctionToolSchema).optional()
 }).merge(LanguageModelV1CallSettingsSchema).merge(LanguageModelConfigSchema);
 
-// src/runtimes/edge/converters/toLanguageModelMessages.ts
-var assistantMessageSplitter = () => {
-  const stash = [];
-  let assistantMessage = {
-    role: "assistant",
-    content: []
-  };
-  let toolMessage = {
-    role: "tool",
-    content: []
-  };
-  return {
-    addTextContentPart: (part) => {
-      if (toolMessage.content.length > 0) {
-        stash.push(assistantMessage);
-        stash.push(toolMessage);
-        assistantMessage = {
-          role: "assistant",
-          content: []
-        };
-        toolMessage = {
-          role: "tool",
-          content: []
-        };
-      }
-      assistantMessage.content.push(part);
-    },
-    addToolCallPart: (part) => {
-      assistantMessage.content.push({
-        type: "tool-call",
-        toolCallId: part.toolCallId,
-        toolName: part.toolName,
-        args: part.args
-      });
-      if (part.result) {
-        toolMessage.content.push({
-          type: "tool-result",
-          toolCallId: part.toolCallId,
-          toolName: part.toolName,
-          result: part.result
-          // isError
-        });
-      }
-    },
-    getMessages: () => {
-      if (toolMessage.content.length > 0) {
-        return [...stash, assistantMessage, toolMessage];
-      }
-      return [...stash, assistantMessage];
-    }
-  };
-};
-function toLanguageModelMessages(message) {
-  return message.flatMap((message2) => {
-    const role = message2.role;
-    switch (role) {
-      case "system": {
-        return [{ role: "system", content: message2.content[0].text }];
-      }
-      case "user": {
-        const msg = {
-          role: "user",
-          content: message2.content.map(
-            (part) => {
-              const type = part.type;
-              switch (type) {
-                case "text": {
-                  return part;
-                }
-                case "image": {
-                  return {
-                    type: "image",
-                    image: new URL(part.image)
-                  };
-                }
-                default: {
-                  const unhandledType = type;
-                  throw new Error(
-                    `Unspported content part type: ${unhandledType}`
-                  );
-                }
-              }
-            }
-          )
-        };
-        return [msg];
-      }
-      case "assistant": {
-        const splitter = assistantMessageSplitter();
-        for (const part of message2.content) {
-          const type = part.type;
-          switch (type) {
-            case "text": {
-              splitter.addTextContentPart(part);
-              break;
-            }
-            case "tool-call": {
-              splitter.addToolCallPart(part);
-              break;
-            }
-            default: {
-              const unhandledType = type;
-              throw new Error(`Unhandled content part type: ${unhandledType}`);
-            }
-          }
-        }
-        return splitter.getMessages();
-      }
-      default: {
-        const unhandledRole = role;
-        throw new Error(`Unknown message role: ${unhandledRole}`);
-      }
-    }
-  });
-}
-
-// src/runtimes/edge/converters/toLanguageModelTools.ts
-import { z as z3 } from "zod";
-import zodToJsonSchema from "zod-to-json-schema";
-var toLanguageModelTools = (tools) => {
-  return Object.entries(tools).map(([name, tool]) => ({
-    type: "function",
-    name,
-    ...tool.description ? { description: tool.description } : void 0,
-    parameters: tool.parameters instanceof z3.ZodType ? zodToJsonSchema(tool.parameters) : tool.parameters
-  }));
-};
-
-// src/runtimes/edge/streams/toolResultStream.ts
-import { z as z4 } from "zod";
-import sjson from "secure-json-parse";
-function toolResultStream(tools) {
-  const toolCallExecutions = /* @__PURE__ */ new Map();
-  return 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 = 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 () => {
-                  try {
-                    const result2 = await tool.execute(args);
-                    controller.enqueue({
-                      type: "tool-result",
-                      toolCallType,
-                      toolCallId,
-                      toolName,
-                      result: result2
-                    });
-                  } catch (error) {
-                    console.error("Error: ", error);
-                    controller.enqueue({
-                      type: "tool-result",
-                      toolCallType,
-                      toolCallId,
-                      toolName,
-                      result: "Error: " + error,
-                      isError: true
-                    });
-                  } finally {
-                    toolCallExecutions.delete(toolCallId);
-                  }
-                })()
-              );
-            }
-          }
-          break;
-        }
-        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());
-    }
-  });
-}
-
-// src/runtimes/edge/partial-json/parse-partial-json.ts
-import sjson2 from "secure-json-parse";
-
-// src/runtimes/edge/partial-json/fix-json.ts
-function fixJson(input) {
-  const stack = ["ROOT"];
-  let lastValidIndex = -1;
-  let literalStart = null;
-  function processValueStart(char, i, swapState) {
-    {
-      switch (char) {
-        case '"': {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_STRING");
-          break;
-        }
-        case "f":
-        case "t":
-        case "n": {
-          lastValidIndex = i;
-          literalStart = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_LITERAL");
-          break;
-        }
-        case "-": {
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_NUMBER");
-          break;
-        }
-        case "0":
-        case "1":
-        case "2":
-        case "3":
-        case "4":
-        case "5":
-        case "6":
-        case "7":
-        case "8":
-        case "9": {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_NUMBER");
-          break;
-        }
-        case "{": {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_OBJECT_START");
-          break;
-        }
-        case "[": {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_ARRAY_START");
-          break;
-        }
-      }
-    }
-  }
-  function processAfterObjectValue(char, i) {
-    switch (char) {
-      case ",": {
-        stack.pop();
-        stack.push("INSIDE_OBJECT_AFTER_COMMA");
-        break;
-      }
-      case "}": {
-        lastValidIndex = i;
-        stack.pop();
-        break;
-      }
-    }
-  }
-  function processAfterArrayValue(char, i) {
-    switch (char) {
-      case ",": {
-        stack.pop();
-        stack.push("INSIDE_ARRAY_AFTER_COMMA");
-        break;
-      }
-      case "]": {
-        lastValidIndex = i;
-        stack.pop();
-        break;
-      }
-    }
-  }
-  for (let i = 0; i < input.length; i++) {
-    const char = input[i];
-    const currentState = stack[stack.length - 1];
-    switch (currentState) {
-      case "ROOT":
-        processValueStart(char, i, "FINISH");
-        break;
-      case "INSIDE_OBJECT_START": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_KEY");
-            break;
-          }
-          case "}": {
-            lastValidIndex = i;
-            stack.pop();
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_AFTER_COMMA": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_KEY");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_KEY": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_AFTER_KEY");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_AFTER_KEY": {
-        switch (char) {
-          case ":": {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_BEFORE_VALUE");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_BEFORE_VALUE": {
-        processValueStart(char, i, "INSIDE_OBJECT_AFTER_VALUE");
-        break;
-      }
-      case "INSIDE_OBJECT_AFTER_VALUE": {
-        processAfterObjectValue(char, i);
-        break;
-      }
-      case "INSIDE_STRING": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            lastValidIndex = i;
-            break;
-          }
-          case "\\": {
-            stack.push("INSIDE_STRING_ESCAPE");
-            break;
-          }
-          default: {
-            lastValidIndex = i;
-          }
-        }
-        break;
-      }
-      case "INSIDE_ARRAY_START": {
-        switch (char) {
-          case "]": {
-            lastValidIndex = i;
-            stack.pop();
-            break;
-          }
-          default: {
-            lastValidIndex = i;
-            processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_ARRAY_AFTER_VALUE": {
-        switch (char) {
-          case ",": {
-            stack.pop();
-            stack.push("INSIDE_ARRAY_AFTER_COMMA");
-            break;
-          }
-          case "]": {
-            lastValidIndex = i;
-            stack.pop();
-            break;
-          }
-          default: {
-            lastValidIndex = i;
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_ARRAY_AFTER_COMMA": {
-        processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
-        break;
-      }
-      case "INSIDE_STRING_ESCAPE": {
-        stack.pop();
-        lastValidIndex = i;
-        break;
-      }
-      case "INSIDE_NUMBER": {
-        switch (char) {
-          case "0":
-          case "1":
-          case "2":
-          case "3":
-          case "4":
-          case "5":
-          case "6":
-          case "7":
-          case "8":
-          case "9": {
-            lastValidIndex = i;
-            break;
-          }
-          case "e":
-          case "E":
-          case "-":
-          case ".": {
-            break;
-          }
-          case ",": {
-            stack.pop();
-            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
-              processAfterArrayValue(char, i);
-            }
-            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
-              processAfterObjectValue(char, i);
-            }
-            break;
-          }
-          case "}": {
-            stack.pop();
-            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
-              processAfterObjectValue(char, i);
-            }
-            break;
-          }
-          case "]": {
-            stack.pop();
-            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
-              processAfterArrayValue(char, i);
-            }
-            break;
-          }
-          default: {
-            stack.pop();
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_LITERAL": {
-        const partialLiteral = input.substring(literalStart, i + 1);
-        if (!"false".startsWith(partialLiteral) && !"true".startsWith(partialLiteral) && !"null".startsWith(partialLiteral)) {
-          stack.pop();
-          if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
-            processAfterObjectValue(char, i);
-          } else if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
-            processAfterArrayValue(char, i);
-          }
-        } else {
-          lastValidIndex = i;
-        }
-        break;
-      }
-    }
-  }
-  let result = input.slice(0, lastValidIndex + 1);
-  for (let i = stack.length - 1; i >= 0; i--) {
-    const state = stack[i];
-    switch (state) {
-      case "INSIDE_STRING": {
-        result += '"';
-        break;
-      }
-      case "INSIDE_OBJECT_KEY":
-      case "INSIDE_OBJECT_AFTER_KEY":
-      case "INSIDE_OBJECT_AFTER_COMMA":
-      case "INSIDE_OBJECT_START":
-      case "INSIDE_OBJECT_BEFORE_VALUE":
-      case "INSIDE_OBJECT_AFTER_VALUE": {
-        result += "}";
-        break;
-      }
-      case "INSIDE_ARRAY_START":
-      case "INSIDE_ARRAY_AFTER_COMMA":
-      case "INSIDE_ARRAY_AFTER_VALUE": {
-        result += "]";
-        break;
-      }
-      case "INSIDE_LITERAL": {
-        const partialLiteral = input.substring(literalStart, input.length);
-        if ("true".startsWith(partialLiteral)) {
-          result += "true".slice(partialLiteral.length);
-        } else if ("false".startsWith(partialLiteral)) {
-          result += "false".slice(partialLiteral.length);
-        } else if ("null".startsWith(partialLiteral)) {
-          result += "null".slice(partialLiteral.length);
-        }
-      }
-    }
-  }
-  return result;
-}
-
-// src/runtimes/edge/partial-json/parse-partial-json.ts
-var parsePartialJson = (json) => {
-  try {
-    return sjson2.parse(json);
-  } catch {
-    try {
-      return sjson2.parse(fixJson(json));
-    } catch {
-      return void 0;
-    }
-  }
-};
-
-// src/runtimes/edge/streams/runResultStream.ts
-function runResultStream() {
-  let message = {
-    content: [],
-    status: { type: "running" }
-  };
-  const currentToolCall = { toolCallId: "", argsText: "" };
-  return new TransformStream({
-    transform(chunk, controller) {
-      const chunkType = chunk.type;
-      switch (chunkType) {
-        case "text-delta": {
-          message = appendOrUpdateText(message, chunk.textDelta);
-          controller.enqueue(message);
-          break;
-        }
-        case "tool-call-delta": {
-          const { toolCallId, toolName, argsTextDelta } = chunk;
-          if (currentToolCall.toolCallId !== toolCallId) {
-            currentToolCall.toolCallId = toolCallId;
-            currentToolCall.argsText = argsTextDelta;
-          } else {
-            currentToolCall.argsText += argsTextDelta;
-          }
-          message = appendOrUpdateToolCall(
-            message,
-            toolCallId,
-            toolName,
-            currentToolCall.argsText
-          );
-          controller.enqueue(message);
-          break;
-        }
-        case "tool-call": {
-          break;
-        }
-        case "tool-result": {
-          message = appendOrUpdateToolResult(
-            message,
-            chunk.toolCallId,
-            chunk.toolName,
-            chunk.result
-          );
-          controller.enqueue(message);
-          break;
-        }
-        case "finish": {
-          message = appendOrUpdateFinish(message, chunk);
-          controller.enqueue(message);
-          break;
-        }
-        case "error": {
-          if (chunk.error instanceof Error && chunk.error.name === "AbortError") {
-            message = appendOrUpdateCancel(message);
-            controller.enqueue(message);
-            break;
-          } else {
-            throw chunk.error;
-          }
-        }
-        default: {
-          const unhandledType = chunkType;
-          throw new Error(`Unhandled chunk type: ${unhandledType}`);
-        }
-      }
-    }
-  });
-}
-var appendOrUpdateText = (message, textDelta) => {
-  let contentParts = message.content;
-  let contentPart = message.content.at(-1);
-  if (contentPart?.type !== "text") {
-    contentPart = { type: "text", text: textDelta };
-  } else {
-    contentParts = contentParts.slice(0, -1);
-    contentPart = { type: "text", text: contentPart.text + textDelta };
-  }
-  return {
-    ...message,
-    content: contentParts.concat([contentPart])
-  };
-};
-var appendOrUpdateToolCall = (message, toolCallId, toolName, argsText) => {
-  let contentParts = message.content;
-  let contentPart = message.content.at(-1);
-  if (contentPart?.type !== "tool-call" || contentPart.toolCallId !== toolCallId) {
-    contentPart = {
-      type: "tool-call",
-      toolCallId,
-      toolName,
-      argsText,
-      args: parsePartialJson(argsText)
-    };
-  } else {
-    contentParts = contentParts.slice(0, -1);
-    contentPart = {
-      ...contentPart,
-      argsText,
-      args: parsePartialJson(argsText)
-    };
-  }
-  return {
-    ...message,
-    content: contentParts.concat([contentPart])
-  };
-};
-var appendOrUpdateToolResult = (message, toolCallId, toolName, result) => {
-  let found = false;
-  const newContentParts = message.content.map((part) => {
-    if (part.type !== "tool-call" || part.toolCallId !== toolCallId)
-      return part;
-    found = true;
-    if (part.toolName !== toolName)
-      throw new Error(
-        `Tool call ${toolCallId} found with tool name ${part.toolName}, but expected ${toolName}`
-      );
-    return {
-      ...part,
-      result
-    };
-  });
-  if (!found)
-    throw new Error(
-      `Received tool result for unknown tool call "${toolName}" / "${toolCallId}". This is likely an internal bug in assistant-ui.`
-    );
-  return {
-    ...message,
-    content: newContentParts
-  };
-};
-var appendOrUpdateFinish = (message, chunk) => {
-  const { type, ...rest } = chunk;
-  return {
-    ...message,
-    status: getStatus(chunk),
-    roundtrips: [
-      ...message.roundtrips ?? [],
-      {
-        logprobs: rest.logprobs,
-        usage: rest.usage
-      }
-    ]
-  };
-};
-var getStatus = (chunk) => {
-  if (chunk.finishReason === "tool-calls") {
-    return {
-      type: "requires-action",
-      reason: "tool-calls"
-    };
-  } else if (chunk.finishReason === "stop" || chunk.finishReason === "unknown") {
-    return {
-      type: "complete",
-      reason: chunk.finishReason
-    };
-  } else {
-    return {
-      type: "incomplete",
-      reason: chunk.finishReason
-    };
-  }
-};
-var appendOrUpdateCancel = (message) => {
-  return {
-    ...message,
-    status: {
-      type: "incomplete",
-      reason: "cancelled"
-    }
-  };
-};
-
-// src/runtimes/edge/converters/toCoreMessages.ts
-var toCoreMessage = (message) => {
-  const role = message.role;
-  switch (role) {
-    case "assistant":
-      return {
-        role,
-        content: message.content.map((part) => {
-          if (part.type === "ui") throw new Error("UI parts are not supported");
-          if (part.type === "tool-call") {
-            const { argsText, ...rest } = part;
-            return rest;
-          }
-          return part;
-        })
-      };
-    case "user":
-      return {
-        role,
-        content: message.content.map((part) => {
-          if (part.type === "ui") throw new Error("UI parts are not supported");
-          return part;
-        })
-      };
-    case "system":
-      return {
-        role,
-        content: message.content
-      };
-    default: {
-      const unsupportedRole = role;
-      throw new Error(`Unknown message role: ${unsupportedRole}`);
-    }
-  }
-};
-
 // src/runtimes/edge/createEdgeRuntimeAPI.ts
 var voidStream = () => {
   return new WritableStream({