ai 3.1.0-canary.4 → 3.1.1

package/dist/index.mjs

@@ -1,5 +1,1578 @@
-// shared/utils.ts
+// core/generate-object/generate-object.ts
+import { NoObjectGeneratedError } from "@ai-sdk/provider";
+import { safeParseJSON } from "@ai-sdk/provider-utils";
+
+// core/generate-text/token-usage.ts
+function calculateTokenUsage(usage) {
+  return {
+    promptTokens: usage.promptTokens,
+    completionTokens: usage.completionTokens,
+    totalTokens: usage.promptTokens + usage.completionTokens
+  };
+}
+
+// core/util/detect-image-mimetype.ts
+var mimeTypeSignatures = [
+  { mimeType: "image/gif", bytes: [71, 73, 70] },
+  { mimeType: "image/png", bytes: [137, 80, 78, 71] },
+  { mimeType: "image/jpeg", bytes: [255, 216] },
+  { mimeType: "image/webp", bytes: [82, 73, 70, 70] }
+];
+function detectImageMimeType(image) {
+  for (const { bytes, mimeType } of mimeTypeSignatures) {
+    if (image.length >= bytes.length && bytes.every((byte, index) => image[index] === byte)) {
+      return mimeType;
+    }
+  }
+  return void 0;
+}
+
+// core/prompt/data-content.ts
+import { InvalidDataContentError } from "@ai-sdk/provider";
+import {
+  convertBase64ToUint8Array,
+  convertUint8ArrayToBase64
+} from "@ai-sdk/provider-utils";
+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 InvalidDataContentError({ content });
+}
+
+// core/prompt/convert-to-language-model-prompt.ts
+function convertToLanguageModelPrompt(prompt) {
+  const languageModelMessages = [];
+  if (prompt.system != null) {
+    languageModelMessages.push({ role: "system", content: prompt.system });
+  }
+  switch (prompt.type) {
+    case "prompt": {
+      languageModelMessages.push({
+        role: "user",
+        content: [{ type: "text", text: prompt.prompt }]
+      });
+      break;
+    }
+    case "messages": {
+      languageModelMessages.push(
+        ...prompt.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) => {
+                    var _a;
+                    switch (part.type) {
+                      case "text": {
+                        return part;
+                      }
+                      case "image": {
+                        if (part.image instanceof URL) {
+                          return {
+                            type: "image",
+                            image: part.image,
+                            mimeType: part.mimeType
+                          };
+                        }
+                        const imageUint8 = convertDataContentToUint8Array(
+                          part.image
+                        );
+                        return {
+                          type: "image",
+                          image: imageUint8,
+                          mimeType: (_a = part.mimeType) != null ? _a : detectImageMimeType(imageUint8)
+                        };
+                      }
+                    }
+                  }
+                )
+              };
+            }
+            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;
+            }
+          }
+        })
+      );
+      break;
+    }
+    default: {
+      const _exhaustiveCheck = prompt;
+      throw new Error(`Unsupported prompt type: ${_exhaustiveCheck}`);
+    }
+  }
+  return languageModelMessages;
+}
+
+// core/prompt/get-validated-prompt.ts
+import { InvalidPromptError } from "@ai-sdk/provider";
+function getValidatedPrompt(prompt) {
+  if (prompt.prompt == null && prompt.messages == null) {
+    throw new InvalidPromptError({
+      prompt,
+      message: "prompt or messages must be defined"
+    });
+  }
+  if (prompt.prompt != null && prompt.messages != null) {
+    throw new InvalidPromptError({
+      prompt,
+      message: "prompt and messages cannot be defined at the same time"
+    });
+  }
+  return prompt.prompt != null ? {
+    type: "prompt",
+    prompt: prompt.prompt,
+    messages: void 0,
+    system: prompt.system
+  } : {
+    type: "messages",
+    prompt: void 0,
+    messages: prompt.messages,
+    // only possible case bc of checks above
+    system: prompt.system
+  };
+}
+
+// core/prompt/prepare-call-settings.ts
+import { InvalidArgumentError } from "@ai-sdk/provider";
+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 (topP != null) {
+    if (typeof topP !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "topP",
+        value: topP,
+        message: "topP must be a number"
+      });
+    }
+  }
+  if (presencePenalty != null) {
+    if (typeof presencePenalty !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "presencePenalty",
+        value: presencePenalty,
+        message: "presencePenalty must be a number"
+      });
+    }
+  }
+  if (frequencyPenalty != null) {
+    if (typeof frequencyPenalty !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "frequencyPenalty",
+        value: frequencyPenalty,
+        message: "frequencyPenalty must be a number"
+      });
+    }
+  }
+  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,
+    frequencyPenalty,
+    seed,
+    maxRetries: maxRetries != null ? maxRetries : 2
+  };
+}
+
+// core/util/convert-zod-to-json-schema.ts
+import zodToJsonSchema from "zod-to-json-schema";
+function convertZodToJSONSchema(zodSchema) {
+  return zodToJsonSchema(zodSchema);
+}
+
+// core/util/retry-with-exponential-backoff.ts
+import { APICallError, RetryError } from "@ai-sdk/provider";
+import { getErrorMessage, isAbortError } from "@ai-sdk/provider-utils";
+
+// 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 (isAbortError(error)) {
+      throw 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} attempts. Last error: ${errorMessage}`,
+        reason: "maxRetriesExceeded",
+        errors: newErrors
+      });
+    }
+    if (error instanceof Error && 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} attempts 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 = convertZodToJSONSchema(schema);
+  if (mode === "auto" || mode == null) {
+    mode = model.defaultObjectGenerationMode;
+  }
+  let result;
+  let finishReason;
+  let usage;
+  let warnings;
+  let rawResponse;
+  let logprobs;
+  switch (mode) {
+    case "json": {
+      const validatedPrompt = getValidatedPrompt({
+        system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
+        prompt,
+        messages
+      });
+      const generateResult = await retry(() => {
+        return model.doGenerate({
+          mode: { type: "object-json" },
+          ...prepareCallSettings(settings),
+          inputFormat: validatedPrompt.type,
+          prompt: convertToLanguageModelPrompt(validatedPrompt),
+          abortSignal
+        });
+      });
+      if (generateResult.text === void 0) {
+        throw new NoObjectGeneratedError();
+      }
+      result = generateResult.text;
+      finishReason = generateResult.finishReason;
+      usage = generateResult.usage;
+      warnings = generateResult.warnings;
+      rawResponse = generateResult.rawResponse;
+      logprobs = generateResult.logprobs;
+      break;
+    }
+    case "grammar": {
+      const validatedPrompt = getValidatedPrompt({
+        system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
+        prompt,
+        messages
+      });
+      const generateResult = await retry(
+        () => model.doGenerate({
+          mode: { type: "object-grammar", schema: jsonSchema },
+          ...settings,
+          inputFormat: validatedPrompt.type,
+          prompt: convertToLanguageModelPrompt(validatedPrompt),
+          abortSignal
+        })
+      );
+      if (generateResult.text === void 0) {
+        throw new NoObjectGeneratedError();
+      }
+      result = generateResult.text;
+      finishReason = generateResult.finishReason;
+      usage = generateResult.usage;
+      warnings = generateResult.warnings;
+      rawResponse = generateResult.rawResponse;
+      logprobs = generateResult.logprobs;
+      break;
+    }
+    case "tool": {
+      const validatedPrompt = getValidatedPrompt({
+        system,
+        prompt,
+        messages
+      });
+      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: validatedPrompt.type,
+          prompt: convertToLanguageModelPrompt(validatedPrompt),
+          abortSignal
+        })
+      );
+      const functionArgs = (_b = (_a = generateResult.toolCalls) == null ? void 0 : _a[0]) == null ? void 0 : _b.args;
+      if (functionArgs === void 0) {
+        throw new NoObjectGeneratedError();
+      }
+      result = functionArgs;
+      finishReason = generateResult.finishReason;
+      usage = generateResult.usage;
+      warnings = generateResult.warnings;
+      rawResponse = generateResult.rawResponse;
+      logprobs = generateResult.logprobs;
+      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),
+    warnings,
+    rawResponse,
+    logprobs
+  });
+}
+var GenerateObjectResult = class {
+  constructor(options) {
+    this.object = options.object;
+    this.finishReason = options.finishReason;
+    this.usage = options.usage;
+    this.warnings = options.warnings;
+    this.rawResponse = options.rawResponse;
+    this.logprobs = options.logprobs;
+  }
+};
+var experimental_generateObject = generateObject;
+
+// 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 SecureJSON 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 SecureJSON.parse(jsonText);
+  } catch (ignored) {
+    try {
+      const fixedJsonText = fixJson(jsonText);
+      return SecureJSON.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 = convertZodToJSONSchema(schema);
+  if (mode === "auto" || mode == null) {
+    mode = model.defaultObjectGenerationMode;
+  }
+  let callOptions;
+  let transformer;
+  switch (mode) {
+    case "json": {
+      const validatedPrompt = getValidatedPrompt({
+        system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
+        prompt,
+        messages
+      });
+      callOptions = {
+        mode: { type: "object-json" },
+        ...prepareCallSettings(settings),
+        inputFormat: validatedPrompt.type,
+        prompt: convertToLanguageModelPrompt(validatedPrompt),
+        abortSignal
+      };
+      transformer = {
+        transform: (chunk, controller) => {
+          switch (chunk.type) {
+            case "text-delta":
+              controller.enqueue(chunk.textDelta);
+              break;
+            case "finish":
+            case "error":
+              controller.enqueue(chunk);
+              break;
+          }
+        }
+      };
+      break;
+    }
+    case "grammar": {
+      const validatedPrompt = getValidatedPrompt({
+        system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
+        prompt,
+        messages
+      });
+      callOptions = {
+        mode: { type: "object-grammar", schema: jsonSchema },
+        ...settings,
+        inputFormat: validatedPrompt.type,
+        prompt: convertToLanguageModelPrompt(validatedPrompt),
+        abortSignal
+      };
+      transformer = {
+        transform: (chunk, controller) => {
+          switch (chunk.type) {
+            case "text-delta":
+              controller.enqueue(chunk.textDelta);
+              break;
+            case "finish":
+            case "error":
+              controller.enqueue(chunk);
+              break;
+          }
+        }
+      };
+      break;
+    }
+    case "tool": {
+      const validatedPrompt = getValidatedPrompt({
+        system,
+        prompt,
+        messages
+      });
+      callOptions = {
+        mode: {
+          type: "object-tool",
+          tool: {
+            type: "function",
+            name: "json",
+            description: "Respond with a JSON object.",
+            parameters: jsonSchema
+          }
+        },
+        ...settings,
+        inputFormat: validatedPrompt.type,
+        prompt: convertToLanguageModelPrompt(validatedPrompt),
+        abortSignal
+      };
+      transformer = {
+        transform(chunk, controller) {
+          switch (chunk.type) {
+            case "tool-call-delta":
+              controller.enqueue(chunk.argsTextDelta);
+              break;
+            case "finish":
+            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 result = await retry(() => model.doStream(callOptions));
+  return new StreamObjectResult({
+    stream: result.stream.pipeThrough(new TransformStream(transformer)),
+    warnings: result.warnings,
+    rawResponse: result.rawResponse
+  });
+}
+var StreamObjectResult = class {
+  constructor({
+    stream,
+    warnings,
+    rawResponse
+  }) {
+    this.originalStream = stream;
+    this.warnings = warnings;
+    this.rawResponse = rawResponse;
+  }
+  get partialObjectStream() {
+    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);
+          }
+        } else if (chunk.type === "error") {
+          throw chunk.error;
+        }
+      }
+    });
+  }
+  get fullStream() {
+    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({ type: "object", object: currentObject });
+          }
+        } else {
+          switch (chunk.type) {
+            case "finish":
+              controller.enqueue({
+                ...chunk,
+                usage: calculateTokenUsage(chunk.usage)
+              });
+              break;
+            default:
+              controller.enqueue(chunk);
+              break;
+          }
+        }
+      }
+    });
+  }
+};
+var experimental_streamObject = streamObject;
+
+// core/generate-text/tool-call.ts
+import {
+  InvalidToolArgumentsError,
+  NoSuchToolError
+} from "@ai-sdk/provider";
+import { safeParseJSON as safeParseJSON2 } from "@ai-sdk/provider-utils";
+function parseToolCall({
+  toolCall,
+  tools
+}) {
+  const toolName = toolCall.toolName;
+  if (tools == null) {
+    throw new NoSuchToolError({ toolName: toolCall.toolName });
+  }
+  const tool2 = tools[toolName];
+  if (tool2 == null) {
+    throw new NoSuchToolError({
+      toolName: toolCall.toolName,
+      availableTools: Object.keys(tools)
+    });
+  }
+  const parseResult = safeParseJSON2({
+    text: toolCall.args,
+    schema: tool2.parameters
+  });
+  if (parseResult.success === false) {
+    throw new InvalidToolArgumentsError({
+      toolName,
+      toolArgs: toolCall.args,
+      cause: parseResult.error
+    });
+  }
+  return {
+    type: "tool-call",
+    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 validatedPrompt = getValidatedPrompt({ system, prompt, messages });
+  const modelResponse = await retry(() => {
+    return model.doGenerate({
+      mode: {
+        type: "regular",
+        tools: tools == null ? void 0 : Object.entries(tools).map(([name, tool2]) => ({
+          type: "function",
+          name,
+          description: tool2.description,
+          parameters: convertZodToJSONSchema(tool2.parameters)
+        }))
+      },
+      ...prepareCallSettings(settings),
+      inputFormat: validatedPrompt.type,
+      prompt: convertToLanguageModelPrompt(validatedPrompt),
+      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),
+    warnings: modelResponse.warnings,
+    rawResponse: modelResponse.rawResponse,
+    logprobs: modelResponse.logprobs
+  });
+}
+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;
+    this.warnings = options.warnings;
+    this.rawResponse = options.rawResponse;
+    this.logprobs = options.logprobs;
+  }
+};
+var experimental_generateText = generateText;
+
+// core/generate-text/run-tools-transformation.ts
+import { NoSuchToolError as NoSuchToolError2 } from "@ai-sdk/provider";
+
+// shared/generate-id.ts
 import { customAlphabet } from "nanoid/non-secure";
+var generateId = customAlphabet(
+  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  7
+);
+
+// core/generate-text/run-tools-transformation.ts
+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 NoSuchToolError2({ toolName: chunk.toolName })
+            });
+            break;
+          }
+          const tool2 = tools[toolName];
+          if (tool2 == null) {
+            toolResultsStreamController.enqueue({
+              type: "error",
+              error: new NoSuchToolError2({
+                toolName: chunk.toolName,
+                availableTools: Object.keys(tools)
+              })
+            });
+            break;
+          }
+          try {
+            const toolCall = parseToolCall({
+              toolCall: chunk,
+              tools
+            });
+            controller.enqueue(toolCall);
+            if (tool2.execute != null) {
+              const toolExecutionId = generateId();
+              outstandingToolCalls.add(toolExecutionId);
+              tool2.execute(toolCall.args).then(
+                (result) => {
+                  toolResultsStreamController.enqueue({
+                    ...toolCall,
+                    type: "tool-result",
+                    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": {
+          controller.enqueue({
+            type: "finish",
+            finishReason: chunk.finishReason,
+            logprobs: chunk.logprobs,
+            usage: calculateTokenUsage(chunk.usage)
+          });
+          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) {
+      return Promise.all([
+        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 validatedPrompt = getValidatedPrompt({ system, prompt, messages });
+  const { stream, warnings, rawResponse } = 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: convertZodToJSONSchema(tool2.parameters)
+        }))
+      },
+      ...prepareCallSettings(settings),
+      inputFormat: validatedPrompt.type,
+      prompt: convertToLanguageModelPrompt(validatedPrompt),
+      abortSignal
+    })
+  );
+  return new StreamTextResult({
+    stream: runToolsTransformation({
+      tools,
+      generatorStream: stream
+    }),
+    warnings,
+    rawResponse
+  });
+}
+var StreamTextResult = class {
+  constructor({
+    stream,
+    warnings,
+    rawResponse
+  }) {
+    this.originalStream = stream;
+    this.warnings = warnings;
+    this.rawResponse = rawResponse;
+  }
+  /**
+  A text stream that returns only the generated text deltas. You can use it
+  as either an AsyncIterable or a ReadableStream. When an error occurs, the
+  stream will throw the error.
+     */
+  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;
+        }
+      }
+    });
+  }
+  /**
+  A stream with all events, including text deltas, tool calls, tool results, and
+  errors.
+  You can use it as either an AsyncIterable or a ReadableStream. When an error occurs, the
+  stream will throw the 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);
+        }
+      }
+    });
+  }
+  /**
+  Converts the result to an `AIStream` object that is compatible with `StreamingTextResponse`.
+  It can be used with the `useChat` and `useCompletion` hooks.
+  
+  @param callbacks 
+  Stream callbacks that will be called when the stream emits events.
+  
+  @returns an `AIStream` object.
+     */
+  toAIStream(callbacks) {
+    return this.textStream.pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer());
+  }
+  /**
+  Writes stream data output to a Node.js response-like object.
+  It sets a `Content-Type` header to `text/plain; charset=utf-8` and 
+  writes each stream data part as a separate chunk.
+  
+  @param response A Node.js response-like object (ServerResponse).
+  @param init Optional headers and status code.
+     */
+  pipeAIStreamToResponse(response, init) {
+    var _a;
+    response.writeHead((_a = init == null ? void 0 : init.status) != null ? _a : 200, {
+      "Content-Type": "text/plain; charset=utf-8",
+      ...init == null ? void 0 : init.headers
+    });
+    const reader = this.textStream.pipeThrough(createCallbacksTransformer(void 0)).pipeThrough(createStreamDataTransformer()).getReader();
+    const read = async () => {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          response.write(value);
+        }
+      } catch (error) {
+        throw error;
+      } finally {
+        response.end();
+      }
+    };
+    read();
+  }
+  /**
+  Writes text delta output to a Node.js response-like object.
+  It sets a `Content-Type` header to `text/plain; charset=utf-8` and 
+  writes each text delta as a separate chunk.
+  
+  @param response A Node.js response-like object (ServerResponse).
+  @param init Optional headers and status code.
+     */
+  pipeTextStreamToResponse(response, init) {
+    var _a;
+    response.writeHead((_a = init == null ? void 0 : init.status) != null ? _a : 200, {
+      "Content-Type": "text/plain; charset=utf-8",
+      ...init == null ? void 0 : init.headers
+    });
+    const reader = this.textStream.getReader();
+    const read = async () => {
+      const encoder = new TextEncoder();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          response.write(encoder.encode(value));
+        }
+      } catch (error) {
+        throw error;
+      } finally {
+        response.end();
+      }
+    };
+    read();
+  }
+  /**
+  Converts the result to a streamed response object with a stream data part stream.
+  It can be used with the `useChat` and `useCompletion` hooks.
+  
+  @param init Optional headers.
+  
+  @return A response object.
+     */
+  toAIStreamResponse(init) {
+    return new StreamingTextResponse(this.toAIStream(), init);
+  }
+  /**
+  Creates a simple text stream response.
+  Each text delta is encoded as UTF-8 and sent as a separate chunk.
+  Non-text-delta events are ignored.
+  
+  @param init Optional headers and status code.
+     */
+  toTextStreamResponse(init) {
+    var _a;
+    const encoder = new TextEncoder();
+    return new Response(
+      this.textStream.pipeThrough(
+        new TransformStream({
+          transform(chunk, controller) {
+            controller.enqueue(encoder.encode(chunk));
+          }
+        })
+      ),
+      {
+        status: (_a = init == null ? void 0 : init.status) != null ? _a : 200,
+        headers: {
+          "Content-Type": "text/plain; charset=utf-8",
+          ...init == null ? void 0 : init.headers
+        }
+      }
+    );
+  }
+};
+var experimental_streamText = streamText;
+
+// core/tool/tool.ts
+function tool(tool2) {
+  return tool2;
+}
+
+// core/types/errors.ts
+import {
+  APICallError as APICallError2,
+  EmptyResponseBodyError,
+  InvalidArgumentError as InvalidArgumentError2,
+  InvalidDataContentError as InvalidDataContentError2,
+  InvalidPromptError as InvalidPromptError2,
+  InvalidResponseDataError,
+  InvalidToolArgumentsError as InvalidToolArgumentsError2,
+  JSONParseError,
+  LoadAPIKeyError,
+  NoObjectGeneratedError as NoObjectGeneratedError2,
+  NoSuchToolError as NoSuchToolError3,
+  RetryError as RetryError2,
+  ToolCallParseError,
+  TypeValidationError,
+  UnsupportedFunctionalityError,
+  UnsupportedJSONSchemaError
+} from "@ai-sdk/provider";
 
 // shared/stream-parts.ts
 var textStreamPart = {
@@ -101,9 +1674,9 @@ 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";
-    })) {
+    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.'
       );
@@ -181,11 +1754,50 @@ function formatStreamPart(type, value) {
 `;
 }
 
