@assistant-ui/react 0.5.91 → 0.5.93

package/dist/edge.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,1146 +15,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/edge.ts
 var edge_exports = {};
 __export(edge_exports, {
-  createEdgeRuntimeAPI: () => createEdgeRuntimeAPI,
-  getEdgeRuntimeResponse: () => getEdgeRuntimeResponse
+  createEdgeRuntimeAPI: () => import_createEdgeRuntimeAPI.createEdgeRuntimeAPI,
+  getEdgeRuntimeResponse: () => import_createEdgeRuntimeAPI.getEdgeRuntimeResponse
 });
 module.exports = __toCommonJS(edge_exports);
-
-// 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: "b" /* ToolCallBegin */,
-              value: {
-                toolCallId: chunk.toolCallId,
-                toolName: chunk.toolName
-              }
-            });
-          }
-          controller.enqueue({
-            type: "c" /* ToolCallDelta */,
-            value: {
-              toolCallId: chunk.toolCallId,
-              argsTextDelta: chunk.argsTextDelta
-            }
-          });
-          break;
-        }
-        // ignore
-        case "tool-call":
-        case "response-metadata":
-          break;
-        case "tool-result": {
-          controller.enqueue({
-            type: "a" /* ToolCallResult */,
-            value: {
-              toolCallId: chunk.toolCallId,
-              result: chunk.result
-            }
-          });
-          break;
-        }
-        case "step-finish": {
-          const { type, ...rest } = chunk;
-          controller.enqueue({
-            type: "e" /* StepFinish */,
-            value: rest
-          });
-          break;
-        }
-        case "finish": {
-          const { type, ...rest } = chunk;
-          controller.enqueue({
-            type: "d" /* Finish */,
-            value: rest
-          });
-          break;
-        }
-        case "error": {
-          controller.enqueue({
-            type: "3" /* Error */,
-            value: chunk.error
-          });
-          break;
-        }
-        default: {
-          const unhandledType = chunkType;
-          throw new Error(`Unhandled chunk type: ${unhandledType}`);
-        }
-      }
-    }
-  });
-}
-
-// src/types/ModelConfigTypes.ts
-var import_zod = require("zod");
-var LanguageModelV1CallSettingsSchema = import_zod.z.object({
-  maxTokens: import_zod.z.number().int().positive().optional(),
-  temperature: import_zod.z.number().optional(),
-  topP: import_zod.z.number().optional(),
-  presencePenalty: import_zod.z.number().optional(),
-  frequencyPenalty: import_zod.z.number().optional(),
-  seed: import_zod.z.number().int().optional(),
-  headers: import_zod.z.record(import_zod.z.string().optional()).optional()
-});
-var LanguageModelConfigSchema = import_zod.z.object({
-  apiKey: import_zod.z.string().optional(),
-  baseUrl: import_zod.z.string().optional(),
-  modelName: import_zod.z.string().optional()
-});
-
-// src/runtimes/edge/EdgeRuntimeRequestOptions.ts
-var import_zod2 = require("zod");
-var LanguageModelV1FunctionToolSchema = import_zod2.z.object({
-  type: import_zod2.z.literal("function"),
-  name: import_zod2.z.string(),
-  description: import_zod2.z.string().optional(),
-  parameters: import_zod2.z.custom(
-    (val) => typeof val === "object" && val !== null
-  )
-});
-var TextContentPartSchema = import_zod2.z.object({
-  type: import_zod2.z.literal("text"),
-  text: import_zod2.z.string()
-});
-var ImageContentPartSchema = import_zod2.z.object({
-  type: import_zod2.z.literal("image"),
-  image: import_zod2.z.string()
-});
-var Unstable_AudioContentPart = import_zod2.z.object({
-  type: import_zod2.z.literal("audio"),
-  audio: import_zod2.z.object({
-    data: import_zod2.z.string(),
-    format: import_zod2.z.union([import_zod2.z.literal("mp3"), import_zod2.z.literal("wav")])
-  })
-});
-var CoreToolCallContentPartSchema = import_zod2.z.object({
-  type: import_zod2.z.literal("tool-call"),
-  toolCallId: import_zod2.z.string(),
-  toolName: import_zod2.z.string(),
-  args: import_zod2.z.record(import_zod2.z.unknown()),
-  result: import_zod2.z.unknown().optional(),
-  isError: import_zod2.z.boolean().optional()
-});
-var CoreUserMessageSchema = import_zod2.z.object({
-  role: import_zod2.z.literal("user"),
-  content: import_zod2.z.array(
-    import_zod2.z.discriminatedUnion("type", [
-      TextContentPartSchema,
-      ImageContentPartSchema,
-      Unstable_AudioContentPart
-    ])
-  ).min(1)
-});
-var CoreAssistantMessageSchema = import_zod2.z.object({
-  role: import_zod2.z.literal("assistant"),
-  content: import_zod2.z.array(
-    import_zod2.z.discriminatedUnion("type", [
-      TextContentPartSchema,
-      CoreToolCallContentPartSchema
-    ])
-  ).min(1)
-});
-var CoreSystemMessageSchema = import_zod2.z.object({
-  role: import_zod2.z.literal("system"),
-  content: import_zod2.z.tuple([TextContentPartSchema])
-});
-var CoreMessageSchema = import_zod2.z.discriminatedUnion("role", [
-  CoreSystemMessageSchema,
-  CoreUserMessageSchema,
-  CoreAssistantMessageSchema
-]);
-var EdgeRuntimeRequestOptionsSchema = import_zod2.z.object({
-  system: import_zod2.z.string().optional(),
-  messages: import_zod2.z.array(CoreMessageSchema).min(1),
-  tools: import_zod2.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
-      });
-      toolMessage.content.push({
-        type: "tool-result",
-        toolCallId: part.toolCallId,
-        toolName: part.toolName,
-        result: part.result ?? "<no result>",
-        isError: part.isError ?? false
-      });
-    },
-    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
-var import_zod3 = require("zod");
-var import_zod_to_json_schema = __toESM(require("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 import_zod3.z.ZodType ? (0, import_zod_to_json_schema.default)(tool.parameters) : tool.parameters
-  }));
-};
-
-// src/runtimes/edge/streams/toolResultStream.ts
-var import_zod4 = require("zod");
-var import_secure_json_parse = __toESM(require("secure-json-parse"));
-function toolResultStream(tools, abortSignal) {
-  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 = import_secure_json_parse.default.parse(argsText);
-          if (tool.parameters instanceof import_zod4.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 "step-finish":
-        case "finish":
-        case "error":
-        case "response-metadata":
-          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
-var import_secure_json_parse2 = __toESM(require("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 import_secure_json_parse2.default.parse(json);
-  } catch {
-    try {
-      return import_secure_json_parse2.default.parse(fixJson(json));
-    } catch {
-      return void 0;
-    }
-  }
-};
-
-// src/runtimes/edge/streams/runResultStream.ts
-function runResultStream() {
-  let message = {
-    content: [],
-    status: { type: "running" }
-  };
-  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;
-          message = appendOrUpdateToolCall(
-            message,
-            toolCallId,
-            toolName,
-            argsTextDelta
-          );
-          controller.enqueue(message);
-          break;
-        }
-        case "tool-call":
-        case "response-metadata":
-          break;
-        case "tool-result": {
-          message = appendOrUpdateToolResult(
-            message,
-            chunk.toolCallId,
-            chunk.toolName,
-            chunk.result
-          );
-          controller.enqueue(message);
-          break;
-        }
-        case "step-finish": {
-          message = appendOrUpdateStepFinish(message, chunk);
-          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, argsTextDelta) => {
-  let contentParts = message.content ?? [];
-  const contentPartIdx = contentParts.findIndex(
-    (c) => c.type === "tool-call" && c.toolCallId === toolCallId
-  );
-  let contentPart = contentPartIdx === -1 ? null : contentParts[contentPartIdx];
-  if (contentPart == null) {
-    contentPart = {
-      type: "tool-call",
-      toolCallId,
-      toolName,
-      argsText: argsTextDelta,
-      args: parsePartialJson(argsTextDelta)
-    };
-    contentParts = [...contentParts, contentPart];
-  } else {
-    const argsText = contentPart.argsText + argsTextDelta;
-    contentPart = {
-      ...contentPart,
-      argsText,
-      args: parsePartialJson(argsText)
-    };
-    contentParts = [
-      ...contentParts.slice(0, contentPartIdx),
-      contentPart,
-      ...contentParts.slice(contentPartIdx + 1)
-    ];
-  }
-  return {
-    ...message,
-    content: contentParts
-  };
-};
-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 appendOrUpdateStepFinish = (message, chunk) => {
-  const { type, ...rest } = chunk;
-  const steps = [
-    ...message.metadata?.steps ?? [],
-    {
-      usage: rest.usage
-    }
-  ];
-  return {
-    ...message,
-    metadata: {
-      ...message.metadata,
-      roundtrips: steps,
-      steps
-    }
-  };
-};
-var appendOrUpdateFinish = (message, chunk) => {
-  const { type, ...rest } = chunk;
-  const steps = [
-    ...message.metadata?.steps ?? [],
-    {
-      logprobs: rest.logprobs,
-      usage: rest.usage
-    }
-  ];
-  return {
-    ...message,
-    status: getStatus(chunk),
-    metadata: {
-      ...message.metadata,
-      roundtrips: steps,
-      steps
-    }
-  };
-};
-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;
-          }),
-          ...message.attachments.map((a) => a.content).flat()
-        ]
-      };
-    case "system":
-      return {
-        role,
-        content: message.content
-      };
-    default: {
-      const unsupportedRole = role;
-      throw new Error(`Unknown message role: ${unsupportedRole}`);
-    }
-  }
-};
-
-// 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(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.`
-      );
-    }
-  }
-  const 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;
-            const resultingMessages = [
-              ...messages,
-              toCoreMessage({
-                role: "assistant",
-                content: lastChunk.content
-              })
-            ];
-            onFinish({
-              messages: resultingMessages,
-              metadata: {
-                // TODO
-                // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
-                roundtrips: lastChunk.metadata?.steps,
-                // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
-                steps: lastChunk.metadata?.steps
-              }
-            });
-          }
-        })
-      );
-    }
-    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"
-      }
-    }
-  );
-};
-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;
-}
+var import_createEdgeRuntimeAPI = require("./runtimes/edge/createEdgeRuntimeAPI");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createEdgeRuntimeAPI,