ai 3.0.8 → 3.1.0-canary.0

package/core/dist/index.mjs

@@ -0,0 +1,1479 @@
+// core/util/uint8-utils.ts
+function convertBase64ToUint8Array(base64String) {
+  const base64Url = base64String.replace(/-/g, "+").replace(/_/g, "/");
+  const latin1string = globalThis.atob(base64Url);
+  return Uint8Array.from(latin1string, (byte) => byte.codePointAt(0));
+}
+function convertUint8ArrayToBase64(array) {
+  let latin1string = "";
+  for (const value of array) {
+    latin1string += String.fromCodePoint(value);
+  }
+  return globalThis.btoa(latin1string);
+}
+
+// core/prompt/data-content.ts
+function convertDataContentToBase64String(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (content instanceof ArrayBuffer) {
+    return convertUint8ArrayToBase64(new Uint8Array(content));
+  }
+  return convertUint8ArrayToBase64(content);
+}
+function convertDataContentToUint8Array(content) {
+  if (content instanceof Uint8Array) {
+    return content;
+  }
+  if (typeof content === "string") {
+    return convertBase64ToUint8Array(content);
+  }
+  if (content instanceof ArrayBuffer) {
+    return new Uint8Array(content);
+  }
+  throw new Error(
+    `Invalid data content. Expected a string, Uint8Array, ArrayBuffer, or Buffer, but got ${typeof content}.`
+  );
+}
+
+// core/prompt/convert-to-language-model-prompt.ts
+function convertToLanguageModelPrompt({
+  system,
+  prompt,
+  messages
+}) {
+  if (prompt == null && messages == null) {
+    throw new Error("prompt or messages must be defined");
+  }
+  if (prompt != null && messages != null) {
+    throw new Error("prompt and messages cannot be defined at the same time");
+  }
+  const languageModelMessages = [];
+  if (system != null) {
+    languageModelMessages.push({ role: "system", content: system });
+  }
+  if (typeof prompt === "string") {
+    languageModelMessages.push({
+      role: "user",
+      content: [{ type: "text", text: prompt }]
+    });
+  } else {
+    messages = messages;
+    languageModelMessages.push(
+      ...messages.map((message) => {
+        switch (message.role) {
+          case "user": {
+            if (typeof message.content === "string") {
+              return {
+                role: "user",
+                content: [{ type: "text", text: message.content }]
+              };
+            }
+            return {
+              role: "user",
+              content: message.content.map(
+                (part) => {
+                  switch (part.type) {
+                    case "text": {
+                      return part;
+                    }
+                    case "image": {
+                      return {
+                        type: "image",
+                        image: convertDataContentToUint8Array(part.image),
+                        mimeType: part.mimeType
+                      };
+                    }
+                  }
+                }
+              )
+            };
+          }
+          case "assistant": {
+            if (typeof message.content === "string") {
+              return {
+                role: "assistant",
+                content: [{ type: "text", text: message.content }]
+              };
+            }
+            return { role: "assistant", content: message.content };
+          }
+          case "tool": {
+            return message;
+          }
+        }
+      })
+    );
+  }
+  return languageModelMessages;
+}
+
+// core/prompt/get-input-format.ts
+function getInputFormat({
+  prompt,
+  messages
+}) {
+  if (prompt == null && messages == null) {
+    throw new Error("prompt or messages must be defined");
+  }
+  if (prompt != null && messages != null) {
+    throw new Error("prompt and messages cannot be defined at the same time");
+  }
+  return prompt != null ? "prompt" : "messages";
+}
+
+// core/schema/parse-json.ts
+import SecureJSON from "secure-json-parse";
+
+// core/language-model/errors/get-error-message.ts
+function getErrorMessage(error) {
+  if (error == null) {
+    return "unknown error";
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return JSON.stringify(error);
+}
+
+// core/language-model/errors/json-parse-error.ts
+var JSONParseError = class extends Error {
+  constructor({ text, cause }) {
+    super(
+      `JSON parsing failed: Text: ${text}.
+Error message: ${getErrorMessage(cause)}`
+    );
+    this.name = "JSONParseError";
+    this.cause = cause;
+    this.text = text;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      cause: this.cause,
+      stack: this.stack,
+      valueText: this.text
+    };
+  }
+};
+
+// core/language-model/errors/type-validation-error.ts
+var TypeValidationError = class extends Error {
+  constructor({ value, cause }) {
+    super(
+      `Type validation failed: Value: ${JSON.stringify(value)}.
+Error message: ${getErrorMessage(cause)}`
+    );
+    this.name = "TypeValidationError";
+    this.cause = cause;
+    this.value = value;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      cause: this.cause,
+      stack: this.stack,
+      value: this.value
+    };
+  }
+};
+
+// core/schema/validate-types.ts
+function safeValidateTypes({
+  value,
+  schema
+}) {
+  try {
+    const validationResult = schema.validate(value);
+    if (validationResult.success) {
+      return validationResult;
+    }
+    return {
+      success: false,
+      error: new TypeValidationError({
+        value,
+        cause: validationResult.error
+      })
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof TypeValidationError ? error : new TypeValidationError({ value, cause: error })
+    };
+  }
+}
+
+// core/schema/parse-json.ts
+function safeParseJSON({
+  text,
+  schema
+}) {
+  try {
+    const value = SecureJSON.parse(text);
+    if (schema == null) {
+      return {
+        success: true,
+        value
+      };
+    }
+    return safeValidateTypes({ value, schema });
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof JSONParseError ? error : new JSONParseError({ text, cause: error })
+    };
+  }
+}
+
+// core/schema/zod-schema.ts
+import { zodToJsonSchema } from "zod-to-json-schema";
+var ZodSchema = class {
+  constructor(zodSchema) {
+    this.zodSchema = zodSchema;
+  }
+  validate(value) {
+    const result = this.zodSchema.safeParse(value);
+    return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+  }
+  getJsonSchema() {
+    return zodToJsonSchema(this.zodSchema);
+  }
+};
+
+// core/generate-object/inject-json-schema-into-system.ts
+var DEFAULT_SCHEMA_PREFIX = "JSON schema:";
+var DEFAULT_SCHEMA_SUFFIX = "You MUST answer with a JSON object that matches the JSON schema above.";
+function injectJsonSchemaIntoSystem({
+  system,
+  schema,
+  schemaPrefix = DEFAULT_SCHEMA_PREFIX,
+  schemaSuffix = DEFAULT_SCHEMA_SUFFIX
+}) {
+  return [
+    system,
+    system != null ? "" : null,
+    // add a newline if system is not null
+    schemaPrefix,
+    JSON.stringify(schema),
+    schemaSuffix
+  ].filter((line) => line != null).join("\n");
+}
+
+// core/language-model/errors/no-object-generated-error.ts
+var NoTextGeneratedError = class extends Error {
+  constructor() {
+    super(`No text generated.`);
+    this.name = "NoTextGeneratedError";
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      cause: this.cause,
+      message: this.message,
+      stack: this.stack
+    };
+  }
+};
+
+// core/generate-object/generate-object.ts
+async function generateObject({
+  model,
+  schema: zodSchema,
+  mode,
+  system,
+  prompt,
+  messages,
+  ...settings
+}) {
+  var _a, _b;
+  const schema = new ZodSchema(zodSchema);
+  const jsonSchema = schema.getJsonSchema();
+  let result;
+  mode = mode != null ? mode : model.defaultObjectGenerationMode;
+  switch (mode) {
+    case "json": {
+      const generateResult = await model.doGenerate({
+        mode: { type: "object-json" },
+        ...settings,
+        inputFormat: getInputFormat({ prompt, messages }),
+        prompt: convertToLanguageModelPrompt({
+          system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
+          prompt,
+          messages
+        })
+      });
+      if (generateResult.text === void 0) {
+        throw new NoTextGeneratedError();
+      }
+      result = generateResult.text;
+      break;
+    }
+    case "grammar": {
+      const generateResult = await model.doGenerate({
+        mode: { type: "object-grammar", schema: jsonSchema },
+        ...settings,
+        inputFormat: getInputFormat({ prompt, messages }),
+        prompt: convertToLanguageModelPrompt({
+          system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
+          prompt,
+          messages
+        })
+      });
+      if (generateResult.text === void 0) {
+        throw new NoTextGeneratedError();
+      }
+      result = generateResult.text;
+      break;
+    }
+    case "tool": {
+      const generateResult = await model.doGenerate({
+        mode: {
+          type: "object-tool",
+          tool: {
+            type: "function",
+            name: "json",
+            description: "Respond with a JSON object.",
+            parameters: jsonSchema
+          }
+        },
+        ...settings,
+        inputFormat: getInputFormat({ prompt, messages }),
+        prompt: convertToLanguageModelPrompt({ system, prompt, messages })
+      });
+      const functionArgs = (_b = (_a = generateResult.toolCalls) == null ? void 0 : _a[0]) == null ? void 0 : _b.args;
+      if (functionArgs === void 0) {
+        throw new NoTextGeneratedError();
+      }
+      result = functionArgs;
+      break;
+    }
+    case void 0: {
+      throw new Error("Model does not have a default object generation mode.");
+    }
+    default: {
+      const _exhaustiveCheck = mode;
+      throw new Error(`Unsupported mode: ${_exhaustiveCheck}`);
+    }
+  }
+  const parseResult = safeParseJSON({ text: result, schema });
+  if (!parseResult.success) {
+    throw parseResult.error;
+  }
+  return new GenerateObjectResult({
+    object: parseResult.value
+  });
+}
+var GenerateObjectResult = class {
+  constructor(options) {
+    this.object = options.object;
+  }
+};
+
+// core/util/is-deep-equal-data.ts
+function isDeepEqualData(obj1, obj2) {
+  if (obj1 === obj2)
+    return true;
+  if (obj1 == null || obj2 == null)
+    return false;
+  if (typeof obj1 !== "object" && typeof obj2 !== "object")
+    return obj1 === obj2;
+  if (obj1.constructor !== obj2.constructor)
+    return false;
+  if (obj1 instanceof Date && obj2 instanceof Date) {
+    return obj1.getTime() === obj2.getTime();
+  }
+  if (Array.isArray(obj1)) {
+    if (obj1.length !== obj2.length)
+      return false;
+    for (let i = 0; i < obj1.length; i++) {
+      if (!isDeepEqualData(obj1[i], obj2[i]))
+        return false;
+    }
+    return true;
+  }
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length)
+    return false;
+  for (const key of keys1) {
+    if (!keys2.includes(key))
+      return false;
+    if (!isDeepEqualData(obj1[key], obj2[key]))
+      return false;
+  }
+  return true;
+}
+
+// core/util/parse-partial-json.ts
+import SecureJSON2 from "secure-json-parse";
+
+// core/util/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 "}": {
+            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;
+}
+
+// core/util/parse-partial-json.ts
+function parsePartialJson(jsonText) {
+  if (jsonText == null) {
+    return void 0;
+  }
+  try {
+    return SecureJSON2.parse(jsonText);
+  } catch (ignored) {
+    try {
+      const fixedJsonText = fixJson(jsonText);
+      return SecureJSON2.parse(fixedJsonText);
+    } catch (ignored2) {
+    }
+  }
+  return void 0;
+}
+
+// core/generate-object/stream-object.ts
+async function streamObject({
+  model,
+  schema: zodSchema,
+  mode,
+  system,
+  prompt,
+  messages,
+  ...settings
+}) {
+  const schema = new ZodSchema(zodSchema);
+  const jsonSchema = schema.getJsonSchema();
+  let modelStream;
+  mode = mode != null ? mode : model.defaultObjectGenerationMode;
+  switch (mode) {
+    case "json": {
+      const { stream, warnings } = await model.doStream({
+        mode: { type: "object-json" },
+        ...settings,
+        inputFormat: getInputFormat({ prompt, messages }),
+        prompt: convertToLanguageModelPrompt({
+          system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
+          prompt,
+          messages
+        })
+      });
+      modelStream = stream.pipeThrough(
+        new TransformStream({
+          transform(chunk, controller) {
+            switch (chunk.type) {
+              case "text-delta":
+                controller.enqueue(chunk.textDelta);
+                break;
+              case "error":
+                controller.enqueue(chunk);
+                break;
+            }
+          }
+        })
+      );
+      break;
+    }
+    case "grammar": {
+      const { stream, warnings } = await model.doStream({
+        mode: { type: "object-grammar", schema: jsonSchema },
+        ...settings,
+        inputFormat: getInputFormat({ prompt, messages }),
+        prompt: convertToLanguageModelPrompt({
+          system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
+          prompt,
+          messages
+        })
+      });
+      modelStream = stream.pipeThrough(
+        new TransformStream({
+          transform(chunk, controller) {
+            switch (chunk.type) {
+              case "text-delta":
+                controller.enqueue(chunk.textDelta);
+                break;
+              case "error":
+                controller.enqueue(chunk);
+                break;
+            }
+          }
+        })
+      );
+      break;
+    }
+    case "tool": {
+      const { stream, warnings } = await model.doStream({
+        mode: {
+          type: "object-tool",
+          tool: {
+            type: "function",
+            name: "json",
+            description: "Respond with a JSON object.",
+            parameters: jsonSchema
+          }
+        },
+        ...settings,
+        inputFormat: getInputFormat({ prompt, messages }),
+        prompt: convertToLanguageModelPrompt({ system, prompt, messages })
+      });
+      modelStream = stream.pipeThrough(
+        new TransformStream({
+          transform(chunk, controller) {
+            switch (chunk.type) {
+              case "tool-call-delta":
+                controller.enqueue(chunk.argsTextDelta);
+                break;
+              case "error":
+                controller.enqueue(chunk);
+                break;
+            }
+          }
+        })
+      );
+      break;
+    }
+    case void 0: {
+      throw new Error("Model does not have a default object generation mode.");
+    }
+    default: {
+      const _exhaustiveCheck = mode;
+      throw new Error(`Unsupported mode: ${_exhaustiveCheck}`);
+    }
+  }
+  return new StreamObjectResult(modelStream);
+}
+var StreamObjectResult = class {
+  constructor(modelStream) {
+    let accumulatedText = "";
+    let latestObject = void 0;
+    this.objectStream = {
+      [Symbol.asyncIterator]() {
+        const reader = modelStream.getReader();
+        return {
+          next: async () => {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) {
+                return { value: null, done: true };
+              }
+              if (typeof value === "string") {
+                accumulatedText += value;
+                const currentObject = parsePartialJson(
+                  accumulatedText
+                );
+                if (!isDeepEqualData(latestObject, currentObject)) {
+                  latestObject = currentObject;
+                  return { value: currentObject, done: false };
+                }
+              }
+            }
+          }
+        };
+      }
+    };
+  }
+};
+
+// core/generate-text/generate-text.ts
+import zodToJsonSchema2 from "zod-to-json-schema";
+
+// core/generate-text/tool-call.ts
+function parseToolCall({
+  toolCall,
+  tools
+}) {
+  const toolName = toolCall.toolName;
+  if (tools == null) {
+    throw new Error(`Tool not found: ${toolName}`);
+  }
+  const tool2 = tools[toolName];
+  if (tool2 == null) {
+    throw new Error(`Tool not found: ${toolName}`);
+  }
+  const parseResult = safeParseJSON({
+    text: toolCall.args,
+    schema: new ZodSchema(tool2.parameters)
+  });
+  if (parseResult.success === false) {
+    throw new Error(
+      `Tool call ${toolName} has invalid arguments: ${parseResult.error}`
+    );
+  }
+  const toolArgs = parseResult.value;
+  return {
+    toolCallId: toolCall.toolCallId,
+    toolName,
+    args: toolArgs
+  };
+}
+
+// core/generate-text/generate-text.ts
+async function generateText({
+  model,
+  tools,
+  system,
+  prompt,
+  messages,
+  ...settings
+}) {
+  var _a, _b;
+  const modelResponse = await model.doGenerate({
+    mode: {
+      type: "regular",
+      tools: tools == null ? void 0 : Object.entries(tools).map(([name, tool2]) => ({
+        type: "function",
+        name,
+        description: tool2.description,
+        parameters: zodToJsonSchema2(tool2.parameters)
+      }))
+    },
+    ...settings,
+    inputFormat: getInputFormat({ prompt, messages }),
+    prompt: convertToLanguageModelPrompt({
+      system,
+      prompt,
+      messages
+    })
+  });
+  const toolCalls = [];
+  for (const modelToolCall of (_a = modelResponse.toolCalls) != null ? _a : []) {
+    toolCalls.push(parseToolCall({ toolCall: modelToolCall, tools }));
+  }
+  const toolResults = tools == null ? [] : await executeTools({ toolCalls, tools });
+  return new GenerateTextResult({
+    // Always return a string so that the caller doesn't have to check for undefined.
+    // If they need to check if the model did not return any text,
+    // they can check the length of the string:
+    text: (_b = modelResponse.text) != null ? _b : "",
+    toolCalls,
+    toolResults
+  });
+}
+async function executeTools({
+  toolCalls,
+  tools
+}) {
+  const toolResults = await Promise.all(
+    toolCalls.map(async (toolCall) => {
+      const tool2 = tools[toolCall.toolName];
+      if ((tool2 == null ? void 0 : tool2.execute) == null) {
+        return void 0;
+      }
+      const result = await tool2.execute(toolCall.args);
+      return {
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        args: toolCall.args,
+        result
+      };
+    })
+  );
+  return toolResults.filter(
+    (result) => result != null
+  );
+}
+var GenerateTextResult = class {
+  constructor(options) {
+    this.text = options.text;
+    this.toolCalls = options.toolCalls;
+    this.toolResults = options.toolResults;
+  }
+};
+
+// core/generate-text/stream-text.ts
+import zodToJsonSchema3 from "zod-to-json-schema";
+
+// core/generate-text/run-tools-transformation.ts
+import { nanoid } from "nanoid";
+function runToolsTransformation({
+  tools,
+  generatorStream
+}) {
+  let canClose = false;
+  const outstandingToolCalls = /* @__PURE__ */ new Set();
+  let toolResultsStreamController = null;
+  const toolResultsStream = new ReadableStream({
+    start(controller) {
+      toolResultsStreamController = controller;
+    }
+  });
+  const forwardStream = new TransformStream({
+    transform(chunk, controller) {
+      const chunkType = chunk.type;
+      switch (chunkType) {
+        case "text-delta":
+        case "error": {
+          controller.enqueue(chunk);
+          break;
+        }
+        case "tool-call": {
+          const toolName = chunk.toolName;
+          if (tools == null) {
+            toolResultsStreamController.enqueue({
+              type: "error",
+              error: `Tool ${chunk.toolName} not found (no tools provided)`
+            });
+            break;
+          }
+          const tool2 = tools[toolName];
+          if (tool2 == null) {
+            toolResultsStreamController.enqueue({
+              type: "error",
+              error: `Tool ${chunk.toolName} not found`
+            });
+            break;
+          }
+          const toolCall = parseToolCall({
+            toolCall: chunk,
+            tools
+          });
+          controller.enqueue({
+            type: "tool-call",
+            ...toolCall
+          });
+          if (tool2.execute != null) {
+            const toolExecutionId = nanoid();
+            outstandingToolCalls.add(toolExecutionId);
+            tool2.execute(toolCall.args).then(
+              (result) => {
+                toolResultsStreamController.enqueue({
+                  type: "tool-result",
+                  ...toolCall,
+                  result
+                });
+                outstandingToolCalls.delete(toolExecutionId);
+                if (canClose && outstandingToolCalls.size === 0) {
+                  toolResultsStreamController.close();
+                }
+              },
+              (error) => {
+                toolResultsStreamController.enqueue({
+                  type: "error",
+                  error
+                });
+                outstandingToolCalls.delete(toolExecutionId);
+                if (canClose && outstandingToolCalls.size === 0) {
+                  toolResultsStreamController.close();
+                }
+              }
+            );
+          }
+          break;
+        }
+        case "tool-call-delta": {
+          break;
+        }
+        default: {
+          const _exhaustiveCheck = chunkType;
+          throw new Error(`Unhandled chunk type: ${_exhaustiveCheck}`);
+        }
+      }
+    },
+    flush() {
+      canClose = true;
+      if (outstandingToolCalls.size === 0) {
+        toolResultsStreamController.close();
+      }
+    }
+  });
+  return new ReadableStream({
+    async start(controller) {
+      generatorStream.pipeThrough(forwardStream).pipeTo(
+        new WritableStream({
+          write(chunk) {
+            controller.enqueue(chunk);
+          },
+          close() {
+          }
+        })
+      );
+      toolResultsStream.pipeTo(
+        new WritableStream({
+          write(chunk) {
+            controller.enqueue(chunk);
+          },
+          close() {
+            controller.close();
+          }
+        })
+      );
+    }
+  });
+}
+
+// shared/stream-parts.ts
+var textStreamPart = {
+  code: "0",
+  name: "text",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"text" parts expect a string value.');
+    }
+    return { type: "text", value };
+  }
+};
+var functionCallStreamPart = {
+  code: "1",
+  name: "function_call",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("function_call" in value) || typeof value.function_call !== "object" || value.function_call == null || !("name" in value.function_call) || !("arguments" in value.function_call) || typeof value.function_call.name !== "string" || typeof value.function_call.arguments !== "string") {
+      throw new Error(
+        '"function_call" parts expect an object with a "function_call" property.'
+      );
+    }
+    return {
+      type: "function_call",
+      value
+    };
+  }
+};
+var dataStreamPart = {
+  code: "2",
+  name: "data",
+  parse: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error('"data" parts expect an array value.');
+    }
+    return { type: "data", value };
+  }
+};
+var errorStreamPart = {
+  code: "3",
+  name: "error",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"error" parts expect a string value.');
+    }
+    return { type: "error", value };
+  }
+};
+var assistantMessageStreamPart = {
+  code: "4",
+  name: "assistant_message",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("id" in value) || !("role" in value) || !("content" in value) || typeof value.id !== "string" || typeof value.role !== "string" || value.role !== "assistant" || !Array.isArray(value.content) || !value.content.every(
+      (item) => item != null && typeof item === "object" && "type" in item && item.type === "text" && "text" in item && item.text != null && typeof item.text === "object" && "value" in item.text && typeof item.text.value === "string"
+    )) {
+      throw new Error(
+        '"assistant_message" parts expect an object with an "id", "role", and "content" property.'
+      );
+    }
+    return {
+      type: "assistant_message",
+      value
+    };
+  }
+};
+var assistantControlDataStreamPart = {
+  code: "5",
+  name: "assistant_control_data",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("threadId" in value) || !("messageId" in value) || typeof value.threadId !== "string" || typeof value.messageId !== "string") {
+      throw new Error(
+        '"assistant_control_data" parts expect an object with a "threadId" and "messageId" property.'
+      );
+    }
+    return {
+      type: "assistant_control_data",
+      value: {
+        threadId: value.threadId,
+        messageId: value.messageId
+      }
+    };
+  }
+};
+var dataMessageStreamPart = {
+  code: "6",
+  name: "data_message",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("role" in value) || !("data" in value) || typeof value.role !== "string" || value.role !== "data") {
+      throw new Error(
+        '"data_message" parts expect an object with a "role" and "data" property.'
+      );
+    }
+    return {
+      type: "data_message",
+      value
+    };
+  }
+};
+var toolCallStreamPart = {
+  code: "7",
+  name: "tool_calls",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("tool_calls" in value) || typeof value.tool_calls !== "object" || value.tool_calls == null || !Array.isArray(value.tool_calls) || value.tool_calls.some((tc) => {
+      tc == null || typeof tc !== "object" || !("id" in tc) || typeof tc.id !== "string" || !("type" in tc) || typeof tc.type !== "string" || !("function" in tc) || tc.function == null || typeof tc.function !== "object" || !("arguments" in tc.function) || typeof tc.function.name !== "string" || typeof tc.function.arguments !== "string";
+    })) {
+      throw new Error(
+        '"tool_calls" parts expect an object with a ToolCallPayload.'
+      );
+    }
+    return {
+      type: "tool_calls",
+      value
+    };
+  }
+};
+var messageAnnotationsStreamPart = {
+  code: "8",
+  name: "message_annotations",
+  parse: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error('"message_annotations" parts expect an array value.');
+    }
+    return { type: "message_annotations", value };
+  }
+};
+var streamParts = [
+  textStreamPart,
+  functionCallStreamPart,
+  dataStreamPart,
+  errorStreamPart,
+  assistantMessageStreamPart,
+  assistantControlDataStreamPart,
+  dataMessageStreamPart,
+  toolCallStreamPart,
+  messageAnnotationsStreamPart
+];
+var streamPartsByCode = {
+  [textStreamPart.code]: textStreamPart,
+  [functionCallStreamPart.code]: functionCallStreamPart,
+  [dataStreamPart.code]: dataStreamPart,
+  [errorStreamPart.code]: errorStreamPart,
+  [assistantMessageStreamPart.code]: assistantMessageStreamPart,
+  [assistantControlDataStreamPart.code]: assistantControlDataStreamPart,
+  [dataMessageStreamPart.code]: dataMessageStreamPart,
+  [toolCallStreamPart.code]: toolCallStreamPart,
+  [messageAnnotationsStreamPart.code]: messageAnnotationsStreamPart
+};
+var StreamStringPrefixes = {
+  [textStreamPart.name]: textStreamPart.code,
+  [functionCallStreamPart.name]: functionCallStreamPart.code,
+  [dataStreamPart.name]: dataStreamPart.code,
+  [errorStreamPart.name]: errorStreamPart.code,
+  [assistantMessageStreamPart.name]: assistantMessageStreamPart.code,
+  [assistantControlDataStreamPart.name]: assistantControlDataStreamPart.code,
+  [dataMessageStreamPart.name]: dataMessageStreamPart.code,
+  [toolCallStreamPart.name]: toolCallStreamPart.code,
+  [messageAnnotationsStreamPart.name]: messageAnnotationsStreamPart.code
+};
+var validCodes = streamParts.map((part) => part.code);
+function formatStreamPart(type, value) {
+  const streamPart = streamParts.find((part) => part.name === type);
+  if (!streamPart) {
+    throw new Error(`Invalid stream part type: ${type}`);
+  }
+  return `${streamPart.code}:${JSON.stringify(value)}
+`;
+}
+
+// shared/utils.ts
+import { customAlphabet } from "nanoid/non-secure";
+var nanoid2 = customAlphabet(
+  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  7
+);
+var COMPLEX_HEADER = "X-Experimental-Stream-Data";
+
+// core/generate-text/stream-text-http-response.ts
+var StreamTextHttpResponse = class extends Response {
+  constructor(messageStream) {
+    super(
+      messageStream.pipeThrough(
+        new TransformStream({
+          transform(chunk, controller) {
+            var _a;
+            switch (chunk.type) {
+              case "error": {
+                break;
+              }
+              case "text-delta": {
+                controller.enqueue(formatStreamPart("text", chunk.textDelta));
+                break;
+              }
+              case "tool-call": {
+                controller.enqueue(
+                  formatStreamPart("tool_calls", {
+                    tool_calls: [
+                      {
+                        type: "function",
+                        id: (_a = chunk.toolCallId) != null ? _a : "",
+                        // TODO client need to support null id
+                        function: {
+                          name: chunk.toolName,
+                          arguments: JSON.stringify(chunk.args)
+                        }
+                      }
+                    ]
+                  })
+                );
+                break;
+              }
+              case "tool-result": {
+                break;
+              }
+              default: {
+                const exhaustiveCheck = chunk;
+                throw new Error(
+                  `Unhandled stream part type: ${exhaustiveCheck}`
+                );
+              }
+            }
+          }
+        })
+      ),
+      {
+        status: 200,
+        headers: {
+          "Content-Type": "text/plain; charset=utf-8",
+          [COMPLEX_HEADER]: "true"
+        }
+      }
+    );
+  }
+};
+
+// core/generate-text/stream-text.ts
+async function streamText({
+  model,
+  tools,
+  system,
+  prompt,
+  messages,
+  ...settings
+}) {
+  const { stream, warnings } = await model.doStream({
+    mode: {
+      type: "regular",
+      tools: tools == null ? void 0 : Object.entries(tools).map(([name, tool2]) => ({
+        type: "function",
+        name,
+        description: tool2.description,
+        parameters: zodToJsonSchema3(tool2.parameters)
+      }))
+    },
+    ...settings,
+    inputFormat: getInputFormat({ prompt, messages }),
+    prompt: convertToLanguageModelPrompt({
+      system,
+      prompt,
+      messages
+    })
+  });
+  const toolStream = runToolsTransformation({
+    tools,
+    generatorStream: stream
+  });
+  return new StreamTextResult(toolStream);
+}
+var StreamTextResult = class {
+  constructor(stream) {
+    this.rootStream = stream;
+    this.textStream = {
+      [Symbol.asyncIterator]() {
+        const reader = stream.getReader();
+        return {
+          next: async () => {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) {
+                return { value: null, done: true };
+              }
+              if (value.type === "text-delta") {
+                if (value.textDelta.length > 0) {
+                  return { value: value.textDelta, done: false };
+                }
+              }
+            }
+          }
+        };
+      }
+    };
+    this.fullStream = {
+      [Symbol.asyncIterator]() {
+        const reader = stream.getReader();
+        return {
+          next: async () => {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) {
+                return { value: null, done: true };
+              }
+              if (value.type === "text-delta") {
+                if (value.textDelta.length > 0) {
+                  return { value, done: false };
+                }
+              } else {
+                return { value, done: false };
+              }
+            }
+          }
+        };
+      }
+    };
+  }
+  toResponse() {
+    return new StreamTextHttpResponse(this.rootStream);
+  }
+};
+
+// core/tool/tool.ts
+function tool(tool2) {
+  return tool2;
+}
+
+// core/language-model/errors/unsupported-functionality-error.ts
+var UnsupportedFunctionalityError = class extends Error {
+  constructor({
+    provider,
+    functionality
+  }) {
+    super(
+      `Functionality not supported by the provider. Provider: ${provider}.
+Functionality: ${functionality}`
+    );
+    this.name = "UnsupportedFunctionalityError";
+    this.provider = provider;
+    this.functionality = functionality;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      stack: this.stack,
+      provider: this.provider,
+      functionality: this.functionality
+    };
+  }
+};
+export {
+  GenerateObjectResult,
+  GenerateTextResult,
+  StreamObjectResult,
+  StreamTextHttpResponse,
+  StreamTextResult,
+  UnsupportedFunctionalityError,
+  convertDataContentToBase64String,
+  convertDataContentToUint8Array,
+  generateObject,
+  generateText,
+  streamObject,
+  streamText,
+  tool
+};
+//# sourceMappingURL=index.mjs.map