+// shared/read-data-stream.ts
+var NEWLINE = "\n".charCodeAt(0);
+function concatChunks(chunks, totalLength) {
+  const concatenatedChunks = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    concatenatedChunks.set(chunk, offset);
+    offset += chunk.length;
+  }
+  chunks.length = 0;
+  return concatenatedChunks;
+}
+async function* readDataStream(reader, {
+  isAborted
+} = {}) {
+  const decoder = new TextDecoder();
+  const chunks = [];
+  let totalLength = 0;
+  while (true) {
+    const { value } = await reader.read();
+    if (value) {
+      chunks.push(value);
+      totalLength += value.length;
+      if (value[value.length - 1] !== NEWLINE) {
+        continue;
+      }
+    }
+    if (chunks.length === 0) {
+      break;
+    }
+    const concatenatedChunks = concatChunks(chunks, totalLength);
+    totalLength = 0;
+    const streamParts2 = decoder.decode(concatenatedChunks, { stream: true }).split("\n").filter((line) => line !== "").map(parseStreamPart);
+    for (const streamPart of streamParts2) {
+      yield streamPart;
+    }
+    if (isAborted == null ? void 0 : isAborted()) {
+      reader.cancel();
+      break;
+    }
+  }
+}
+
 // shared/utils.ts
