@alpic80/rivet-ai-sdk-provider 2.0.0

package/dist/index.mjs

@@ -0,0 +1,1842 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// node_modules/.pnpm/@ai-sdk+provider@2.0.0/node_modules/@ai-sdk/provider/dist/index.mjs
+var marker = "vercel.ai.error";
+var symbol = Symbol.for(marker);
+var _a;
+var _AISDKError = class _AISDKError2 extends Error {
+  /**
+   * Creates an AI SDK Error.
+   *
+   * @param {Object} params - The parameters for creating the error.
+   * @param {string} params.name - The name of the error.
+   * @param {string} params.message - The error message.
+   * @param {unknown} [params.cause] - The underlying cause of the error.
+   */
+  constructor({
+    name: name14,
+    message,
+    cause
+  }) {
+    super(message);
+    this[_a] = true;
+    this.name = name14;
+    this.cause = cause;
+  }
+  /**
+   * Checks if the given error is an AI SDK Error.
+   * @param {unknown} error - The error to check.
+   * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
+   */
+  static isInstance(error) {
+    return _AISDKError2.hasMarker(error, marker);
+  }
+  static hasMarker(error, marker15) {
+    const markerSymbol = Symbol.for(marker15);
+    return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
+  }
+};
+_a = symbol;
+var AISDKError = _AISDKError;
+var name = "AI_APICallError";
+var marker2 = `vercel.ai.error.${name}`;
+var symbol2 = Symbol.for(marker2);
+var _a2;
+var APICallError = class extends AISDKError {
+  constructor({
+    message,
+    url,
+    requestBodyValues,
+    statusCode,
+    responseHeaders,
+    responseBody,
+    cause,
+    isRetryable = statusCode != null && (statusCode === 408 || // request timeout
+    statusCode === 409 || // conflict
+    statusCode === 429 || // too many requests
+    statusCode >= 500),
+    // server error
+    data
+  }) {
+    super({ name, message, cause });
+    this[_a2] = true;
+    this.url = url;
+    this.requestBodyValues = requestBodyValues;
+    this.statusCode = statusCode;
+    this.responseHeaders = responseHeaders;
+    this.responseBody = responseBody;
+    this.isRetryable = isRetryable;
+    this.data = data;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker2);
+  }
+};
+_a2 = symbol2;
+var name2 = "AI_EmptyResponseBodyError";
+var marker3 = `vercel.ai.error.${name2}`;
+var symbol3 = Symbol.for(marker3);
+var _a3;
+var EmptyResponseBodyError = class extends AISDKError {
+  // used in isInstance
+  constructor({ message = "Empty response body" } = {}) {
+    super({ name: name2, message });
+    this[_a3] = true;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker3);
+  }
+};
+_a3 = symbol3;
+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);
+}
+var name3 = "AI_InvalidArgumentError";
+var marker4 = `vercel.ai.error.${name3}`;
+var symbol4 = Symbol.for(marker4);
+var _a4;
+var InvalidArgumentError = class extends AISDKError {
+  constructor({
+    message,
+    cause,
+    argument
+  }) {
+    super({ name: name3, message, cause });
+    this[_a4] = true;
+    this.argument = argument;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker4);
+  }
+};
+_a4 = symbol4;
+var name4 = "AI_InvalidPromptError";
+var marker5 = `vercel.ai.error.${name4}`;
+var symbol5 = Symbol.for(marker5);
+var _a5;
+_a5 = symbol5;
+var name5 = "AI_InvalidResponseDataError";
+var marker6 = `vercel.ai.error.${name5}`;
+var symbol6 = Symbol.for(marker6);
+var _a6;
+_a6 = symbol6;
+var name6 = "AI_JSONParseError";
+var marker7 = `vercel.ai.error.${name6}`;
+var symbol7 = Symbol.for(marker7);
+var _a7;
+var JSONParseError = class extends AISDKError {
+  constructor({ text, cause }) {
+    super({
+      name: name6,
+      message: `JSON parsing failed: Text: ${text}.
+Error message: ${getErrorMessage(cause)}`,
+      cause
+    });
+    this[_a7] = true;
+    this.text = text;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker7);
+  }
+};
+_a7 = symbol7;
+var name7 = "AI_LoadAPIKeyError";
+var marker8 = `vercel.ai.error.${name7}`;
+var symbol8 = Symbol.for(marker8);
+var _a8;
+var LoadAPIKeyError = class extends AISDKError {
+  // used in isInstance
+  constructor({ message }) {
+    super({ name: name7, message });
+    this[_a8] = true;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker8);
+  }
+};
+_a8 = symbol8;
+var name8 = "AI_LoadSettingError";
+var marker9 = `vercel.ai.error.${name8}`;
+var symbol9 = Symbol.for(marker9);
+var _a9;
+_a9 = symbol9;
+var name9 = "AI_NoContentGeneratedError";
+var marker10 = `vercel.ai.error.${name9}`;
+var symbol10 = Symbol.for(marker10);
+var _a10;
+_a10 = symbol10;
+var name10 = "AI_NoSuchModelError";
+var marker11 = `vercel.ai.error.${name10}`;
+var symbol11 = Symbol.for(marker11);
+var _a11;
+var NoSuchModelError = class extends AISDKError {
+  constructor({
+    errorName = name10,
+    modelId,
+    modelType,
+    message = `No such ${modelType}: ${modelId}`
+  }) {
+    super({ name: errorName, message });
+    this[_a11] = true;
+    this.modelId = modelId;
+    this.modelType = modelType;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker11);
+  }
+};
+_a11 = symbol11;
+var name11 = "AI_TooManyEmbeddingValuesForCallError";
+var marker12 = `vercel.ai.error.${name11}`;
+var symbol12 = Symbol.for(marker12);
+var _a12;
+_a12 = symbol12;
+var name12 = "AI_TypeValidationError";
+var marker13 = `vercel.ai.error.${name12}`;
+var symbol13 = Symbol.for(marker13);
+var _a13;
+var _TypeValidationError = class _TypeValidationError2 extends AISDKError {
+  constructor({ value, cause }) {
+    super({
+      name: name12,
+      message: `Type validation failed: Value: ${JSON.stringify(value)}.
+Error message: ${getErrorMessage(cause)}`,
+      cause
+    });
+    this[_a13] = true;
+    this.value = value;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker13);
+  }
+  /**
+   * Wraps an error into a TypeValidationError.
+   * If the cause is already a TypeValidationError with the same value, it returns the cause.
+   * Otherwise, it creates a new TypeValidationError.
+   *
+   * @param {Object} params - The parameters for wrapping the error.
+   * @param {unknown} params.value - The value that failed validation.
+   * @param {unknown} params.cause - The original error or cause of the validation failure.
+   * @returns {TypeValidationError} A TypeValidationError instance.
+   */
+  static wrap({
+    value,
+    cause
+  }) {
+    return _TypeValidationError2.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError2({ value, cause });
+  }
+};
+_a13 = symbol13;
+var TypeValidationError = _TypeValidationError;
+var name13 = "AI_UnsupportedFunctionalityError";
+var marker14 = `vercel.ai.error.${name13}`;
+var symbol14 = Symbol.for(marker14);
+var _a14;
+var UnsupportedFunctionalityError = class extends AISDKError {
+  constructor({
+    functionality,
+    message = `'${functionality}' functionality not supported.`
+  }) {
+    super({ name: name13, message });
+    this[_a14] = true;
+    this.functionality = functionality;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker14);
+  }
+};
+_a14 = symbol14;
+
+// node_modules/.pnpm/eventsource-parser@3.0.6/node_modules/eventsource-parser/dist/index.js
+var ParseError = class extends Error {
+  constructor(message, options) {
+    super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+  }
+};
+function noop(_arg) {
+}
+function createParser(callbacks) {
+  if (typeof callbacks == "function")
+    throw new TypeError(
+      "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
+    );
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks;
+  let incompleteLine = "", isFirstChunk = true, id, data = "", eventType = "";
+  function feed(newChunk) {
+    const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`);
+    for (const line of complete)
+      parseLine(line);
+    incompleteLine = incomplete, isFirstChunk = false;
+  }
+  function parseLine(line) {
+    if (line === "") {
+      dispatchEvent();
+      return;
+    }
+    if (line.startsWith(":")) {
+      onComment && onComment(line.slice(line.startsWith(": ") ? 2 : 1));
+      return;
+    }
+    const fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex !== -1) {
+      const field = line.slice(0, fieldSeparatorIndex), offset = line[fieldSeparatorIndex + 1] === " " ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+      processField(field, value, line);
+      return;
+    }
+    processField(line, "", line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value;
+        break;
+      case "data":
+        data = `${data}${value}
+`;
+        break;
+      case "id":
+        id = value.includes("\0") ? void 0 : value;
+        break;
+      case "retry":
+        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
+          new ParseError(`Invalid \`retry\` value: "${value}"`, {
+            type: "invalid-retry",
+            value,
+            line
+          })
+        );
+        break;
+      default:
+        onError(
+          new ParseError(
+            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
+            { type: "unknown-field", field, value, line }
+          )
+        );
+        break;
+    }
+  }
+  function dispatchEvent() {
+    data.length > 0 && onEvent({
+      id,
+      event: eventType || void 0,
+      // If the data buffer's last character is a U+000A LINE FEED (LF) character,
+      // then remove the last character from the data buffer.
+      data: data.endsWith(`
+`) ? data.slice(0, -1) : data
+    }), id = void 0, data = "", eventType = "";
+  }
+  function reset(options = {}) {
+    incompleteLine && options.consume && parseLine(incompleteLine), isFirstChunk = true, id = void 0, data = "", eventType = "", incompleteLine = "";
+  }
+  return { feed, reset };
+}
+function splitLines(chunk) {
+  const lines = [];
+  let incompleteLine = "", searchIndex = 0;
+  for (; searchIndex < chunk.length; ) {
+    const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+    let lineEnd = -1;
+    if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
+      incompleteLine = chunk.slice(searchIndex);
+      break;
+    } else {
+      const line = chunk.slice(searchIndex, lineEnd);
+      lines.push(line), searchIndex = lineEnd + 1, chunk[searchIndex - 1] === "\r" && chunk[searchIndex] === `
+` && searchIndex++;
+    }
+  }
+  return [lines, incompleteLine];
+}
+
+// node_modules/.pnpm/eventsource-parser@3.0.6/node_modules/eventsource-parser/dist/stream.js
+var EventSourceParserStream = class extends TransformStream {
+  constructor({ onError, onRetry, onComment } = {}) {
+    let parser;
+    super({
+      start(controller) {
+        parser = createParser({
+          onEvent: (event) => {
+            controller.enqueue(event);
+          },
+          onError(error) {
+            onError === "terminate" ? controller.error(error) : typeof onError == "function" && onError(error);
+          },
+          onRetry,
+          onComment
+        });
+      },
+      transform(chunk) {
+        parser.feed(chunk);
+      }
+    });
+  }
+};
+
+// node_modules/.pnpm/@ai-sdk+provider-utils@3.0.12_zod@3.25.76/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+import * as z4 from "zod/v4";
+import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind3 } from "zod/v3";
+import { ZodFirstPartyTypeKind } from "zod/v3";
+import {
+  ZodFirstPartyTypeKind as ZodFirstPartyTypeKind2
+} from "zod/v3";
+function combineHeaders(...headers) {
+  return headers.reduce(
+    (combinedHeaders, currentHeaders) => __spreadValues(__spreadValues({}, combinedHeaders), currentHeaders != null ? currentHeaders : {}),
+    {}
+  );
+}
+function extractResponseHeaders(response) {
+  return Object.fromEntries([...response.headers]);
+}
+var createIdGenerator = ({
+  prefix,
+  size = 16,
+  alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  separator = "-"
+} = {}) => {
+  const generator = () => {
+    const alphabetLength = alphabet.length;
+    const chars = new Array(size);
+    for (let i = 0; i < size; i++) {
+      chars[i] = alphabet[Math.random() * alphabetLength | 0];
+    }
+    return chars.join("");
+  };
+  if (prefix == null) {
+    return generator;
+  }
+  if (alphabet.includes(separator)) {
+    throw new InvalidArgumentError({
+      argument: "separator",
+      message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
+    });
+  }
+  return () => `${prefix}${separator}${generator()}`;
+};
+var generateId = createIdGenerator();
+function isAbortError(error) {
+  return (error instanceof Error || error instanceof DOMException) && (error.name === "AbortError" || error.name === "ResponseAborted" || // Next.js
+  error.name === "TimeoutError");
+}
+function getRuntimeEnvironmentUserAgent(globalThisAny = globalThis) {
+  var _a15, _b, _c;
+  if (globalThisAny.window) {
+    return `runtime/browser`;
+  }
+  if ((_a15 = globalThisAny.navigator) == null ? void 0 : _a15.userAgent) {
+    return `runtime/${globalThisAny.navigator.userAgent.toLowerCase()}`;
+  }
+  if ((_c = (_b = globalThisAny.process) == null ? void 0 : _b.versions) == null ? void 0 : _c.node) {
+    return `runtime/node.js/${globalThisAny.process.version.substring(0)}`;
+  }
+  if (globalThisAny.EdgeRuntime) {
+    return `runtime/vercel-edge`;
+  }
+  return "runtime/unknown";
+}
+function removeUndefinedEntries(record) {
+  return Object.fromEntries(
+    Object.entries(record).filter(([_key, value]) => value != null)
+  );
+}
+function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
+  const cleanedHeaders = removeUndefinedEntries(
+    headers != null ? headers : {}
+  );
+  const normalizedHeaders = new Headers(cleanedHeaders);
+  const currentUserAgentHeader = normalizedHeaders.get("user-agent") || "";
+  normalizedHeaders.set(
+    "user-agent",
+    [currentUserAgentHeader, ...userAgentSuffixParts].filter(Boolean).join(" ")
+  );
+  return Object.fromEntries(normalizedHeaders);
+}
+function loadApiKey({
+  apiKey,
+  environmentVariableName,
+  apiKeyParameterName = "apiKey",
+  description
+}) {
+  if (typeof apiKey === "string") {
+    return apiKey;
+  }
+  if (apiKey != null) {
+    throw new LoadAPIKeyError({
+      message: `${description} API key must be a string.`
+    });
+  }
+  if (typeof process === "undefined") {
+    throw new LoadAPIKeyError({
+      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables is not supported in this environment.`
+    });
+  }
+  apiKey = process.env[environmentVariableName];
+  if (apiKey == null) {
+    throw new LoadAPIKeyError({
+      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter or the ${environmentVariableName} environment variable.`
+    });
+  }
+  if (typeof apiKey !== "string") {
+    throw new LoadAPIKeyError({
+      message: `${description} API key must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
+    });
+  }
+  return apiKey;
+}
+var suspectProtoRx = /"__proto__"\s*:/;
+var suspectConstructorRx = /"constructor"\s*:/;
+function _parse(text) {
+  const obj = JSON.parse(text);
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) {
+    return obj;
+  }
+  return filter(obj);
+}
+function filter(obj) {
+  let next = [obj];
+  while (next.length) {
+    const nodes = next;
+    next = [];
+    for (const node of nodes) {
+      if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
+        throw new SyntaxError("Object contains forbidden prototype property");
+      }
+      if (Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+        throw new SyntaxError("Object contains forbidden prototype property");
+      }
+      for (const key in node) {
+        const value = node[key];
+        if (value && typeof value === "object") {
+          next.push(value);
+        }
+      }
+    }
+  }
+  return obj;
+}
+function secureJsonParse(text) {
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  try {
+    return _parse(text);
+  } finally {
+    Error.stackTraceLimit = stackTraceLimit;
+  }
+}
+var validatorSymbol = Symbol.for("vercel.ai.validator");
+function validator(validate) {
+  return { [validatorSymbol]: true, validate };
+}
+function isValidator(value) {
+  return typeof value === "object" && value !== null && validatorSymbol in value && value[validatorSymbol] === true && "validate" in value;
+}
+function asValidator(value) {
+  return isValidator(value) ? value : typeof value === "function" ? value() : standardSchemaValidator(value);
+}
+function standardSchemaValidator(standardSchema) {
+  return validator(async (value) => {
+    const result = await standardSchema["~standard"].validate(value);
+    return result.issues == null ? { success: true, value: result.value } : {
+      success: false,
+      error: new TypeValidationError({
+        value,
+        cause: result.issues
+      })
+    };
+  });
+}
+async function validateTypes({
+  value,
+  schema
+}) {
+  const result = await safeValidateTypes({ value, schema });
+  if (!result.success) {
+    throw TypeValidationError.wrap({ value, cause: result.error });
+  }
+  return result.value;
+}
+async function safeValidateTypes({
+  value,
+  schema
+}) {
+  const validator2 = asValidator(schema);
+  try {
+    if (validator2.validate == null) {
+      return { success: true, value, rawValue: value };
+    }
+    const result = await validator2.validate(value);
+    if (result.success) {
+      return { success: true, value: result.value, rawValue: value };
+    }
+    return {
+      success: false,
+      error: TypeValidationError.wrap({ value, cause: result.error }),
+      rawValue: value
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: TypeValidationError.wrap({ value, cause: error }),
+      rawValue: value
+    };
+  }
+}
+async function parseJSON({
+  text,
+  schema
+}) {
+  try {
+    const value = secureJsonParse(text);
+    if (schema == null) {
+      return value;
+    }
+    return validateTypes({ value, schema });
+  } catch (error) {
+    if (JSONParseError.isInstance(error) || TypeValidationError.isInstance(error)) {
+      throw error;
+    }
+    throw new JSONParseError({ text, cause: error });
+  }
+}
+async function safeParseJSON({
+  text,
+  schema
+}) {
+  try {
+    const value = secureJsonParse(text);
+    if (schema == null) {
+      return { success: true, value, rawValue: value };
+    }
+    return await safeValidateTypes({ value, schema });
+  } catch (error) {
+    return {
+      success: false,
+      error: JSONParseError.isInstance(error) ? error : new JSONParseError({ text, cause: error }),
+      rawValue: void 0
+    };
+  }
+}
+async function parseProviderOptions({
+  provider,
+  providerOptions,
+  schema
+}) {
+  if ((providerOptions == null ? void 0 : providerOptions[provider]) == null) {
+    return void 0;
+  }
+  const parsedProviderOptions = await safeValidateTypes({
+    value: providerOptions[provider],
+    schema
+  });
+  if (!parsedProviderOptions.success) {
+    throw new InvalidArgumentError({
+      argument: "providerOptions",
+      message: `invalid ${provider} provider options`,
+      cause: parsedProviderOptions.error
+    });
+  }
+  return parsedProviderOptions.value;
+}
+var createJsonErrorResponseHandler = ({
+  errorSchema,
+  errorToMessage,
+  isRetryable
+}) => async ({ response, url, requestBodyValues }) => {
+  const responseBody = await response.text();
+  const responseHeaders = extractResponseHeaders(response);
+  if (responseBody.trim() === "") {
+    return {
+      responseHeaders,
+      value: new APICallError({
+        message: response.statusText,
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders,
+        responseBody,
+        isRetryable: isRetryable == null ? void 0 : isRetryable(response)
+      })
+    };
+  }
+  try {
+    const parsedError = await parseJSON({
+      text: responseBody,
+      schema: errorSchema
+    });
+    return {
+      responseHeaders,
+      value: new APICallError({
+        message: errorToMessage(parsedError),
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders,
+        responseBody,
+        data: parsedError,
+        isRetryable: isRetryable == null ? void 0 : isRetryable(response, parsedError)
+      })
+    };
+  } catch (parseError) {
+    return {
+      responseHeaders,
+      value: new APICallError({
+        message: response.statusText,
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders,
+        responseBody,
+        isRetryable: isRetryable == null ? void 0 : isRetryable(response)
+      })
+    };
+  }
+};
+var ignoreOverride = Symbol(
+  "Let zodToJsonSchema decide on which parser to use"
+);
+var ALPHA_NUMERIC = new Set(
+  "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
+);
+var schemaSymbol = Symbol.for("vercel.ai.schema");
+var { btoa, atob } = globalThis;
+function convertUint8ArrayToBase64(array) {
+  let latin1string = "";
+  for (let i = 0; i < array.length; i++) {
+    latin1string += String.fromCodePoint(array[i]);
+  }
+  return btoa(latin1string);
+}
+function convertToBase64(value) {
+  return value instanceof Uint8Array ? convertUint8ArrayToBase64(value) : value;
+}
+function withoutTrailingSlash(url) {
+  return url == null ? void 0 : url.replace(/\/$/, "");
+}
+
+// src/rivet-chat-language-model.ts
+import { z as z3 } from "zod/v4";
+
+// src/rivet-chat-prompt.ts
+var SUPPORTED_IMAGE_MEDIA_TYPES = [
+  "image/jpeg",
+  "image/png",
+  "image/gif"
+];
+var isSupportedImageMediaType = (mediaType) => SUPPORTED_IMAGE_MEDIA_TYPES.includes(mediaType);
+
+// src/convert-to-rivet-chat-messages.ts
+function convertToRivetChatMessages(prompt) {
+  const messages = [];
+  for (let i = 0; i < prompt.length; i++) {
+    const pr = prompt[i];
+    if (!pr) continue;
+    const { role, content } = pr;
+    switch (role) {
+      case "system": {
+        messages.push({ type: "system", message: content });
+        break;
+      }
+      case "user": {
+        messages.push({
+          type: "user",
+          message: content.map((part) => {
+            switch (part.type) {
+              case "text": {
+                return part.text;
+              }
+              case "file": {
+                if (part.mediaType.startsWith("image/")) {
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+                  if (isSupportedImageMediaType(mediaType)) {
+                    return {
+                      type: "url",
+                      mediaType,
+                      url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${convertToBase64(part.data)}`
+                    };
+                  } else {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "Invalid images mediaType"
+                    });
+                  }
+                } else {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: "Only images and PDF file parts are supported"
+                  });
+                }
+              }
+            }
+          })
+        });
+        break;
+      }
+      case "assistant": {
+        let text = "";
+        const toolCalls = [];
+        for (const part of content) {
+          switch (part.type) {
+            case "text": {
+              text += part.text;
+              break;
+            }
+            case "tool-call": {
+              toolCalls.push({
+                id: part.toolCallId,
+                name: part.toolName,
+                arguments: JSON.stringify(part.input)
+              });
+              break;
+            }
+            case "reasoning": {
+              text += part.text;
+              break;
+            }
+            default: {
+              throw new Error(
+                `Unsupported content type in assistant message: ${part.type}`
+              );
+            }
+          }
+        }
+        messages.push({
+          type: "assistant",
+          message: text,
+          function_calls: toolCalls.length > 0 ? toolCalls : void 0
+        });
+        break;
+      }
+      case "tool": {
+        for (const toolResponse of content) {
+          const output = toolResponse.output;
+          let contentValue;
+          switch (output.type) {
+            case "text":
+            case "error-text":
+              contentValue = output.value;
+              break;
+            case "content":
+            case "json":
+            case "error-json":
+              contentValue = JSON.stringify(output.value);
+              break;
+          }
+          messages.push({
+            type: "function",
+            message: contentValue,
+            name: toolResponse.toolCallId
+          });
+        }
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  return messages;
+}
+
+// src/get-response-metadata.ts
+function getResponseMetadata({
+  id,
+  model,
+  created
+}) {
+  return {
+    id: id != null ? id : void 0,
+    modelId: model != null ? model : void 0,
+    timestamp: created != null ? new Date(created * 1e3) : void 0
+  };
+}
+
+// src/map-rivet-finish-reason.ts
+function mapRivetFinishReason(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+    case "model_length":
+      return "length";
+    case "tool_calls":
+      return "tool-calls";
+    default:
+      return "unknown";
+  }
+}
+
+// src/rivet-chat-options.ts
+import { z } from "zod/v4";
+var rivetRunParamsSchema = z.object({
+  openaiApiKey: z.string().optional(),
+  openaiEndpoint: z.string().optional(),
+  openaiOrganization: z.string().optional(),
+  exposeCost: z.boolean().optional(),
+  exposeUsage: z.boolean().optional(),
+  logTrace: z.boolean().optional(),
+  stream: z.string().optional(),
+  streamNode: z.string().optional(),
+  events: z.string().optional()
+});
+var standardChatConfigSchema = z.object({
+  temperature: z.number().optional(),
+  top_p: z.number().optional(),
+  top_k: z.number().optional(),
+  maxTokens: z.number().optional(),
+  stop_sequences: z.array(z.string()).optional(),
+  presencePenalty: z.number().optional(),
+  frequencyPenalty: z.number().optional(),
+  seed: z.number().optional(),
+  toolChoice: z.enum(["none", "auto", "required", "function"]).optional(),
+  toolChoiceFunction: z.string().optional(),
+  responseFormat: z.enum(["", "text", "json", "json_schema"]).optional(),
+  responseSchemaName: z.string().optional()
+});
+var rivetCustomChatConfigSchema = z.object({
+  useTopP: z.boolean().optional(),
+  stop: z.string().optional(),
+  enableFunctionUse: z.boolean().optional(),
+  user: z.string().optional(),
+  numberOfChoices: z.number().optional(),
+  endpoint: z.string().optional(),
+  overrideModel: z.string().optional(),
+  overrideMaxTokens: z.number().optional(),
+  headers: z.array(
+    z.object({
+      key: z.string(),
+      value: z.string()
+    })
+  ).optional(),
+  parallelFunctionCalling: z.boolean().optional(),
+  additionalParameters: z.array(
+    z.object({
+      key: z.string(),
+      value: z.string()
+    })
+  ).optional(),
+  useServerTokenCalculation: z.boolean().optional(),
+  outputUsage: z.boolean().optional(),
+  usePredictedOutput: z.boolean().optional(),
+  reasoningEffort: z.enum(["", "low", "medium", "high"]).optional(),
+  modalitiesIncludeText: z.boolean().optional(),
+  modalitiesIncludeAudio: z.boolean().optional(),
+  audioVoice: z.string().optional(),
+  audioFormat: z.enum(["wav", "mp3", "flac", "opus", "pcm16"]).optional()
+});
+var rivetLanguageModelOptions = z.object({
+  runParams: rivetRunParamsSchema,
+  chatConfig: rivetCustomChatConfigSchema
+});
+var rivetChatConfigSchema = standardChatConfigSchema.merge(rivetCustomChatConfigSchema);
+var rivetToolOptions = z.record(
+  z.string(),
+  z.object({
+    //See RivetTool
+    name: z.string(),
+    namespace: z.string().optional(),
+    description: z.string(),
+    parameters: z.object({}).passthrough(),
+    strict: z.boolean().optional()
+  })
+);
+
+// src/rivet-error.ts
+import { z as z2 } from "zod/v4";
+var rivetErrorDataSchema = z2.object({
+  object: z2.literal("error"),
+  message: z2.string(),
+  type: z2.string(),
+  param: z2.string().nullable(),
+  code: z2.string().nullable()
+});
+var rivetFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: rivetErrorDataSchema,
+  errorToMessage: (data) => data.message
+});
+
+// src/utils.ts
+function printObject(obj) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(
+    obj,
+    (_, value) => {
+      if (typeof value === "function") {
+        return `[Function: ${value.name || "anonymous"}]`;
+      }
+      if (typeof value === "object" && value !== null) {
+        if (seen.has(value)) {
+          return "[Circular]";
+        }
+        seen.add(value);
+      }
+      return value;
+    },
+    2
+    // Indentation level for pretty-printing
+  );
+}
+
+// src/rivet-prepare-tools.ts
+async function prepareTools({
+  tools,
+  toolChoice
+}) {
+  var _a15;
+  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
+  const toolWarnings = [];
+  if (tools == null) {
+    return { tools: void 0, toolSchemas: void 0, toolChoice: void 0, toolWarnings };
+  }
+  console.log(`
+
+prepare tools input:${printObject(tools)}`);
+  const rivetTools = [];
+  const rivetSchemas = [];
+  for (const tool of tools) {
+    if (tool.type === "provider-defined") {
+      toolWarnings.push({ type: "unsupported-tool", tool });
+    } else {
+      const options = (_a15 = await parseProviderOptions({
+        provider: "rivet",
+        providerOptions: tool.providerOptions,
+        schema: rivetToolOptions
+      })) != null ? _a15 : {};
+      rivetTools.push({
+        name: tool.name,
+        description: tool.description || "",
+        parameters: tool.inputSchema,
+        strict: false
+      });
+      for (const [_, value] of Object.entries(options)) {
+        rivetSchemas.push({
+          name: value.name,
+          description: value.description || "",
+          parameters: value.parameters,
+          strict: false
+        });
+      }
+    }
+  }
+  console.log(`rivetSchemas:${printObject(rivetSchemas)}`);
+  if (toolChoice == null) {
+    return { tools: rivetTools, toolSchemas: rivetSchemas, toolChoice: void 0, toolWarnings };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+    case "none":
+    case "required":
+      return { tools: rivetTools, toolSchemas: rivetSchemas, toolChoice: { toolChoice: type }, toolWarnings };
+    // Rivet toolChoice for 'tool' is called 'function',
+    case "tool":
+      return {
+        tools: rivetTools,
+        toolSchemas: rivetSchemas,
+        toolChoice: { toolChoice: "function", toolChoiceFunction: toolChoice.toolName },
+        toolWarnings
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+
+// src/version.ts
+var VERSION = true ? "2.0.0" : "0.0.0-test";
+
+// src/post-to-api.ts
+var getOriginalFetch = () => globalThis.fetch;
+var postJsonToApi = async ({
+  url,
+  headers,
+  body,
+  failedResponseHandler,
+  successfulResponseHandler,
+  abortSignal,
+  fetch
+}) => postToApi({
+  url,
+  headers: __spreadValues({
+    "Content-Type": "application/json"
+  }, headers),
+  body: {
+    content: JSON.stringify(body),
+    values: body
+  },
+  failedResponseHandler,
+  successfulResponseHandler,
+  abortSignal,
+  fetch
+});
+var postToApi = async ({
+  url,
+  headers = {},
+  body,
+  successfulResponseHandler,
+  failedResponseHandler,
+  abortSignal,
+  fetch = getOriginalFetch()
+}) => {
+  try {
+    let bodyContent;
+    if (typeof body.content === "string" || body.content instanceof FormData) {
+      bodyContent = body.content;
+    } else if (body.content instanceof Uint8Array) {
+      bodyContent = body.content.buffer;
+    } else if (body.content instanceof ArrayBuffer) {
+      bodyContent = body.content;
+    } else {
+      throw new TypeError("Unsupported body content type");
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers: withUserAgentSuffix(
+        headers,
+        `ai-sdk/provider-utils/${VERSION}`,
+        getRuntimeEnvironmentUserAgent()
+      ),
+      body: bodyContent,
+      signal: abortSignal
+    });
+    const responseHeaders = extractResponseHeaders(response);
+    if (!response.ok) {
+      let errorInformation;
+      try {
+        errorInformation = await failedResponseHandler({
+          response,
+          url,
+          requestBodyValues: body.values
+        });
+      } catch (error) {
+        if (isAbortError(error) || APICallError.isInstance(error)) {
+          throw error;
+        }
+        throw new APICallError({
+          message: "Failed to process error response",
+          cause: error,
+          statusCode: response.status,
+          url,
+          responseHeaders,
+          requestBodyValues: body.values
+        });
+      }
+      throw errorInformation.value;
+    }
+    try {
+      return await successfulResponseHandler({
+        response,
+        url,
+        requestBodyValues: body.values
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        if (isAbortError(error) || APICallError.isInstance(error)) {
+          throw error;
+        }
+      }
+      throw new APICallError({
+        message: "Failed to process successful response",
+        cause: error,
+        statusCode: response.status,
+        url,
+        responseHeaders,
+        requestBodyValues: body.values
+      });
+    }
+  } catch (error) {
+    throw handleFetchError({ error, url, requestBodyValues: body.values });
+  }
+};
+var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
+function handleFetchError({
+  error,
+  url,
+  requestBodyValues
+}) {
+  if (isAbortError(error)) {
+    return error;
+  }
+  if (error instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES.includes(error.message.toLowerCase())) {
+    const cause = error.cause;
+    if (cause != null) {
+      return new APICallError({
+        message: `Cannot connect to API: ${cause.message}`,
+        cause,
+        url,
+        requestBodyValues,
+        isRetryable: true
+        // retry when network error
+      });
+    }
+  }
+  return error;
+}
+var createEventSourceResponseHandler = (chunkSchema) => async ({ response }) => {
+  const responseHeaders = extractResponseHeaders(response);
+  if (response.body == null) {
+    throw new EmptyResponseBodyError({});
+  }
+  return {
+    responseHeaders,
+    value: parseJsonEventStream({
+      stream: response.body,
+      schema: chunkSchema
+    })
+  };
+};
+function parseJsonEventStream({
+  stream,
+  schema
+}) {
+  return stream.pipeThrough(new TransformStream({
+    transform(chunk, controller) {
+      const decoded = new TextDecoder().decode(chunk);
+      console.log(`Decoded:${printObject(decoded)}`);
+      controller.enqueue(decoded);
+    }
+  })).pipeThrough(new EventSourceParserStream()).pipeThrough(
+    new TransformStream({
+      async transform({ data }, controller) {
+        if (data === "[DONE]") {
+          return;
+        }
+        console.log(`Data to schema:${printObject(data)}`);
+        controller.enqueue(await safeParseJSON({ text: data, schema }));
+      }
+    })
+  );
+}
+
+// src/rivet-chat-language-model.ts
+var RivetChatLanguageModel = class {
+  constructor(modelId, config) {
+    this.specificationVersion = "v2";
+    this.supportedUrls = {
+      "application/pdf": [/^https:\/\/.*$/]
+    };
+    var _a15;
+    this.modelId = modelId;
+    this.config = config;
+    this.generateId = (_a15 = config.generateId) != null ? _a15 : generateId;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  // Response Schema name and content to be passed in earlier if needed
+  async getArgs({
+    prompt,
+    //in Rivet separate
+    maxOutputTokens,
+    //in Rivet chat config
+    temperature,
+    //in Rivet chat config
+    topP,
+    //in Rivet chat config
+    topK,
+    //in Rivet chat config (some models like Anthropic and Google)
+    frequencyPenalty,
+    //in Rivet chat config
+    presencePenalty,
+    //in Rivet chat config
+    stopSequences,
+    //in Rivet chat config
+    responseFormat,
+    //in Rivet chat config
+    seed,
+    //in Rivet chat config
+    providerOptions,
+    tools,
+    //in Rivet separate
+    toolChoice
+    //in Rivet tool section
+  }) {
+    var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    const warnings = [];
+    const emptyOptions = {
+      runParams: {},
+      chatConfig: {}
+    };
+    console.log(`providerOptions:${printObject(providerOptions)}`);
+    const options = (_a15 = await parseProviderOptions({
+      provider: "rivet",
+      providerOptions,
+      schema: rivetLanguageModelOptions
+    })) != null ? _a15 : emptyOptions;
+    console.log(`options:${printObject(options)}`);
+    const {
+      tools: rivetTools,
+      toolSchemas: rivetSchemas,
+      toolChoice: rivetToolChoice,
+      toolWarnings
+    } = await prepareTools({ tools, toolChoice });
+    options.runParams = (_b = options.runParams) != null ? _b : {};
+    options.chatConfig = (_c = options.chatConfig) != null ? _c : {};
+    const chatConfig = __spreadValues({}, options.chatConfig);
+    chatConfig.maxTokens = (_d = chatConfig.maxTokens) != null ? _d : maxOutputTokens;
+    chatConfig.temperature = (_e = chatConfig.temperature) != null ? _e : temperature;
+    chatConfig.top_p = (_f = chatConfig.top_p) != null ? _f : topP;
+    chatConfig.top_k = (_g = chatConfig.top_k) != null ? _g : topK;
+    chatConfig.stop_sequences = (_h = chatConfig.stop_sequences) != null ? _h : stopSequences;
+    chatConfig.frequencyPenalty = (_i = chatConfig.frequencyPenalty) != null ? _i : frequencyPenalty;
+    chatConfig.presencePenalty = (_j = chatConfig.presencePenalty) != null ? _j : presencePenalty;
+    chatConfig.seed = (_k = chatConfig.seed) != null ? _k : seed;
+    if (responseFormat) {
+      const isJson = (responseFormat == null ? void 0 : responseFormat.type) === "json";
+      const hasSchema = isJson && !!(responseFormat == null ? void 0 : responseFormat.schema);
+      chatConfig.responseFormat = isJson ? hasSchema ? "json_schema" : "json" : responseFormat == null ? void 0 : responseFormat.type;
+      chatConfig.responseSchemaName = isJson && hasSchema ? responseFormat.schema : void 0;
+    }
+    if (rivetToolChoice) {
+      chatConfig.toolChoice = rivetToolChoice.toolChoice;
+      chatConfig.toolChoiceFunction = rivetToolChoice.toolChoiceFunction;
+    }
+    const messages = convertToRivetChatMessages(prompt);
+    return {
+      args: {
+        chatConfig: {
+          type: "object",
+          value: chatConfig
+        },
+        input: {
+          //assign chat messages to the input node
+          type: "chat-message[]",
+          value: messages
+        },
+        tools: {
+          type: "gpt-function[]",
+          value: rivetTools
+        },
+        toolSchemas: {
+          type: "gpt-function[]",
+          value: rivetSchemas
+        },
+        runParams: __spreadValues({}, options.runParams)
+      },
+      warnings: [...warnings, ...toolWarnings]
+    };
+  }
+  async doGenerate(options) {
+    const { args: body, warnings } = await this.getArgs(options);
+    const headers = combineHeaders(this.config.headers(), options.headers);
+    let responseId = headers["X-Completion-Id"];
+    responseId = responseId != null ? responseId : this.generateId();
+    const {
+      responseHeaders,
+      value: response,
+      rawValue: rawResponse
+    } = await postJsonToApi({
+      url: `${this.config.baseURL}/${this.modelId}`,
+      headers,
+      body,
+      failedResponseHandler: rivetFailedResponseHandler,
+      successfulResponseHandler: rivetChatResponseHandler(`rivetcmpl-${responseId}`, this.modelId),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const choice = response.choices[0];
+    if (!choice) {
+      throw new Error("No choices found");
+    }
+    const content = [];
+    if (choice.message.content != null && Array.isArray(choice.message.content)) {
+      for (const part of choice.message.content) {
+        if (part.type === "thinking") {
+          const reasoningText = extractReasoningContent(part.thinking);
+          if (reasoningText.length > 0) {
+            content.push({ type: "reasoning", text: reasoningText });
+          }
+        } else if (part.type === "text") {
+          if (part.text.length > 0) {
+            content.push({ type: "text", text: part.text });
+          }
+        }
+      }
+    } else {
+      const text = extractTextContent(choice.message.content);
+      if (text != null && text.length > 0) {
+        content.push({ type: "text", text });
+      }
+    }
+    if (choice.message.tool_calls != null) {
+      for (const toolCall of choice.message.tool_calls) {
+        content.push({
+          type: "tool-call",
+          toolCallId: toolCall.id,
+          toolName: toolCall.function.name,
+          input: toolCall.function.arguments
+        });
+      }
+    }
+    return {
+      content,
+      finishReason: mapRivetFinishReason(choice.finish_reason),
+      usage: {
+        inputTokens: response.usage.prompt_tokens,
+        outputTokens: response.usage.completion_tokens,
+        totalTokens: response.usage.total_tokens
+      },
+      request: { body },
+      response: __spreadProps(__spreadValues({}, getResponseMetadata(response)), {
+        headers: responseHeaders,
+        body: rawResponse
+      }),
+      warnings
+    };
+  }
+  async doStream(options) {
+    var _a15;
+    const { args, warnings } = await this.getArgs(options);
+    const body = args;
+    console.log(`body:${printObject(body)}`);
+    const headers = combineHeaders(this.config.headers(), options.headers);
+    let responseId = (_a15 = headers["X-Completion-Id"]) != null ? _a15 : this.generateId();
+    const model = this.modelId;
+    const { responseHeaders, value: response } = await postJsonToApi({
+      url: `${this.config.baseURL}/${this.modelId}`,
+      headers,
+      body,
+      failedResponseHandler: rivetFailedResponseHandler,
+      successfulResponseHandler: createRivetEventSourceResponseHandler(`rivetcmpl-${responseId}`, model),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    let finishReason = "unknown";
+    const usage = {
+      inputTokens: void 0,
+      outputTokens: void 0,
+      totalTokens: void 0
+    };
+    let isFirstChunk = true;
+    let activeText = false;
+    let activeReasoningId = null;
+    const generateId2 = this.generateId;
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
+          transform(chunk, controller) {
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+            }
+            if (!chunk.success) {
+              controller.enqueue({ type: "error", error: chunk.error });
+              return;
+            }
+            const value = chunk.value;
+            if (isFirstChunk) {
+              isFirstChunk = false;
+              controller.enqueue(__spreadValues({
+                type: "response-metadata"
+              }, getResponseMetadata(value)));
+            }
+            if (value.usage != null) {
+              usage.inputTokens = value.usage.prompt_tokens;
+              usage.outputTokens = value.usage.completion_tokens;
+              usage.totalTokens = value.usage.total_tokens;
+            }
+            const choice = value.choices[0];
+            if (!choice) {
+              throw new Error("No choices found");
+            }
+            const delta = choice.delta;
+            const textContent = extractTextContent(delta.content);
+            if (delta.content != null && Array.isArray(delta.content)) {
+              for (const part of delta.content) {
+                if (part.type === "thinking") {
+                  const reasoningDelta = extractReasoningContent(part.thinking);
+                  if (reasoningDelta.length > 0) {
+                    if (activeReasoningId == null) {
+                      if (activeText) {
+                        controller.enqueue({ type: "text-end", id: "0" });
+                        activeText = false;
+                      }
+                      activeReasoningId = generateId2();
+                      controller.enqueue({
+                        type: "reasoning-start",
+                        id: activeReasoningId
+                      });
+                    }
+                    controller.enqueue({
+                      type: "reasoning-delta",
+                      id: activeReasoningId,
+                      delta: reasoningDelta
+                    });
+                  }
+                }
+              }
+            }
+            if (textContent != null && textContent.length > 0) {
+              if (!activeText) {
+                if (activeReasoningId != null) {
+                  controller.enqueue({
+                    type: "reasoning-end",
+                    id: activeReasoningId
+                  });
+                  activeReasoningId = null;
+                }
+                controller.enqueue({ type: "text-start", id: "0" });
+                activeText = true;
+              }
+              controller.enqueue({
+                type: "text-delta",
+                id: "0",
+                delta: textContent
+              });
+            }
+            if ((delta == null ? void 0 : delta.tool_calls) != null) {
+              for (const toolCall of delta.tool_calls) {
+                const toolCallId = toolCall.id;
+                const toolName = toolCall.function.name;
+                const input = toolCall.function.arguments;
+                controller.enqueue({
+                  type: "tool-input-start",
+                  id: toolCallId,
+                  toolName
+                });
+                controller.enqueue({
+                  type: "tool-input-delta",
+                  id: toolCallId,
+                  delta: input
+                });
+                controller.enqueue({
+                  type: "tool-input-end",
+                  id: toolCallId
+                });
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId,
+                  toolName,
+                  input
+                });
+              }
+            }
+            if (choice.finish_reason != null) {
+              finishReason = mapRivetFinishReason(choice.finish_reason);
+            }
+          },
+          flush(controller) {
+            if (activeReasoningId != null) {
+              controller.enqueue({
+                type: "reasoning-end",
+                id: activeReasoningId
+              });
+            }
+            if (activeText) {
+              controller.enqueue({ type: "text-end", id: "0" });
+            }
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              usage
+            });
+          }
+        })
+      ),
+      request: { body },
+      response: { headers: responseHeaders }
+    };
+  }
+};
+function extractReasoningContent(thinking) {
+  return thinking.filter((chunk) => chunk.type === "text").map((chunk) => chunk.text).join("");
+}
+function extractTextContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (content == null) {
+    return void 0;
+  }
+  const textContent = [];
+  for (const chunk of content) {
+    const { type } = chunk;
+    switch (type) {
+      case "text":
+        textContent.push(chunk.text);
+        break;
+      case "thinking":
+      case "image_url":
+      case "reference":
+        break;
+      default: {
+        const _exhaustiveCheck = type;
+        throw new Error(`Unsupported type: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  return textContent.length ? textContent.join("") : void 0;
+}
+var rivetContentSchema = z3.union([
+  z3.string(),
+  z3.array(
+    z3.discriminatedUnion("type", [
+      z3.object({
+        type: z3.literal("text"),
+        text: z3.string()
+      }),
+      z3.object({
+        type: z3.literal("image_url"),
+        image_url: z3.union([
+          z3.string(),
+          z3.object({
+            url: z3.string(),
+            detail: z3.string().nullable()
+          })
+        ])
+      }),
+      z3.object({
+        type: z3.literal("reference"),
+        reference_ids: z3.array(z3.number())
+      }),
+      z3.object({
+        type: z3.literal("thinking"),
+        thinking: z3.array(
+          z3.object({
+            type: z3.literal("text"),
+            text: z3.string()
+          })
+        )
+      })
+    ])
+  )
+]).nullish();
+var rivetUsageSchema = z3.object({
+  prompt_tokens: z3.number(),
+  completion_tokens: z3.number(),
+  total_tokens: z3.number()
+});
+var rivetChatResponseSchema = z3.object({
+  id: z3.string().nullish(),
+  created: z3.number().nullish(),
+  model: z3.string().nullish(),
+  choices: z3.array(
+    z3.object({
+      message: z3.object({
+        role: z3.literal("assistant"),
+        content: rivetContentSchema,
+        tool_calls: z3.array(
+          z3.object({
+            id: z3.string(),
+            function: z3.object({ name: z3.string(), arguments: z3.string() })
+          })
+        ).nullish()
+      }),
+      index: z3.number(),
+      finish_reason: z3.string().nullish()
+    })
+  ),
+  object: z3.literal("chat.completion"),
+  usage: rivetUsageSchema
+});
+var rivetChatResponseHandler = (id, model) => async ({
+  url,
+  requestBodyValues,
+  response
+}) => {
+  const raw = await response.json();
+  const mapped = mapGraphOutputsToSDK(raw, id, model);
+  return {
+    value: rivetChatResponseSchema.parse(mapped)
+  };
+};
+function mapGraphOutputsToSDK(outputs, id, model) {
+  var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  return {
+    id,
+    created: Date.now(),
+    model,
+    object: "chat.completion",
+    choices: [
+      {
+        message: {
+          role: "assistant",
+          content: (_b = (_a15 = outputs.output) == null ? void 0 : _a15.value) != null ? _b : ""
+        },
+        index: 0,
+        finish_reason: "stop"
+      }
+    ],
+    usage: {
+      prompt_tokens: (_d = (_c = outputs.requestTokens) == null ? void 0 : _c.value) != null ? _d : 0,
+      completion_tokens: (_f = (_e = outputs.responseTokens) == null ? void 0 : _e.value) != null ? _f : 0,
+      total_tokens: ((_h = (_g = outputs.requestTokens) == null ? void 0 : _g.value) != null ? _h : 0) + ((_j = (_i = outputs.responseTokens) == null ? void 0 : _i.value) != null ? _j : 0)
+    }
+  };
+}
+var rivetChatChunkSchema = z3.object({
+  id: z3.string().nullish(),
+  created: z3.number().nullish(),
+  model: z3.string().nullish(),
+  choices: z3.array(
+    z3.object({
+      delta: z3.object({
+        role: z3.enum(["assistant"]).optional(),
+        content: rivetContentSchema,
+        tool_calls: z3.array(
+          z3.object({
+            id: z3.string(),
+            function: z3.object({ name: z3.string(), arguments: z3.string() })
+          })
+        ).nullish()
+      }),
+      finish_reason: z3.string().nullish(),
+      index: z3.number()
+    })
+  ),
+  usage: rivetUsageSchema.nullish()
+});
+function createRivetEventSourceResponseHandler(id, model) {
+  return createEventSourceResponseHandler(z3.any().transform((data) => {
+    console.log(`SSE event received:${printObject(data)}`);
+    return mapRivetEventToOpenAIChunk(data, id, model);
+  }));
+}
+function mapRivetEventToOpenAIChunk(eventData, id, model) {
+  var _a15, _b, _c, _d, _e, _f, _g;
+  const eventType = eventData.type;
+  switch (eventType) {
+    case "partialOutput":
+      return {
+        id,
+        created: Math.floor(Date.now() / 1e3),
+        model,
+        choices: [
+          {
+            delta: {
+              role: "assistant",
+              content: (_a15 = eventData.delta) != null ? _a15 : "",
+              tool_calls: void 0
+            },
+            finish_reason: null,
+            index: 0
+          }
+        ],
+        usage: void 0
+      };
+    case "done":
+      return {
+        id,
+        created: Math.floor(Date.now() / 1e3),
+        model,
+        choices: [
+          {
+            delta: {
+              role: "assistant",
+              content: (_d = (_c = (_b = eventData.graphOutput) == null ? void 0 : _b.response) == null ? void 0 : _c.value) != null ? _d : "",
+              tool_calls: void 0
+            },
+            finish_reason: "stop",
+            index: 0
+          }
+        ],
+        usage: toOpenAIUsage((_g = (_f = (_e = eventData.graphOutput.usages) == null ? void 0 : _e.value) == null ? void 0 : _f[0]) == null ? void 0 : _g.value)
+      };
+    default:
+      return {
+        id,
+        created: Math.floor(Date.now() / 1e3),
+        model,
+        choices: [
+          {
+            delta: {
+              role: "assistant",
+              content: "",
+              tool_calls: void 0
+            },
+            finish_reason: null,
+            index: 0
+          }
+        ],
+        usage: void 0
+      };
+  }
+}
+var toOpenAIUsage = (usage) => {
+  console.log(`Usage to convert:${printObject(usage)}`);
+  return usage ? {
+    prompt_tokens: usage.prompt_tokens,
+    completion_tokens: usage.completion_tokens,
+    total_tokens: usage.total_tokens
+  } : void 0;
+};
+
+// src/rivet-provider.ts
+function createRivet(options = {}) {
+  var _a15;
+  const baseURL = (_a15 = withoutTrailingSlash(options.baseURL)) != null ? _a15 : "https://api.rivet.ai/v1";
+  const getHeaders = () => withUserAgentSuffix(
+    __spreadValues({
+      Authorization: `Bearer ${loadApiKey({
+        apiKey: options.apiKey,
+        environmentVariableName: "RIVET_API_KEY",
+        description: "Rivet"
+      })}`
+    }, options.headers),
+    `ai-sdk/rivet/${VERSION}`
+  );
+  const createChatModel = (modelId) => new RivetChatLanguageModel(modelId, {
+    provider: "rivet.chat",
+    baseURL,
+    headers: getHeaders,
+    fetch: options.fetch,
+    generateId: options.generateId
+  });
+  const provider = function(modelId) {
+    if (new.target) {
+      throw new Error("The Rivet model function cannot be called with the new keyword.");
+    }
+    return createChatModel(modelId);
+  };
+  provider.languageModel = createChatModel;
+  provider.chat = createChatModel;
+  provider.textEmbeddingModel = (modelId) => {
+    throw new NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
+  };
+  provider.imageModel = (modelId) => {
+    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
+  };
+  return provider;
+}
+var rivet = createRivet();
+export {
+  VERSION,
+  createRivet,
+  rivet
+};
+//# sourceMappingURL=index.mjs.map