ai 3.1.0-canary.4 → 3.1.1

package/core/dist/index.mjs

@@ -1,1873 +0,0 @@
-// core/generate-object/generate-object.ts
-import zodToJsonSchema from "zod-to-json-schema";
-
-// ai-model-specification/errors/api-call-error.ts
-var APICallError = class extends Error {
-  constructor({
-    message,
-    url,
-    requestBodyValues,
-    statusCode,
-    responseBody,
-    cause,
-    isRetryable = statusCode != null && (statusCode === 408 || // request timeout
-    statusCode === 409 || // conflict
-    statusCode === 429 || // too many requests
-    statusCode >= 500),
-    // server error
-    data
-  }) {
-    super(message);
-    this.name = "AI_APICallError";
-    this.url = url;
-    this.requestBodyValues = requestBodyValues;
-    this.statusCode = statusCode;
-    this.responseBody = responseBody;
-    this.cause = cause;
-    this.isRetryable = isRetryable;
-    this.data = data;
-  }
-  static isAPICallError(error) {
-    return error instanceof Error && error.name === "AI_APICallError" && typeof error.url === "string" && typeof error.requestBodyValues === "object" && (error.statusCode == null || typeof error.statusCode === "number") && (error.responseBody == null || typeof error.responseBody === "string") && (error.cause == null || typeof error.cause === "object") && typeof error.isRetryable === "boolean" && (error.data == null || typeof error.data === "object");
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      url: this.url,
-      requestBodyValues: this.requestBodyValues,
-      statusCode: this.statusCode,
-      responseBody: this.responseBody,
-      cause: this.cause,
-      isRetryable: this.isRetryable,
-      data: this.data
-    };
-  }
-};
-
-// ai-model-specification/errors/invalid-argument-error.ts
-var InvalidArgumentError = class extends Error {
-  constructor({
-    parameter,
-    value,
-    message
-  }) {
-    super(`Invalid argument for parameter ${parameter}: ${message}`);
-    this.name = "AI_InvalidArgumentError";
-    this.parameter = parameter;
-    this.value = value;
-  }
-  static isInvalidArgumentError(error) {
-    return error instanceof Error && error.name === "AI_InvalidArgumentError" && typeof error.parameter === "string" && typeof error.value === "string";
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      stack: this.stack,
-      parameter: this.parameter,
-      value: this.value
-    };
-  }
-};
-
-// ai-model-specification/util/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);
-}
-
-// ai-model-specification/util/parse-json.ts
-import SecureJSON from "secure-json-parse";
-
-// ai-model-specification/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 = "AI_JSONParseError";
-    this.cause = cause;
-    this.text = text;
-  }
-  static isJSONParseError(error) {
-    return error instanceof Error && error.name === "AI_JSONParseError" && typeof error.text === "string" && typeof error.cause === "string";
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      cause: this.cause,
-      stack: this.stack,
-      valueText: this.text
-    };
-  }
-};
-
-// ai-model-specification/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 = "AI_TypeValidationError";
-    this.cause = cause;
-    this.value = value;
-  }
-  static isTypeValidationError(error) {
-    return error instanceof Error && error.name === "AI_TypeValidationError" && typeof error.value === "string" && typeof error.cause === "string";
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      cause: this.cause,
-      stack: this.stack,
-      value: this.value
-    };
-  }
-};
-
-// ai-model-specification/util/validate-types.ts
-function safeValidateTypes({
-  value,
-  schema
-}) {
-  try {
-    const validationResult = schema.safeParse(value);
-    if (validationResult.success) {
-      return {
-        success: true,
-        value: validationResult.data
-      };
-    }
-    return {
-      success: false,
-      error: new TypeValidationError({
-        value,
-        cause: validationResult.error
-      })
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: TypeValidationError.isTypeValidationError(error) ? error : new TypeValidationError({ value, cause: error })
-    };
-  }
-}
-
-// ai-model-specification/util/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: JSONParseError.isJSONParseError(error) ? error : new JSONParseError({ text, cause: error })
-    };
-  }
-}
-
-// ai-model-specification/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);
-}
-
-// ai-model-specification/errors/invalid-tool-arguments-error.ts
-var InvalidToolArgumentsError = class extends Error {
-  constructor({
-    toolArgs,
-    toolName,
-    cause,
-    message = `Invalid arguments for tool ${toolName}: ${getErrorMessage(
-      cause
-    )}`
-  }) {
-    super(message);
-    this.name = "AI_InvalidToolArgumentsError";
-    this.toolArgs = toolArgs;
-    this.toolName = toolName;
-    this.cause = cause;
-  }
-  static isInvalidToolArgumentsError(error) {
-    return error instanceof Error && error.name === "AI_InvalidToolArgumentsError" && typeof error.toolName === "string" && typeof error.toolArgs === "string";
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      cause: this.cause,
-      stack: this.stack,
-      toolName: this.toolName,
-      toolArgs: this.toolArgs
-    };
-  }
-};
-
-// ai-model-specification/errors/no-object-generated-error.ts
-var NoTextGeneratedError = class extends Error {
-  constructor() {
-    super(`No text generated.`);
-    this.name = "AI_NoTextGeneratedError";
-  }
-  static isNoTextGeneratedError(error) {
-    return error instanceof Error && error.name === "AI_NoTextGeneratedError";
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      cause: this.cause,
-      message: this.message,
-      stack: this.stack
-    };
-  }
-};
-
-// ai-model-specification/errors/no-such-tool-error.ts
-var NoSuchToolError = class extends Error {
-  constructor({ message, toolName }) {
-    super(message);
-    this.name = "AI_NoSuchToolError";
-    this.toolName = toolName;
-  }
-  static isNoSuchToolError(error) {
-    return error instanceof Error && error.name === "AI_NoSuchToolError" && typeof error.toolName === "string";
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      stack: this.stack,
-      toolName: this.toolName
-    };
-  }
-};
-
-// ai-model-specification/errors/retry-error.ts
-var RetryError = class extends Error {
-  constructor({
-    message,
-    reason,
-    errors
-  }) {
-    super(message);
-    this.name = "AI_RetryError";
-    this.reason = reason;
-    this.errors = errors;
-    this.lastError = errors[errors.length - 1];
-  }
-  static isRetryError(error) {
-    return error instanceof Error && error.name === "AI_RetryError" && typeof error.reason === "string" && Array.isArray(error.errors);
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      reason: this.reason,
-      lastError: this.lastError,
-      errors: this.errors
-    };
-  }
-};
-
-// core/generate-text/token-usage.ts
-function calculateTokenUsage(usage) {
-  return {
-    promptTokens: usage.promptTokens,
-    completionTokens: usage.completionTokens,
-    totalTokens: usage.promptTokens + usage.completionTokens
-  };
-}
-
-// 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: part.image instanceof URL ? part.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/prompt/prepare-call-settings.ts
-function prepareCallSettings({
-  maxTokens,
-  temperature,
-  topP,
-  presencePenalty,
-  frequencyPenalty,
-  seed,
-  maxRetries
-}) {
-  if (maxTokens != null) {
-    if (!Number.isInteger(maxTokens)) {
-      throw new InvalidArgumentError({
-        parameter: "maxTokens",
-        value: maxTokens,
-        message: "maxTokens must be an integer"
-      });
-    }
-    if (maxTokens < 1) {
-      throw new InvalidArgumentError({
-        parameter: "maxTokens",
-        value: maxTokens,
-        message: "maxTokens must be >= 1"
-      });
-    }
-  }
-  if (temperature != null) {
-    if (typeof temperature !== "number") {
-      throw new InvalidArgumentError({
-        parameter: "temperature",
-        value: temperature,
-        message: "temperature must be a number"
-      });
-    }
-    if (temperature < 0 || temperature > 1) {
-      throw new InvalidArgumentError({
-        parameter: "temperature",
-        value: temperature,
-        message: "temperature must be between 0 and 1 (inclusive)"
-      });
-    }
-  }
-  if (topP != null) {
-    if (typeof topP !== "number") {
-      throw new InvalidArgumentError({
-        parameter: "topP",
-        value: topP,
-        message: "topP must be a number"
-      });
-    }
-    if (topP < 0 || topP > 1) {
-      throw new InvalidArgumentError({
-        parameter: "topP",
-        value: topP,
-        message: "topP must be between 0 and 1 (inclusive)"
-      });
-    }
-  }
-  if (presencePenalty != null) {
-    if (typeof presencePenalty !== "number") {
-      throw new InvalidArgumentError({
-        parameter: "presencePenalty",
-        value: presencePenalty,
-        message: "presencePenalty must be a number"
-      });
-    }
-    if (presencePenalty < -1 || presencePenalty > 1) {
-      throw new InvalidArgumentError({
-        parameter: "presencePenalty",
-        value: presencePenalty,
-        message: "presencePenalty must be between -1 and 1 (inclusive)"
-      });
-    }
-  }
-  if (frequencyPenalty != null) {
-    if (typeof frequencyPenalty !== "number") {
-      throw new InvalidArgumentError({
-        parameter: "frequencyPenalty",
-        value: frequencyPenalty,
-        message: "frequencyPenalty must be a number"
-      });
-    }
-    if (frequencyPenalty < -1 || frequencyPenalty > 1) {
-      throw new InvalidArgumentError({
-        parameter: "frequencyPenalty",
-        value: frequencyPenalty,
-        message: "frequencyPenalty must be between -1 and 1 (inclusive)"
-      });
-    }
-  }
-  if (seed != null) {
-    if (!Number.isInteger(seed)) {
-      throw new InvalidArgumentError({
-        parameter: "seed",
-        value: seed,
-        message: "seed must be an integer"
-      });
-    }
-  }
-  if (maxRetries != null) {
-    if (!Number.isInteger(maxRetries)) {
-      throw new InvalidArgumentError({
-        parameter: "maxRetries",
-        value: maxRetries,
-        message: "maxRetries must be an integer"
-      });
-    }
-    if (maxRetries < 0) {
-      throw new InvalidArgumentError({
-        parameter: "maxRetries",
-        value: maxRetries,
-        message: "maxRetries must be >= 0"
-      });
-    }
-  }
-  return {
-    maxTokens,
-    temperature: temperature != null ? temperature : 0,
-    topP,
-    presencePenalty: presencePenalty != null ? presencePenalty : 0,
-    frequencyPenalty: frequencyPenalty != null ? frequencyPenalty : 0,
-    seed,
-    maxRetries: maxRetries != null ? maxRetries : 2
-  };
-}
-
-// core/util/delay.ts
-async function delay(delayInMs) {
-  return new Promise((resolve) => setTimeout(resolve, delayInMs));
-}
-
-// core/util/retry-with-exponential-backoff.ts
-var retryWithExponentialBackoff = ({
-  maxRetries = 2,
-  initialDelayInMs = 2e3,
-  backoffFactor = 2
-} = {}) => async (f) => _retryWithExponentialBackoff(f, {
-  maxRetries,
-  delayInMs: initialDelayInMs,
-  backoffFactor
-});
-async function _retryWithExponentialBackoff(f, {
-  maxRetries,
-  delayInMs,
-  backoffFactor
-}, errors = []) {
-  try {
-    return await f();
-  } catch (error) {
-    if (maxRetries === 0) {
-      throw error;
-    }
-    const errorMessage = getErrorMessage(error);
-    const newErrors = [...errors, error];
-    const tryNumber = newErrors.length;
-    if (tryNumber > maxRetries) {
-      throw new RetryError({
-        message: `Failed after ${tryNumber} attemps. Last error: ${errorMessage}`,
-        reason: "maxRetriesExceeded",
-        errors: newErrors
-      });
-    }
-    if (error instanceof Error) {
-      if (error.name === "AbortError") {
-        throw error;
-      }
-      if (
-        // deal with bundling duplication by using names
-        APICallError.isAPICallError(error) && error.isRetryable === true && tryNumber <= maxRetries
-      ) {
-        await delay(delayInMs);
-        return _retryWithExponentialBackoff(
-          f,
-          { maxRetries, delayInMs: backoffFactor * delayInMs, backoffFactor },
-          newErrors
-        );
-      }
-    }
-    if (tryNumber === 1) {
-      throw error;
-    }
-    throw new RetryError({
-      message: `Failed after ${tryNumber} attemps with non-retryable error: '${errorMessage}'`,
-      reason: "errorNotRetryable",
-      errors: newErrors
-    });
-  }
-}
-
-// 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/generate-object/generate-object.ts
-async function generateObject({
-  model,
-  schema,
-  mode,
-  system,
-  prompt,
-  messages,
-  maxRetries,
-  abortSignal,
-  ...settings
-}) {
-  var _a, _b;
-  const retry = retryWithExponentialBackoff({ maxRetries });
-  const jsonSchema = zodToJsonSchema(schema);
-  if (mode === "auto" || mode == null) {
-    mode = model.defaultObjectGenerationMode;
-  }
-  let result;
-  let finishReason;
-  let usage;
-  switch (mode) {
-    case "json": {
-      const generateResult = await retry(
-        () => model.doGenerate({
-          mode: { type: "object-json" },
-          ...prepareCallSettings(settings),
-          inputFormat: getInputFormat({ prompt, messages }),
-          prompt: convertToLanguageModelPrompt({
-            system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
-            prompt,
-            messages
-          }),
-          abortSignal
-        })
-      );
-      if (generateResult.text === void 0) {
-        throw new NoTextGeneratedError();
-      }
-      result = generateResult.text;
-      finishReason = generateResult.finishReason;
-      usage = generateResult.usage;
-      break;
-    }
-    case "grammar": {
-      const generateResult = await retry(
-        () => model.doGenerate({
-          mode: { type: "object-grammar", schema: jsonSchema },
-          ...settings,
-          inputFormat: getInputFormat({ prompt, messages }),
-          prompt: convertToLanguageModelPrompt({
-            system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
-            prompt,
-            messages
-          }),
-          abortSignal
-        })
-      );
-      if (generateResult.text === void 0) {
-        throw new NoTextGeneratedError();
-      }
-      result = generateResult.text;
-      finishReason = generateResult.finishReason;
-      usage = generateResult.usage;
-      break;
-    }
-    case "tool": {
-      const generateResult = await retry(
-        () => 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 }),
-          abortSignal
-        })
-      );
-      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;
-      finishReason = generateResult.finishReason;
-      usage = generateResult.usage;
-      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,
-    finishReason,
-    usage: calculateTokenUsage(usage)
-  });
-}
-var GenerateObjectResult = class {
-  constructor(options) {
-    this.object = options.object;
-    this.finishReason = options.finishReason;
-    this.usage = options.usage;
-  }
-};
-
-// core/generate-object/stream-object.ts
-import zodToJsonSchema2 from "zod-to-json-schema";
-
-// core/util/async-iterable-stream.ts
-function createAsyncIterableStream(source, transformer) {
-  const transformedStream = source.pipeThrough(
-    new TransformStream(transformer)
-  );
-  transformedStream[Symbol.asyncIterator] = () => {
-    const reader = transformedStream.getReader();
-    return {
-      async next() {
-        const { done, value } = await reader.read();
-        return done ? { done: true, value: void 0 } : { done: false, value };
-      }
-    };
-  };
-  return transformedStream;
-}
-
-// 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,
-  mode,
-  system,
-  prompt,
-  messages,
-  maxRetries,
-  abortSignal,
-  ...settings
-}) {
-  const retry = retryWithExponentialBackoff({ maxRetries });
-  const jsonSchema = zodToJsonSchema2(schema);
-  if (mode === "auto" || mode == null) {
-    mode = model.defaultObjectGenerationMode;
-  }
-  let callOptions;
-  let transformer;
-  switch (mode) {
-    case "json": {
-      callOptions = {
-        mode: { type: "object-json" },
-        ...prepareCallSettings(settings),
-        inputFormat: getInputFormat({ prompt, messages }),
-        prompt: convertToLanguageModelPrompt({
-          system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
-          prompt,
-          messages
-        }),
-        abortSignal
-      };
-      transformer = {
-        transform: (chunk, controller) => {
-          switch (chunk.type) {
-            case "text-delta":
-              controller.enqueue(chunk.textDelta);
-              break;
-            case "error":
-              controller.enqueue(chunk);
-              break;
-          }
-        }
-      };
-      break;
-    }
-    case "grammar": {
-      callOptions = {
-        mode: { type: "object-grammar", schema: jsonSchema },
-        ...settings,
-        inputFormat: getInputFormat({ prompt, messages }),
-        prompt: convertToLanguageModelPrompt({
-          system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
-          prompt,
-          messages
-        }),
-        abortSignal
-      };
-      transformer = {
-        transform: (chunk, controller) => {
-          switch (chunk.type) {
-            case "text-delta":
-              controller.enqueue(chunk.textDelta);
-              break;
-            case "error":
-              controller.enqueue(chunk);
-              break;
-          }
-        }
-      };
-      break;
-    }
-    case "tool": {
-      callOptions = {
-        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 }),
-        abortSignal
-      };
-      transformer = {
-        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}`);
-    }
-  }
-  const { stream, warnings } = await retry(() => model.doStream(callOptions));
-  return new StreamObjectResult(
-    stream.pipeThrough(new TransformStream(transformer))
-  );
-}
-var StreamObjectResult = class {
-  constructor(stream) {
-    this.originalStream = stream;
-  }
-  get objectStream() {
-    let accumulatedText = "";
-    let latestObject = void 0;
-    return createAsyncIterableStream(this.originalStream, {
-      transform(chunk, controller) {
-        if (typeof chunk === "string") {
-          accumulatedText += chunk;
-          const currentObject = parsePartialJson(
-            accumulatedText
-          );
-          if (!isDeepEqualData(latestObject, currentObject)) {
-            latestObject = currentObject;
-            controller.enqueue(currentObject);
-          }
-        }
-        if (typeof chunk === "object" && chunk.type === "error") {
-          throw chunk.error;
-        }
-      }
-    });
-  }
-};
-
-// core/generate-text/generate-text.ts
-import zodToJsonSchema3 from "zod-to-json-schema";
-
-// core/generate-text/tool-call.ts
-function parseToolCall({
-  toolCall,
-  tools
-}) {
-  const toolName = toolCall.toolName;
-  if (tools == null) {
-    throw new NoSuchToolError({
-      message: `Tool ${toolCall.toolName} not found (no tools provided).`,
-      toolName: toolCall.toolName
-    });
-  }
-  const tool2 = tools[toolName];
-  if (tool2 == null) {
-    throw new NoSuchToolError({
-      message: `Tool ${toolCall.toolName} not found.`,
-      toolName: toolCall.toolName
-    });
-  }
-  const parseResult = safeParseJSON({
-    text: toolCall.args,
-    schema: tool2.parameters
-  });
-  if (parseResult.success === false) {
-    throw new InvalidToolArgumentsError({
-      toolName,
-      toolArgs: toolCall.args,
-      cause: parseResult.error
-    });
-  }
-  return {
-    toolCallId: toolCall.toolCallId,
-    toolName,
-    args: parseResult.value
-  };
-}
-
-// core/generate-text/generate-text.ts
-async function generateText({
-  model,
-  tools,
-  system,
-  prompt,
-  messages,
-  maxRetries,
-  abortSignal,
-  ...settings
-}) {
-  var _a, _b;
-  const retry = retryWithExponentialBackoff({ maxRetries });
-  const modelResponse = await retry(
-    () => model.doGenerate({
-      mode: {
-        type: "regular",
-        tools: tools == null ? void 0 : Object.entries(tools).map(([name, tool2]) => ({
-          type: "function",
-          name,
-          description: tool2.description,
-          parameters: zodToJsonSchema3(tool2.parameters)
-        }))
-      },
-      ...prepareCallSettings(settings),
-      inputFormat: getInputFormat({ prompt, messages }),
-      prompt: convertToLanguageModelPrompt({
-        system,
-        prompt,
-        messages
-      }),
-      abortSignal
-    })
-  );
-  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,
-    finishReason: modelResponse.finishReason,
-    usage: calculateTokenUsage(modelResponse.usage)
-  });
-}
-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;
-    this.finishReason = options.finishReason;
-    this.usage = options.usage;
-  }
-};
-
-// core/generate-text/stream-text.ts
-import zodToJsonSchema4 from "zod-to-json-schema";
-
-// 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)}
-`;
-}
-
-// streams/ai-stream.ts
-import {
-  createParser
-} from "eventsource-parser";
-function createCallbacksTransformer(cb) {
-  const textEncoder = new TextEncoder();
-  let aggregatedResponse = "";
-  const callbacks = cb || {};
-  return new TransformStream({
-    async start() {
-      if (callbacks.onStart)
-        await callbacks.onStart();
-    },
-    async transform(message, controller) {
-      const content = typeof message === "string" ? message : message.content;
-      controller.enqueue(textEncoder.encode(content));
-      aggregatedResponse += content;
-      if (callbacks.onToken)
-        await callbacks.onToken(content);
-      if (callbacks.onText && typeof message === "string") {
-        await callbacks.onText(message);
-      }
-    },
-    async flush() {
-      const isOpenAICallbacks = isOfTypeOpenAIStreamCallbacks(callbacks);
-      if (callbacks.onCompletion) {
-        await callbacks.onCompletion(aggregatedResponse);
-      }
-      if (callbacks.onFinal && !isOpenAICallbacks) {
-        await callbacks.onFinal(aggregatedResponse);
-      }
-    }
-  });
-}
-function isOfTypeOpenAIStreamCallbacks(callbacks) {
-  return "experimental_onFunctionCall" in callbacks;
-}
-function readableFromAsyncIterable(iterable) {
-  let it = iterable[Symbol.asyncIterator]();
-  return new ReadableStream({
-    async pull(controller) {
-      const { done, value } = await it.next();
-      if (done)
-        controller.close();
-      else
-        controller.enqueue(value);
-    },
-    async cancel(reason) {
-      var _a;
-      await ((_a = it.return) == null ? void 0 : _a.call(it, reason));
-    }
-  });
-}
-
-// streams/stream-data.ts
-function createStreamDataTransformer(experimental_streamData) {
-  if (!experimental_streamData) {
-    return new TransformStream({
-      transform: async (chunk, controller) => {
-        controller.enqueue(chunk);
-      }
-    });
-  }
-  const encoder = new TextEncoder();
-  const decoder = new TextDecoder();
-  return new TransformStream({
-    transform: async (chunk, controller) => {
-      const message = decoder.decode(chunk);
-      controller.enqueue(encoder.encode(formatStreamPart("text", message)));
-    }
-  });
-}
-
-// 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: new NoSuchToolError({
-                message: `Tool ${chunk.toolName} not found (no tools provided).`,
-                toolName: chunk.toolName
-              })
-            });
-            break;
-          }
-          const tool2 = tools[toolName];
-          if (tool2 == null) {
-            toolResultsStreamController.enqueue({
-              type: "error",
-              error: new NoSuchToolError({
-                message: `Tool ${chunk.toolName} not found.`,
-                toolName: chunk.toolName
-              })
-            });
-            break;
-          }
-          try {
-            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();
-                  }
-                }
-              );
-            }
-          } catch (error) {
-            toolResultsStreamController.enqueue({
-              type: "error",
-              error
-            });
-          }
-          break;
-        }
-        case "finish-metadata":
-        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();
-          }
-        })
-      );
-    }
-  });
-}
-
-// core/generate-text/stream-text.ts
-async function streamText({
-  model,
-  tools,
-  system,
-  prompt,
-  messages,
-  maxRetries,
-  abortSignal,
-  ...settings
-}) {
-  const retry = retryWithExponentialBackoff({ maxRetries });
-  const { stream, warnings } = await retry(
-    () => model.doStream({
-      mode: {
-        type: "regular",
-        tools: tools == null ? void 0 : Object.entries(tools).map(([name, tool2]) => ({
-          type: "function",
-          name,
-          description: tool2.description,
-          parameters: zodToJsonSchema4(tool2.parameters)
-        }))
-      },
-      ...prepareCallSettings(settings),
-      inputFormat: getInputFormat({ prompt, messages }),
-      prompt: convertToLanguageModelPrompt({
-        system,
-        prompt,
-        messages
-      }),
-      abortSignal
-    })
-  );
-  const toolStream = runToolsTransformation({
-    tools,
-    generatorStream: stream
-  });
-  return new StreamTextResult(toolStream);
-}
-var StreamTextResult = class {
-  constructor(stream) {
-    this.originalStream = stream;
-  }
-  get textStream() {
-    return createAsyncIterableStream(this.originalStream, {
-      transform(chunk, controller) {
-        if (chunk.type === "text-delta") {
-          if (chunk.textDelta.length > 0) {
-            controller.enqueue(chunk.textDelta);
-          }
-        } else if (chunk.type === "error") {
-          throw chunk.error;
-        }
-      }
-    });
-  }
-  get fullStream() {
-    return createAsyncIterableStream(this.originalStream, {
-      transform(chunk, controller) {
-        if (chunk.type === "text-delta") {
-          if (chunk.textDelta.length > 0) {
-            controller.enqueue(chunk);
-          }
-        } else {
-          controller.enqueue(chunk);
-        }
-      }
-    });
-  }
-  toAIStream(callbacks) {
-    return readableFromAsyncIterable(this.textStream).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
-      createStreamDataTransformer(callbacks == null ? void 0 : callbacks.experimental_streamData)
-    );
-  }
-};
-
-// core/tool/tool.ts
-function tool(tool2) {
-  return tool2;
-}
-export {
-  GenerateObjectResult,
-  GenerateTextResult,
-  StreamObjectResult,
-  StreamTextResult,
-  convertDataContentToBase64String,
-  convertDataContentToUint8Array,
-  generateObject,
-  generateText,
-  streamObject,
-  streamText,
-  tool
-};
-//# sourceMappingURL=index.mjs.map