-var nanoid = customAlphabet(
-  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
-  7
-);
 function createChunkDecoder(complex) {
   const decoder = new TextDecoder();
   if (!complex) {
@@ -201,7 +1813,6 @@ function createChunkDecoder(complex) {
   };
 }
 var isStreamStringEqualToType = (type, value) => value.startsWith(`${StreamStringPrefixes[type]}:`) && value.endsWith("\n");
-var COMPLEX_HEADER = "X-Experimental-Stream-Data";
 
 // streams/ai-stream.ts
 import {
@@ -328,7 +1939,7 @@ function readableFromAsyncIterable(iterable) {
 }
 
 // streams/stream-data.ts
-var experimental_StreamData = class {
+var StreamData = class {
   constructor() {
     this.encoder = new TextEncoder();
     this.controller = null;
@@ -414,14 +2025,7 @@ var experimental_StreamData = class {
     this.messageAnnotations.push(value);
   }
 };
-function createStreamDataTransformer(experimental_streamData) {
-  if (!experimental_streamData) {
-    return new TransformStream({
-      transform: async (chunk, controller) => {
-        controller.enqueue(chunk);
-      }
-    });
-  }
+function createStreamDataTransformer() {
   const encoder = new TextEncoder();
   const decoder = new TextDecoder();
   return new TransformStream({
@@ -431,6 +2035,8 @@ function createStreamDataTransformer(experimental_streamData) {
     }
   });
 }
+var experimental_StreamData = class extends StreamData {
+};
 
 // streams/anthropic-stream.ts
 function parseAnthropicStream() {
@@ -470,16 +2076,16 @@ async function* streamable(stream) {
 }
 function AnthropicStream(res, cb) {
   if (Symbol.asyncIterator in res) {
-    return readableFromAsyncIterable(streamable(res)).pipeThrough(createCallbacksTransformer(cb)).pipeThrough(createStreamDataTransformer(cb == null ? void 0 : cb.experimental_streamData));
+    return readableFromAsyncIterable(streamable(res)).pipeThrough(createCallbacksTransformer(cb)).pipeThrough(createStreamDataTransformer());
   } else {
     return AIStream(res, parseAnthropicStream(), cb).pipeThrough(
-      createStreamDataTransformer(cb == null ? void 0 : cb.experimental_streamData)
+      createStreamDataTransformer()
     );
   }
 }
 
 // streams/assistant-response.ts
-function experimental_AssistantResponse({ threadId, messageId }, process2) {
+function AssistantResponse({ threadId, messageId }, process2) {
   const stream = new ReadableStream({
     async start(controller) {
       var _a;
@@ -570,6 +2176,7 @@ function experimental_AssistantResponse({ threadId, messageId }, process2) {
     }
   });
 }
+var experimental_AssistantResponse = AssistantResponse;
 
 // streams/aws-bedrock-stream.ts
 async function* asDeltaIterable(response, extractTextDeltaFromChunk) {
@@ -587,20 +2194,17 @@ async function* asDeltaIterable(response, extractTextDeltaFromChunk) {
     }
   }
 }
+function AWSBedrockAnthropicMessagesStream(response, callbacks) {
+  return AWSBedrockStream(response, callbacks, (chunk) => {
+    var _a;
+    return (_a = chunk.delta) == null ? void 0 : _a.text;
+  });
+}
 function AWSBedrockAnthropicStream(response, callbacks) {
   return AWSBedrockStream(response, callbacks, (chunk) => chunk.completion);
 }
 function AWSBedrockCohereStream(response, callbacks) {
-  return AWSBedrockStream(
-    response,
-    callbacks,
-    // As of 2023-11-17, Bedrock does not support streaming for Cohere,
-    // so we take the full generation:
-    (chunk) => {
-      var _a, _b;
-      return (_b = (_a = chunk.generations) == null ? void 0 : _a[0]) == null ? void 0 : _b.text;
-    }
-  );
+  return AWSBedrockStream(response, callbacks, (chunk) => chunk == null ? void 0 : chunk.text);
 }
 function AWSBedrockLlama2Stream(response, callbacks) {
   return AWSBedrockStream(response, callbacks, (chunk) => chunk.generation);
@@ -608,9 +2212,7 @@ function AWSBedrockLlama2Stream(response, callbacks) {
 function AWSBedrockStream(response, callbacks, extractTextDeltaFromChunk) {
   return readableFromAsyncIterable(
     asDeltaIterable(response, extractTextDeltaFromChunk)
-  ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
-    createStreamDataTransformer(callbacks == null ? void 0 : callbacks.experimental_streamData)
-  );
+  ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer());
 }
 
 // streams/cohere-stream.ts
@@ -665,13 +2267,9 @@ async function* streamable2(stream) {
 }
 function CohereStream(reader, callbacks) {
   if (Symbol.asyncIterator in reader) {
-    return readableFromAsyncIterable(streamable2(reader)).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
-      createStreamDataTransformer(callbacks == null ? void 0 : callbacks.experimental_streamData)
-    );
+    return readableFromAsyncIterable(streamable2(reader)).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer());
   } else {
-    return createParser2(reader).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
-      createStreamDataTransformer(callbacks == null ? void 0 : callbacks.experimental_streamData)
-    );
+    return createParser2(reader).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer());
   }
 }
 
@@ -690,7 +2288,7 @@ async function* streamable3(response) {
   }
 }
 function GoogleGenerativeAIStream(response, cb) {
-  return readableFromAsyncIterable(streamable3(response)).pipeThrough(createCallbacksTransformer(cb)).pipeThrough(createStreamDataTransformer(cb == null ? void 0 : cb.experimental_streamData));
+  return readableFromAsyncIterable(streamable3(response)).pipeThrough(createCallbacksTransformer(cb)).pipeThrough(createStreamDataTransformer());
 }
 
 // streams/huggingface-stream.ts
@@ -718,9 +2316,7 @@ function createParser3(res) {
   });
 }
 function HuggingFaceStream(res, callbacks) {
-  return createParser3(res).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
-    createStreamDataTransformer(callbacks == null ? void 0 : callbacks.experimental_streamData)
-  );
+  return createParser3(res).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer());
 }
 
 // streams/inkeep-stream.ts
