@assistant-ui/react 0.5.20 → 0.5.22

package/dist/chunk-ZWRFAYHH.mjs

@@ -0,0 +1,819 @@
+"use client";
+
+// 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/toCoreMessages.ts
+var toCoreMessages = (message) => {
+  return message.map(toCoreMessage);
+};
+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/converters/toLanguageModelTools.ts
+import { z } 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 z.ZodType ? zodToJsonSchema(tool.parameters) : tool.parameters
+  }));
+};
+
+// src/types/ModelConfigTypes.ts
+import { z as z2 } from "zod";
+var LanguageModelV1CallSettingsSchema = z2.object({
+  maxTokens: z2.number().int().positive().optional(),
+  temperature: z2.number().optional(),
+  topP: z2.number().optional(),
+  presencePenalty: z2.number().optional(),
+  frequencyPenalty: z2.number().optional(),
+  seed: z2.number().int().optional(),
+  headers: z2.record(z2.string().optional()).optional()
+});
+var LanguageModelConfigSchema = z2.object({
+  apiKey: z2.string().optional(),
+  baseUrl: z2.string().optional(),
+  modelName: z2.string().optional()
+});
+var mergeModelConfigs = (configSet) => {
+  const configs = Array.from(configSet).map((c) => c.getModelConfig()).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+  return configs.reduce((acc, config) => {
+    if (config.system) {
+      if (acc.system) {
+        acc.system += `
+
+${config.system}`;
+      } else {
+        acc.system = config.system;
+      }
+    }
+    if (config.tools) {
+      for (const [name, tool] of Object.entries(config.tools)) {
+        if (acc.tools?.[name]) {
+          throw new Error(
+            `You tried to define a tool with the name ${name}, but it already exists.`
+          );
+        }
+        if (!acc.tools) acc.tools = {};
+        acc.tools[name] = tool;
+      }
+    }
+    if (config.config) {
+      acc.config = {
+        ...acc.config,
+        ...config.config
+      };
+    }
+    if (config.callSettings) {
+      acc.callSettings = {
+        ...acc.callSettings,
+        ...config.callSettings
+      };
+    }
+    return acc;
+  }, {});
+};
+
+// src/runtimes/edge/partial-json/parse-partial-json.ts
+import sjson 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 sjson.parse(json);
+  } catch {
+    try {
+      return sjson.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/streams/toolResultStream.ts
+import { z as z3 } from "zod";
+import sjson2 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 = 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
+              });
+              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());
+    }
+  });
+}
+
+export {
+  LanguageModelV1CallSettingsSchema,
+  LanguageModelConfigSchema,
+  mergeModelConfigs,
+  toLanguageModelMessages,
+  toCoreMessages,
+  toCoreMessage,
+  toLanguageModelTools,
+  runResultStream,
+  toolResultStream
+};
+//# sourceMappingURL=chunk-ZWRFAYHH.mjs.map