From 23cd3109b407a1de0ac30b0f0d819e7cf8cc6099 Mon Sep 17 00:00:00 2001 From: Aiden Cline <63023139+rekram1-node@users.noreply.github.com> Date: Fri, 23 Oct 2026 10:45:35 -0500 Subject: [PATCH] feat(ai): add Vercel AI Gateway image generation (#58469) --- packages/ai/README.md | 4 ++- packages/ai/src/protocols/openai-images.ts | 36 +++++++++++-------- .../ai/src/providers/vercel-ai-gateway.ts | 7 +++- packages/ai/test/exports.test.ts | 2 ++ .../generates-an-image.json | 32 +++++++++++++++++ .../vercel-ai-gateway-images.recorded.test.ts | 35 ++++++++++++++++++ 6 files changed, 99 insertions(+), 17 deletions(-) create mode 100644 packages/ai/test/fixtures/recordings/vercel-ai-gateway-images/generates-an-image.json create mode 100644 packages/ai/test/provider/vercel-ai-gateway-images.recorded.test.ts diff --git a/packages/ai/README.md b/packages/ai/README.md index 72c77a73fd1..c45f7f2350a 100644 --- a/packages/ai/README.md +++ b/packages/ai/README.md @@ -575,9 +575,11 @@ call rather than being dropped, so check this table before swapping only the `mo | Replicate | ✗ | ✗ | ✗ | ✗ | ✗ | ✗ (use `providerOptions`) | ✗ | | Stability `image` | 1 | ✗ | ✓ | ✓ | ✓ | 1 (not on `core`) | ✗ | | Stability `upscale()` | ✗ | ✗ | ✗ | ✓ | ✓ | exactly 1 (required) | ✗ | +| Vercel AI Gateway | ✓ | per model | ✗ | ✗ | ignored | per model | per model | ✓ lowers natively; ✗ fails whenever the field is set (including `n: 1`); `1` means `n > 1` fails. ¹ `Image.stream` on OpenAI generates one image. fal -rejects `size` and `aspectRatio` together; which one a fal or BFL model takes depends on the model. +rejects `size` and `aspectRatio` together; which one a fal or BFL model takes depends on the model. Vercel AI Gateway +forwards `format` but does not apply it, so the returned bytes keep the upstream model's own format. `Media.Asset` is the one asset type shared by image requests, image responses, LLM messages, and tool results. `asset.source` is the serializable `Media.Source` (`bytes`, `base64`, `url`, or `ref`); `asset.bytes()`, diff --git a/packages/ai/src/protocols/openai-images.ts b/packages/ai/src/protocols/openai-images.ts index f778cdb5786..04d53641122 100644 --- a/packages/ai/src/protocols/openai-images.ts +++ b/packages/ai/src/protocols/openai-images.ts @@ -11,7 +11,7 @@ import { Media } from "../media.js" import { Framing } from "../route/framing.js" import { MediaProtocol } from "../route/media-protocol.js" import { MediaRoute } from "../route/media.js" -import { mergeJsonRecords, type MediaUsage, type OpenString } from "../schema/index.js" +import { mergeJsonRecords, ProviderID, type MediaUsage, type OpenString } from "../schema/index.js" import { ProviderShared } from "./shared.js" import { MediaInput } from "./utils/media-input.js" @@ -99,7 +99,7 @@ interface State { readonly size?: string readonly quality?: string readonly background?: string - readonly usage?: MediaUsage + readonly usage?: Schema.Schema.Type } // --------------------------------------------------------------------------- @@ -128,8 +128,8 @@ const isEdit = (request: Request) => (request.images?.length ?? 0) > 0 const isInline = (asset: Media.Asset) => asset.source.type === "bytes" || asset.source.type === "base64" -const reference = (asset: Media.Asset) => - ProviderShared.mediaReference(asset, route.provider, route.name).pipe( +const reference = (asset: Media.Asset, provider: ProviderID) => + ProviderShared.mediaReference(asset, provider, route.name).pipe( Effect.map((item) => (item.type === "ref" ? { file_id: item.value } : { image_url: item.value })), ) @@ -161,8 +161,8 @@ const fromRequest = Effect.fn("OpenAIImages.fromRequest")(function* (request: Me return MediaProtocol.multipart(form) } - const references = yield* Effect.forEach(images, reference) - const maskReference = mask === undefined ? undefined : yield* reference(mask) + const references = yield* Effect.forEach(images, (image) => reference(image, request.model.provider)) + const maskReference = mask === undefined ? undefined : yield* reference(mask, request.model.provider) return MediaProtocol.json( mergeJsonRecords( { @@ -180,7 +180,7 @@ const fromRequest = Effect.fn("OpenAIImages.fromRequest")(function* (request: Me // 6. Stream parsing // --------------------------------------------------------------------------- -const usage = (value: Schema.Schema.Type | undefined): MediaUsage | undefined => +const usage = (value: Schema.Schema.Type | undefined, provider: ProviderID): MediaUsage | undefined => value === undefined ? undefined : { @@ -188,7 +188,7 @@ const usage = (value: Schema.Schema.Type | undefined): MediaUsage input: value.input_tokens, output: value.output_tokens, total: value.total_tokens, - details: { openai: value }, + details: { [provider]: value }, } /** `size` echoes the rendered `WIDTHxHEIGHT`; `auto` or any other value leaves the dimensions unknown. */ @@ -217,7 +217,7 @@ const onEvent = Effect.fnUntraced(function* (state: State, frame: string) { size: event.size, quality: event.quality, background: event.background, - usage: usage(event.usage), + usage: event.usage, }, [ImageOutputEvent.make({ index: state.completed, image })], ] as const @@ -243,20 +243,21 @@ const onDocument = Effect.fnUntraced(function* (frame: Exclude) { size: decoded.size, quality: decoded.quality, background: decoded.background, - usage: usage(decoded.usage), + usage: decoded.usage, } return [state, images.map((image, index) => ImageOutputEvent.make({ index, image }))] as const }) const step = (state: State, frame: Frame) => (typeof frame === "string" ? onEvent(state, frame) : onDocument(frame)) -const finish = (state: State) => { +const finish = (state: State, context: MediaProtocol.ResponseContext) => { if (state.completed === 0) return Effect.fail(route.incomplete()) + const provider = context.request.model.provider return Effect.succeed([ ImageFinishEvent.make({ - usage: state.usage, + usage: usage(state.usage, provider), providerMetadata: { - openai: { + [provider]: { outputFormat: state.format, size: state.size, quality: state.quality, @@ -283,9 +284,14 @@ export const protocol = MediaProtocol.stream( finish, }) -export const model = (input: MediaRoute.ModelInput) => +/** `provider` attributes models, refs, and metadata to an OpenAI-compatible host; it defaults to `openai`. */ +export const model = (input: MediaRoute.ModelInput & { readonly provider?: string }) => ImageModel.fromRoute( - { protocol, baseURL: DEFAULT_BASE_URL, path: ({ request }) => (isEdit(request) ? EDIT_PATH : PATH) }, + { + protocol: input.provider === undefined ? protocol : { ...protocol, provider: ProviderID.make(input.provider) }, + baseURL: DEFAULT_BASE_URL, + path: ({ request }) => (isEdit(request) ? EDIT_PATH : PATH), + }, input, ) diff --git a/packages/ai/src/providers/vercel-ai-gateway.ts b/packages/ai/src/providers/vercel-ai-gateway.ts index ff8dd854c5f..57d9793c4ba 100644 --- a/packages/ai/src/providers/vercel-ai-gateway.ts +++ b/packages/ai/src/providers/vercel-ai-gateway.ts @@ -11,6 +11,7 @@ import { import { AnthropicMessages } from "../protocols/anthropic-messages.js" import { OpenAIChat } from "../protocols/openai-chat.js" import { OpenResponses } from "../protocols/open-responses.js" +import { OpenAIImages } from "../protocols/openai-images.js" import { JsonObject, optionalNull, ProviderShared } from "../protocols/shared.js" import { gatewayProtocol } from "../protocols/utils/gateway-protocol.js" import type { ProviderPackage } from "../provider-package.js" @@ -20,6 +21,7 @@ import { Route, type RouteDefaultsInput } from "../route/client.js" import { Endpoint } from "../route/endpoint.js" import { RequestExecutor } from "../route/executor.js" import { Framing } from "../route/framing.js" +import { MediaRoute } from "../route/media.js" import type { Protocol } from "../route/protocol.js" import { AIError, @@ -350,7 +352,9 @@ export const configure = (input: Options = {}) => { }), }, }) - return { id, model, messages, responses, chat, experimental: { evaluation }, configure } + const media = MediaRoute.deployment({ ...input, baseURL: configured.endpoint.baseURL }, configured.auth) + const image = (modelID: string | ModelID) => OpenAIImages.model({ ...media, id: modelID, provider: id }) + return { id, model, messages, responses, chat, image, experimental: { evaluation }, configure } } export const provider = configure() @@ -358,6 +362,7 @@ export const experimental = provider.experimental export const messages = provider.messages export const responses = provider.responses export const chat = provider.chat +export const image = provider.image export const model: ProviderPackage.Definition["model"] = (modelID, settings) => fromSettings(settings).model(modelID) diff --git a/packages/ai/test/exports.test.ts b/packages/ai/test/exports.test.ts index 33ff572c503..b632883897c 100644 --- a/packages/ai/test/exports.test.ts +++ b/packages/ai/test/exports.test.ts @@ -183,6 +183,8 @@ describe("public exports", () => { expect(Alibaba.configure({ region: "ap-southeast-1", apiKey: "fixture" }).image("qwen-image-2.0").route.id).toBe( "alibaba-images", ) + expect(VercelAIGateway.configure({ apiKey: "fixture" }).image("meta/muse-image-1.0").route.id).toBe("openai-images") + expect(VercelAIGateway.provider.image).toBe(VercelAIGateway.image) expect(XAI.configure({ apiKey: "fixture" }).video("grok-imagine-video-1.5").route.id).toBe("xai-video") expect(XAI.provider.video).toBe(XAI.video) expect(Google.configure({ apiKey: "fixture" }).video("veo-3.1-generate-preview").route.id).toBe("google-video") diff --git a/packages/ai/test/fixtures/recordings/vercel-ai-gateway-images/generates-an-image.json b/packages/ai/test/fixtures/recordings/vercel-ai-gateway-images/generates-an-image.json new file mode 100644 index 00000000000..03b2e7383ac --- /dev/null +++ b/packages/ai/test/fixtures/recordings/vercel-ai-gateway-images/generates-an-image.json @@ -0,0 +1,32 @@ +{ + "version": 1, + "metadata": { + "tags": [ + "prefix:vercel-ai-gateway-images", + "provider:vercel-ai-gateway", + "protocol:openai-images" + ], + "name": "vercel-ai-gateway-images/generates-an-image", + "recordedAt": "2026-10-23T14:49:14.488Z" + }, + "interactions": [ + { + "transport": "http", + "request": { + "method": "POST", + "url": "https://ai-gateway.vercel.sh/v1/images/generations", + "headers": { + "content-type": "application/json" + }, + "body": "{\"model\":\"meta/muse-image-1.0\",\"prompt\":\"A simple flat black circle centered on a plain white background.\",\"output_format\":\"webp\"}" + }, + "response": { + "status": 200, + "headers": { + "content-type": "application/json" + }, + "body": "{\"created\":1792766954,\"data\":[{\"b64_json\":\"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\"}],\"usage\":{\"total_tokens\":10072,\"input_tokens\":9668,\"output_tokens\":404,\"input_tokens_details\":{\"text_tokens\":0,\"image_tokens\":0}},\"providerMetadata\":{\"openai\":{\"images\":[{\"created\":1792766954,\"background\":\"opaque\",\"outputFormat\":\"webp\"}]},\"gateway\":{\"routing\":{\"originalModelId\":\"meta/muse-image-1.0\",\"resolvedProvider\":\"meta\",\"fallbacksAvailable\":[],\"planningReasoning\":\"System credentials planned for: meta. Total execution order: meta(system)\",\"canonicalSlug\":\"meta/muse-image-1.0\",\"finalProvider\":\"meta\",\"modelAttemptCount\":1,\"modelAttempts\":[{\"canonicalSlug\":\"meta/muse-image-1.0\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"meta\",\"credentialType\":\"system\",\"success\":true,\"startTime\":1792766949294,\"endTime\":1792766954432,\"statusCode\":200}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0.01\",\"marketCost\":\"0.01\",\"surchargeCost\":\"0\",\"gatewayCost\":\"0.01\",\"inferenceCost\":\"0.01\",\"inputInferenceCost\":\"0\",\"outputInferenceCost\":\"0.01\",\"generationId\":\"gen_01M5MKSDW6DJYX8P6NJMS0CA21\"}}}" + } + } + ] +} diff --git a/packages/ai/test/provider/vercel-ai-gateway-images.recorded.test.ts b/packages/ai/test/provider/vercel-ai-gateway-images.recorded.test.ts new file mode 100644 index 00000000000..d98481b80f9 --- /dev/null +++ b/packages/ai/test/provider/vercel-ai-gateway-images.recorded.test.ts @@ -0,0 +1,35 @@ +import { describe, expect } from "bun:test" +import { Effect } from "effect" +import { Image } from "../../src/index.js" +import { VercelAIGateway } from "../../src/providers.js" +import { recordedTests } from "../recorded-test.js" + +const model = VercelAIGateway.configure({ + apiKey: process.env.AI_GATEWAY_API_KEY ?? "fixture", +}).image("meta/muse-image-1.0") + +const recorded = recordedTests({ + prefix: "vercel-ai-gateway-images", + provider: "vercel-ai-gateway", + protocol: "openai-images", + requires: ["AI_GATEWAY_API_KEY"], +}) + +describe("Vercel AI Gateway Images recorded", () => { + recorded.effect("generates an image", () => + Effect.gen(function* () { + const response = yield* Image.generate({ + model, + prompt: "A simple flat black circle centered on a plain white background.", + format: "webp", + }) + + expect(response.images).toHaveLength(1) + expect(response.image.mediaType).toBe("image/webp") + expect(new TextDecoder().decode((yield* response.image.bytes()).subarray(8, 12))).toBe("WEBP") + expect(model.provider).toBe("vercel-ai-gateway") + expect(response.usage?.details).toHaveProperty("vercel-ai-gateway") + expect(response.providerMetadata).toHaveProperty("vercel-ai-gateway") + }), + ) +})