@tanstack/ai-cloudflare 0.0.0 → 0.1.1

package/dist/esm/adapters/transcription.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcription.js","names":[],"sources":["../../../src/adapters/transcription.ts"],"sourcesContent":["import { BaseTranscriptionAdapter } from '@tanstack/ai/adapters'\nimport { toRunErrorPayload } from '@tanstack/ai/adapter-internals'\nimport { arrayBufferToBase64, generateId } from '@tanstack/ai-utils'\nimport { isBindingConfig, resolveConfigFromEnv } from '../utils/config'\nimport { runModel } from '../utils/run'\nimport type {\n  TranscriptionOptions,\n  TranscriptionResult,\n  TranscriptionSegment,\n  TranscriptionWord,\n} from '@tanstack/ai'\nimport type {\n  CloudflareConfig,\n  CloudflareConfigInput,\n  FetchLike,\n} from '../utils/config'\nimport type { CloudflareTranscriptionModel } from '../utils/models'\n\n/** Extra inputs forwarded to the transcription model (model specific). */\nexport type CloudflareTranscriptionProviderOptions = Record<string, unknown>\n\ninterface WhisperOutput {\n  text?: string\n  transcription_info?: { language?: string; duration?: number }\n  segments?: Array<{ start: number; end: number; text: string }>\n  words?: Array<{ word?: string; start?: number; end?: number }>\n}\n\ninterface NovaOutput {\n  results?: {\n    channels?: Array<{\n      alternatives?: Array<{\n        transcript?: string\n        words?: Array<{ word?: string; start?: number; end?: number }>\n      }>\n    }>\n  }\n  metadata?: { duration?: number }\n}\n\nasync function toBytes(\n  audio: TranscriptionOptions['audio'],\n  fetchImpl: FetchLike,\n  signal: AbortSignal | undefined,\n): Promise<{ bytes: ArrayBuffer; contentType: string }> {\n  if (typeof audio === 'string') {\n    // Base64 (data URI or bare) or a URL to fetch.\n    if (/^https?:\\/\\//.test(audio)) {\n      const response = await fetchImpl(audio, { signal })\n      if (!response.ok) {\n        throw new Error(\n          `Could not fetch audio from ${audio} (${response.status})`,\n        )\n      }\n      return {\n        bytes: await response.arrayBuffer(),\n        contentType: response.headers.get('content-type') ?? 'audio/mpeg',\n      }\n    }\n    const match = /^data:([^;]+);base64,(.*)$/.exec(audio)\n    const base64 = match?.[2] ?? audio\n    const binary = atob(base64)\n    const bytes = new Uint8Array(binary.length)\n    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i)\n    return { bytes: bytes.buffer, contentType: match?.[1] ?? 'audio/mpeg' }\n  }\n  if (audio instanceof ArrayBuffer) {\n    return { bytes: audio, contentType: 'audio/mpeg' }\n  }\n  return {\n    bytes: await audio.arrayBuffer(),\n    contentType: audio.type || 'audio/mpeg',\n  }\n}\n\n/**\n * Cloudflare transcription adapter. Whisper models take base64 audio in the\n * `audio` input; Deepgram Nova takes the raw bytes. Both return text plus\n * timed words, and Whisper also returns segments.\n */\nexport class CloudflareTranscriptionAdapter<\n  TModel extends CloudflareTranscriptionModel,\n> extends BaseTranscriptionAdapter<\n  TModel,\n  CloudflareTranscriptionProviderOptions\n> {\n  readonly name = 'cloudflare' as const\n\n  constructor(\n    private readonly cfConfig: CloudflareConfig,\n    model: TModel,\n  ) {\n    super(model, {})\n  }\n\n  async transcribe(\n    options: TranscriptionOptions<CloudflareTranscriptionProviderOptions>,\n  ): Promise<TranscriptionResult> {\n    const { model, logger, language, prompt } = options\n    try {\n      logger.request(\n        `activity=transcription provider=${this.name} model=${model}`,\n        {\n          provider: this.name,\n          model,\n        },\n      )\n      const fetchImpl =\n        (isBindingConfig(this.cfConfig) ? undefined : this.cfConfig.fetch) ??\n        fetch\n      const { bytes, contentType } = await toBytes(\n        options.audio,\n        fetchImpl,\n        options.abortSignal,\n      )\n      const output = model.startsWith('@cf/deepgram/')\n        ? await this.runNova(model, bytes, contentType, options)\n        : await this.runWhisper(\n            model,\n            bytes,\n            { language, prompt, ...options.modelOptions },\n            options.abortSignal,\n          )\n      return { id: generateId(this.name), model, ...output }\n    } catch (error: unknown) {\n      logger.errors(`${this.name}.transcribe fatal`, {\n        error: toRunErrorPayload(error, `${this.name}.transcribe failed`),\n        source: `${this.name}.transcribe`,\n      })\n      throw error\n    }\n  }\n\n  private async runWhisper(\n    model: string,\n    bytes: ArrayBuffer,\n    inputs: { language?: string; prompt?: string } & Record<string, unknown>,\n    signal: AbortSignal | undefined,\n  ): Promise<Omit<TranscriptionResult, 'id' | 'model'>> {\n    const { language, prompt, ...rest } = inputs\n    const output = (await runModel(\n      this.cfConfig,\n      model,\n      {\n        ...(language && { language }),\n        ...(prompt && { initial_prompt: prompt }),\n        ...rest,\n        audio: arrayBufferToBase64(bytes),\n      },\n      { signal },\n    )) as WhisperOutput\n    if (typeof output.text !== 'string') {\n      throw new Error(`Workers AI ${model} returned no transcript`)\n    }\n    return {\n      text: output.text,\n      language: output.transcription_info?.language,\n      duration: output.transcription_info?.duration,\n      segments: output.segments?.map(\n        (segment, id): TranscriptionSegment => ({\n          id,\n          start: segment.start,\n          end: segment.end,\n          text: segment.text.trim(),\n        }),\n      ),\n      words: toWords(output.words),\n    }\n  }\n\n  private async runNova(\n    model: string,\n    bytes: ArrayBuffer,\n    contentType: string,\n    options: TranscriptionOptions<CloudflareTranscriptionProviderOptions>,\n  ): Promise<Omit<TranscriptionResult, 'id' | 'model'>> {\n    const output = (await runModel(\n      this.cfConfig,\n      model,\n      {\n        ...(options.language && { language: options.language }),\n        ...options.modelOptions,\n      },\n      {\n        signal: options.abortSignal,\n        binary: { field: 'audio', body: bytes, contentType },\n      },\n    )) as NovaOutput\n    const alternative = output.results?.channels?.[0]?.alternatives?.[0]\n    if (typeof alternative?.transcript !== 'string') {\n      throw new Error(`Workers AI ${model} returned no transcript`)\n    }\n    return {\n      text: alternative.transcript,\n      duration: output.metadata?.duration,\n      words: toWords(alternative?.words),\n    }\n  }\n}\n\nfunction toWords(\n  words: Array<{ word?: string; start?: number; end?: number }> | undefined,\n): Array<TranscriptionWord> | undefined {\n  return words?.map((w) => ({\n    word: (w.word ?? '').trim(),\n    start: w.start ?? 0,\n    end: w.end ?? 0,\n  }))\n}\n\nexport function createCloudflareTranscription<\n  TModel extends CloudflareTranscriptionModel,\n>(\n  model: TModel,\n  config: CloudflareConfig,\n): CloudflareTranscriptionAdapter<TModel> {\n  return new CloudflareTranscriptionAdapter(config, model)\n}\n\nexport function cloudflareTranscription<\n  TModel extends CloudflareTranscriptionModel,\n>(\n  model: TModel,\n  config?: CloudflareConfigInput,\n): CloudflareTranscriptionAdapter<TModel> {\n  return new CloudflareTranscriptionAdapter(resolveConfigFromEnv(config), model)\n}\n"],"mappings":";;;;;;AAwCA,eAAe,QACb,OACA,WACA,QACsD;CACtD,IAAI,OAAO,UAAU,UAAU;EAE7B,IAAI,eAAe,KAAK,KAAK,GAAG;GAC9B,MAAM,WAAW,MAAM,UAAU,OAAO,EAAE,OAAO,CAAC;GAClD,IAAI,CAAC,SAAS,IACZ,MAAM,IAAI,MACR,8BAA8B,MAAM,IAAI,SAAS,OAAO,EAC1D;GAEF,OAAO;IACL,OAAO,MAAM,SAAS,YAAY;IAClC,aAAa,SAAS,QAAQ,IAAI,cAAc,KAAK;GACvD;EACF;EACA,MAAM,QAAQ,6BAA6B,KAAK,KAAK;EACrD,MAAM,SAAS,QAAQ,MAAM;EAC7B,MAAM,SAAS,KAAK,MAAM;EAC1B,MAAM,QAAQ,IAAI,WAAW,OAAO,MAAM;EAC1C,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK,MAAM,KAAK,OAAO,WAAW,CAAC;EACtE,OAAO;GAAE,OAAO,MAAM;GAAQ,aAAa,QAAQ,MAAM;EAAa;CACxE;CACA,IAAI,iBAAiB,aACnB,OAAO;EAAE,OAAO;EAAO,aAAa;CAAa;CAEnD,OAAO;EACL,OAAO,MAAM,MAAM,YAAY;EAC/B,aAAa,MAAM,QAAQ;CAC7B;AACF;;;;;;AAOA,IAAa,iCAAb,cAEU,yBAGR;CAImB;CAHnB,OAAgB;CAEhB,YACE,UACA,OACA;EACA,MAAM,OAAO,CAAC,CAAC;EAHE,KAAA,WAAA;CAInB;CAEA,MAAM,WACJ,SAC8B;EAC9B,MAAM,EAAE,OAAO,QAAQ,UAAU,WAAW;EAC5C,IAAI;GACF,OAAO,QACL,mCAAmC,KAAK,KAAK,SAAS,SACtD;IACE,UAAU,KAAK;IACf;GACF,CACF;GACA,MAAM,aACH,gBAAgB,KAAK,QAAQ,IAAI,KAAA,IAAY,KAAK,SAAS,UAC5D;GACF,MAAM,EAAE,OAAO,gBAAgB,MAAM,QACnC,QAAQ,OACR,WACA,QAAQ,WACV;GACA,MAAM,SAAS,MAAM,WAAW,eAAe,IAC3C,MAAM,KAAK,QAAQ,OAAO,OAAO,aAAa,OAAO,IACrD,MAAM,KAAK,WACT,OACA,OACA;IAAE;IAAU;IAAQ,GAAG,QAAQ;GAAa,GAC5C,QAAQ,WACV;GACJ,OAAO;IAAE,IAAI,WAAW,KAAK,IAAI;IAAG;IAAO,GAAG;GAAO;EACvD,SAAS,OAAgB;GACvB,OAAO,OAAO,GAAG,KAAK,KAAK,oBAAoB;IAC7C,OAAO,kBAAkB,OAAO,GAAG,KAAK,KAAK,mBAAmB;IAChE,QAAQ,GAAG,KAAK,KAAK;GACvB,CAAC;GACD,MAAM;EACR;CACF;CAEA,MAAc,WACZ,OACA,OACA,QACA,QACoD;EACpD,MAAM,EAAE,UAAU,QAAQ,GAAG,SAAS;EACtC,MAAM,SAAU,MAAM,SACpB,KAAK,UACL,OACA;GACE,GAAI,YAAY,EAAE,SAAS;GAC3B,GAAI,UAAU,EAAE,gBAAgB,OAAO;GACvC,GAAG;GACH,OAAO,oBAAoB,KAAK;EAClC,GACA,EAAE,OAAO,CACX;EACA,IAAI,OAAO,OAAO,SAAS,UACzB,MAAM,IAAI,MAAM,cAAc,MAAM,wBAAwB;EAE9D,OAAO;GACL,MAAM,OAAO;GACb,UAAU,OAAO,oBAAoB;GACrC,UAAU,OAAO,oBAAoB;GACrC,UAAU,OAAO,UAAU,KACxB,SAAS,QAA8B;IACtC;IACA,OAAO,QAAQ;IACf,KAAK,QAAQ;IACb,MAAM,QAAQ,KAAK,KAAK;GAC1B,EACF;GACA,OAAO,QAAQ,OAAO,KAAK;EAC7B;CACF;CAEA,MAAc,QACZ,OACA,OACA,aACA,SACoD;EACpD,MAAM,SAAU,MAAM,SACpB,KAAK,UACL,OACA;GACE,GAAI,QAAQ,YAAY,EAAE,UAAU,QAAQ,SAAS;GACrD,GAAG,QAAQ;EACb,GACA;GACE,QAAQ,QAAQ;GAChB,QAAQ;IAAE,OAAO;IAAS,MAAM;IAAO;GAAY;EACrD,CACF;EACA,MAAM,cAAc,OAAO,SAAS,WAAW,EAAE,EAAE,eAAe;EAClE,IAAI,OAAO,aAAa,eAAe,UACrC,MAAM,IAAI,MAAM,cAAc,MAAM,wBAAwB;EAE9D,OAAO;GACL,MAAM,YAAY;GAClB,UAAU,OAAO,UAAU;GAC3B,OAAO,QAAQ,aAAa,KAAK;EACnC;CACF;AACF;AAEA,SAAS,QACP,OACsC;CACtC,OAAO,OAAO,KAAK,OAAO;EACxB,OAAO,EAAE,QAAQ,GAAA,CAAI,KAAK;EAC1B,OAAO,EAAE,SAAS;EAClB,KAAK,EAAE,OAAO;CAChB,EAAE;AACJ;AAEA,SAAgB,8BAGd,OACA,QACwC;CACxC,OAAO,IAAI,+BAA+B,QAAQ,KAAK;AACzD;AAEA,SAAgB,wBAGd,OACA,QACwC;CACxC,OAAO,IAAI,+BAA+B,qBAAqB,MAAM,GAAG,KAAK;AAC/E"}

package/dist/esm/adapters/tts.d.ts

@@ -0,0 +1,26 @@
+import { BaseTTSAdapter } from '@tanstack/ai/adapters';
+import { TTSOptions, TTSResult } from '@tanstack/ai';
+import { CloudflareConfig, CloudflareConfigInput } from '../utils/config.js';
+import { CloudflareTTSModel } from '../utils/models.js';
+/** Text-to-speech inputs forwarded to the model (Deepgram Aura fields). */
+export interface CloudflareTTSProviderOptions {
+    speaker?: string;
+    encoding?: 'linear16' | 'flac' | 'mulaw' | 'alaw' | 'mp3' | 'opus' | 'aac';
+    container?: 'none' | 'wav' | 'ogg';
+    sample_rate?: number;
+    bit_rate?: number;
+    [key: string]: unknown;
+}
+/**
+ * Cloudflare text-to-speech adapter for Workers AI models such as Deepgram
+ * Aura. `voice` maps to `speaker` and `format` to `encoding`; the audio comes
+ * back base64-encoded.
+ */
+export declare class CloudflareTTSAdapter<TModel extends CloudflareTTSModel> extends BaseTTSAdapter<TModel, CloudflareTTSProviderOptions> {
+    private readonly cfConfig;
+    readonly name: "cloudflare";
+    constructor(cfConfig: CloudflareConfig, model: TModel);
+    generateSpeech(options: TTSOptions<CloudflareTTSProviderOptions>): Promise<TTSResult>;
+}
+export declare function createCloudflareTTS<TModel extends CloudflareTTSModel>(model: TModel, config: CloudflareConfig): CloudflareTTSAdapter<TModel>;
+export declare function cloudflareTTS<TModel extends CloudflareTTSModel>(model: TModel, config?: CloudflareConfigInput): CloudflareTTSAdapter<TModel>;

package/dist/esm/adapters/tts.js

@@ -0,0 +1,68 @@
+import { resolveConfigFromEnv } from "../utils/config.js";
+import { outputToBase64, runModel } from "../utils/run.js";
+import { generateId } from "@tanstack/ai-utils";
+import { BaseTTSAdapter } from "@tanstack/ai/adapters";
+import { toRunErrorPayload } from "@tanstack/ai/adapter-internals";
+//#region src/adapters/tts.ts
+var CONTENT_TYPES = {
+	mp3: "audio/mpeg",
+	opus: "audio/opus",
+	aac: "audio/aac",
+	flac: "audio/flac",
+	wav: "audio/wav",
+	pcm: "audio/pcm"
+};
+/**
+* Cloudflare text-to-speech adapter for Workers AI models such as Deepgram
+* Aura. `voice` maps to `speaker` and `format` to `encoding`; the audio comes
+* back base64-encoded.
+*/
+var CloudflareTTSAdapter = class extends BaseTTSAdapter {
+	cfConfig;
+	name = "cloudflare";
+	constructor(cfConfig, model) {
+		super(model, {});
+		this.cfConfig = cfConfig;
+	}
+	async generateSpeech(options) {
+		const { model, logger, text, voice, format = "mp3" } = options;
+		const inputs = {
+			...voice && { speaker: voice },
+			encoding: format === "wav" || format === "pcm" ? "linear16" : format,
+			...format === "wav" && { container: "wav" },
+			...options.modelOptions,
+			text
+		};
+		try {
+			logger.request(`activity=tts provider=${this.name} model=${model} chars=${text.length}`, {
+				provider: this.name,
+				model
+			});
+			const output = await runModel(this.cfConfig, model, inputs, { signal: options.abortSignal });
+			const audio = output && typeof output === "object" && "audio" in output ? output.audio : await outputToBase64(output);
+			return {
+				id: generateId(this.name),
+				model,
+				audio,
+				format,
+				contentType: CONTENT_TYPES[format]
+			};
+		} catch (error) {
+			logger.errors(`${this.name}.generateSpeech fatal`, {
+				error: toRunErrorPayload(error, `${this.name}.generateSpeech failed`),
+				source: `${this.name}.generateSpeech`
+			});
+			throw error;
+		}
+	}
+};
+function createCloudflareTTS(model, config) {
+	return new CloudflareTTSAdapter(config, model);
+}
+function cloudflareTTS(model, config) {
+	return new CloudflareTTSAdapter(resolveConfigFromEnv(config), model);
+}
+//#endregion
+export { CloudflareTTSAdapter, cloudflareTTS, createCloudflareTTS };
+
+//# sourceMappingURL=tts.js.map

package/dist/esm/adapters/tts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tts.js","names":[],"sources":["../../../src/adapters/tts.ts"],"sourcesContent":["import { BaseTTSAdapter } from '@tanstack/ai/adapters'\nimport { toRunErrorPayload } from '@tanstack/ai/adapter-internals'\nimport { generateId } from '@tanstack/ai-utils'\nimport { resolveConfigFromEnv } from '../utils/config'\nimport { outputToBase64, runModel } from '../utils/run'\nimport type { TTSOptions, TTSResult } from '@tanstack/ai'\nimport type { CloudflareConfig, CloudflareConfigInput } from '../utils/config'\nimport type { CloudflareTTSModel } from '../utils/models'\n\n/** Text-to-speech inputs forwarded to the model (Deepgram Aura fields). */\nexport interface CloudflareTTSProviderOptions {\n  speaker?: string\n  encoding?: 'linear16' | 'flac' | 'mulaw' | 'alaw' | 'mp3' | 'opus' | 'aac'\n  container?: 'none' | 'wav' | 'ogg'\n  sample_rate?: number\n  bit_rate?: number\n  [key: string]: unknown\n}\n\nconst CONTENT_TYPES: Record<string, string> = {\n  mp3: 'audio/mpeg',\n  opus: 'audio/opus',\n  aac: 'audio/aac',\n  flac: 'audio/flac',\n  wav: 'audio/wav',\n  pcm: 'audio/pcm',\n}\n\n/**\n * Cloudflare text-to-speech adapter for Workers AI models such as Deepgram\n * Aura. `voice` maps to `speaker` and `format` to `encoding`; the audio comes\n * back base64-encoded.\n */\nexport class CloudflareTTSAdapter<\n  TModel extends CloudflareTTSModel,\n> extends BaseTTSAdapter<TModel, CloudflareTTSProviderOptions> {\n  readonly name = 'cloudflare' as const\n\n  constructor(\n    private readonly cfConfig: CloudflareConfig,\n    model: TModel,\n  ) {\n    super(model, {})\n  }\n\n  async generateSpeech(\n    options: TTSOptions<CloudflareTTSProviderOptions>,\n  ): Promise<TTSResult> {\n    const { model, logger, text, voice, format = 'mp3' } = options\n    const inputs = {\n      ...(voice && { speaker: voice }),\n      // Aura takes the codec as `encoding` and the wrapper as `container`;\n      // `wav` and `pcm` are both linear16.\n      encoding: format === 'wav' || format === 'pcm' ? 'linear16' : format,\n      ...(format === 'wav' && { container: 'wav' }),\n      ...options.modelOptions,\n      text,\n    }\n    try {\n      logger.request(\n        `activity=tts provider=${this.name} model=${model} chars=${text.length}`,\n        { provider: this.name, model },\n      )\n      const output = await runModel(this.cfConfig, model, inputs, {\n        signal: options.abortSignal,\n      })\n      const audio =\n        output && typeof output === 'object' && 'audio' in output\n          ? (output as { audio: string }).audio\n          : await outputToBase64(output)\n      return {\n        id: generateId(this.name),\n        model,\n        audio,\n        format,\n        contentType: CONTENT_TYPES[format],\n      }\n    } catch (error: unknown) {\n      logger.errors(`${this.name}.generateSpeech fatal`, {\n        error: toRunErrorPayload(error, `${this.name}.generateSpeech failed`),\n        source: `${this.name}.generateSpeech`,\n      })\n      throw error\n    }\n  }\n}\n\nexport function createCloudflareTTS<TModel extends CloudflareTTSModel>(\n  model: TModel,\n  config: CloudflareConfig,\n): CloudflareTTSAdapter<TModel> {\n  return new CloudflareTTSAdapter(config, model)\n}\n\nexport function cloudflareTTS<TModel extends CloudflareTTSModel>(\n  model: TModel,\n  config?: CloudflareConfigInput,\n): CloudflareTTSAdapter<TModel> {\n  return new CloudflareTTSAdapter(resolveConfigFromEnv(config), model)\n}\n"],"mappings":";;;;;;AAmBA,IAAM,gBAAwC;CAC5C,KAAK;CACL,MAAM;CACN,KAAK;CACL,MAAM;CACN,KAAK;CACL,KAAK;AACP;;;;;;AAOA,IAAa,uBAAb,cAEU,eAAqD;CAI1C;CAHnB,OAAgB;CAEhB,YACE,UACA,OACA;EACA,MAAM,OAAO,CAAC,CAAC;EAHE,KAAA,WAAA;CAInB;CAEA,MAAM,eACJ,SACoB;EACpB,MAAM,EAAE,OAAO,QAAQ,MAAM,OAAO,SAAS,UAAU;EACvD,MAAM,SAAS;GACb,GAAI,SAAS,EAAE,SAAS,MAAM;GAG9B,UAAU,WAAW,SAAS,WAAW,QAAQ,aAAa;GAC9D,GAAI,WAAW,SAAS,EAAE,WAAW,MAAM;GAC3C,GAAG,QAAQ;GACX;EACF;EACA,IAAI;GACF,OAAO,QACL,yBAAyB,KAAK,KAAK,SAAS,MAAM,SAAS,KAAK,UAChE;IAAE,UAAU,KAAK;IAAM;GAAM,CAC/B;GACA,MAAM,SAAS,MAAM,SAAS,KAAK,UAAU,OAAO,QAAQ,EAC1D,QAAQ,QAAQ,YAClB,CAAC;GACD,MAAM,QACJ,UAAU,OAAO,WAAW,YAAY,WAAW,SAC9C,OAA6B,QAC9B,MAAM,eAAe,MAAM;GACjC,OAAO;IACL,IAAI,WAAW,KAAK,IAAI;IACxB;IACA;IACA;IACA,aAAa,cAAc;GAC7B;EACF,SAAS,OAAgB;GACvB,OAAO,OAAO,GAAG,KAAK,KAAK,wBAAwB;IACjD,OAAO,kBAAkB,OAAO,GAAG,KAAK,KAAK,uBAAuB;IACpE,QAAQ,GAAG,KAAK,KAAK;GACvB,CAAC;GACD,MAAM;EACR;CACF;AACF;AAEA,SAAgB,oBACd,OACA,QAC8B;CAC9B,OAAO,IAAI,qBAAqB,QAAQ,KAAK;AAC/C;AAEA,SAAgB,cACd,OACA,QAC8B;CAC9B,OAAO,IAAI,qBAAqB,qBAAqB,MAAM,GAAG,KAAK;AACrE"}

package/dist/esm/byok.d.ts

@@ -0,0 +1,9 @@
+/** The account id that goes with {@link cloudflareByok}. */
+export declare const cloudflareAccountByok: import('@tanstack/ai/byok').ByokProvider<"cloudflare-account">;
+/**
+ * BYOK descriptor for a user-supplied Cloudflare API token. A user who brings
+ * a token brings the account it belongs to, so {@link cloudflareAccountByok}
+ * rides along: register both with `defineByok({ providers })` and a send for
+ * `cloudflare` carries both headers.
+ */
+export declare const cloudflareByok: import('@tanstack/ai/byok').ByokProvider<"cloudflare">;

package/dist/esm/byok.js

@@ -0,0 +1,24 @@
+import { defineByokProvider } from "@tanstack/ai/byok";
+//#region src/byok.ts
+/** The account id that goes with {@link cloudflareByok}. */
+var cloudflareAccountByok = defineByokProvider({
+	id: "cloudflare-account",
+	label: "Cloudflare account ID",
+	env: "CLOUDFLARE_ACCOUNT_ID"
+});
+/**
+* BYOK descriptor for a user-supplied Cloudflare API token. A user who brings
+* a token brings the account it belongs to, so {@link cloudflareAccountByok}
+* rides along: register both with `defineByok({ providers })` and a send for
+* `cloudflare` carries both headers.
+*/
+var cloudflareByok = defineByokProvider({
+	id: "cloudflare",
+	label: "Cloudflare API token",
+	env: "CLOUDFLARE_API_TOKEN",
+	with: [cloudflareAccountByok]
+});
+//#endregion
+export { cloudflareAccountByok, cloudflareByok };
+
+//# sourceMappingURL=byok.js.map

package/dist/esm/byok.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"byok.js","names":[],"sources":["../../src/byok.ts"],"sourcesContent":["import { defineByokProvider } from '@tanstack/ai/byok'\n\n/** The account id that goes with {@link cloudflareByok}. */\nexport const cloudflareAccountByok = defineByokProvider({\n  id: 'cloudflare-account',\n  label: 'Cloudflare account ID',\n  env: 'CLOUDFLARE_ACCOUNT_ID',\n})\n\n/**\n * BYOK descriptor for a user-supplied Cloudflare API token. A user who brings\n * a token brings the account it belongs to, so {@link cloudflareAccountByok}\n * rides along: register both with `defineByok({ providers })` and a send for\n * `cloudflare` carries both headers.\n */\nexport const cloudflareByok = defineByokProvider({\n  id: 'cloudflare',\n  label: 'Cloudflare API token',\n  env: 'CLOUDFLARE_API_TOKEN',\n  with: [cloudflareAccountByok],\n})\n"],"mappings":";;;AAGA,IAAa,wBAAwB,mBAAmB;CACtD,IAAI;CACJ,OAAO;CACP,KAAK;AACP,CAAC;;;;;;;AAQD,IAAa,iBAAiB,mBAAmB;CAC/C,IAAI;CACJ,OAAO;CACP,KAAK;CACL,MAAM,CAAC,qBAAqB;AAC9B,CAAC"}

package/dist/esm/gateway.d.ts

@@ -0,0 +1,30 @@
+import { AIGatewayProviders } from '@cloudflare/workers-types';
+import { CloudflareGatewayOptions } from './utils/config.js';
+export interface CloudflareGatewayTarget extends Omit<CloudflareGatewayOptions, 'id'> {
+    accountId: string;
+    gatewayId: string;
+    /** Cloudflare API token, needed when the gateway has authentication on. */
+    cfApiKey?: string;
+}
+/**
+ * Builds the `baseURL` and headers that point any provider adapter at that
+ * provider's endpoint on your AI Gateway. Pass them through the adapter's
+ * client options (`baseURL` + `defaultHeaders` for OpenAI-style SDKs).
+ *
+ * The headers carry the per-request `cf-aig-*` options plus
+ * `cf-aig-authorization: Bearer <cfApiKey>` when `cfApiKey` is set. The
+ * gateway id lives in the URL, so no `cf-aig-gateway-id` header is sent.
+ *
+ * @example
+ * ```typescript
+ * const gateway = cloudflareGateway('openai', { accountId, gatewayId: 'prod' })
+ * const adapter = createOpenaiChat('gpt-5.5', process.env.OPENAI_API_KEY!, {
+ *   baseURL: gateway.baseURL,
+ *   defaultHeaders: gateway.headers,
+ * })
+ * ```
+ */
+export declare function cloudflareGateway(provider: AIGatewayProviders | 'compat' | (string & {}), target: CloudflareGatewayTarget): {
+    baseURL: string;
+    headers: Record<string, string>;
+};

package/dist/esm/gateway.js

@@ -0,0 +1,45 @@
+import { gatewayHeaders } from "./utils/config.js";
+//#region src/gateway.ts
+/**
+* Gateway endpoints mirror each vendor's own path after the host, and most
+* vendor SDKs already append their version segment (Anthropic `/v1/messages`,
+* Mistral `/v1/...`, Cohere `/v1/chat`). OpenAI-style SDKs append only
+* `/chat/completions`, which matches Cloudflare's `openai`, `groq`,
+* `perplexity-ai`, `deepseek`, and `cerebras` endpoints. xAI is the exception:
+* Cloudflare serves it at `/grok/v1/...`, so its base URL keeps the `/v1`.
+*/
+var PROVIDER_PATH_SUFFIX = { grok: "/v1" };
+/**
+* Builds the `baseURL` and headers that point any provider adapter at that
+* provider's endpoint on your AI Gateway. Pass them through the adapter's
+* client options (`baseURL` + `defaultHeaders` for OpenAI-style SDKs).
+*
+* The headers carry the per-request `cf-aig-*` options plus
+* `cf-aig-authorization: Bearer <cfApiKey>` when `cfApiKey` is set. The
+* gateway id lives in the URL, so no `cf-aig-gateway-id` header is sent.
+*
+* @example
+* ```typescript
+* const gateway = cloudflareGateway('openai', { accountId, gatewayId: 'prod' })
+* const adapter = createOpenaiChat('gpt-5.5', process.env.OPENAI_API_KEY!, {
+*   baseURL: gateway.baseURL,
+*   defaultHeaders: gateway.headers,
+* })
+* ```
+*/
+function cloudflareGateway(provider, target) {
+	const { accountId, gatewayId, cfApiKey, ...options } = target;
+	const { "cf-aig-gateway-id": _id, ...headers } = gatewayHeaders({
+		id: gatewayId,
+		...options
+	});
+	if (cfApiKey) headers["cf-aig-authorization"] = `Bearer ${cfApiKey}`;
+	return {
+		baseURL: `https://gateway.ai.cloudflare.com/v1/${accountId}/${gatewayId}/${provider}${PROVIDER_PATH_SUFFIX[provider] ?? ""}`,
+		headers
+	};
+}
+//#endregion
+export { cloudflareGateway };
+
+//# sourceMappingURL=gateway.js.map

package/dist/esm/gateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway.js","names":[],"sources":["../../src/gateway.ts"],"sourcesContent":["import { gatewayHeaders } from './utils/config'\nimport type { AIGatewayProviders } from '@cloudflare/workers-types'\nimport type { CloudflareGatewayOptions } from './utils/config'\n\nexport interface CloudflareGatewayTarget extends Omit<\n  CloudflareGatewayOptions,\n  'id'\n> {\n  accountId: string\n  gatewayId: string\n  /** Cloudflare API token, needed when the gateway has authentication on. */\n  cfApiKey?: string\n}\n\n/**\n * Gateway endpoints mirror each vendor's own path after the host, and most\n * vendor SDKs already append their version segment (Anthropic `/v1/messages`,\n * Mistral `/v1/...`, Cohere `/v1/chat`). OpenAI-style SDKs append only\n * `/chat/completions`, which matches Cloudflare's `openai`, `groq`,\n * `perplexity-ai`, `deepseek`, and `cerebras` endpoints. xAI is the exception:\n * Cloudflare serves it at `/grok/v1/...`, so its base URL keeps the `/v1`.\n */\nconst PROVIDER_PATH_SUFFIX: Record<string, string> = { grok: '/v1' }\n\n/**\n * Builds the `baseURL` and headers that point any provider adapter at that\n * provider's endpoint on your AI Gateway. Pass them through the adapter's\n * client options (`baseURL` + `defaultHeaders` for OpenAI-style SDKs).\n *\n * The headers carry the per-request `cf-aig-*` options plus\n * `cf-aig-authorization: Bearer <cfApiKey>` when `cfApiKey` is set. The\n * gateway id lives in the URL, so no `cf-aig-gateway-id` header is sent.\n *\n * @example\n * ```typescript\n * const gateway = cloudflareGateway('openai', { accountId, gatewayId: 'prod' })\n * const adapter = createOpenaiChat('gpt-5.5', process.env.OPENAI_API_KEY!, {\n *   baseURL: gateway.baseURL,\n *   defaultHeaders: gateway.headers,\n * })\n * ```\n */\nexport function cloudflareGateway(\n  provider: AIGatewayProviders | 'compat' | (string & {}),\n  target: CloudflareGatewayTarget,\n): { baseURL: string; headers: Record<string, string> } {\n  const { accountId, gatewayId, cfApiKey, ...options } = target\n  const { 'cf-aig-gateway-id': _id, ...headers } = gatewayHeaders({\n    id: gatewayId,\n    ...options,\n  })\n  if (cfApiKey) headers['cf-aig-authorization'] = `Bearer ${cfApiKey}`\n  return {\n    baseURL: `https://gateway.ai.cloudflare.com/v1/${accountId}/${gatewayId}/${provider}${PROVIDER_PATH_SUFFIX[provider] ?? ''}`,\n    headers,\n  }\n}\n"],"mappings":";;;;;;;;;;AAsBA,IAAM,uBAA+C,EAAE,MAAM,MAAM;;;;;;;;;;;;;;;;;;;AAoBnE,SAAgB,kBACd,UACA,QACsD;CACtD,MAAM,EAAE,WAAW,WAAW,UAAU,GAAG,YAAY;CACvD,MAAM,EAAE,qBAAqB,KAAK,GAAG,YAAY,eAAe;EAC9D,IAAI;EACJ,GAAG;CACL,CAAC;CACD,IAAI,UAAU,QAAQ,0BAA0B,UAAU;CAC1D,OAAO;EACL,SAAS,wCAAwC,UAAU,GAAG,UAAU,GAAG,WAAW,qBAAqB,aAAa;EACxH;CACF;AACF"}

package/dist/esm/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @module @tanstack/ai-cloudflare
+ *
+ * Cloudflare provider adapter for TanStack AI: Workers AI chat, embeddings,
+ * images, speech and transcription over the `env.AI` binding or the REST
+ * API, plus AI Gateway routing for any provider.
+ */
+export { CloudflareTextAdapter, createCloudflareText, cloudflareText, type CloudflareTextProviderOptions, } from './adapters/text.js';
+export { createCloudflareSummarize, cloudflareSummarize, type CloudflareSummarizeModel, } from './adapters/summarize.js';
+export { CloudflareEmbeddingAdapter, createCloudflareEmbedding, cloudflareEmbedding, type CloudflareEmbeddingProviderOptions, } from './adapters/embedding.js';
+export { CloudflareImageAdapter, createCloudflareImage, cloudflareImage, type CloudflareImageProviderOptions, } from './adapters/image.js';
+export { CloudflareTTSAdapter, createCloudflareTTS, cloudflareTTS, type CloudflareTTSProviderOptions, } from './adapters/tts.js';
+export { CloudflareTranscriptionAdapter, createCloudflareTranscription, cloudflareTranscription, type CloudflareTranscriptionProviderOptions, } from './adapters/transcription.js';
+export { cloudflareGateway, type CloudflareGatewayTarget } from './gateway.js';
+export type { CloudflareBindingConfig, CloudflareConfig, CloudflareConfigInput, CloudflareGatewayOptions, CloudflareRestConfig, CloudflareTextConfig, CloudflareTextRestConfig, } from './utils/config.js';
+export type { CloudflareEmbeddingModel, CloudflareImageModel, CloudflareTextModel, CloudflareTranscriptionModel, CloudflareTTSModel, } from './utils/models.js';

package/dist/esm/index.js

@@ -0,0 +1,8 @@
+import { CloudflareTextAdapter, cloudflareText, createCloudflareText } from "./adapters/text.js";
+import { cloudflareSummarize, createCloudflareSummarize } from "./adapters/summarize.js";
+import { CloudflareEmbeddingAdapter, cloudflareEmbedding, createCloudflareEmbedding } from "./adapters/embedding.js";
+import { CloudflareImageAdapter, cloudflareImage, createCloudflareImage } from "./adapters/image.js";
+import { CloudflareTTSAdapter, cloudflareTTS, createCloudflareTTS } from "./adapters/tts.js";
+import { CloudflareTranscriptionAdapter, cloudflareTranscription, createCloudflareTranscription } from "./adapters/transcription.js";
+import { cloudflareGateway } from "./gateway.js";
+export { CloudflareEmbeddingAdapter, CloudflareImageAdapter, CloudflareTTSAdapter, CloudflareTextAdapter, CloudflareTranscriptionAdapter, cloudflareEmbedding, cloudflareGateway, cloudflareImage, cloudflareSummarize, cloudflareTTS, cloudflareText, cloudflareTranscription, createCloudflareEmbedding, createCloudflareImage, createCloudflareSummarize, createCloudflareTTS, createCloudflareText, createCloudflareTranscription };

package/dist/esm/utils/config.d.ts

@@ -0,0 +1,60 @@
+import { Ai, GatewayOptions } from '@cloudflare/workers-types';
+import { ClientOptions } from 'openai';
+/**
+ * AI Gateway routing options. `id` is the gateway id (use `"default"` for the
+ * account's auto-created gateway). The remaining fields are per-request
+ * gateway controls (cache, logging, retries) and map to `cf-aig-*` headers on
+ * the REST path or to the `gateway` run option on the binding path.
+ */
+export type CloudflareGatewayOptions = GatewayOptions;
+export type FetchLike = NonNullable<ClientOptions['fetch']>;
+/**
+ * Run through the Workers AI binding (`env.AI`) inside a Cloudflare Worker.
+ * No API token is needed.
+ */
+export interface CloudflareBindingConfig {
+    binding: Ai;
+    gateway?: CloudflareGatewayOptions;
+    accountId?: never;
+    apiKey?: never;
+}
+/** Run through the Cloudflare REST API from any runtime. */
+export interface CloudflareRestConfig {
+    accountId: string;
+    apiKey: string;
+    gateway?: CloudflareGatewayOptions;
+    /** Custom fetch for every request. */
+    fetch?: FetchLike;
+    binding?: never;
+}
+/**
+ * REST config for the chat surface. Also accepts the OpenAI SDK client
+ * options (`baseURL`, `defaultHeaders`, `timeout`, `maxRetries`, ...), which
+ * only the text and summarize adapters read.
+ */
+export interface CloudflareTextRestConfig extends CloudflareRestConfig, Omit<ClientOptions, 'apiKey' | 'fetch'> {
+}
+export type CloudflareConfig = CloudflareBindingConfig | CloudflareRestConfig;
+export type CloudflareTextConfig = CloudflareBindingConfig | CloudflareTextRestConfig;
+/**
+ * What the env-reading factories accept: a binding, or REST fields with any
+ * missing ones read from `CLOUDFLARE_ACCOUNT_ID` and `CLOUDFLARE_API_TOKEN`.
+ */
+export type CloudflareConfigInput<TRest extends CloudflareRestConfig = CloudflareRestConfig> = CloudflareBindingConfig | Partial<TRest>;
+export declare const CLOUDFLARE_API_BASE = "https://api.cloudflare.com/client/v4";
+export declare function isBindingConfig(config: {
+    binding?: Ai;
+}): config is CloudflareBindingConfig;
+/** Base URL for the OpenAI-compatible chat surface of an account. */
+export declare function restChatBaseURL(config: CloudflareTextRestConfig): string;
+/**
+ * Translates gateway options into the `cf-aig-*` request headers the REST
+ * API reads. Retries are not mapped: set them on the gateway itself.
+ */
+export declare function gatewayHeaders(gateway: CloudflareGatewayOptions | undefined): Record<string, string>;
+/**
+ * Resolves a config for the env-reading factories: a binding config passes
+ * through, anything else is filled from `CLOUDFLARE_ACCOUNT_ID` and
+ * `CLOUDFLARE_API_TOKEN`.
+ */
+export declare function resolveConfigFromEnv<TRest extends CloudflareRestConfig>(config: CloudflareConfigInput<TRest> | undefined): CloudflareBindingConfig | (Partial<TRest> & CloudflareRestConfig);

package/dist/esm/utils/config.js

@@ -0,0 +1,48 @@
+import { getApiKeyFromEnv } from "@tanstack/ai-utils";
+//#region src/utils/config.ts
+var CLOUDFLARE_API_BASE = "https://api.cloudflare.com/client/v4";
+function isBindingConfig(config) {
+	return config.binding !== void 0;
+}
+/** Base URL for the OpenAI-compatible chat surface of an account. */
+function restChatBaseURL(config) {
+	return config.baseURL || `https://api.cloudflare.com/client/v4/accounts/${config.accountId}/ai/v1`;
+}
+/**
+* Translates gateway options into the `cf-aig-*` request headers the REST
+* API reads. Retries are not mapped: set them on the gateway itself.
+*/
+function gatewayHeaders(gateway) {
+	if (!gateway) return {};
+	const headers = { "cf-aig-gateway-id": gateway.id };
+	if (gateway.skipCache !== void 0) headers["cf-aig-skip-cache"] = String(gateway.skipCache);
+	if (gateway.cacheTtl !== void 0) headers["cf-aig-cache-ttl"] = String(gateway.cacheTtl);
+	if (gateway.cacheKey !== void 0) headers["cf-aig-cache-key"] = gateway.cacheKey;
+	if (gateway.collectLog !== void 0) headers["cf-aig-collect-log"] = String(gateway.collectLog);
+	if (gateway.eventId !== void 0) headers["cf-aig-event-id"] = gateway.eventId;
+	if (gateway.requestTimeoutMs !== void 0) headers["cf-aig-request-timeout"] = String(gateway.requestTimeoutMs);
+	if (gateway.metadata !== void 0) headers["cf-aig-metadata"] = JSON.stringify(gateway.metadata);
+	return headers;
+}
+/**
+* Resolves a config for the env-reading factories: a binding config passes
+* through, anything else is filled from `CLOUDFLARE_ACCOUNT_ID` and
+* `CLOUDFLARE_API_TOKEN`.
+*/
+function resolveConfigFromEnv(config) {
+	if (config && isBindingConfig(config)) return config;
+	const rest = config ?? {};
+	try {
+		return {
+			...rest,
+			accountId: rest.accountId ?? getApiKeyFromEnv("CLOUDFLARE_ACCOUNT_ID"),
+			apiKey: rest.apiKey ?? getApiKeyFromEnv("CLOUDFLARE_API_TOKEN")
+		};
+	} catch (cause) {
+		throw new Error("CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN are required. Set them in your environment, pass { accountId, apiKey }, or pass { binding: env.AI } inside a Worker.", { cause });
+	}
+}
+//#endregion
+export { CLOUDFLARE_API_BASE, gatewayHeaders, isBindingConfig, resolveConfigFromEnv, restChatBaseURL };
+
+//# sourceMappingURL=config.js.map

package/dist/esm/utils/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","names":[],"sources":["../../../src/utils/config.ts"],"sourcesContent":["import { getApiKeyFromEnv } from '@tanstack/ai-utils'\nimport type { Ai, GatewayOptions } from '@cloudflare/workers-types'\nimport type { ClientOptions } from 'openai'\n\n/**\n * AI Gateway routing options. `id` is the gateway id (use `\"default\"` for the\n * account's auto-created gateway). The remaining fields are per-request\n * gateway controls (cache, logging, retries) and map to `cf-aig-*` headers on\n * the REST path or to the `gateway` run option on the binding path.\n */\nexport type CloudflareGatewayOptions = GatewayOptions\n\nexport type FetchLike = NonNullable<ClientOptions['fetch']>\n\n/**\n * Run through the Workers AI binding (`env.AI`) inside a Cloudflare Worker.\n * No API token is needed.\n */\nexport interface CloudflareBindingConfig {\n  binding: Ai\n  gateway?: CloudflareGatewayOptions\n  accountId?: never\n  apiKey?: never\n}\n\n/** Run through the Cloudflare REST API from any runtime. */\nexport interface CloudflareRestConfig {\n  accountId: string\n  apiKey: string\n  gateway?: CloudflareGatewayOptions\n  /** Custom fetch for every request. */\n  fetch?: FetchLike\n  binding?: never\n}\n\n/**\n * REST config for the chat surface. Also accepts the OpenAI SDK client\n * options (`baseURL`, `defaultHeaders`, `timeout`, `maxRetries`, ...), which\n * only the text and summarize adapters read.\n */\nexport interface CloudflareTextRestConfig\n  extends CloudflareRestConfig, Omit<ClientOptions, 'apiKey' | 'fetch'> {}\n\nexport type CloudflareConfig = CloudflareBindingConfig | CloudflareRestConfig\n\nexport type CloudflareTextConfig =\n  | CloudflareBindingConfig\n  | CloudflareTextRestConfig\n\n/**\n * What the env-reading factories accept: a binding, or REST fields with any\n * missing ones read from `CLOUDFLARE_ACCOUNT_ID` and `CLOUDFLARE_API_TOKEN`.\n */\nexport type CloudflareConfigInput<\n  TRest extends CloudflareRestConfig = CloudflareRestConfig,\n> = CloudflareBindingConfig | Partial<TRest>\n\nexport const CLOUDFLARE_API_BASE = 'https://api.cloudflare.com/client/v4'\n\nexport function isBindingConfig(config: {\n  binding?: Ai\n}): config is CloudflareBindingConfig {\n  return config.binding !== undefined\n}\n\n/** Base URL for the OpenAI-compatible chat surface of an account. */\nexport function restChatBaseURL(config: CloudflareTextRestConfig): string {\n  return (\n    config.baseURL ||\n    `${CLOUDFLARE_API_BASE}/accounts/${config.accountId}/ai/v1`\n  )\n}\n\n/**\n * Translates gateway options into the `cf-aig-*` request headers the REST\n * API reads. Retries are not mapped: set them on the gateway itself.\n */\nexport function gatewayHeaders(\n  gateway: CloudflareGatewayOptions | undefined,\n): Record<string, string> {\n  if (!gateway) return {}\n  const headers: Record<string, string> = { 'cf-aig-gateway-id': gateway.id }\n  if (gateway.skipCache !== undefined) {\n    headers['cf-aig-skip-cache'] = String(gateway.skipCache)\n  }\n  if (gateway.cacheTtl !== undefined) {\n    headers['cf-aig-cache-ttl'] = String(gateway.cacheTtl)\n  }\n  if (gateway.cacheKey !== undefined) {\n    headers['cf-aig-cache-key'] = gateway.cacheKey\n  }\n  if (gateway.collectLog !== undefined) {\n    headers['cf-aig-collect-log'] = String(gateway.collectLog)\n  }\n  if (gateway.eventId !== undefined) {\n    headers['cf-aig-event-id'] = gateway.eventId\n  }\n  if (gateway.requestTimeoutMs !== undefined) {\n    headers['cf-aig-request-timeout'] = String(gateway.requestTimeoutMs)\n  }\n  if (gateway.metadata !== undefined) {\n    headers['cf-aig-metadata'] = JSON.stringify(gateway.metadata)\n  }\n  return headers\n}\n\n/**\n * Resolves a config for the env-reading factories: a binding config passes\n * through, anything else is filled from `CLOUDFLARE_ACCOUNT_ID` and\n * `CLOUDFLARE_API_TOKEN`.\n */\nexport function resolveConfigFromEnv<TRest extends CloudflareRestConfig>(\n  config: CloudflareConfigInput<TRest> | undefined,\n): CloudflareBindingConfig | (Partial<TRest> & CloudflareRestConfig) {\n  if (config && isBindingConfig(config)) return config\n  const rest: Partial<TRest> = config ?? {}\n  try {\n    return {\n      ...rest,\n      accountId: rest.accountId ?? getApiKeyFromEnv('CLOUDFLARE_ACCOUNT_ID'),\n      apiKey: rest.apiKey ?? getApiKeyFromEnv('CLOUDFLARE_API_TOKEN'),\n    }\n  } catch (cause) {\n    throw new Error(\n      'CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN are required. Set them in your environment, pass { accountId, apiKey }, or pass { binding: env.AI } inside a Worker.',\n      { cause },\n    )\n  }\n}\n"],"mappings":";;AAyDA,IAAa,sBAAsB;AAEnC,SAAgB,gBAAgB,QAEM;CACpC,OAAO,OAAO,YAAY,KAAA;AAC5B;;AAGA,SAAgB,gBAAgB,QAA0C;CACxE,OACE,OAAO,WACP,iDAAmC,OAAO,UAAU;AAExD;;;;;AAMA,SAAgB,eACd,SACwB;CACxB,IAAI,CAAC,SAAS,OAAO,CAAC;CACtB,MAAM,UAAkC,EAAE,qBAAqB,QAAQ,GAAG;CAC1E,IAAI,QAAQ,cAAc,KAAA,GACxB,QAAQ,uBAAuB,OAAO,QAAQ,SAAS;CAEzD,IAAI,QAAQ,aAAa,KAAA,GACvB,QAAQ,sBAAsB,OAAO,QAAQ,QAAQ;CAEvD,IAAI,QAAQ,aAAa,KAAA,GACvB,QAAQ,sBAAsB,QAAQ;CAExC,IAAI,QAAQ,eAAe,KAAA,GACzB,QAAQ,wBAAwB,OAAO,QAAQ,UAAU;CAE3D,IAAI,QAAQ,YAAY,KAAA,GACtB,QAAQ,qBAAqB,QAAQ;CAEvC,IAAI,QAAQ,qBAAqB,KAAA,GAC/B,QAAQ,4BAA4B,OAAO,QAAQ,gBAAgB;CAErE,IAAI,QAAQ,aAAa,KAAA,GACvB,QAAQ,qBAAqB,KAAK,UAAU,QAAQ,QAAQ;CAE9D,OAAO;AACT;;;;;;AAOA,SAAgB,qBACd,QACmE;CACnE,IAAI,UAAU,gBAAgB,MAAM,GAAG,OAAO;CAC9C,MAAM,OAAuB,UAAU,CAAC;CACxC,IAAI;EACF,OAAO;GACL,GAAG;GACH,WAAW,KAAK,aAAa,iBAAiB,uBAAuB;GACrE,QAAQ,KAAK,UAAU,iBAAiB,sBAAsB;EAChE;CACF,SAAS,OAAO;EACd,MAAM,IAAI,MACR,uKACA,EAAE,MAAM,CACV;CACF;AACF"}

package/dist/esm/utils/fetch.d.ts

@@ -0,0 +1,27 @@
+import { Ai } from '@cloudflare/workers-types';
+import { CloudflareGatewayOptions, FetchLike } from './config.js';
+/**
+ * Workers AI streams end with a usage-only trailer (`{"response":"","usage":
+ * {...}}`) that has no `choices` field. The OpenAI Chat Completions stream
+ * reader indexes `chunk.choices[0]` on every event, so give such events an
+ * empty `choices` array (OpenAI's own usage-only trailer shape) and keep the
+ * usage totals they carry.
+ */
+export declare function normalizeSseResponse(response: Response): Response;
+/**
+ * Cloudflare error bodies look like `{ name, message, internalCode }` or
+ * `{ errors: [{ code, message }] }`. The OpenAI SDK only reads
+ * `body.error.message`, so rewrap them or every failure reads as
+ * "status code (no body)".
+ */
+export declare function normalizeErrorResponse(response: Response): Promise<Response>;
+/** Applies the error and SSE normalizations a raw Cloudflare response needs. */
+export declare function normalizeResponse(response: Response): Promise<Response>;
+/**
+ * Makes `env.AI` look like an OpenAI-compatible HTTP endpoint to the OpenAI
+ * SDK: the JSON request body becomes `binding.run(model, inputs)` and the
+ * raw inference `Response` (OpenAI-format JSON or SSE) is handed back.
+ */
+export declare function createBindingFetch(binding: Ai, gateway?: CloudflareGatewayOptions): FetchLike;
+/** Wraps a REST fetch so responses get the same error and trailer fixes. */
+export declare function createRestFetch(baseFetch: FetchLike | undefined): FetchLike;

package/dist/esm/utils/fetch.js

@@ -0,0 +1,94 @@
+//#region src/utils/fetch.ts
+/**
+* Workers AI streams end with a usage-only trailer (`{"response":"","usage":
+* {...}}`) that has no `choices` field. The OpenAI Chat Completions stream
+* reader indexes `chunk.choices[0]` on every event, so give such events an
+* empty `choices` array (OpenAI's own usage-only trailer shape) and keep the
+* usage totals they carry.
+*/
+function normalizeSseResponse(response) {
+	const contentType = response.headers.get("content-type") ?? "";
+	if (!response.body || !contentType.includes("text/event-stream")) return response;
+	let buffer = "";
+	const fixLine = (line) => {
+		if (!line.startsWith("data: ") || line === "data: [DONE]") return line;
+		try {
+			const event = JSON.parse(line.slice(6));
+			if (event && typeof event === "object" && !("choices" in event)) return `data: ${JSON.stringify({
+				...event,
+				choices: []
+			})}`;
+		} catch {}
+		return line;
+	};
+	const body = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new TransformStream({
+		transform(chunk, controller) {
+			buffer += chunk;
+			const lines = buffer.split("\n");
+			buffer = lines.pop() ?? "";
+			for (const line of lines) controller.enqueue(`${fixLine(line)}\n`);
+		},
+		flush(controller) {
+			if (buffer) controller.enqueue(fixLine(buffer));
+		}
+	})).pipeThrough(new TextEncoderStream());
+	return new Response(body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers
+	});
+}
+/**
+* Cloudflare error bodies look like `{ name, message, internalCode }` or
+* `{ errors: [{ code, message }] }`. The OpenAI SDK only reads
+* `body.error.message`, so rewrap them or every failure reads as
+* "status code (no body)".
+*/
+async function normalizeErrorResponse(response) {
+	const text = await response.text();
+	let body = text;
+	try {
+		const json = JSON.parse(text);
+		if (json && typeof json === "object" && !("error" in json)) {
+			const first = json.errors?.[0];
+			body = JSON.stringify({ error: {
+				message: json.message ?? first?.message ?? text,
+				type: json.name ?? "cloudflare_error",
+				code: json.internalCode ?? first?.code ?? null
+			} });
+		}
+	} catch {}
+	return new Response(body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers
+	});
+}
+/** Applies the error and SSE normalizations a raw Cloudflare response needs. */
+async function normalizeResponse(response) {
+	return response.ok ? normalizeSseResponse(response) : await normalizeErrorResponse(response);
+}
+/**
+* Makes `env.AI` look like an OpenAI-compatible HTTP endpoint to the OpenAI
+* SDK: the JSON request body becomes `binding.run(model, inputs)` and the
+* raw inference `Response` (OpenAI-format JSON or SSE) is handed back.
+*/
+function createBindingFetch(binding, gateway) {
+	const run = binding.run.bind(binding);
+	return async (_input, init) => {
+		const { model, ...inputs } = JSON.parse(typeof init?.body === "string" ? init.body : "{}");
+		return await normalizeResponse(await run(model, inputs, {
+			returnRawResponse: true,
+			...gateway && { gateway }
+		}));
+	};
+}
+/** Wraps a REST fetch so responses get the same error and trailer fixes. */
+function createRestFetch(baseFetch) {
+	const fetchImpl = baseFetch ?? fetch;
+	return async (input, init) => await normalizeResponse(await fetchImpl(input, init));
+}
+//#endregion
+export { createBindingFetch, createRestFetch, normalizeErrorResponse, normalizeResponse, normalizeSseResponse };
+
+//# sourceMappingURL=fetch.js.map

package/dist/esm/utils/fetch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.js","names":[],"sources":["../../../src/utils/fetch.ts"],"sourcesContent":["import type { Ai } from '@cloudflare/workers-types'\nimport type { CloudflareGatewayOptions, FetchLike } from './config'\n\n/**\n * Workers AI streams end with a usage-only trailer (`{\"response\":\"\",\"usage\":\n * {...}}`) that has no `choices` field. The OpenAI Chat Completions stream\n * reader indexes `chunk.choices[0]` on every event, so give such events an\n * empty `choices` array (OpenAI's own usage-only trailer shape) and keep the\n * usage totals they carry.\n */\nexport function normalizeSseResponse(response: Response): Response {\n  const contentType = response.headers.get('content-type') ?? ''\n  if (!response.body || !contentType.includes('text/event-stream')) {\n    return response\n  }\n  let buffer = ''\n  const fixLine = (line: string): string => {\n    if (!line.startsWith('data: ') || line === 'data: [DONE]') return line\n    try {\n      const event = JSON.parse(line.slice(6)) as Record<string, unknown>\n      if (event && typeof event === 'object' && !('choices' in event)) {\n        return `data: ${JSON.stringify({ ...event, choices: [] })}`\n      }\n    } catch {\n      // Not JSON: forward untouched.\n    }\n    return line\n  }\n  const body = response.body\n    .pipeThrough(new TextDecoderStream())\n    .pipeThrough(\n      new TransformStream<string, string>({\n        transform(chunk, controller) {\n          buffer += chunk\n          const lines = buffer.split('\\n')\n          buffer = lines.pop() ?? ''\n          for (const line of lines) controller.enqueue(`${fixLine(line)}\\n`)\n        },\n        flush(controller) {\n          if (buffer) controller.enqueue(fixLine(buffer))\n        },\n      }),\n    )\n    .pipeThrough(new TextEncoderStream())\n  return new Response(body, {\n    status: response.status,\n    statusText: response.statusText,\n    headers: response.headers,\n  })\n}\n\n/**\n * Cloudflare error bodies look like `{ name, message, internalCode }` or\n * `{ errors: [{ code, message }] }`. The OpenAI SDK only reads\n * `body.error.message`, so rewrap them or every failure reads as\n * \"status code (no body)\".\n */\nexport async function normalizeErrorResponse(\n  response: Response,\n): Promise<Response> {\n  const text = await response.text()\n  let body = text\n  try {\n    const json = JSON.parse(text) as {\n      error?: unknown\n      errors?: Array<{ code?: number; message?: string }>\n      message?: string\n      name?: string\n      internalCode?: number\n    }\n    if (json && typeof json === 'object' && !('error' in json)) {\n      const first = json.errors?.[0]\n      body = JSON.stringify({\n        error: {\n          message: json.message ?? first?.message ?? text,\n          type: json.name ?? 'cloudflare_error',\n          code: json.internalCode ?? first?.code ?? null,\n        },\n      })\n    }\n  } catch {\n    // Not JSON: forward the text as-is.\n  }\n  return new Response(body, {\n    status: response.status,\n    statusText: response.statusText,\n    headers: response.headers,\n  })\n}\n\n/** Applies the error and SSE normalizations a raw Cloudflare response needs. */\nexport async function normalizeResponse(response: Response): Promise<Response> {\n  return response.ok\n    ? normalizeSseResponse(response)\n    : await normalizeErrorResponse(response)\n}\n\n/**\n * Makes `env.AI` look like an OpenAI-compatible HTTP endpoint to the OpenAI\n * SDK: the JSON request body becomes `binding.run(model, inputs)` and the\n * raw inference `Response` (OpenAI-format JSON or SSE) is handed back.\n */\nexport function createBindingFetch(\n  binding: Ai,\n  gateway?: CloudflareGatewayOptions,\n): FetchLike {\n  // `Ai` is typed against the bundled model catalog; the adapter accepts any\n  // model id, so widen the binding to the open catalog shape for this call.\n  const run = binding.run.bind(binding) as (\n    model: string,\n    inputs: Record<string, unknown>,\n    options: Record<string, unknown>,\n  ) => Promise<unknown>\n  return async (_input, init) => {\n    const { model, ...inputs } = JSON.parse(\n      typeof init?.body === 'string' ? init.body : '{}',\n    ) as { model: string } & Record<string, unknown>\n    const response = (await run(model, inputs, {\n      returnRawResponse: true,\n      ...(gateway && { gateway }),\n    })) as Response\n    return await normalizeResponse(response)\n  }\n}\n\n/** Wraps a REST fetch so responses get the same error and trailer fixes. */\nexport function createRestFetch(baseFetch: FetchLike | undefined): FetchLike {\n  const fetchImpl = baseFetch ?? fetch\n  return async (input, init) =>\n    await normalizeResponse(await fetchImpl(input, init))\n}\n"],"mappings":";;;;;;;;AAUA,SAAgB,qBAAqB,UAA8B;CACjE,MAAM,cAAc,SAAS,QAAQ,IAAI,cAAc,KAAK;CAC5D,IAAI,CAAC,SAAS,QAAQ,CAAC,YAAY,SAAS,mBAAmB,GAC7D,OAAO;CAET,IAAI,SAAS;CACb,MAAM,WAAW,SAAyB;EACxC,IAAI,CAAC,KAAK,WAAW,QAAQ,KAAK,SAAS,gBAAgB,OAAO;EAClE,IAAI;GACF,MAAM,QAAQ,KAAK,MAAM,KAAK,MAAM,CAAC,CAAC;GACtC,IAAI,SAAS,OAAO,UAAU,YAAY,EAAE,aAAa,QACvD,OAAO,SAAS,KAAK,UAAU;IAAE,GAAG;IAAO,SAAS,CAAC;GAAE,CAAC;EAE5D,QAAQ,CAER;EACA,OAAO;CACT;CACA,MAAM,OAAO,SAAS,KACnB,YAAY,IAAI,kBAAkB,CAAC,CAAC,CACpC,YACC,IAAI,gBAAgC;EAClC,UAAU,OAAO,YAAY;GAC3B,UAAU;GACV,MAAM,QAAQ,OAAO,MAAM,IAAI;GAC/B,SAAS,MAAM,IAAI,KAAK;GACxB,KAAK,MAAM,QAAQ,OAAO,WAAW,QAAQ,GAAG,QAAQ,IAAI,EAAE,GAAG;EACnE;EACA,MAAM,YAAY;GAChB,IAAI,QAAQ,WAAW,QAAQ,QAAQ,MAAM,CAAC;EAChD;CACF,CAAC,CACH,CAAC,CACA,YAAY,IAAI,kBAAkB,CAAC;CACtC,OAAO,IAAI,SAAS,MAAM;EACxB,QAAQ,SAAS;EACjB,YAAY,SAAS;EACrB,SAAS,SAAS;CACpB,CAAC;AACH;;;;;;;AAQA,eAAsB,uBACpB,UACmB;CACnB,MAAM,OAAO,MAAM,SAAS,KAAK;CACjC,IAAI,OAAO;CACX,IAAI;EACF,MAAM,OAAO,KAAK,MAAM,IAAI;EAO5B,IAAI,QAAQ,OAAO,SAAS,YAAY,EAAE,WAAW,OAAO;GAC1D,MAAM,QAAQ,KAAK,SAAS;GAC5B,OAAO,KAAK,UAAU,EACpB,OAAO;IACL,SAAS,KAAK,WAAW,OAAO,WAAW;IAC3C,MAAM,KAAK,QAAQ;IACnB,MAAM,KAAK,gBAAgB,OAAO,QAAQ;GAC5C,EACF,CAAC;EACH;CACF,QAAQ,CAER;CACA,OAAO,IAAI,SAAS,MAAM;EACxB,QAAQ,SAAS;EACjB,YAAY,SAAS;EACrB,SAAS,SAAS;CACpB,CAAC;AACH;;AAGA,eAAsB,kBAAkB,UAAuC;CAC7E,OAAO,SAAS,KACZ,qBAAqB,QAAQ,IAC7B,MAAM,uBAAuB,QAAQ;AAC3C;;;;;;AAOA,SAAgB,mBACd,SACA,SACW;CAGX,MAAM,MAAM,QAAQ,IAAI,KAAK,OAAO;CAKpC,OAAO,OAAO,QAAQ,SAAS;EAC7B,MAAM,EAAE,OAAO,GAAG,WAAW,KAAK,MAChC,OAAO,MAAM,SAAS,WAAW,KAAK,OAAO,IAC/C;EAKA,OAAO,MAAM,kBAAkB,MAJP,IAAI,OAAO,QAAQ;GACzC,mBAAmB;GACnB,GAAI,WAAW,EAAE,QAAQ;EAC3B,CAAC,CACsC;CACzC;AACF;;AAGA,SAAgB,gBAAgB,WAA6C;CAC3E,MAAM,YAAY,aAAa;CAC/B,OAAO,OAAO,OAAO,SACnB,MAAM,kBAAkB,MAAM,UAAU,OAAO,IAAI,CAAC;AACxD"}

package/dist/esm/utils/models.d.ts

@@ -0,0 +1,16 @@
+import { AiModels, BaseAiAutomaticSpeechRecognition, BaseAiTextEmbeddings, BaseAiTextGeneration, BaseAiTextToImage, BaseAiTextToSpeech } from '@cloudflare/workers-types';
+/** Model ids from the Workers AI catalog whose task shape matches `TTask`. */
+type ModelsFor<TTask> = {
+    [K in keyof AiModels]: AiModels[K] extends TTask ? K : never;
+}[keyof AiModels];
+/**
+ * Chat model id. Catalog ids get autocomplete; any other id works too,
+ * including third-party `provider/model` ids routed through AI Gateway
+ * (for example `openai/gpt-5.5`).
+ */
+export type CloudflareTextModel = ModelsFor<BaseAiTextGeneration> | (string & {});
+export type CloudflareEmbeddingModel = ModelsFor<BaseAiTextEmbeddings> | (string & {});
+export type CloudflareImageModel = ModelsFor<BaseAiTextToImage> | (string & {});
+export type CloudflareTTSModel = ModelsFor<BaseAiTextToSpeech> | '@cf/deepgram/aura-1' | '@cf/deepgram/aura-2-en' | '@cf/deepgram/aura-2-es' | (string & {});
+export type CloudflareTranscriptionModel = ModelsFor<BaseAiAutomaticSpeechRecognition> | '@cf/openai/whisper-large-v3-turbo' | '@cf/deepgram/nova-3' | (string & {});
+export {};

package/dist/esm/utils/run.d.ts

@@ -0,0 +1,21 @@
+import { CloudflareConfig } from './config.js';
+export type RunInputs = Record<string, unknown>;
+export interface RunBinary {
+    /** Input field that carries the bytes on the binding path. */
+    field: string;
+    body: Uint8Array | ArrayBuffer | Blob;
+    contentType: string;
+}
+/**
+ * Runs a Workers AI model with its native task inputs (embeddings, image,
+ * speech, transcription) through the binding or the REST `/ai/run` endpoint.
+ *
+ * Returns the model's decoded output: an object for JSON tasks, or bytes
+ * (`Uint8Array` / `ReadableStream`) for binary media outputs.
+ */
+export declare function runModel(config: CloudflareConfig, model: string, inputs: RunInputs, options?: {
+    signal?: AbortSignal;
+    binary?: RunBinary;
+}): Promise<unknown>;
+/** Base64-encodes a binary model output, whatever shape it arrived in. */
+export declare function outputToBase64(output: unknown): Promise<string>;