pi-media-models 0.1.0

package/src/adapters/dashscope.ts

@@ -0,0 +1,151 @@
+import { MediaJob, mapJobState } from '../media-job.js'
+import { BaseAdapter, artifactsOrThrow, dataUris, makeModel } from './base.js'
+import type { AdapterContext, AdapterResult, Capability, JobStatus, JsonObject, MediaRequest, ModelDescriptor } from '../types.js'
+
+function withoutControlOptions(options: JsonObject | undefined): JsonObject {
+  if (!options) return {}
+  const { endpoint: _endpoint, taskEndpoint: _taskEndpoint, timeoutMs: _timeoutMs, baseUrl: _baseUrl, async: _async, ...payload } = options
+  return payload
+}
+
+export class DashScopeAdapter extends BaseAdapter {
+  readonly displayName: string
+  readonly envKey = 'DASHSCOPE_API_KEY'
+
+  constructor(readonly id: 'dashscope' | 'qwencloud', private readonly baseUrl: string, dependencies: ConstructorParameters<typeof BaseAdapter>[0]) {
+    super(dependencies)
+    this.displayName = id === 'dashscope' ? 'Alibaba Cloud Bailian / DashScope' : 'QwenCloud (DashScope international)'
+  }
+
+  models(): ModelDescriptor[] {
+    return [
+      makeModel(this.id, 'alibaba', 'qwen-image-3.0-pro', ['image.text_to_image']),
+      makeModel(this.id, 'alibaba', 'qwen-image-edit-plus', ['image.image_to_image', 'image.edit', 'image.multi_reference']),
+      makeModel(this.id, 'alibaba', 'wan3.0-video', ['video.text_to_video', 'video.image_to_video', 'video.first_last_frame', 'video.reference', 'video.edit', 'video.extend', 'video.native_audio']),
+      makeModel(this.id, 'alibaba', 'wan2.7-videoedit', ['video.edit', 'video.reference', 'video.native_audio']),
+      makeModel(this.id, 'alibaba', 'fun-music-v1', ['audio.generate']),
+      makeModel(this.id, 'alibaba', 'qwen3-tts-flash', ['speech.tts']),
+      makeModel(this.id, 'alibaba', 'qwen-audio-3.0-asr-flash-filetrans', ['speech.stt']),
+    ]
+  }
+
+  supports(_capability: Capability): boolean { return true }
+
+  async execute(request: MediaRequest, context: AdapterContext): Promise<AdapterResult> {
+    this.assertSupport(request)
+    const key = this.key(request)
+    const endpoint = this.endpoint(request)
+    const baseUrl = typeof request.providerOptions?.baseUrl === 'string' ? request.providerOptions.baseUrl.replace(/\/+$/, '') : this.baseUrl
+    const payload = await this.payload(request, context.signal)
+    const asyncRequest = request.capability.startsWith('video.') || request.capability === 'speech.stt' ||
+      (request.capability === 'image.text_to_image' && !/^qwen-image-3/i.test(request.model)) || request.providerOptions?.async === true
+    const submitted = await this.http.json<Record<string, unknown>>(`${baseUrl}${endpoint}`, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${key}`, 'Content-Type': 'application/json', ...(asyncRequest ? { 'X-DashScope-Async': 'enable' } : {}) },
+      body: JSON.stringify(payload), signal: context.signal, provider: this.id, secrets: [key], timeoutMs: 60_000,
+    })
+    const output = (submitted.output && typeof submitted.output === 'object' ? submitted.output : submitted) as Record<string, unknown>
+    const taskId = typeof output.task_id === 'string' ? output.task_id : undefined
+    if (!taskId) return artifactsOrThrow(this.result(request, submitted, this.kind(request), { text: this.text(submitted) }))
+    const taskEndpoint = typeof request.providerOptions?.taskEndpoint === 'string'
+      ? request.providerOptions.taskEndpoint.replace('{task_id}', encodeURIComponent(taskId))
+      : `/api/v1/tasks/${encodeURIComponent(taskId)}`
+    const job = new MediaJob<Record<string, unknown>>({
+      id: taskId, provider: this.id, signal: context.signal, timeoutMs: this.timeout(request), minDelayMs: 1_000, maxDelayMs: 8_000,
+      onProgress: status => context.onProgress?.(`${this.id} ${taskId}: ${status.state}`),
+      poll: async signal => {
+        const status = await this.http.json<Record<string, unknown>>(`${baseUrl}${taskEndpoint}`, {
+          headers: { Authorization: `Bearer ${key}` }, signal, provider: this.id, secrets: [key], timeoutMs: 30_000,
+        })
+        const currentOutput = (status.output && typeof status.output === 'object' ? status.output : status) as Record<string, unknown>
+        const state = mapJobState(currentOutput.task_status ?? currentOutput.status)
+        return {
+          state,
+          ...(state === 'succeeded' ? { result: status } : {}),
+          ...(typeof currentOutput.message === 'string' ? { message: currentOutput.message } : {}),
+        } satisfies JobStatus<Record<string, unknown>>
+      },
+      cancel: async signal => {
+        await this.http.request(`${baseUrl}${taskEndpoint}/cancel`, {
+          method: 'POST', headers: { Authorization: `Bearer ${key}` }, signal,
+          provider: this.id, secrets: [key], timeoutMs: 10_000,
+        })
+      },
+    })
+    const completed = await job.wait()
+    return artifactsOrThrow(this.result(request, completed, this.kind(request), { jobId: taskId, text: this.text(completed) }))
+  }
+
+  private endpoint(request: MediaRequest): string {
+    if (typeof request.providerOptions?.endpoint === 'string') return request.providerOptions.endpoint
+    if (request.capability.startsWith('video.')) return '/api/v1/services/aigc/video-generation/video-synthesis'
+    if (request.capability === 'image.text_to_image' && /^qwen-image-3/i.test(request.model)) return '/api/v1/services/aigc/multimodal-generation/generation'
+    if (request.capability === 'image.text_to_image') return '/api/v1/services/aigc/text2image/image-synthesis'
+    if (request.capability.startsWith('image.')) return '/api/v1/services/aigc/multimodal-generation/generation'
+    if (request.capability === 'speech.stt') return '/api/v1/services/audio/asr/transcription'
+    if (request.capability === 'audio.generate') return '/api/v1/services/audio/music/generation'
+    return '/api/v1/services/aigc/multimodal-generation/generation'
+  }
+
+  private async payload(request: MediaRequest, signal?: AbortSignal): Promise<JsonObject> {
+    const inputImage = request.inputImage ? await this.input.asDataUri(request.inputImage, signal) : undefined
+    const endImage = request.endImage ? await this.input.asDataUri(request.endImage, signal) : undefined
+    const inputVideo = request.inputVideo ? await this.input.asDataUri(request.inputVideo, signal) : undefined
+    const inputAudio = request.inputAudio ? await this.input.asDataUri(request.inputAudio, signal) : undefined
+    const referenceImages = await dataUris(this.input, request.referenceImages, signal)
+    const referenceVideos = await dataUris(this.input, request.referenceVideos, signal)
+    const referenceAudios = await dataUris(this.input, request.referenceAudios, signal)
+    const parameters: JsonObject = {
+      ...(request.resolution ? { resolution: request.resolution, size: request.resolution } : {}),
+      ...(request.aspectRatio ? { ratio: request.aspectRatio, aspect_ratio: request.aspectRatio } : {}),
+      ...(request.duration ? { duration: request.duration } : {}),
+      ...(request.seed !== undefined ? { seed: request.seed } : {}),
+      ...(request.count ? { n: request.count } : {}),
+      ...(request.generateAudio !== undefined ? { audio: request.generateAudio } : {}),
+    }
+    let input: JsonObject
+    if (request.capability.startsWith('image.') && (request.capability !== 'image.text_to_image' || /^qwen-image-3/i.test(request.model))) {
+      input = { messages: [{ role: 'user', content: [
+        ...[inputImage, ...referenceImages].filter(Boolean).map(image => ({ image })),
+        { text: request.prompt ?? '' },
+      ] }] }
+    } else if (request.capability === 'audio.generate') {
+      input = { prompt: request.prompt ?? '', ...(request.text ? { lyrics: request.text } : {}) }
+    } else if (request.capability === 'speech.tts') {
+      input = { text: request.text ?? request.prompt ?? '', voice: request.voice, language: request.language }
+    } else if (request.capability === 'speech.stt') {
+      input = { file_urls: inputAudio ? [inputAudio] : [], language_hints: request.language ? [request.language] : undefined }
+    } else if (request.capability.startsWith('video.')) {
+      const media = [
+        ...(inputImage ? [{ type: 'first_frame', url: inputImage }] : []),
+        ...(endImage ? [{ type: 'last_frame', url: endImage }] : []),
+        ...referenceImages.map(url => ({ type: 'reference_image', url })),
+        ...(inputVideo ? [{ type: 'reference_video', url: inputVideo }] : []),
+        ...referenceVideos.map(url => ({ type: 'reference_video', url })),
+        ...(inputAudio ? [{ type: 'reference_audio', url: inputAudio }] : []),
+        ...referenceAudios.map(url => ({ type: 'reference_audio', url })),
+      ]
+      input = { ...(request.prompt ? { prompt: request.prompt } : {}), ...(media.length ? { media } : {}) }
+    } else {
+      input = { ...(request.prompt ? { prompt: request.prompt } : {}) }
+    }
+    return { model: request.model, input, parameters, ...withoutControlOptions(request.providerOptions) }
+  }
+
+  private kind(request: MediaRequest): 'image' | 'video' | 'audio' | 'text' {
+    return request.capability.startsWith('image.') ? 'image' : request.capability.startsWith('video.') ? 'video' : request.capability === 'speech.stt' ? 'text' : 'audio'
+  }
+
+  private text(payload: unknown): string | undefined {
+    if (!payload || typeof payload !== 'object') return undefined
+    const output = (payload as Record<string, unknown>).output
+    if (!output || typeof output !== 'object') return undefined
+    const text = (output as Record<string, unknown>).text
+    return typeof text === 'string' ? text : undefined
+  }
+
+  private timeout(request: MediaRequest): number {
+    const value = request.providerOptions?.timeoutMs
+    return typeof value === 'number' && value > 0 ? value : 30 * 60_000
+  }
+}

package/src/adapters/fal.ts

@@ -0,0 +1,135 @@
+import { MediaJob, mapJobState } from '../media-job.js'
+import { BaseAdapter, artifactsOrThrow, extractText, makeModel, mergeOptions } from './base.js'
+import type { AdapterContext, AdapterResult, Capability, JobStatus, JsonObject, MediaRequest, ModelDescriptor } from '../types.js'
+
+interface FalSubmit { request_id?: string; status_url?: string; response_url?: string; cancel_url?: string; status?: string }
+
+export class FalAdapter extends BaseAdapter {
+  readonly id = 'fal'
+  readonly displayName = 'fal.ai'
+  readonly envKey = 'FAL_KEY'
+
+  models(): ModelDescriptor[] {
+    return [
+      makeModel(this.id, 'fal-partner', '<fal endpoint slug>', [
+        'image.text_to_image', 'image.image_to_image', 'image.edit', 'image.multi_reference',
+        'video.text_to_video', 'video.image_to_video', 'video.first_last_frame', 'video.reference',
+        'video.edit', 'video.extend', 'video.native_audio', 'audio.generate', 'speech.tts', 'speech.stt',
+      ], 'fal schemas are endpoint-specific; providerOptions passes model-native fields'),
+    ]
+  }
+
+  supports(): boolean { return true }
+
+  async execute(request: MediaRequest, context: AdapterContext): Promise<AdapterResult> {
+    const key = this.key(request)
+    const payload = await this.payload(request, key, context.signal)
+    const endpoint = `https://queue.fal.run/${request.model.replace(/^\/+/, '')}`
+    const submitted = await this.http.json<FalSubmit>(endpoint, {
+      method: 'POST', headers: { Authorization: `Key ${key}`, 'Content-Type': 'application/json' }, body: JSON.stringify(payload),
+      signal: context.signal, provider: this.id, secrets: [key], timeoutMs: 60_000,
+    })
+    if (!submitted.request_id && !submitted.response_url) {
+      return artifactsOrThrow(this.result(request, submitted, this.kind(request), {
+        ...(request.capability === 'speech.stt' ? { text: extractText(submitted) } : {}),
+      }))
+    }
+    const requestId = submitted.request_id ?? 'fal-job'
+    const statusUrl = submitted.status_url ?? `${endpoint}/requests/${encodeURIComponent(requestId)}/status`
+    const responseUrl = submitted.response_url ?? `${endpoint}/requests/${encodeURIComponent(requestId)}`
+    const cancelUrl = submitted.cancel_url ?? `${endpoint}/requests/${encodeURIComponent(requestId)}/cancel`
+
+    const job = new MediaJob<unknown>({
+      id: requestId,
+      provider: this.id,
+      signal: context.signal,
+      timeoutMs: this.timeout(request),
+      minDelayMs: 800,
+      maxDelayMs: 5_000,
+      onProgress: status => context.onProgress?.(`fal ${requestId}: ${status.state}`),
+      poll: async signal => {
+        const status = await this.http.json<Record<string, unknown>>(statusUrl, {
+          headers: { Authorization: `Key ${key}` }, signal, provider: this.id, secrets: [key], timeoutMs: 30_000,
+        })
+        const state = mapJobState(status.status)
+        if (state === 'succeeded') {
+          const result = await this.http.json<unknown>(responseUrl, {
+            headers: { Authorization: `Key ${key}` }, signal, provider: this.id, secrets: [key], timeoutMs: 60_000,
+          })
+          return { state, result } satisfies JobStatus<unknown>
+        }
+        return { state, ...(typeof status.error === 'string' ? { message: status.error } : {}) } satisfies JobStatus<unknown>
+      },
+      cancel: async signal => {
+        await this.http.request(cancelUrl, {
+          method: 'PUT', headers: { Authorization: `Key ${key}` }, signal, provider: this.id, secrets: [key], timeoutMs: 10_000,
+        })
+      },
+    })
+    const data = await job.wait()
+    return artifactsOrThrow(this.result(request, data, this.kind(request), {
+      jobId: requestId,
+      ...(request.capability === 'speech.stt' ? { text: extractText(data) } : {}),
+    }))
+  }
+
+  private async payload(request: MediaRequest, key: string, signal?: AbortSignal): Promise<JsonObject> {
+    const resolveMany = async (sources: readonly string[] | undefined) => Promise.all((sources ?? []).map(source => this.asFalUrl(source, key, signal)))
+    const refs = await resolveMany(request.referenceImages)
+    const videos = await resolveMany(request.referenceVideos)
+    const audios = await resolveMany(request.referenceAudios)
+    const imageUrl = request.inputImage ? await this.asFalUrl(request.inputImage, key, signal) : undefined
+    const endImageUrl = request.endImage ? await this.asFalUrl(request.endImage, key, signal) : undefined
+    const videoUrl = request.inputVideo ? await this.asFalUrl(request.inputVideo, key, signal) : undefined
+    const audioUrl = request.inputAudio ? await this.asFalUrl(request.inputAudio, key, signal) : undefined
+    return mergeOptions({
+      ...(request.prompt ? { prompt: request.prompt } : {}),
+      ...(request.text ? { text: request.text } : {}),
+      ...(imageUrl ? { image_url: imageUrl } : {}),
+      ...(endImageUrl ? { end_image_url: endImageUrl } : {}),
+      ...(refs.length ? { reference_image_urls: refs } : {}),
+      ...(videos.length ? { reference_video_urls: videos } : {}),
+      ...(audios.length ? { reference_audio_urls: audios } : {}),
+      ...(videoUrl ? { video_url: videoUrl } : {}),
+      ...(audioUrl ? { audio_url: audioUrl } : {}),
+      ...(request.duration ? { duration: request.duration } : {}),
+      ...(request.resolution ? { resolution: request.resolution } : {}),
+      ...(request.aspectRatio ? { aspect_ratio: request.aspectRatio } : {}),
+      ...(request.seed !== undefined ? { seed: request.seed } : {}),
+      ...(request.generateAudio !== undefined ? { generate_audio: request.generateAudio } : {}),
+      ...(request.voice ? { voice: request.voice } : {}),
+      ...(request.language ? { language: request.language } : {}),
+      ...(request.responseFormat ? { output_format: request.responseFormat } : {}),
+      ...(request.operation ? { operation: request.operation } : {}),
+    }, request.providerOptions)
+  }
+
+  private async asFalUrl(source: string, key: string, signal?: AbortSignal): Promise<string> {
+    const resolved = await this.input.resolve(source)
+    if (resolved.kind === 'url') return resolved.url ?? source
+    const bytes = await this.input.bytes(resolved, signal)
+    const upload = await this.http.json<{ upload_url?: string; file_url?: string }>('https://rest.fal.ai/storage/upload/initiate?storage_type=fal-cdn-v3', {
+      method: 'POST', headers: { Authorization: `Key ${key}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ content_type: resolved.mimeType, file_name: resolved.fileName, file_size: bytes.byteLength }),
+      signal, provider: this.id, secrets: [key], timeoutMs: 30_000,
+    })
+    if (!upload.upload_url || !upload.file_url) throw new Error('fal CDN upload initiation returned no upload_url/file_url')
+    await this.http.request(upload.upload_url, {
+      method: 'PUT', headers: { 'Content-Type': resolved.mimeType }, body: new Blob([Uint8Array.from(bytes)], { type: resolved.mimeType }), signal,
+      provider: this.id, timeoutMs: 120_000,
+    })
+    return upload.file_url
+  }
+
+  private kind(request: MediaRequest): 'image' | 'video' | 'audio' | 'text' {
+    if (request.capability.startsWith('image.')) return 'image'
+    if (request.capability.startsWith('video.')) return 'video'
+    if (request.capability === 'speech.stt') return 'text'
+    return 'audio'
+  }
+
+  private timeout(request: MediaRequest): number {
+    const value = request.providerOptions?.timeoutMs
+    return typeof value === 'number' && value > 0 ? value : 30 * 60_000
+  }
+}

package/src/adapters/google.ts

@@ -0,0 +1,214 @@
+import { GoogleAuth } from 'google-auth-library'
+import { fileURLToPath } from 'node:url'
+import { MediaError } from '../errors.js'
+import { MediaJob } from '../media-job.js'
+import { BaseAdapter, artifactsOrThrow, makeModel } from './base.js'
+import type { AdapterContext, AdapterResult, Capability, JobStatus, JsonObject, MediaRequest, ModelDescriptor } from '../types.js'
+import type { AdapterDependencies } from './base.js'
+
+const GOOGLE_CAPS: Capability[] = [
+  'image.text_to_image', 'image.image_to_image', 'image.edit', 'image.multi_reference',
+  'video.text_to_video', 'video.image_to_video', 'video.first_last_frame', 'video.reference',
+  'video.extend', 'video.native_audio', 'audio.generate', 'speech.tts', 'speech.stt',
+]
+
+export class GoogleMediaAdapter extends BaseAdapter {
+  readonly displayName: string
+  readonly envKey: string | undefined
+
+  constructor(readonly id: 'gemini' | 'vertex', dependencies: AdapterDependencies) {
+    super(dependencies)
+    this.displayName = id === 'gemini' ? 'Google Gemini API' : 'Google Vertex AI (ADC)'
+    this.envKey = id === 'gemini' ? 'GEMINI_API_KEY' : undefined
+  }
+
+  models(): ModelDescriptor[] {
+    return [
+      makeModel(this.id, 'google', 'gemini-2.5-flash-image', ['image.text_to_image', 'image.image_to_image', 'image.edit', 'image.multi_reference']),
+      makeModel(this.id, 'google', 'imagen-4.0-generate-001', ['image.text_to_image']),
+      makeModel(this.id, 'google', 'veo-3.1-generate-preview', ['video.text_to_video', 'video.image_to_video', 'video.first_last_frame', 'video.reference', 'video.extend', 'video.native_audio']),
+      makeModel(this.id, 'google', 'gemini-2.5-flash-preview-tts', ['speech.tts']),
+      makeModel(this.id, 'google', 'gemini-2.5-flash', ['speech.stt']),
+      makeModel(this.id, 'google', 'lyria-3.5', ['audio.generate']),
+    ]
+  }
+
+  supports(capability: Capability): boolean { return GOOGLE_CAPS.includes(capability) }
+
+  async execute(request: MediaRequest, context: AdapterContext): Promise<AdapterResult> {
+    this.assertSupport(request)
+    if (request.capability.startsWith('video.')) return this.longRunning(request, context)
+    if (request.capability === 'audio.generate' || (request.capability === 'image.text_to_image' && /^imagen-/i.test(request.model))) {
+      return this.predictMedia(request, context)
+    }
+    return this.generateContent(request, context)
+  }
+
+  private async generateContent(request: MediaRequest, context: AdapterContext): Promise<AdapterResult> {
+    const parts: JsonObject[] = []
+    if (request.prompt || request.text) parts.push({ text: request.text ?? request.prompt })
+    const sources = [request.inputImage, ...(request.referenceImages ?? []), request.inputAudio]
+      .filter((value): value is string => Boolean(value))
+    for (const source of sources) parts.push({ inlineData: await this.input.asInlineData(source, context.signal) })
+    if (request.capability === 'speech.stt' && !request.prompt) parts.unshift({ text: 'Transcribe this audio accurately. Return only the transcript.' })
+    const generationConfig: JsonObject = request.capability === 'speech.tts'
+      ? {
+          responseModalities: ['AUDIO'],
+          speechConfig: { voiceConfig: { prebuiltVoiceConfig: { voiceName: request.voice ?? 'Kore' } } },
+        }
+      : request.capability.startsWith('image.')
+        ? {
+            responseModalities: ['TEXT', 'IMAGE'],
+            ...(request.aspectRatio || request.resolution ? { imageConfig: {
+              ...(request.aspectRatio ? { aspectRatio: request.aspectRatio } : {}),
+              ...(request.resolution ? { imageSize: request.resolution } : {}),
+            } } : {}),
+          }
+        : { responseModalities: ['TEXT'] }
+    const body = { contents: [{ role: 'user', parts }], generationConfig, ...googleNativeOptions(request.providerOptions) }
+    const { url, headers } = await this.modelRequest(request, "generateContent")
+    const payload = await this.http.json<Record<string, unknown>>(url, {
+      method: 'POST', headers: { ...headers, 'Content-Type': 'application/json' }, body: JSON.stringify(body),
+      signal: context.signal, provider: this.id, secrets: this.secrets(request), timeoutMs: 180_000,
+    })
+    const kind = request.capability.startsWith('image.') ? 'image' : request.capability === 'speech.tts' ? 'audio' : 'text'
+    const text = findText(payload)
+    const result = this.result(request, payload, kind, { ...(text ? { text } : {}), ...(this.id === 'gemini' ? { headers } : {}) })
+    return request.capability === 'speech.stt' ? result : artifactsOrThrow(result)
+  }
+
+  private async predictMedia(request: MediaRequest, context: AdapterContext): Promise<AdapterResult> {
+    const kind = request.capability === 'audio.generate' ? 'audio' : 'image'
+    const body = request.capability === 'audio.generate'
+      ? { instances: [{ prompt: request.prompt ?? request.text ?? '' }], parameters: googleNativeOptions(request.providerOptions) }
+      : { instances: [{ prompt: request.prompt ?? '' }], parameters: {
+          sampleCount: request.count ?? 1,
+          ...(request.aspectRatio ? { aspectRatio: request.aspectRatio } : {}),
+          ...(request.resolution ? { sampleImageSize: request.resolution } : {}),
+          ...(request.seed !== undefined ? { seed: request.seed } : {}),
+          ...googleNativeOptions(request.providerOptions),
+        } }
+    const { url, headers } = await this.modelRequest(request, "predict")
+    const payload = await this.http.json<Record<string, unknown>>(url, {
+      method: 'POST', headers: { ...headers, 'Content-Type': 'application/json' }, body: JSON.stringify(body),
+      signal: context.signal, provider: this.id, secrets: this.secrets(request), timeoutMs: 180_000,
+    })
+    return artifactsOrThrow(this.result(request, payload, kind, { headers }))
+  }
+
+  private async longRunning(request: MediaRequest, context: AdapterContext): Promise<AdapterResult> {
+    const instance: JsonObject = { ...(request.prompt ? { prompt: request.prompt } : {}) }
+    if (request.inputImage) instance.image = await this.googleMedia(request.inputImage, context.signal)
+    if (request.endImage) instance.lastFrame = await this.googleMedia(request.endImage, context.signal)
+    if (request.inputVideo) instance.video = await this.googleMedia(request.inputVideo, context.signal)
+    if (request.referenceImages?.length) {
+      instance.referenceImages = await Promise.all(request.referenceImages.map(async source => ({
+        image: await this.googleMedia(source, context.signal), referenceType: 'asset',
+      })))
+    }
+    const parameters: JsonObject = {
+      ...(request.aspectRatio ? { aspectRatio: request.aspectRatio } : {}),
+      ...(request.resolution ? { resolution: request.resolution } : {}),
+      ...(request.duration ? { durationSeconds: request.duration } : {}),
+      ...(request.seed !== undefined ? { seed: request.seed } : {}),
+      ...(request.generateAudio !== undefined ? { generateAudio: request.generateAudio } : {}),
+      ...(request.count ? { sampleCount: request.count } : {}),
+    }
+    const body = { instances: [instance], parameters: { ...parameters, ...googleNativeOptions(request.providerOptions) } }
+    const { url, headers, operationsBase } = await this.modelRequest(request, "predictLongRunning")
+    const submitted = await this.http.json<Record<string, unknown>>(url, {
+      method: 'POST', headers: { ...headers, 'Content-Type': 'application/json' }, body: JSON.stringify(body),
+      signal: context.signal, provider: this.id, secrets: this.secrets(request), timeoutMs: 60_000,
+    })
+    const name = typeof submitted.name === 'string' ? submitted.name : undefined
+    if (!name) return artifactsOrThrow(this.result(request, submitted, request.capability === 'audio.generate' ? 'audio' : 'video', { headers }))
+    const operationUrl = `${operationsBase}/${name.replace(/^\/+/, '')}`
+    const vertexPollUrl = url.replace(/:predictLongRunning$/, ':fetchPredictOperation')
+    const job = new MediaJob<Record<string, unknown>>({
+      id: name, provider: this.id, signal: context.signal, timeoutMs: timeout(request), minDelayMs: 5_000, maxDelayMs: 15_000,
+      onProgress: () => context.onProgress?.(`${this.id} operation ${name}: running`),
+      poll: async signal => {
+        const status = this.id === 'vertex'
+          ? await this.http.json<Record<string, unknown>>(vertexPollUrl, {
+              method: 'POST', headers: { ...headers, 'Content-Type': 'application/json' },
+              body: JSON.stringify({ operationName: name }), signal, provider: this.id, secrets: this.secrets(request), timeoutMs: 30_000,
+            })
+          : await this.http.json<Record<string, unknown>>(operationUrl, {
+              headers, signal, provider: this.id, secrets: this.secrets(request), timeoutMs: 30_000,
+            })
+        if (status.error) return { state: 'failed', message: JSON.stringify(status.error) }
+        return status.done === true
+          ? { state: 'succeeded', result: status }
+          : { state: 'running' }
+      },
+    })
+    const completed = await job.wait()
+    return artifactsOrThrow(this.result(request, completed, request.capability === 'audio.generate' ? 'audio' : 'video', { jobId: name, headers }))
+  }
+
+  private async googleMedia(source: string, signal?: AbortSignal): Promise<JsonObject> {
+    const resolved = await this.input.resolve(source)
+    if (resolved.kind === 'url') return { uri: resolved.url, mimeType: resolved.mimeType }
+    const inline = await this.input.asInlineData(source, signal)
+    return this.id === 'gemini'
+      ? { inlineData: { data: inline.data, mimeType: inline.mimeType } }
+      : { bytesBase64Encoded: inline.data, mimeType: inline.mimeType }
+  }
+
+  private async modelRequest(request: MediaRequest, method: string): Promise<{ url: string; headers: Record<string, string>; operationsBase: string }> {
+    if (this.id === 'gemini') {
+      const key = this.key(request)
+      const base = 'https://generativelanguage.googleapis.com/v1beta'
+      return { url: `${base}/models/${encodeURIComponent(request.model)}:${method}`, headers: { 'x-goog-api-key': key }, operationsBase: base }
+    }
+    const options = request.providerOptions;
+    const configuredFile = typeof options?.credentialsFile === "string" ? options.credentialsFile : undefined
+    const rawKeyFilename = configuredFile ?? this.env.VERTEX_CREDENTIALS_FILE ?? this.env.GOOGLE_APPLICATION_CREDENTIALS
+    const keyFilename = rawKeyFilename?.startsWith('file://') ? fileURLToPath(rawKeyFilename) : rawKeyFilename
+    const auth = new GoogleAuth({
+      scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+      ...(keyFilename ? { keyFilename } : {}),
+    })
+    const configuredProject = typeof options?.project === 'string' ? options.project : undefined
+    const project = configuredProject ?? this.env.GOOGLE_CLOUD_PROJECT ?? this.env.GCLOUD_PROJECT ?? await auth.getProjectId()
+    const configuredLocation = typeof options?.location === 'string' ? options.location : undefined
+    const location = configuredLocation ?? this.env.GOOGLE_CLOUD_LOCATION ?? 'us-central1'
+    if (!project) throw new MediaError('CONFIG', 'Vertex AI requires a project id from providerOptions.vertex.project, environment, ADC, or the credentials JSON', { provider: this.id })
+    const base = `https://${location}-aiplatform.googleapis.com/v1`
+    const resource = `projects/${encodeURIComponent(project)}/locations/${encodeURIComponent(location)}/publishers/google/models/${encodeURIComponent(request.model)}`
+    const authHeaders = await auth.getRequestHeaders(`${base}/${resource}:${method}`)
+    const headers: Record<string, string> = {}
+    for (const [key, value] of authHeaders.entries()) headers[key] = value
+    return { url: `${base}/${resource}:${method}`, headers, operationsBase: base }
+  }
+
+  private secrets(request: MediaRequest): string[] {
+    const configKey = typeof request.providerOptions?.apiKey === 'string' ? request.providerOptions.apiKey : undefined
+    const envKey = this.envKey && this.env[this.envKey] ? this.env[this.envKey] as string : undefined
+    return [configKey, envKey].filter((val): val is string => Boolean(val))
+  }
+}
+
+function findText(payload: unknown): string | undefined {
+  if (!payload || typeof payload !== 'object') return undefined
+  const candidates = (payload as { candidates?: Array<{ content?: { parts?: Array<{ text?: string }> } }> }).candidates
+  const values = candidates?.flatMap(candidate => candidate.content?.parts?.map(part => part.text).filter((text): text is string => Boolean(text)) ?? []) ?? []
+  return values.length ? values.join('\n') : undefined
+}
+
+function googleNativeOptions(options?: JsonObject): JsonObject {
+  if (!options) return {}
+  const {
+    credentialsFile: _credentialsFile,
+    project: _project,
+    location: _location,
+    timeoutMs: _timeoutMs,
+    ...native
+  } = options
+  return native
+}
+
+function timeout(request: MediaRequest): number {
+  const value = request.providerOptions?.timeoutMs
+  return typeof value === 'number' && value > 0 ? value : 40 * 60_000
+}

package/src/adapters/openai.ts

@@ -0,0 +1,117 @@
+import { BaseAdapter, artifactsOrThrow, bearerHeaders, makeModel, mergeOptions, requirePrompt } from './base.js'
+import type { AdapterContext, AdapterResult, Capability, MediaRequest, ModelDescriptor } from '../types.js'
+
+const IMAGE_CAPS: Capability[] = ['image.text_to_image', 'image.image_to_image', 'image.edit', 'image.multi_reference']
+const SPEECH_CAPS: Capability[] = ['speech.tts', 'speech.stt']
+
+export class OpenAIAdapter extends BaseAdapter {
+  readonly id = 'openai'
+  readonly displayName = 'OpenAI API'
+  readonly envKey = 'OPENAI_API_KEY'
+  private readonly baseUrl = 'https://api.openai.com/v1'
+
+  models(): ModelDescriptor[] {
+    return [
+      makeModel(this.id, 'openai', 'gpt-image-2', IMAGE_CAPS),
+      makeModel(this.id, 'openai', 'gpt-image-1.5', IMAGE_CAPS),
+      makeModel(this.id, 'openai', 'dall-e-3', ['image.text_to_image']),
+      makeModel(this.id, 'openai', 'gpt-4o-mini-tts', ['speech.tts']),
+      makeModel(this.id, 'openai', 'gpt-4o-transcribe', ['speech.stt']),
+      makeModel(this.id, 'openai', 'whisper-1', ['speech.stt']),
+    ]
+  }
+
+  supports(capability: Capability, model: string): boolean {
+    if (capability.startsWith('video.') || capability === 'audio.generate') return false
+    if (capability.startsWith('image.')) return /(?:gpt-image|dall-e)/i.test(model)
+    if (capability === 'speech.tts') return /tts/i.test(model)
+    if (capability === 'speech.stt') return /(?:transcribe|whisper)/i.test(model)
+    return false
+  }
+
+  async execute(request: MediaRequest, context: AdapterContext): Promise<AdapterResult> {
+    this.assertSupport(request)
+    if (request.capability === 'speech.tts') return this.tts(request, context)
+    if (request.capability === 'speech.stt') return this.stt(request, context)
+    if (request.capability === 'image.text_to_image') return this.generateImage(request, context)
+    return this.editImage(request, context)
+  }
+
+  private async generateImage(request: MediaRequest, context: AdapterContext): Promise<AdapterResult> {
+    const key = this.key(request)
+    const payload = mergeOptions({
+      model: request.model,
+      prompt: requirePrompt(request),
+      n: request.count ?? 1,
+      ...(request.resolution ? { size: request.resolution } : {}),
+    }, request.providerOptions)
+    const data = await this.http.json<unknown>(`${this.baseUrl}/images/generations`, {
+      method: 'POST', headers: bearerHeaders(key, { 'Content-Type': 'application/json' }),
+      body: JSON.stringify(payload), signal: context.signal, provider: this.id, secrets: [key], timeoutMs: 120_000,
+    })
+    return artifactsOrThrow(this.result(request, data, 'image'))
+  }
+
+  private async editImage(request: MediaRequest, context: AdapterContext): Promise<AdapterResult> {
+    const key = this.key(request)
+    const sources = [request.inputImage, ...(request.referenceImages ?? [])].filter((value): value is string => Boolean(value))
+    if (sources.length === 0) throw new Error('OpenAI image edit requires inputImage or referenceImages')
+    if (sources.length > 16) throw new Error('OpenAI GPT Image editing supports at most 16 source images')
+    const form = new FormData()
+    form.set('model', request.model)
+    form.set('prompt', requirePrompt(request))
+    form.set('n', String(request.count ?? 1))
+    if (request.resolution) form.set('size', request.resolution)
+    for (const source of sources) {
+      const file = await this.input.asBlob(source, context.signal)
+      form.append('image[]', file.blob, file.fileName)
+    }
+    if (request.mask) {
+      const mask = await this.input.asBlob(request.mask, context.signal)
+      form.set('mask', mask.blob, mask.fileName)
+    }
+    for (const [name, value] of Object.entries(request.providerOptions ?? {})) {
+      if (value !== undefined) form.set(name, typeof value === 'string' ? value : JSON.stringify(value))
+    }
+    const data = await this.http.json<unknown>(`${this.baseUrl}/images/edits`, {
+      method: 'POST', headers: bearerHeaders(key), body: form, signal: context.signal,
+      provider: this.id, secrets: [key], timeoutMs: 120_000,
+    })
+    return artifactsOrThrow(this.result(request, data, 'image'))
+  }
+
+  private async tts(request: MediaRequest, context: AdapterContext): Promise<AdapterResult> {
+    const key = this.key(request)
+    const format = request.responseFormat ?? 'mp3'
+    const payload = mergeOptions({
+      model: request.model,
+      input: request.text ?? request.prompt ?? '',
+      voice: request.voice ?? 'alloy',
+      response_format: format,
+    }, request.providerOptions)
+    const response = await this.http.request(`${this.baseUrl}/audio/speech`, {
+      method: 'POST', headers: bearerHeaders(key, { 'Content-Type': 'application/json' }), body: JSON.stringify(payload),
+      signal: context.signal, provider: this.id, secrets: [key], timeoutMs: 120_000,
+    })
+    const bytes = Buffer.from(await response.arrayBuffer()).toString('base64')
+    return this.result(request, { b64_json: bytes, mime_type: response.headers.get('content-type') ?? `audio/${format}` }, 'audio')
+  }
+
+  private async stt(request: MediaRequest, context: AdapterContext): Promise<AdapterResult> {
+    if (!request.inputAudio) throw new Error('OpenAI transcription requires inputAudio')
+    const key = this.key(request)
+    const audio = await this.input.asBlob(request.inputAudio, context.signal)
+    const form = new FormData()
+    form.set('file', audio.blob, audio.fileName)
+    form.set('model', request.model)
+    if (request.language) form.set('language', request.language)
+    for (const [name, value] of Object.entries(request.providerOptions ?? {})) {
+      if (value !== undefined) form.set(name, typeof value === 'string' ? value : JSON.stringify(value))
+    }
+    const response = await this.http.json<{ text?: string }>(`${this.baseUrl}/audio/transcriptions`, {
+      method: 'POST', headers: bearerHeaders(key), body: form, signal: context.signal,
+      provider: this.id, secrets: [key], timeoutMs: 120_000,
+    })
+    return this.result(request, {}, 'text', { text: response.text ?? '' })
+  }
+}