@ai-sdk/gateway
Version:
The Gateway provider for the [AI SDK](https://ai-sdk.dev/docs) allows the use of a wide variety of AI models and providers.
972 lines (943 loc) • 31.9 kB
JavaScript
;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name7 in all)
__defProp(target, name7, { get: all[name7], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var src_exports = {};
__export(src_exports, {
GatewayAuthenticationError: () => GatewayAuthenticationError,
GatewayError: () => GatewayError,
GatewayInternalServerError: () => GatewayInternalServerError,
GatewayInvalidRequestError: () => GatewayInvalidRequestError,
GatewayModelNotFoundError: () => GatewayModelNotFoundError,
GatewayRateLimitError: () => GatewayRateLimitError,
GatewayResponseError: () => GatewayResponseError,
createGateway: () => createGatewayProvider,
createGatewayProvider: () => createGatewayProvider,
gateway: () => gateway
});
module.exports = __toCommonJS(src_exports);
// src/gateway-provider.ts
var import_provider_utils8 = require("@ai-sdk/provider-utils");
// src/errors/as-gateway-error.ts
var import_provider = require("@ai-sdk/provider");
// src/errors/create-gateway-error.ts
var import_v42 = require("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
var import_v4 = require("zod/v4");
var import_provider_utils = require("@ai-sdk/provider-utils");
var name4 = "GatewayModelNotFoundError";
var marker5 = `vercel.ai.gateway.error.${name4}`;
var symbol5 = Symbol.for(marker5);
var modelNotFoundParamSchema = (0, import_provider_utils.lazySchema)(
() => (0, import_provider_utils.zodSchema)(
import_v4.z.object({
modelId: import_v4.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
var import_provider_utils2 = require("@ai-sdk/provider-utils");
async function createGatewayErrorFromResponse({
response,
statusCode,
defaultMessage = "Gateway request failed",
cause,
authMethod
}) {
const parseResult = await (0, import_provider_utils2.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 (0, import_provider_utils2.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 = (0, import_provider_utils2.lazySchema)(
() => (0, import_provider_utils2.zodSchema)(
import_v42.z.object({
error: import_v42.z.object({
message: import_v42.z.string(),
type: import_v42.z.string().nullish(),
param: import_v42.z.unknown().nullish(),
code: import_v42.z.union([import_v42.z.string(), import_v42.z.number()]).nullish()
})
})
)
);
// src/errors/as-gateway-error.ts
function asGatewayError(error, authMethod) {
var _a8;
if (GatewayError.isInstance(error)) {
return error;
}
if (import_provider.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
var import_v43 = require("zod/v4");
var import_provider_utils3 = require("@ai-sdk/provider-utils");
var GATEWAY_AUTH_METHOD_HEADER = "ai-gateway-auth-method";
async function parseAuthMethod(headers) {
const result = await (0, import_provider_utils3.safeValidateTypes)({
value: headers[GATEWAY_AUTH_METHOD_HEADER],
schema: gatewayAuthMethodSchema
});
return result.success ? result.value : void 0;
}
var gatewayAuthMethodSchema = (0, import_provider_utils3.lazySchema)(
() => (0, import_provider_utils3.zodSchema)(import_v43.z.union([import_v43.z.literal("api-key"), import_v43.z.literal("oidc")]))
);
// src/gateway-fetch-metadata.ts
var import_provider_utils4 = require("@ai-sdk/provider-utils");
var import_v44 = require("zod/v4");
var GatewayFetchMetadata = class {
constructor(config) {
this.config = config;
}
async getAvailableModels() {
try {
const { value } = await (0, import_provider_utils4.getFromApi)({
url: `${this.config.baseURL}/config`,
headers: await (0, import_provider_utils4.resolve)(this.config.headers()),
successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
gatewayAvailableModelsResponseSchema
),
failedResponseHandler: (0, import_provider_utils4.createJsonErrorResponseHandler)({
errorSchema: import_v44.z.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 (0, import_provider_utils4.getFromApi)({
url: `${baseUrl.origin}/v1/credits`,
headers: await (0, import_provider_utils4.resolve)(this.config.headers()),
successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
gatewayCreditsResponseSchema
),
failedResponseHandler: (0, import_provider_utils4.createJsonErrorResponseHandler)({
errorSchema: import_v44.z.any(),
errorToMessage: (data) => data
}),
fetch: this.config.fetch
});
return value;
} catch (error) {
throw await asGatewayError(error);
}
}
};
var gatewayAvailableModelsResponseSchema = (0, import_provider_utils4.lazySchema)(
() => (0, import_provider_utils4.zodSchema)(
import_v44.z.object({
models: import_v44.z.array(
import_v44.z.object({
id: import_v44.z.string(),
name: import_v44.z.string(),
description: import_v44.z.string().nullish(),
pricing: import_v44.z.object({
input: import_v44.z.string(),
output: import_v44.z.string(),
input_cache_read: import_v44.z.string().nullish(),
input_cache_write: import_v44.z.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: import_v44.z.object({
specificationVersion: import_v44.z.literal("v3"),
provider: import_v44.z.string(),
modelId: import_v44.z.string()
}),
modelType: import_v44.z.enum(["language", "embedding", "image"]).nullish()
})
)
})
)
);
var gatewayCreditsResponseSchema = (0, import_provider_utils4.lazySchema)(
() => (0, import_provider_utils4.zodSchema)(
import_v44.z.object({
balance: import_v44.z.string(),
total_used: import_v44.z.string()
}).transform(({ balance, total_used }) => ({
balance,
totalUsed: total_used
}))
)
);
// src/gateway-language-model.ts
var import_provider_utils5 = require("@ai-sdk/provider-utils");
var import_v45 = require("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 (0, import_provider_utils5.resolve)(this.config.headers());
try {
const {
responseHeaders,
value: responseBody,
rawValue: rawResponse
} = await (0, import_provider_utils5.postJsonToApi)({
url: this.getUrl(),
headers: (0, import_provider_utils5.combineHeaders)(
resolvedHeaders,
options.headers,
this.getModelConfigHeaders(this.modelId, false),
await (0, import_provider_utils5.resolve)(this.config.o11yHeaders)
),
body: args,
successfulResponseHandler: (0, import_provider_utils5.createJsonResponseHandler)(import_v45.z.any()),
failedResponseHandler: (0, import_provider_utils5.createJsonErrorResponseHandler)({
errorSchema: import_v45.z.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 (0, import_provider_utils5.resolve)(this.config.headers());
try {
const { value: response, responseHeaders } = await (0, import_provider_utils5.postJsonToApi)({
url: this.getUrl(),
headers: (0, import_provider_utils5.combineHeaders)(
resolvedHeaders,
options.headers,
this.getModelConfigHeaders(this.modelId, true),
await (0, import_provider_utils5.resolve)(this.config.o11yHeaders)
),
body: args,
successfulResponseHandler: (0, import_provider_utils5.createEventSourceResponseHandler)(import_v45.z.any()),
failedResponseHandler: (0, import_provider_utils5.createJsonErrorResponseHandler)({
errorSchema: import_v45.z.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": "2",
"ai-language-model-id": modelId,
"ai-language-model-streaming": String(streaming)
};
}
};
// src/gateway-embedding-model.ts
var import_provider_utils6 = require("@ai-sdk/provider-utils");
var import_v46 = require("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 (0, import_provider_utils6.resolve)(this.config.headers());
try {
const {
responseHeaders,
value: responseBody,
rawValue
} = await (0, import_provider_utils6.postJsonToApi)({
url: this.getUrl(),
headers: (0, import_provider_utils6.combineHeaders)(
resolvedHeaders,
headers != null ? headers : {},
this.getModelConfigHeaders(),
await (0, import_provider_utils6.resolve)(this.config.o11yHeaders)
),
body: {
values,
...providerOptions ? { providerOptions } : {}
},
successfulResponseHandler: (0, import_provider_utils6.createJsonResponseHandler)(
gatewayEmbeddingResponseSchema
),
failedResponseHandler: (0, import_provider_utils6.createJsonErrorResponseHandler)({
errorSchema: import_v46.z.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": "2",
"ai-model-id": this.modelId
};
}
};
var gatewayEmbeddingResponseSchema = (0, import_provider_utils6.lazySchema)(
() => (0, import_provider_utils6.zodSchema)(
import_v46.z.object({
embeddings: import_v46.z.array(import_v46.z.array(import_v46.z.number())),
usage: import_v46.z.object({ tokens: import_v46.z.number() }).nullish(),
providerMetadata: import_v46.z.record(import_v46.z.string(), import_v46.z.record(import_v46.z.string(), import_v46.z.unknown())).optional()
})
)
);
// src/gateway-image-model.ts
var import_provider_utils7 = require("@ai-sdk/provider-utils");
var import_v47 = require("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,
providerOptions,
headers,
abortSignal
}) {
var _a8;
const resolvedHeaders = await (0, import_provider_utils7.resolve)(this.config.headers());
try {
const {
responseHeaders,
value: responseBody,
rawValue
} = await (0, import_provider_utils7.postJsonToApi)({
url: this.getUrl(),
headers: (0, import_provider_utils7.combineHeaders)(
resolvedHeaders,
headers != null ? headers : {},
this.getModelConfigHeaders(),
await (0, import_provider_utils7.resolve)(this.config.o11yHeaders)
),
body: {
prompt,
n,
...size && { size },
...aspectRatio && { aspectRatio },
...seed && { seed },
...providerOptions && { providerOptions }
},
successfulResponseHandler: (0, import_provider_utils7.createJsonResponseHandler)(
gatewayImageResponseSchema
),
failedResponseHandler: (0, import_provider_utils7.createJsonErrorResponseHandler)({
errorSchema: import_v47.z.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": "2",
"ai-model-id": this.modelId
};
}
};
var providerMetadataEntrySchema = import_v47.z.object({
images: import_v47.z.array(import_v47.z.unknown()).optional()
}).catchall(import_v47.z.unknown());
var gatewayImageResponseSchema = import_v47.z.object({
images: import_v47.z.array(import_v47.z.string()),
// Always base64 strings over the wire
warnings: import_v47.z.array(
import_v47.z.object({
type: import_v47.z.literal("other"),
message: import_v47.z.string()
})
).optional(),
providerMetadata: import_v47.z.record(import_v47.z.string(), providerMetadataEntrySchema).optional()
});
// src/vercel-environment.ts
var import_oidc = require("@vercel/oidc");
var import_oidc2 = require("@vercel/oidc");
async function getVercelRequestId() {
var _a8;
return (_a8 = (0, import_oidc.getContext)().headers) == null ? void 0 : _a8["x-vercel-id"];
}
// src/gateway-provider.ts
var import_provider_utils9 = require("@ai-sdk/provider-utils");
// src/version.ts
var VERSION = true ? "3.0.4" : "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 = (0, import_provider_utils8.withoutTrailingSlash)(options.baseURL)) != null ? _b8 : "https://ai-gateway.vercel.sh/v3/ai";
const getHeaders = async () => {
try {
const auth = await getGatewayAuthToken(options);
return (0, import_provider_utils9.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 = (0, import_provider_utils8.loadOptionalSetting)({
settingValue: void 0,
environmentVariableName: "VERCEL_DEPLOYMENT_ID"
});
const environment = (0, import_provider_utils8.loadOptionalSetting)({
settingValue: void 0,
environmentVariableName: "VERCEL_ENV"
});
const region = (0, import_provider_utils8.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;
return provider;
}
var gateway = createGatewayProvider();
async function getGatewayAuthToken(options) {
const apiKey = (0, import_provider_utils8.loadOptionalSetting)({
settingValue: options.apiKey,
environmentVariableName: "AI_GATEWAY_API_KEY"
});
if (apiKey) {
return {
token: apiKey,
authMethod: "api-key"
};
}
const oidcToken = await (0, import_oidc2.getVercelOidcToken)();
return {
token: oidcToken,
authMethod: "oidc"
};
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
GatewayAuthenticationError,
GatewayError,
GatewayInternalServerError,
GatewayInvalidRequestError,
GatewayModelNotFoundError,
GatewayRateLimitError,
GatewayResponseError,
createGateway,
createGatewayProvider,
gateway
});
//# sourceMappingURL=index.js.map