@@ -757,7 +2353,7 @@ function InkeepStream(res, callbacks) {
     }
   };
   return AIStream(res, inkeepEventParser, passThroughCallbacks).pipeThrough(
-    createStreamDataTransformer(passThroughCallbacks == null ? void 0 : passThroughCallbacks.experimental_streamData)
+    createStreamDataTransformer()
   );
 }
 
@@ -782,9 +2378,7 @@ function LangChainStream(callbacks) {
     }
   };
   return {
-    stream: stream.readable.pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
-      createStreamDataTransformer(callbacks == null ? void 0 : callbacks.experimental_streamData)
-    ),
+    stream: stream.readable.pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer()),
     writer,
     handlers: {
       handleLLMNewToken: async (token) => {
@@ -835,9 +2429,7 @@ async function* streamable4(stream) {
 }
 function MistralStream(response, callbacks) {
   const stream = readableFromAsyncIterable(streamable4(response));
-  return stream.pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
-    createStreamDataTransformer(callbacks == null ? void 0 : callbacks.experimental_streamData)
-  );
+  return stream.pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer());
 }
 
 // streams/openai-stream.ts
@@ -981,9 +2573,7 @@ function OpenAIStream(res, callbacks) {
     const functionCallTransformer = createFunctionCallTransformer(cb);
     return stream.pipeThrough(functionCallTransformer);
   } else {
-    return stream.pipeThrough(
-      createStreamDataTransformer(cb == null ? void 0 : cb.experimental_streamData)
-    );
+    return stream.pipeThrough(createStreamDataTransformer());
   }
 }
 function createFunctionCallTransformer(callbacks) {
@@ -993,7 +2583,6 @@ function createFunctionCallTransformer(callbacks) {
   let aggregatedFinalCompletionResponse = "";
   let isFunctionStreamingIn = false;
   let functionCallMessages = callbacks[__internal__OpenAIFnMessagesSymbol] || [];
-  const isComplexMode = callbacks == null ? void 0 : callbacks.experimental_streamData;
   const decode = createChunkDecoder();
   return new TransformStream({
     async transform(chunk, controller) {
@@ -1008,7 +2597,7 @@ function createFunctionCallTransformer(callbacks) {
       }
       if (!isFunctionStreamingIn) {
         controller.enqueue(
-          isComplexMode ? textEncoder.encode(formatStreamPart("text", message)) : chunk
+          textEncoder.encode(formatStreamPart("text", message))
         );
         return;
       } else {
@@ -1060,13 +2649,13 @@ function createFunctionCallTransformer(callbacks) {
             const toolCalls = {
               tools: []
             };
-            for (const tool of payload.tool_calls) {
+            for (const tool2 of payload.tool_calls) {
               toolCalls.tools.push({
-                id: tool.id,
+                id: tool2.id,
                 type: "function",
                 func: {
-                  name: tool.function.name,
-                  arguments: JSON.parse(tool.function.arguments)
+                  name: tool2.function.name,
+                  arguments: JSON.parse(tool2.function.arguments)
                 }
               });
             }
@@ -1119,17 +2708,17 @@ function createFunctionCallTransformer(callbacks) {
           if (!functionResponse) {
             controller.enqueue(
               textEncoder.encode(
-                isComplexMode ? formatStreamPart(
+                formatStreamPart(
                   payload.function_call ? "function_call" : "tool_calls",
                   // parse to prevent double-encoding:
                   JSON.parse(aggregatedResponse)
-                ) : aggregatedResponse
+                )
               )
             );
             return;
           } else if (typeof functionResponse === "string") {
             controller.enqueue(
-              isComplexMode ? textEncoder.encode(formatStreamPart("text", functionResponse)) : textEncoder.encode(functionResponse)
+              textEncoder.encode(formatStreamPart("text", functionResponse))
             );
             aggregatedFinalCompletionResponse = functionResponse;
             return;
@@ -1179,53 +2768,10 @@ async function ReplicateStream(res, cb, options) {
     }
   });
   return AIStream(eventStream, void 0, cb).pipeThrough(
-    createStreamDataTransformer(cb == null ? void 0 : cb.experimental_streamData)
+    createStreamDataTransformer()
   );
 }
 
-// shared/read-data-stream.ts
-var NEWLINE = "\n".charCodeAt(0);
-function concatChunks(chunks, totalLength) {
-  const concatenatedChunks = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const chunk of chunks) {
-    concatenatedChunks.set(chunk, offset);
-    offset += chunk.length;
-  }
-  chunks.length = 0;
-  return concatenatedChunks;
-}
-async function* readDataStream(reader, {
-  isAborted
-} = {}) {
-  const decoder = new TextDecoder();
-  const chunks = [];
-  let totalLength = 0;
-  while (true) {
-    const { value } = await reader.read();
-    if (value) {
-      chunks.push(value);
-      totalLength += value.length;
-      if (value[value.length - 1] !== NEWLINE) {
-        continue;
-      }
-    }
-    if (chunks.length === 0) {
-      break;
-    }
-    const concatenatedChunks = concatChunks(chunks, totalLength);
-    totalLength = 0;
-    const streamParts2 = decoder.decode(concatenatedChunks, { stream: true }).split("\n").filter((line) => line !== "").map(parseStreamPart);
-    for (const streamPart of streamParts2) {
-      yield streamPart;
-    }
-    if (isAborted == null ? void 0 : isAborted()) {
-      reader.cancel();
-      break;
-    }
-  }
-}
-
 // shared/parse-complex-response.ts
 function assignAnnotationsToMessage(message, annotations) {
   if (!message || !annotations || !annotations.length)
@@ -1237,7 +2783,7 @@ async function parseComplexResponse({
   abortControllerRef,
   update,
   onFinish,
-  generateId = nanoid,
+  generateId: generateId2 = generateId,
   getCurrentDate = () => /* @__PURE__ */ new Date()
 }) {
   const createdAt = getCurrentDate();
@@ -1256,7 +2802,7 @@ async function parseComplexResponse({
         };
       } else {
         prefixMap["text"] = {
-          id: generateId(),
+          id: generateId2(),
           role: "assistant",
           content: value,
           createdAt
@@ -1266,7 +2812,7 @@ async function parseComplexResponse({
     let functionCallMessage = null;
     if (type === "function_call") {
       prefixMap["function_call"] = {
-        id: generateId(),
+        id: generateId2(),
         role: "assistant",
         content: "",
         function_call: value.function_call,
@@ -1278,7 +2824,7 @@ async function parseComplexResponse({
     let toolCallMessage = null;
     if (type === "tool_calls") {
       prefixMap["tool_calls"] = {
-        id: generateId(),
+        id: generateId2(),
         role: "assistant",
         content: "",
         tool_calls: value.tool_calls,
@@ -1340,74 +2886,41 @@ async function parseComplexResponse({
 // streams/streaming-react-response.ts
 var experimental_StreamingReactResponse = class {
   constructor(res, options) {
-    var _a;
+    var _a, _b;
     let resolveFunc = () => {
     };
     let next = new Promise((resolve) => {
       resolveFunc = resolve;
     });
-    if (options == null ? void 0 : options.data) {
-      const processedStream = res.pipeThrough(
-        options.data.stream
-      );
-      let lastPayload = void 0;
-      parseComplexResponse({
-        reader: processedStream.getReader(),
-        update: (merged, data) => {
-          var _a2, _b, _c;
-          const content2 = (_b = (_a2 = merged[0]) == null ? void 0 : _a2.content) != null ? _b : "";
-          const ui = ((_c = options == null ? void 0 : options.ui) == null ? void 0 : _c.call(options, { content: content2, data })) || content2;
-          const payload = { ui, content: content2 };
-          const resolvePrevious = resolveFunc;
-          const nextRow = new Promise((resolve) => {
-            resolveFunc = resolve;
-          });
-          resolvePrevious({
-            next: nextRow,
-            ...payload
+    const processedStream = (options == null ? void 0 : options.data) != null ? res.pipeThrough((_a = options == null ? void 0 : options.data) == null ? void 0 : _a.stream) : res;
+    let lastPayload = void 0;
+    parseComplexResponse({
+      reader: processedStream.getReader(),
+      update: (merged, data) => {
+        var _a2, _b2, _c;
+        const content = (_b2 = (_a2 = merged[0]) == null ? void 0 : _a2.content) != null ? _b2 : "";
+        const ui = ((_c = options == null ? void 0 : options.ui) == null ? void 0 : _c.call(options, { content, data })) || content;
+        const payload = { ui, content };
+        const resolvePrevious = resolveFunc;
+        const nextRow = new Promise((resolve) => {
+          resolveFunc = resolve;
+        });
+        resolvePrevious({
+          next: nextRow,
+          ...payload
+        });
+        lastPayload = payload;
+      },
+      generateId: (_b = options == null ? void 0 : options.generateId) != null ? _b : generateId,
+      onFinish: () => {
+        if (lastPayload !== void 0) {
+          resolveFunc({
+            next: null,
+            ...lastPayload
           });
-          lastPayload = payload;
-        },
-        generateId: (_a = options.generateId) != null ? _a : nanoid,
-        onFinish: () => {
-          if (lastPayload !== void 0) {
-            resolveFunc({
-              next: null,
-              ...lastPayload
-            });
-          }
         }
-      });
-      return next;
-    }
-    let content = "";
-    const decode = createChunkDecoder();
-    const reader = res.getReader();
-    async function readChunk() {
-      var _a2;
-      const { done, value } = await reader.read();
-      if (!done) {
-        content += decode(value);
       }
-      const ui = ((_a2 = options == null ? void 0 : options.ui) == null ? void 0 : _a2.call(options, { content })) || content;
-      const payload = {
-        ui,
-        content
-      };
-      const resolvePrevious = resolveFunc;
-      const nextRow = done ? null : new Promise((resolve) => {
-        resolveFunc = resolve;
-      });
-      resolvePrevious({
-        next: nextRow,
-        ...payload
-      });
-      if (done) {
-        return;
-      }
-      await readChunk();
-    }
-    readChunk();
+    });
     return next;
   }
 };
@@ -1424,7 +2937,6 @@ var StreamingTextResponse = class extends Response {
       status: 200,
       headers: {
         "Content-Type": "text/plain; charset=utf-8",
-        [COMPLEX_HEADER]: data ? "true" : "false",
         ...init == null ? void 0 : init.headers
       }
     });
@@ -1450,21 +2962,45 @@ function streamToResponse(res, response, init) {
 }
 export {
   AIStream,
+  APICallError2 as APICallError,
+  AWSBedrockAnthropicMessagesStream,
   AWSBedrockAnthropicStream,
   AWSBedrockCohereStream,
   AWSBedrockLlama2Stream,
   AWSBedrockStream,
   AnthropicStream,
-  COMPLEX_HEADER,
+  AssistantResponse,
   CohereStream,
+  EmptyResponseBodyError,
+  GenerateObjectResult,
+  GenerateTextResult,
   GoogleGenerativeAIStream,
   HuggingFaceStream,
   InkeepStream,
+  InvalidArgumentError2 as InvalidArgumentError,
+  InvalidDataContentError2 as InvalidDataContentError,
+  InvalidPromptError2 as InvalidPromptError,
+  InvalidResponseDataError,
+  InvalidToolArgumentsError2 as InvalidToolArgumentsError,
+  JSONParseError,
   LangChainStream,
+  LoadAPIKeyError,
   MistralStream,
+  NoObjectGeneratedError2 as NoObjectGeneratedError,
+  NoSuchToolError3 as NoSuchToolError,
   OpenAIStream,
   ReplicateStream,
+  RetryError2 as RetryError,
+  StreamData,
+  StreamObjectResult,
+  StreamTextResult,
   StreamingTextResponse,
+  ToolCallParseError,
+  TypeValidationError,
+  UnsupportedFunctionalityError,
+  UnsupportedJSONSchemaError,
+  convertDataContentToBase64String,
+  convertDataContentToUint8Array,
   createCallbacksTransformer,
   createChunkDecoder,
   createEventStreamTransformer,
@@ -1472,10 +3008,23 @@ export {
   experimental_AssistantResponse,
   experimental_StreamData,
   experimental_StreamingReactResponse,
+  experimental_generateObject,
+  experimental_generateText,
+  experimental_streamObject,
+  experimental_streamText,
+  formatStreamPart,
+  generateId,
+  generateObject,
+  generateText,
   isStreamStringEqualToType,
-  nanoid,
+  generateId as nanoid,
+  parseStreamPart,
+  readDataStream,
   readableFromAsyncIterable,
+  streamObject,
+  streamText,
   streamToResponse,
+  tool,
   trimStartOfStreamHelper
 };
 //# sourceMappingURL=index.mjs.map