orcaq 1.0.20

package/.output/server/node_modules/@ai-sdk/gateway/dist/index.mjs

@@ -0,0 +1,1082 @@
+// src/gateway-provider.ts
+import {
+  loadOptionalSetting,
+  withoutTrailingSlash
+} from "@ai-sdk/provider-utils";
+
+// src/errors/as-gateway-error.ts
+import { APICallError } from "@ai-sdk/provider";
+
+// src/errors/create-gateway-error.ts
+import { z as z2 } from "zod/v4";
+
+// src/errors/gateway-error.ts
+var marker = "vercel.ai.gateway.error";
+var symbol = Symbol.for(marker);
+var _a, _b;
+var GatewayError = class _GatewayError extends (_b = Error, _a = symbol, _b) {
+  constructor({
+    message,
+    statusCode = 500,
+    cause
+  }) {
+    super(message);
+    this[_a] = true;
+    this.statusCode = statusCode;
+    this.cause = cause;
+  }
+  /**
+   * Checks if the given error is a Gateway Error.
+   * @param {unknown} error - The error to check.
+   * @returns {boolean} True if the error is a Gateway Error, false otherwise.
+   */
+  static isInstance(error) {
+    return _GatewayError.hasMarker(error);
+  }
+  static hasMarker(error) {
+    return typeof error === "object" && error !== null && symbol in error && error[symbol] === true;
+  }
+};
+
+// src/errors/gateway-authentication-error.ts
+var name = "GatewayAuthenticationError";
+var marker2 = `vercel.ai.gateway.error.${name}`;
+var symbol2 = Symbol.for(marker2);
+var _a2, _b2;
+var GatewayAuthenticationError = class _GatewayAuthenticationError extends (_b2 = GatewayError, _a2 = symbol2, _b2) {
+  constructor({
+    message = "Authentication failed",
+    statusCode = 401,
+    cause
+  } = {}) {
+    super({ message, statusCode, cause });
+    this[_a2] = true;
+    // used in isInstance
+    this.name = name;
+    this.type = "authentication_error";
+  }
+  static isInstance(error) {
+    return GatewayError.hasMarker(error) && symbol2 in error;
+  }
+  /**
+   * Creates a contextual error message when authentication fails
+   */
+  static createContextualError({
+    apiKeyProvided,
+    oidcTokenProvided,
+    message = "Authentication failed",
+    statusCode = 401,
+    cause
+  }) {
+    let contextualMessage;
+    if (apiKeyProvided) {
+      contextualMessage = `AI Gateway authentication failed: Invalid API key.
+
+Create a new API key: https://vercel.com/d?to=%2F%5Bteam%5D%2F%7E%2Fai%2Fapi-keys
+
+Provide via 'apiKey' option or 'AI_GATEWAY_API_KEY' environment variable.`;
+    } else if (oidcTokenProvided) {
+      contextualMessage = `AI Gateway authentication failed: Invalid OIDC token.
+
+Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the token.
+
+Alternatively, use an API key: https://vercel.com/d?to=%2F%5Bteam%5D%2F%7E%2Fai%2Fapi-keys`;
+    } else {
+      contextualMessage = `AI Gateway authentication failed: No authentication provided.
+
+Option 1 - API key:
+Create an API key: https://vercel.com/d?to=%2F%5Bteam%5D%2F%7E%2Fai%2Fapi-keys
+Provide via 'apiKey' option or 'AI_GATEWAY_API_KEY' environment variable.
+
+Option 2 - OIDC token:
+Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the token.`;
+    }
+    return new _GatewayAuthenticationError({
+      message: contextualMessage,
+      statusCode,
+      cause
+    });
+  }
+};
+
+// src/errors/gateway-invalid-request-error.ts
+var name2 = "GatewayInvalidRequestError";
+var marker3 = `vercel.ai.gateway.error.${name2}`;
+var symbol3 = Symbol.for(marker3);
+var _a3, _b3;
+var GatewayInvalidRequestError = class extends (_b3 = GatewayError, _a3 = symbol3, _b3) {
+  constructor({
+    message = "Invalid request",
+    statusCode = 400,
+    cause
+  } = {}) {
+    super({ message, statusCode, cause });
+    this[_a3] = true;
+    // used in isInstance
+    this.name = name2;
+    this.type = "invalid_request_error";
+  }
+  static isInstance(error) {
+    return GatewayError.hasMarker(error) && symbol3 in error;
+  }
+};
+
+// src/errors/gateway-rate-limit-error.ts
+var name3 = "GatewayRateLimitError";
+var marker4 = `vercel.ai.gateway.error.${name3}`;
+var symbol4 = Symbol.for(marker4);
+var _a4, _b4;
+var GatewayRateLimitError = class extends (_b4 = GatewayError, _a4 = symbol4, _b4) {
+  constructor({
+    message = "Rate limit exceeded",
+    statusCode = 429,
+    cause
+  } = {}) {
+    super({ message, statusCode, cause });
+    this[_a4] = true;
+    // used in isInstance
+    this.name = name3;
+    this.type = "rate_limit_exceeded";
+  }
+  static isInstance(error) {
+    return GatewayError.hasMarker(error) && symbol4 in error;
+  }
+};
+
+// src/errors/gateway-model-not-found-error.ts
+import { z } from "zod/v4";
+import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
+var name4 = "GatewayModelNotFoundError";
+var marker5 = `vercel.ai.gateway.error.${name4}`;
+var symbol5 = Symbol.for(marker5);
+var modelNotFoundParamSchema = lazySchema(
+  () => zodSchema(
+    z.object({
+      modelId: z.string()
+    })
+  )
+);
+var _a5, _b5;
+var GatewayModelNotFoundError = class extends (_b5 = GatewayError, _a5 = symbol5, _b5) {
+  constructor({
+    message = "Model not found",
+    statusCode = 404,
+    modelId,
+    cause
+  } = {}) {
+    super({ message, statusCode, cause });
+    this[_a5] = true;
+    // used in isInstance
+    this.name = name4;
+    this.type = "model_not_found";
+    this.modelId = modelId;
+  }
+  static isInstance(error) {
+    return GatewayError.hasMarker(error) && symbol5 in error;
+  }
+};
+
+// src/errors/gateway-internal-server-error.ts
+var name5 = "GatewayInternalServerError";
+var marker6 = `vercel.ai.gateway.error.${name5}`;
+var symbol6 = Symbol.for(marker6);
+var _a6, _b6;
+var GatewayInternalServerError = class extends (_b6 = GatewayError, _a6 = symbol6, _b6) {
+  constructor({
+    message = "Internal server error",
+    statusCode = 500,
+    cause
+  } = {}) {
+    super({ message, statusCode, cause });
+    this[_a6] = true;
+    // used in isInstance
+    this.name = name5;
+    this.type = "internal_server_error";
+  }
+  static isInstance(error) {
+    return GatewayError.hasMarker(error) && symbol6 in error;
+  }
+};
+
+// src/errors/gateway-response-error.ts
+var name6 = "GatewayResponseError";
+var marker7 = `vercel.ai.gateway.error.${name6}`;
+var symbol7 = Symbol.for(marker7);
+var _a7, _b7;
+var GatewayResponseError = class extends (_b7 = GatewayError, _a7 = symbol7, _b7) {
+  constructor({
+    message = "Invalid response from Gateway",
+    statusCode = 502,
+    response,
+    validationError,
+    cause
+  } = {}) {
+    super({ message, statusCode, cause });
+    this[_a7] = true;
+    // used in isInstance
+    this.name = name6;
+    this.type = "response_error";
+    this.response = response;
+    this.validationError = validationError;
+  }
+  static isInstance(error) {
+    return GatewayError.hasMarker(error) && symbol7 in error;
+  }
+};
+
+// src/errors/create-gateway-error.ts
+import {
+  lazySchema as lazySchema2,
+  safeValidateTypes,
+  zodSchema as zodSchema2
+} from "@ai-sdk/provider-utils";
+async function createGatewayErrorFromResponse({
+  response,
+  statusCode,
+  defaultMessage = "Gateway request failed",
+  cause,
+  authMethod
+}) {
+  const parseResult = await safeValidateTypes({
+    value: response,
+    schema: gatewayErrorResponseSchema
+  });
+  if (!parseResult.success) {
+    return new GatewayResponseError({
+      message: `Invalid error response format: ${defaultMessage}`,
+      statusCode,
+      response,
+      validationError: parseResult.error,
+      cause
+    });
+  }
+  const validatedResponse = parseResult.value;
+  const errorType = validatedResponse.error.type;
+  const message = validatedResponse.error.message;
+  switch (errorType) {
+    case "authentication_error":
+      return GatewayAuthenticationError.createContextualError({
+        apiKeyProvided: authMethod === "api-key",
+        oidcTokenProvided: authMethod === "oidc",
+        statusCode,
+        cause
+      });
+    case "invalid_request_error":
+      return new GatewayInvalidRequestError({ message, statusCode, cause });
+    case "rate_limit_exceeded":
+      return new GatewayRateLimitError({ message, statusCode, cause });
+    case "model_not_found": {
+      const modelResult = await safeValidateTypes({
+        value: validatedResponse.error.param,
+        schema: modelNotFoundParamSchema
+      });
+      return new GatewayModelNotFoundError({
+        message,
+        statusCode,
+        modelId: modelResult.success ? modelResult.value.modelId : void 0,
+        cause
+      });
+    }
+    case "internal_server_error":
+      return new GatewayInternalServerError({ message, statusCode, cause });
+    default:
+      return new GatewayInternalServerError({ message, statusCode, cause });
+  }
+}
+var gatewayErrorResponseSchema = lazySchema2(
+  () => zodSchema2(
+    z2.object({
+      error: z2.object({
+        message: z2.string(),
+        type: z2.string().nullish(),
+        param: z2.unknown().nullish(),
+        code: z2.union([z2.string(), z2.number()]).nullish()
+      })
+    })
+  )
+);
+
+// src/errors/as-gateway-error.ts
+function asGatewayError(error, authMethod) {
+  var _a8;
+  if (GatewayError.isInstance(error)) {
+    return error;
+  }
+  if (APICallError.isInstance(error)) {
+    return createGatewayErrorFromResponse({
+      response: extractApiCallResponse(error),
+      statusCode: (_a8 = error.statusCode) != null ? _a8 : 500,
+      defaultMessage: "Gateway request failed",
+      cause: error,
+      authMethod
+    });
+  }
+  return createGatewayErrorFromResponse({
+    response: {},
+    statusCode: 500,
+    defaultMessage: error instanceof Error ? `Gateway request failed: ${error.message}` : "Unknown Gateway error",
+    cause: error,
+    authMethod
+  });
+}
+
+// src/errors/extract-api-call-response.ts
+function extractApiCallResponse(error) {
+  if (error.data !== void 0) {
+    return error.data;
+  }
+  if (error.responseBody != null) {
+    try {
+      return JSON.parse(error.responseBody);
+    } catch (e) {
+      return error.responseBody;
+    }
+  }
+  return {};
+}
+
+// src/errors/parse-auth-method.ts
+import { z as z3 } from "zod/v4";
+import {
+  lazySchema as lazySchema3,
+  safeValidateTypes as safeValidateTypes2,
+  zodSchema as zodSchema3
+} from "@ai-sdk/provider-utils";
+var GATEWAY_AUTH_METHOD_HEADER = "ai-gateway-auth-method";
+async function parseAuthMethod(headers) {
+  const result = await safeValidateTypes2({
+    value: headers[GATEWAY_AUTH_METHOD_HEADER],
+    schema: gatewayAuthMethodSchema
+  });
+  return result.success ? result.value : void 0;
+}
+var gatewayAuthMethodSchema = lazySchema3(
+  () => zodSchema3(z3.union([z3.literal("api-key"), z3.literal("oidc")]))
+);
+
+// src/gateway-fetch-metadata.ts
+import {
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  getFromApi,
+  lazySchema as lazySchema4,
+  resolve,
+  zodSchema as zodSchema4
+} from "@ai-sdk/provider-utils";
+import { z as z4 } from "zod/v4";
+var GatewayFetchMetadata = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async getAvailableModels() {
+    try {
+      const { value } = await getFromApi({
+        url: `${this.config.baseURL}/config`,
+        headers: await resolve(this.config.headers()),
+        successfulResponseHandler: createJsonResponseHandler(
+          gatewayAvailableModelsResponseSchema
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler({
+          errorSchema: z4.any(),
+          errorToMessage: (data) => data
+        }),
+        fetch: this.config.fetch
+      });
+      return value;
+    } catch (error) {
+      throw await asGatewayError(error);
+    }
+  }
+  async getCredits() {
+    try {
+      const baseUrl = new URL(this.config.baseURL);
+      const { value } = await getFromApi({
+        url: `${baseUrl.origin}/v1/credits`,
+        headers: await resolve(this.config.headers()),
+        successfulResponseHandler: createJsonResponseHandler(
+          gatewayCreditsResponseSchema
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler({
+          errorSchema: z4.any(),
+          errorToMessage: (data) => data
+        }),
+        fetch: this.config.fetch
+      });
+      return value;
+    } catch (error) {
+      throw await asGatewayError(error);
+    }
+  }
+};
+var gatewayAvailableModelsResponseSchema = lazySchema4(
+  () => zodSchema4(
+    z4.object({
+      models: z4.array(
+        z4.object({
+          id: z4.string(),
+          name: z4.string(),
+          description: z4.string().nullish(),
+          pricing: z4.object({
+            input: z4.string(),
+            output: z4.string(),
+            input_cache_read: z4.string().nullish(),
+            input_cache_write: z4.string().nullish()
+          }).transform(
+            ({ input, output, input_cache_read, input_cache_write }) => ({
+              input,
+              output,
+              ...input_cache_read ? { cachedInputTokens: input_cache_read } : {},
+              ...input_cache_write ? { cacheCreationInputTokens: input_cache_write } : {}
+            })
+          ).nullish(),
+          specification: z4.object({
+            specificationVersion: z4.literal("v3"),
+            provider: z4.string(),
+            modelId: z4.string()
+          }),
+          modelType: z4.enum(["language", "embedding", "image"]).nullish()
+        })
+      )
+    })
+  )
+);
+var gatewayCreditsResponseSchema = lazySchema4(
+  () => zodSchema4(
+    z4.object({
+      balance: z4.string(),
+      total_used: z4.string()
+    }).transform(({ balance, total_used }) => ({
+      balance,
+      totalUsed: total_used
+    }))
+  )
+);
+
+// src/gateway-language-model.ts
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler2,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  postJsonToApi,
+  resolve as resolve2
+} from "@ai-sdk/provider-utils";
+import { z as z5 } from "zod/v4";
+var GatewayLanguageModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v3";
+    this.supportedUrls = { "*/*": [/.*/] };
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async getArgs(options) {
+    const { abortSignal: _abortSignal, ...optionsWithoutSignal } = options;
+    return {
+      args: this.maybeEncodeFileParts(optionsWithoutSignal),
+      warnings: []
+    };
+  }
+  async doGenerate(options) {
+    const { args, warnings } = await this.getArgs(options);
+    const { abortSignal } = options;
+    const resolvedHeaders = await resolve2(this.config.headers());
+    try {
+      const {
+        responseHeaders,
+        value: responseBody,
+        rawValue: rawResponse
+      } = await postJsonToApi({
+        url: this.getUrl(),
+        headers: combineHeaders(
+          resolvedHeaders,
+          options.headers,
+          this.getModelConfigHeaders(this.modelId, false),
+          await resolve2(this.config.o11yHeaders)
+        ),
+        body: args,
+        successfulResponseHandler: createJsonResponseHandler2(z5.any()),
+        failedResponseHandler: createJsonErrorResponseHandler2({
+          errorSchema: z5.any(),
+          errorToMessage: (data) => data
+        }),
+        ...abortSignal && { abortSignal },
+        fetch: this.config.fetch
+      });
+      return {
+        ...responseBody,
+        request: { body: args },
+        response: { headers: responseHeaders, body: rawResponse },
+        warnings
+      };
+    } catch (error) {
+      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+    }
+  }
+  async doStream(options) {
+    const { args, warnings } = await this.getArgs(options);
+    const { abortSignal } = options;
+    const resolvedHeaders = await resolve2(this.config.headers());
+    try {
+      const { value: response, responseHeaders } = await postJsonToApi({
+        url: this.getUrl(),
+        headers: combineHeaders(
+          resolvedHeaders,
+          options.headers,
+          this.getModelConfigHeaders(this.modelId, true),
+          await resolve2(this.config.o11yHeaders)
+        ),
+        body: args,
+        successfulResponseHandler: createEventSourceResponseHandler(z5.any()),
+        failedResponseHandler: createJsonErrorResponseHandler2({
+          errorSchema: z5.any(),
+          errorToMessage: (data) => data
+        }),
+        ...abortSignal && { abortSignal },
+        fetch: this.config.fetch
+      });
+      return {
+        stream: response.pipeThrough(
+          new TransformStream({
+            start(controller) {
+              if (warnings.length > 0) {
+                controller.enqueue({ type: "stream-start", warnings });
+              }
+            },
+            transform(chunk, controller) {
+              if (chunk.success) {
+                const streamPart = chunk.value;
+                if (streamPart.type === "raw" && !options.includeRawChunks) {
+                  return;
+                }
+                if (streamPart.type === "response-metadata" && streamPart.timestamp && typeof streamPart.timestamp === "string") {
+                  streamPart.timestamp = new Date(streamPart.timestamp);
+                }
+                controller.enqueue(streamPart);
+              } else {
+                controller.error(
+                  chunk.error
+                );
+              }
+            }
+          })
+        ),
+        request: { body: args },
+        response: { headers: responseHeaders }
+      };
+    } catch (error) {
+      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+    }
+  }
+  isFilePart(part) {
+    return part && typeof part === "object" && "type" in part && part.type === "file";
+  }
+  /**
+   * Encodes file parts in the prompt to base64. Mutates the passed options
+   * instance directly to avoid copying the file data.
+   * @param options - The options to encode.
+   * @returns The options with the file parts encoded.
+   */
+  maybeEncodeFileParts(options) {
+    for (const message of options.prompt) {
+      for (const part of message.content) {
+        if (this.isFilePart(part)) {
+          const filePart = part;
+          if (filePart.data instanceof Uint8Array) {
+            const buffer = Uint8Array.from(filePart.data);
+            const base64Data = Buffer.from(buffer).toString("base64");
+            filePart.data = new URL(
+              `data:${filePart.mediaType || "application/octet-stream"};base64,${base64Data}`
+            );
+          }
+        }
+      }
+    }
+    return options;
+  }
+  getUrl() {
+    return `${this.config.baseURL}/language-model`;
+  }
+  getModelConfigHeaders(modelId, streaming) {
+    return {
+      "ai-language-model-specification-version": "3",
+      "ai-language-model-id": modelId,
+      "ai-language-model-streaming": String(streaming)
+    };
+  }
+};
+
+// src/gateway-embedding-model.ts
+import {
+  combineHeaders as combineHeaders2,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler3,
+  createJsonResponseHandler as createJsonResponseHandler3,
+  lazySchema as lazySchema5,
+  postJsonToApi as postJsonToApi2,
+  resolve as resolve3,
+  zodSchema as zodSchema5
+} from "@ai-sdk/provider-utils";
+import { z as z6 } from "zod/v4";
+var GatewayEmbeddingModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v3";
+    this.maxEmbeddingsPerCall = 2048;
+    this.supportsParallelCalls = true;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doEmbed({
+    values,
+    headers,
+    abortSignal,
+    providerOptions
+  }) {
+    var _a8;
+    const resolvedHeaders = await resolve3(this.config.headers());
+    try {
+      const {
+        responseHeaders,
+        value: responseBody,
+        rawValue
+      } = await postJsonToApi2({
+        url: this.getUrl(),
+        headers: combineHeaders2(
+          resolvedHeaders,
+          headers != null ? headers : {},
+          this.getModelConfigHeaders(),
+          await resolve3(this.config.o11yHeaders)
+        ),
+        body: {
+          values,
+          ...providerOptions ? { providerOptions } : {}
+        },
+        successfulResponseHandler: createJsonResponseHandler3(
+          gatewayEmbeddingResponseSchema
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler3({
+          errorSchema: z6.any(),
+          errorToMessage: (data) => data
+        }),
+        ...abortSignal && { abortSignal },
+        fetch: this.config.fetch
+      });
+      return {
+        embeddings: responseBody.embeddings,
+        usage: (_a8 = responseBody.usage) != null ? _a8 : void 0,
+        providerMetadata: responseBody.providerMetadata,
+        response: { headers: responseHeaders, body: rawValue },
+        warnings: []
+      };
+    } catch (error) {
+      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+    }
+  }
+  getUrl() {
+    return `${this.config.baseURL}/embedding-model`;
+  }
+  getModelConfigHeaders() {
+    return {
+      "ai-embedding-model-specification-version": "3",
+      "ai-model-id": this.modelId
+    };
+  }
+};
+var gatewayEmbeddingResponseSchema = lazySchema5(
+  () => zodSchema5(
+    z6.object({
+      embeddings: z6.array(z6.array(z6.number())),
+      usage: z6.object({ tokens: z6.number() }).nullish(),
+      providerMetadata: z6.record(z6.string(), z6.record(z6.string(), z6.unknown())).optional()
+    })
+  )
+);
+
+// src/gateway-image-model.ts
+import {
+  combineHeaders as combineHeaders3,
+  convertUint8ArrayToBase64,
+  createJsonResponseHandler as createJsonResponseHandler4,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler4,
+  postJsonToApi as postJsonToApi3,
+  resolve as resolve4
+} from "@ai-sdk/provider-utils";
+import { z as z7 } from "zod/v4";
+var GatewayImageModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v3";
+    // Set a very large number to prevent client-side splitting of requests
+    this.maxImagesPerCall = Number.MAX_SAFE_INTEGER;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doGenerate({
+    prompt,
+    n,
+    size,
+    aspectRatio,
+    seed,
+    files,
+    mask,
+    providerOptions,
+    headers,
+    abortSignal
+  }) {
+    var _a8;
+    const resolvedHeaders = await resolve4(this.config.headers());
+    try {
+      const {
+        responseHeaders,
+        value: responseBody,
+        rawValue
+      } = await postJsonToApi3({
+        url: this.getUrl(),
+        headers: combineHeaders3(
+          resolvedHeaders,
+          headers != null ? headers : {},
+          this.getModelConfigHeaders(),
+          await resolve4(this.config.o11yHeaders)
+        ),
+        body: {
+          prompt,
+          n,
+          ...size && { size },
+          ...aspectRatio && { aspectRatio },
+          ...seed && { seed },
+          ...providerOptions && { providerOptions },
+          ...files && {
+            files: files.map((file) => maybeEncodeImageFile(file))
+          },
+          ...mask && { mask: maybeEncodeImageFile(mask) }
+        },
+        successfulResponseHandler: createJsonResponseHandler4(
+          gatewayImageResponseSchema
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler4({
+          errorSchema: z7.any(),
+          errorToMessage: (data) => data
+        }),
+        ...abortSignal && { abortSignal },
+        fetch: this.config.fetch
+      });
+      return {
+        images: responseBody.images,
+        // Always base64 strings from server
+        warnings: (_a8 = responseBody.warnings) != null ? _a8 : [],
+        providerMetadata: responseBody.providerMetadata,
+        response: {
+          timestamp: /* @__PURE__ */ new Date(),
+          modelId: this.modelId,
+          headers: responseHeaders
+        }
+      };
+    } catch (error) {
+      throw asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+    }
+  }
+  getUrl() {
+    return `${this.config.baseURL}/image-model`;
+  }
+  getModelConfigHeaders() {
+    return {
+      "ai-image-model-specification-version": "3",
+      "ai-model-id": this.modelId
+    };
+  }
+};
+function maybeEncodeImageFile(file) {
+  if (file.type === "file" && file.data instanceof Uint8Array) {
+    return {
+      ...file,
+      data: convertUint8ArrayToBase64(file.data)
+    };
+  }
+  return file;
+}
+var providerMetadataEntrySchema = z7.object({
+  images: z7.array(z7.unknown()).optional()
+}).catchall(z7.unknown());
+var gatewayImageResponseSchema = z7.object({
+  images: z7.array(z7.string()),
+  // Always base64 strings over the wire
+  warnings: z7.array(
+    z7.object({
+      type: z7.literal("other"),
+      message: z7.string()
+    })
+  ).optional(),
+  providerMetadata: z7.record(z7.string(), providerMetadataEntrySchema).optional()
+});
+
+// src/tool/perplexity-search.ts
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema as lazySchema6,
+  zodSchema as zodSchema6
+} from "@ai-sdk/provider-utils";
+import { z as z8 } from "zod";
+var perplexitySearchInputSchema = lazySchema6(
+  () => zodSchema6(
+    z8.object({
+      query: z8.union([z8.string(), z8.array(z8.string())]).describe(
+        "Search query (string) or multiple queries (array of up to 5 strings). Multi-query searches return combined results from all queries."
+      ),
+      max_results: z8.number().optional().describe(
+        "Maximum number of search results to return (1-20, default: 10)"
+      ),
+      max_tokens_per_page: z8.number().optional().describe(
+        "Maximum number of tokens to extract per search result page (256-2048, default: 1024)"
+      ),
+      country: z8.string().optional().describe(
+        "Two-letter ISO 3166-1 alpha-2 country code for regional search results (e.g., 'US', 'GB', 'FR')"
+      ),
+      search_domain_filter: z8.array(z8.string()).optional().describe(
+        "List of domains to include or exclude from search results (max 20). To include: ['nature.com', 'science.org']. To exclude: ['-example.com', '-spam.net']"
+      ),
+      search_language_filter: z8.array(z8.string()).optional().describe(
+        "List of ISO 639-1 language codes to filter results (max 10, lowercase). Examples: ['en', 'fr', 'de']"
+      ),
+      search_after_date: z8.string().optional().describe(
+        "Include only results published after this date. Format: 'MM/DD/YYYY' (e.g., '3/1/2025'). Cannot be used with search_recency_filter."
+      ),
+      search_before_date: z8.string().optional().describe(
+        "Include only results published before this date. Format: 'MM/DD/YYYY' (e.g., '3/15/2025'). Cannot be used with search_recency_filter."
+      ),
+      search_recency_filter: z8.enum(["day", "week", "month", "year"]).optional().describe(
+        "Filter results by relative time period. Cannot be used with search_after_date or search_before_date."
+      )
+    })
+  )
+);
+var perplexitySearchOutputSchema = lazySchema6(
+  () => zodSchema6(
+    z8.union([
+      // Success response
+      z8.object({
+        results: z8.array(
+          z8.object({
+            title: z8.string(),
+            url: z8.string(),
+            snippet: z8.string(),
+            date: z8.string().optional(),
+            lastUpdated: z8.string().optional()
+          })
+        ),
+        id: z8.string()
+      }),
+      // Error response
+      z8.object({
+        error: z8.enum([
+          "api_error",
+          "rate_limit",
+          "timeout",
+          "invalid_input",
+          "unknown"
+        ]),
+        statusCode: z8.number().optional(),
+        message: z8.string()
+      })
+    ])
+  )
+);
+var perplexitySearchToolFactory = createProviderToolFactoryWithOutputSchema({
+  id: "gateway.perplexity_search",
+  inputSchema: perplexitySearchInputSchema,
+  outputSchema: perplexitySearchOutputSchema
+});
+var perplexitySearch = (config = {}) => perplexitySearchToolFactory(config);
+
+// src/gateway-tools.ts
+var gatewayTools = {
+  /**
+   * Search the web using Perplexity's Search API for real-time information,
+   * news, research papers, and articles.
+   *
+   * Provides ranked search results with advanced filtering options including
+   * domain, language, date range, and recency filters.
+   */
+  perplexitySearch
+};
+
+// src/vercel-environment.ts
+import { getContext } from "@vercel/oidc";
+import { getVercelOidcToken } from "@vercel/oidc";
+async function getVercelRequestId() {
+  var _a8;
+  return (_a8 = getContext().headers) == null ? void 0 : _a8["x-vercel-id"];
+}
+
+// src/gateway-provider.ts
+import { withUserAgentSuffix } from "@ai-sdk/provider-utils";
+
+// src/version.ts
+var VERSION = true ? "3.0.11" : "0.0.0-test";
+
+// src/gateway-provider.ts
+var AI_GATEWAY_PROTOCOL_VERSION = "0.0.1";
+function createGatewayProvider(options = {}) {
+  var _a8, _b8;
+  let pendingMetadata = null;
+  let metadataCache = null;
+  const cacheRefreshMillis = (_a8 = options.metadataCacheRefreshMillis) != null ? _a8 : 1e3 * 60 * 5;
+  let lastFetchTime = 0;
+  const baseURL = (_b8 = withoutTrailingSlash(options.baseURL)) != null ? _b8 : "https://ai-gateway.vercel.sh/v3/ai";
+  const getHeaders = async () => {
+    try {
+      const auth = await getGatewayAuthToken(options);
+      return withUserAgentSuffix(
+        {
+          Authorization: `Bearer ${auth.token}`,
+          "ai-gateway-protocol-version": AI_GATEWAY_PROTOCOL_VERSION,
+          [GATEWAY_AUTH_METHOD_HEADER]: auth.authMethod,
+          ...options.headers
+        },
+        `ai-sdk/gateway/${VERSION}`
+      );
+    } catch (error) {
+      throw GatewayAuthenticationError.createContextualError({
+        apiKeyProvided: false,
+        oidcTokenProvided: false,
+        statusCode: 401,
+        cause: error
+      });
+    }
+  };
+  const createO11yHeaders = () => {
+    const deploymentId = loadOptionalSetting({
+      settingValue: void 0,
+      environmentVariableName: "VERCEL_DEPLOYMENT_ID"
+    });
+    const environment = loadOptionalSetting({
+      settingValue: void 0,
+      environmentVariableName: "VERCEL_ENV"
+    });
+    const region = loadOptionalSetting({
+      settingValue: void 0,
+      environmentVariableName: "VERCEL_REGION"
+    });
+    return async () => {
+      const requestId = await getVercelRequestId();
+      return {
+        ...deploymentId && { "ai-o11y-deployment-id": deploymentId },
+        ...environment && { "ai-o11y-environment": environment },
+        ...region && { "ai-o11y-region": region },
+        ...requestId && { "ai-o11y-request-id": requestId }
+      };
+    };
+  };
+  const createLanguageModel = (modelId) => {
+    return new GatewayLanguageModel(modelId, {
+      provider: "gateway",
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      o11yHeaders: createO11yHeaders()
+    });
+  };
+  const getAvailableModels = async () => {
+    var _a9, _b9, _c;
+    const now = (_c = (_b9 = (_a9 = options._internal) == null ? void 0 : _a9.currentDate) == null ? void 0 : _b9.call(_a9).getTime()) != null ? _c : Date.now();
+    if (!pendingMetadata || now - lastFetchTime > cacheRefreshMillis) {
+      lastFetchTime = now;
+      pendingMetadata = new GatewayFetchMetadata({
+        baseURL,
+        headers: getHeaders,
+        fetch: options.fetch
+      }).getAvailableModels().then((metadata) => {
+        metadataCache = metadata;
+        return metadata;
+      }).catch(async (error) => {
+        throw await asGatewayError(
+          error,
+          await parseAuthMethod(await getHeaders())
+        );
+      });
+    }
+    return metadataCache ? Promise.resolve(metadataCache) : pendingMetadata;
+  };
+  const getCredits = async () => {
+    return new GatewayFetchMetadata({
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch
+    }).getCredits().catch(async (error) => {
+      throw await asGatewayError(
+        error,
+        await parseAuthMethod(await getHeaders())
+      );
+    });
+  };
+  const provider = function(modelId) {
+    if (new.target) {
+      throw new Error(
+        "The Gateway Provider model function cannot be called with the new keyword."
+      );
+    }
+    return createLanguageModel(modelId);
+  };
+  provider.specificationVersion = "v3";
+  provider.getAvailableModels = getAvailableModels;
+  provider.getCredits = getCredits;
+  provider.imageModel = (modelId) => {
+    return new GatewayImageModel(modelId, {
+      provider: "gateway",
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      o11yHeaders: createO11yHeaders()
+    });
+  };
+  provider.languageModel = createLanguageModel;
+  const createEmbeddingModel = (modelId) => {
+    return new GatewayEmbeddingModel(modelId, {
+      provider: "gateway",
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      o11yHeaders: createO11yHeaders()
+    });
+  };
+  provider.embeddingModel = createEmbeddingModel;
+  provider.textEmbeddingModel = createEmbeddingModel;
+  provider.tools = gatewayTools;
+  return provider;
+}
+var gateway = createGatewayProvider();
+async function getGatewayAuthToken(options) {
+  const apiKey = loadOptionalSetting({
+    settingValue: options.apiKey,
+    environmentVariableName: "AI_GATEWAY_API_KEY"
+  });
+  if (apiKey) {
+    return {
+      token: apiKey,
+      authMethod: "api-key"
+    };
+  }
+  const oidcToken = await getVercelOidcToken();
+  return {
+    token: oidcToken,
+    authMethod: "oidc"
+  };
+}
+export {
+  GatewayAuthenticationError,
+  GatewayError,
+  GatewayInternalServerError,
+  GatewayInvalidRequestError,
+  GatewayModelNotFoundError,
+  GatewayRateLimitError,
+  GatewayResponseError,
+  createGatewayProvider as createGateway,
+  createGatewayProvider,
+  gateway
+};
+//# sourceMappingURL=index.mjs.map