@tanstack/ai-cloudflare 0.0.0 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tanner Linsley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,54 @@
-# @tanstack/ai-cloudflare
+<div align="center">
+  <picture>
+    <source
+      media="(prefers-color-scheme: dark)"
+      srcset="https://tanstack.com/api/readme/ai.png?theme=dark"
+    />
+    <source
+      media="(prefers-color-scheme: light)"
+      srcset="https://tanstack.com/api/readme/ai.png"
+    />
+    <img
+      src="https://tanstack.com/api/readme/ai.png"
+      alt="TanStack AI"
+      width="900"
+    />
+  </picture>
+</div>
 
-Placeholder package for npm OIDC trusted publishing setup. Not a functional package. Do not depend on this version.
+<br />
+
+# @tanstack/ai-cloudflare
+
+Cloudflare adapter for TanStack AI: Workers AI chat, summarization, embeddings, image generation, text-to-speech, and transcription over the `env.AI` binding or the REST API, with AI Gateway routing for any provider.
+
+## Installation
+
+```bash
+npm install @tanstack/ai @tanstack/ai-cloudflare
+```
+
+## Usage
+
+```typescript
+import { chat, toServerSentEventsResponse } from '@tanstack/ai'
+import { createCloudflareText } from '@tanstack/ai-cloudflare'
+import type { Ai } from '@cloudflare/workers-types'
+
+export default {
+  async fetch(request: Request, env: { AI: Ai }) {
+    const { messages } = await request.json()
+    const stream = chat({
+      adapter: createCloudflareText('@cf/zai-org/glm-5.3-flash', {
+        binding: env.AI,
+      }),
+      messages,
+    })
+    return toServerSentEventsResponse(stream)
+  },
+}
+```
+
+Outside a Worker, pass `{ accountId, apiKey }` or set `CLOUDFLARE_ACCOUNT_ID` and `CLOUDFLARE_API_TOKEN` and use `cloudflareText(model)`.
+
+See the [docs](https://tanstack.com/ai/latest/docs/adapters/cloudflare) for AI Gateway, media adapters, and model options.

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

@@ -0,0 +1,19 @@
+import { BaseEmbeddingAdapter } from '@tanstack/ai/adapters';
+import { EmbeddingOptions, EmbeddingResult } from '@tanstack/ai';
+import { CloudflareConfig, CloudflareConfigInput } from '../utils/config.js';
+import { CloudflareEmbeddingModel } from '../utils/models.js';
+/** Extra inputs forwarded to the embedding model (model specific). */
+export type CloudflareEmbeddingProviderOptions = Record<string, unknown>;
+/**
+ * Cloudflare embedding adapter. Runs Workers AI text-embedding models
+ * (`{ text: [...] }` in, `{ data: number[][] }` out) through the binding or
+ * the REST API.
+ */
+export declare class CloudflareEmbeddingAdapter<TModel extends CloudflareEmbeddingModel> extends BaseEmbeddingAdapter<TModel, CloudflareEmbeddingProviderOptions> {
+    private readonly cfConfig;
+    readonly name: "cloudflare";
+    constructor(cfConfig: CloudflareConfig, model: TModel);
+    createEmbeddings(options: EmbeddingOptions<CloudflareEmbeddingProviderOptions>): Promise<EmbeddingResult>;
+}
+export declare function createCloudflareEmbedding<TModel extends CloudflareEmbeddingModel>(model: TModel, config: CloudflareConfig): CloudflareEmbeddingAdapter<TModel>;
+export declare function cloudflareEmbedding<TModel extends CloudflareEmbeddingModel>(model: TModel, config?: CloudflareConfigInput): CloudflareEmbeddingAdapter<TModel>;

package/dist/esm/adapters/embedding.js

@@ -0,0 +1,60 @@
+import { resolveConfigFromEnv } from "../utils/config.js";
+import { runModel } from "../utils/run.js";
+import { generateId } from "@tanstack/ai-utils";
+import { BaseEmbeddingAdapter } from "@tanstack/ai/adapters";
+import { toRunErrorPayload } from "@tanstack/ai/adapter-internals";
+import { requireTextOnlyEmbeddingInput } from "@tanstack/ai";
+//#region src/adapters/embedding.ts
+/**
+* Cloudflare embedding adapter. Runs Workers AI text-embedding models
+* (`{ text: [...] }` in, `{ data: number[][] }` out) through the binding or
+* the REST API.
+*/
+var CloudflareEmbeddingAdapter = class extends BaseEmbeddingAdapter {
+	cfConfig;
+	name = "cloudflare";
+	constructor(cfConfig, model) {
+		super(model, {});
+		this.cfConfig = cfConfig;
+	}
+	async createEmbeddings(options) {
+		const { model, logger } = options;
+		const texts = requireTextOnlyEmbeddingInput(options.input, this.name, model);
+		if (options.dimensions !== void 0) throw new Error("Workers AI embedding models have fixed dimensions; do not set `dimensions`");
+		try {
+			logger.request(`activity=embed provider=${this.name} model=${model} inputs=${texts.length}`, {
+				provider: this.name,
+				model
+			});
+			const output = await runModel(this.cfConfig, model, {
+				...options.modelOptions,
+				text: texts
+			});
+			if (!Array.isArray(output.data) || output.data.length !== texts.length) throw new Error(`Workers AI ${model} returned ${output.data?.length ?? 0} embeddings for ${texts.length} inputs`);
+			return {
+				id: generateId(this.name),
+				model,
+				embeddings: output.data.map((vector, index) => ({
+					vector,
+					index
+				}))
+			};
+		} catch (error) {
+			logger.errors(`${this.name}.createEmbeddings fatal`, {
+				error: toRunErrorPayload(error, `${this.name}.createEmbeddings failed`),
+				source: `${this.name}.createEmbeddings`
+			});
+			throw error;
+		}
+	}
+};
+function createCloudflareEmbedding(model, config) {
+	return new CloudflareEmbeddingAdapter(config, model);
+}
+function cloudflareEmbedding(model, config) {
+	return new CloudflareEmbeddingAdapter(resolveConfigFromEnv(config), model);
+}
+//#endregion
+export { CloudflareEmbeddingAdapter, cloudflareEmbedding, createCloudflareEmbedding };
+
+//# sourceMappingURL=embedding.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"embedding.js","names":[],"sources":["../../../src/adapters/embedding.ts"],"sourcesContent":["import { BaseEmbeddingAdapter } from '@tanstack/ai/adapters'\nimport { toRunErrorPayload } from '@tanstack/ai/adapter-internals'\nimport { generateId } from '@tanstack/ai-utils'\nimport { requireTextOnlyEmbeddingInput } from '@tanstack/ai'\nimport { resolveConfigFromEnv } from '../utils/config'\nimport { runModel } from '../utils/run'\nimport type { EmbeddingOptions, EmbeddingResult } from '@tanstack/ai'\nimport type { CloudflareConfig, CloudflareConfigInput } from '../utils/config'\nimport type { CloudflareEmbeddingModel } from '../utils/models'\n\n/** Extra inputs forwarded to the embedding model (model specific). */\nexport type CloudflareEmbeddingProviderOptions = Record<string, unknown>\n\n/**\n * Cloudflare embedding adapter. Runs Workers AI text-embedding models\n * (`{ text: [...] }` in, `{ data: number[][] }` out) through the binding or\n * the REST API.\n */\nexport class CloudflareEmbeddingAdapter<\n  TModel extends CloudflareEmbeddingModel,\n> extends BaseEmbeddingAdapter<TModel, CloudflareEmbeddingProviderOptions> {\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 createEmbeddings(\n    options: EmbeddingOptions<CloudflareEmbeddingProviderOptions>,\n  ): Promise<EmbeddingResult> {\n    const { model, logger } = options\n    const texts = requireTextOnlyEmbeddingInput(options.input, this.name, model)\n    if (options.dimensions !== undefined) {\n      throw new Error(\n        'Workers AI embedding models have fixed dimensions; do not set `dimensions`',\n      )\n    }\n    try {\n      logger.request(\n        `activity=embed provider=${this.name} model=${model} inputs=${texts.length}`,\n        { provider: this.name, model },\n      )\n      const output = (await runModel(this.cfConfig, model, {\n        ...options.modelOptions,\n        text: texts,\n      })) as { data?: Array<Array<number>> }\n      if (!Array.isArray(output.data) || output.data.length !== texts.length) {\n        throw new Error(\n          `Workers AI ${model} returned ${output.data?.length ?? 0} embeddings for ${texts.length} inputs`,\n        )\n      }\n      return {\n        id: generateId(this.name),\n        model,\n        embeddings: output.data.map((vector, index) => ({\n          vector,\n          index,\n        })),\n      }\n    } catch (error: unknown) {\n      logger.errors(`${this.name}.createEmbeddings fatal`, {\n        error: toRunErrorPayload(error, `${this.name}.createEmbeddings failed`),\n        source: `${this.name}.createEmbeddings`,\n      })\n      throw error\n    }\n  }\n}\n\nexport function createCloudflareEmbedding<\n  TModel extends CloudflareEmbeddingModel,\n>(model: TModel, config: CloudflareConfig): CloudflareEmbeddingAdapter<TModel> {\n  return new CloudflareEmbeddingAdapter(config, model)\n}\n\nexport function cloudflareEmbedding<TModel extends CloudflareEmbeddingModel>(\n  model: TModel,\n  config?: CloudflareConfigInput,\n): CloudflareEmbeddingAdapter<TModel> {\n  return new CloudflareEmbeddingAdapter(resolveConfigFromEnv(config), model)\n}\n"],"mappings":";;;;;;;;;;;;AAkBA,IAAa,6BAAb,cAEU,qBAAiE;CAItD;CAHnB,OAAgB;CAEhB,YACE,UACA,OACA;EACA,MAAM,OAAO,CAAC,CAAC;EAHE,KAAA,WAAA;CAInB;CAEA,MAAM,iBACJ,SAC0B;EAC1B,MAAM,EAAE,OAAO,WAAW;EAC1B,MAAM,QAAQ,8BAA8B,QAAQ,OAAO,KAAK,MAAM,KAAK;EAC3E,IAAI,QAAQ,eAAe,KAAA,GACzB,MAAM,IAAI,MACR,4EACF;EAEF,IAAI;GACF,OAAO,QACL,2BAA2B,KAAK,KAAK,SAAS,MAAM,UAAU,MAAM,UACpE;IAAE,UAAU,KAAK;IAAM;GAAM,CAC/B;GACA,MAAM,SAAU,MAAM,SAAS,KAAK,UAAU,OAAO;IACnD,GAAG,QAAQ;IACX,MAAM;GACR,CAAC;GACD,IAAI,CAAC,MAAM,QAAQ,OAAO,IAAI,KAAK,OAAO,KAAK,WAAW,MAAM,QAC9D,MAAM,IAAI,MACR,cAAc,MAAM,YAAY,OAAO,MAAM,UAAU,EAAE,kBAAkB,MAAM,OAAO,QAC1F;GAEF,OAAO;IACL,IAAI,WAAW,KAAK,IAAI;IACxB;IACA,YAAY,OAAO,KAAK,KAAK,QAAQ,WAAW;KAC9C;KACA;IACF,EAAE;GACJ;EACF,SAAS,OAAgB;GACvB,OAAO,OAAO,GAAG,KAAK,KAAK,0BAA0B;IACnD,OAAO,kBAAkB,OAAO,GAAG,KAAK,KAAK,yBAAyB;IACtE,QAAQ,GAAG,KAAK,KAAK;GACvB,CAAC;GACD,MAAM;EACR;CACF;AACF;AAEA,SAAgB,0BAEd,OAAe,QAA8D;CAC7E,OAAO,IAAI,2BAA2B,QAAQ,KAAK;AACrD;AAEA,SAAgB,oBACd,OACA,QACoC;CACpC,OAAO,IAAI,2BAA2B,qBAAqB,MAAM,GAAG,KAAK;AAC3E"}

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

@@ -0,0 +1,26 @@
+import { BaseImageAdapter } from '@tanstack/ai/adapters';
+import { ImageGenerationOptions, ImageGenerationResult } from '@tanstack/ai';
+import { CloudflareConfig, CloudflareConfigInput } from '../utils/config.js';
+import { CloudflareImageModel } from '../utils/models.js';
+/** Text-to-image inputs forwarded to the model (`steps`, `guidance`, ...). */
+export interface CloudflareImageProviderOptions {
+    negative_prompt?: string;
+    steps?: number;
+    num_steps?: number;
+    guidance?: number;
+    seed?: number;
+    [key: string]: unknown;
+}
+/**
+ * Cloudflare image adapter. Runs Workers AI text-to-image models and returns
+ * base64 images, whether the model answers with `{ image }` JSON (Flux,
+ * Leonardo) or raw PNG bytes (Stable Diffusion).
+ */
+export declare class CloudflareImageAdapter<TModel extends CloudflareImageModel> extends BaseImageAdapter<TModel, CloudflareImageProviderOptions> {
+    private readonly cfConfig;
+    readonly name: "cloudflare";
+    constructor(cfConfig: CloudflareConfig, model: TModel);
+    generateImages(options: ImageGenerationOptions<CloudflareImageProviderOptions>): Promise<ImageGenerationResult>;
+}
+export declare function createCloudflareImage<TModel extends CloudflareImageModel>(model: TModel, config: CloudflareConfig): CloudflareImageAdapter<TModel>;
+export declare function cloudflareImage<TModel extends CloudflareImageModel>(model: TModel, config?: CloudflareConfigInput): CloudflareImageAdapter<TModel>;

package/dist/esm/adapters/image.js

@@ -0,0 +1,62 @@
+import { resolveConfigFromEnv } from "../utils/config.js";
+import { outputToBase64, runModel } from "../utils/run.js";
+import { generateId } from "@tanstack/ai-utils";
+import { BaseImageAdapter } from "@tanstack/ai/adapters";
+import { toRunErrorPayload } from "@tanstack/ai/adapter-internals";
+import { resolveMediaPrompt } from "@tanstack/ai";
+//#region src/adapters/image.ts
+/**
+* Cloudflare image adapter. Runs Workers AI text-to-image models and returns
+* base64 images, whether the model answers with `{ image }` JSON (Flux,
+* Leonardo) or raw PNG bytes (Stable Diffusion).
+*/
+var CloudflareImageAdapter = class extends BaseImageAdapter {
+	cfConfig;
+	name = "cloudflare";
+	constructor(cfConfig, model) {
+		super(model, {});
+		this.cfConfig = cfConfig;
+	}
+	async generateImages(options) {
+		const { model, logger, numberOfImages = 1 } = options;
+		const prompt = resolveMediaPrompt(options.prompt);
+		const [width, height] = options.size?.split("x").map(Number) ?? [];
+		const inputs = {
+			...width && { width },
+			...height && { height },
+			...options.modelOptions,
+			prompt: prompt.text
+		};
+		try {
+			logger.request(`activity=image provider=${this.name} model=${model} n=${numberOfImages}`, {
+				provider: this.name,
+				model
+			});
+			const images = await Promise.all(Array.from({ length: numberOfImages }, async () => {
+				const output = await runModel(this.cfConfig, model, inputs, { signal: options.abortSignal });
+				return { b64Json: output && typeof output === "object" && "image" in output ? output.image : await outputToBase64(output) };
+			}));
+			return {
+				id: generateId(this.name),
+				model,
+				images
+			};
+		} catch (error) {
+			logger.errors(`${this.name}.generateImages fatal`, {
+				error: toRunErrorPayload(error, `${this.name}.generateImages failed`),
+				source: `${this.name}.generateImages`
+			});
+			throw error;
+		}
+	}
+};
+function createCloudflareImage(model, config) {
+	return new CloudflareImageAdapter(config, model);
+}
+function cloudflareImage(model, config) {
+	return new CloudflareImageAdapter(resolveConfigFromEnv(config), model);
+}
+//#endregion
+export { CloudflareImageAdapter, cloudflareImage, createCloudflareImage };
+
+//# sourceMappingURL=image.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"image.js","names":[],"sources":["../../../src/adapters/image.ts"],"sourcesContent":["import { BaseImageAdapter } from '@tanstack/ai/adapters'\nimport { toRunErrorPayload } from '@tanstack/ai/adapter-internals'\nimport { generateId } from '@tanstack/ai-utils'\nimport { resolveMediaPrompt } from '@tanstack/ai'\nimport { resolveConfigFromEnv } from '../utils/config'\nimport { outputToBase64, runModel } from '../utils/run'\nimport type {\n  GeneratedImage,\n  ImageGenerationOptions,\n  ImageGenerationResult,\n} from '@tanstack/ai'\nimport type { CloudflareConfig, CloudflareConfigInput } from '../utils/config'\nimport type { CloudflareImageModel } from '../utils/models'\n\n/** Text-to-image inputs forwarded to the model (`steps`, `guidance`, ...). */\nexport interface CloudflareImageProviderOptions {\n  negative_prompt?: string\n  steps?: number\n  num_steps?: number\n  guidance?: number\n  seed?: number\n  [key: string]: unknown\n}\n\n/**\n * Cloudflare image adapter. Runs Workers AI text-to-image models and returns\n * base64 images, whether the model answers with `{ image }` JSON (Flux,\n * Leonardo) or raw PNG bytes (Stable Diffusion).\n */\nexport class CloudflareImageAdapter<\n  TModel extends CloudflareImageModel,\n> extends BaseImageAdapter<TModel, CloudflareImageProviderOptions> {\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 generateImages(\n    options: ImageGenerationOptions<CloudflareImageProviderOptions>,\n  ): Promise<ImageGenerationResult> {\n    const { model, logger, numberOfImages = 1 } = options\n    const prompt = resolveMediaPrompt(options.prompt)\n    const [width, height] = options.size?.split('x').map(Number) ?? []\n    const inputs = {\n      ...(width && { width }),\n      ...(height && { height }),\n      ...options.modelOptions,\n      prompt: prompt.text,\n    }\n    try {\n      logger.request(\n        `activity=image provider=${this.name} model=${model} n=${numberOfImages}`,\n        { provider: this.name, model },\n      )\n      const images = await Promise.all(\n        Array.from(\n          { length: numberOfImages },\n          async (): Promise<GeneratedImage> => {\n            const output = await runModel(this.cfConfig, model, inputs, {\n              signal: options.abortSignal,\n            })\n            const image =\n              output && typeof output === 'object' && 'image' in output\n                ? (output as { image: string }).image\n                : await outputToBase64(output)\n            return { b64Json: image }\n          },\n        ),\n      )\n      return { id: generateId(this.name), model, images }\n    } catch (error: unknown) {\n      logger.errors(`${this.name}.generateImages fatal`, {\n        error: toRunErrorPayload(error, `${this.name}.generateImages failed`),\n        source: `${this.name}.generateImages`,\n      })\n      throw error\n    }\n  }\n}\n\nexport function createCloudflareImage<TModel extends CloudflareImageModel>(\n  model: TModel,\n  config: CloudflareConfig,\n): CloudflareImageAdapter<TModel> {\n  return new CloudflareImageAdapter(config, model)\n}\n\nexport function cloudflareImage<TModel extends CloudflareImageModel>(\n  model: TModel,\n  config?: CloudflareConfigInput,\n): CloudflareImageAdapter<TModel> {\n  return new CloudflareImageAdapter(resolveConfigFromEnv(config), model)\n}\n"],"mappings":";;;;;;;;;;;;AA6BA,IAAa,yBAAb,cAEU,iBAAyD;CAI9C;CAHnB,OAAgB;CAEhB,YACE,UACA,OACA;EACA,MAAM,OAAO,CAAC,CAAC;EAHE,KAAA,WAAA;CAInB;CAEA,MAAM,eACJ,SACgC;EAChC,MAAM,EAAE,OAAO,QAAQ,iBAAiB,MAAM;EAC9C,MAAM,SAAS,mBAAmB,QAAQ,MAAM;EAChD,MAAM,CAAC,OAAO,UAAU,QAAQ,MAAM,MAAM,GAAG,CAAC,CAAC,IAAI,MAAM,KAAK,CAAC;EACjE,MAAM,SAAS;GACb,GAAI,SAAS,EAAE,MAAM;GACrB,GAAI,UAAU,EAAE,OAAO;GACvB,GAAG,QAAQ;GACX,QAAQ,OAAO;EACjB;EACA,IAAI;GACF,OAAO,QACL,2BAA2B,KAAK,KAAK,SAAS,MAAM,KAAK,kBACzD;IAAE,UAAU,KAAK;IAAM;GAAM,CAC/B;GACA,MAAM,SAAS,MAAM,QAAQ,IAC3B,MAAM,KACJ,EAAE,QAAQ,eAAe,GACzB,YAAqC;IACnC,MAAM,SAAS,MAAM,SAAS,KAAK,UAAU,OAAO,QAAQ,EAC1D,QAAQ,QAAQ,YAClB,CAAC;IAKD,OAAO,EAAE,SAHP,UAAU,OAAO,WAAW,YAAY,WAAW,SAC9C,OAA6B,QAC9B,MAAM,eAAe,MAAM,EACT;GAC1B,CACF,CACF;GACA,OAAO;IAAE,IAAI,WAAW,KAAK,IAAI;IAAG;IAAO;GAAO;EACpD,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,sBACd,OACA,QACgC;CAChC,OAAO,IAAI,uBAAuB,QAAQ,KAAK;AACjD;AAEA,SAAgB,gBACd,OACA,QACgC;CAChC,OAAO,IAAI,uBAAuB,qBAAqB,MAAM,GAAG,KAAK;AACvE"}

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

@@ -0,0 +1,15 @@
+import { ChatStreamSummarizeAdapter, InferTextProviderOptions } from '@tanstack/ai/adapters';
+import { CloudflareTextAdapter } from './text.js';
+import { CloudflareConfigInput, CloudflareTextConfig, CloudflareTextRestConfig } from '../utils/config.js';
+import { CloudflareTextModel } from '../utils/models.js';
+export type CloudflareSummarizeModel = CloudflareTextModel;
+/**
+ * Creates a Cloudflare summarize adapter. Summaries run as a chat request
+ * against the given model.
+ */
+export declare function createCloudflareSummarize<TModel extends CloudflareSummarizeModel>(model: TModel, config: CloudflareTextConfig): ChatStreamSummarizeAdapter<TModel, InferTextProviderOptions<CloudflareTextAdapter<TModel>>>;
+/**
+ * Creates a Cloudflare summarize adapter, reading `CLOUDFLARE_ACCOUNT_ID` and
+ * `CLOUDFLARE_API_TOKEN` from the environment unless a binding is passed.
+ */
+export declare function cloudflareSummarize<TModel extends CloudflareSummarizeModel>(model: TModel, config?: CloudflareConfigInput<CloudflareTextRestConfig>): ChatStreamSummarizeAdapter<TModel, InferTextProviderOptions<CloudflareTextAdapter<TModel>>>;

package/dist/esm/adapters/summarize.js

@@ -0,0 +1,22 @@
+import { resolveConfigFromEnv } from "../utils/config.js";
+import { CloudflareTextAdapter } from "./text.js";
+import { ChatStreamSummarizeAdapter } from "@tanstack/ai/adapters";
+//#region src/adapters/summarize.ts
+/**
+* Creates a Cloudflare summarize adapter. Summaries run as a chat request
+* against the given model.
+*/
+function createCloudflareSummarize(model, config) {
+	return new ChatStreamSummarizeAdapter(new CloudflareTextAdapter(config, model), model, "cloudflare");
+}
+/**
+* Creates a Cloudflare summarize adapter, reading `CLOUDFLARE_ACCOUNT_ID` and
+* `CLOUDFLARE_API_TOKEN` from the environment unless a binding is passed.
+*/
+function cloudflareSummarize(model, config) {
+	return createCloudflareSummarize(model, resolveConfigFromEnv(config));
+}
+//#endregion
+export { cloudflareSummarize, createCloudflareSummarize };
+
+//# sourceMappingURL=summarize.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"summarize.js","names":[],"sources":["../../../src/adapters/summarize.ts"],"sourcesContent":["import { ChatStreamSummarizeAdapter } from '@tanstack/ai/adapters'\nimport { resolveConfigFromEnv } from '../utils/config'\nimport { CloudflareTextAdapter } from './text'\nimport type { InferTextProviderOptions } from '@tanstack/ai/adapters'\nimport type {\n  CloudflareConfigInput,\n  CloudflareTextConfig,\n  CloudflareTextRestConfig,\n} from '../utils/config'\nimport type { CloudflareTextModel } from '../utils/models'\n\nexport type CloudflareSummarizeModel = CloudflareTextModel\n\n/**\n * Creates a Cloudflare summarize adapter. Summaries run as a chat request\n * against the given model.\n */\nexport function createCloudflareSummarize<\n  TModel extends CloudflareSummarizeModel,\n>(\n  model: TModel,\n  config: CloudflareTextConfig,\n): ChatStreamSummarizeAdapter<\n  TModel,\n  InferTextProviderOptions<CloudflareTextAdapter<TModel>>\n> {\n  return new ChatStreamSummarizeAdapter(\n    new CloudflareTextAdapter(config, model),\n    model,\n    'cloudflare',\n  )\n}\n\n/**\n * Creates a Cloudflare summarize adapter, reading `CLOUDFLARE_ACCOUNT_ID` and\n * `CLOUDFLARE_API_TOKEN` from the environment unless a binding is passed.\n */\nexport function cloudflareSummarize<TModel extends CloudflareSummarizeModel>(\n  model: TModel,\n  config?: CloudflareConfigInput<CloudflareTextRestConfig>,\n): ChatStreamSummarizeAdapter<\n  TModel,\n  InferTextProviderOptions<CloudflareTextAdapter<TModel>>\n> {\n  return createCloudflareSummarize(model, resolveConfigFromEnv(config))\n}\n"],"mappings":";;;;;;;;AAiBA,SAAgB,0BAGd,OACA,QAIA;CACA,OAAO,IAAI,2BACT,IAAI,sBAAsB,QAAQ,KAAK,GACvC,OACA,YACF;AACF;;;;;AAMA,SAAgB,oBACd,OACA,QAIA;CACA,OAAO,0BAA0B,OAAO,qBAAqB,MAAM,CAAC;AACtE"}

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

@@ -0,0 +1,71 @@
+import { OpenAIBaseChatCompletionsTextAdapter } from '@tanstack/openai-base';
+import { ChatCompletionChunk, ChatCompletionMessageParam } from 'openai/resources/chat/completions/completions';
+import { CloudflareConfigInput, CloudflareTextConfig, CloudflareTextRestConfig } from '../utils/config.js';
+import { CloudflareTextModel } from '../utils/models.js';
+import { ModelMessage } from '@tanstack/ai';
+/**
+ * Chat Completions parameters forwarded verbatim to Workers AI. Reasoning
+ * models (GLM, Kimi, gpt-oss, QwQ) read `reasoning_effort` and
+ * `chat_template_kwargs`; `null` for `reasoning_effort` turns reasoning off.
+ */
+export interface CloudflareTextProviderOptions {
+    temperature?: number;
+    max_tokens?: number;
+    top_p?: number;
+    top_k?: number;
+    seed?: number;
+    repetition_penalty?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    reasoning_effort?: 'low' | 'medium' | 'high' | null;
+    chat_template_kwargs?: {
+        enable_thinking?: boolean;
+        clear_thinking?: boolean;
+    };
+}
+/**
+ * Cloudflare text (chat) adapter.
+ *
+ * Drives Workers AI's OpenAI-compatible Chat Completions surface with the
+ * OpenAI SDK. Inside a Worker pass `{ binding: env.AI }`; anywhere else pass
+ * `{ accountId, apiKey }`. Add `gateway` to route through AI Gateway. Any
+ * catalog model works, including third-party `provider/model` ids billed
+ * through AI Gateway.
+ */
+export declare class CloudflareTextAdapter<TModel extends CloudflareTextModel, TProviderOptions extends Record<string, any> = CloudflareTextProviderOptions> extends OpenAIBaseChatCompletionsTextAdapter<TModel, TProviderOptions> {
+    readonly kind: "text";
+    readonly name: "cloudflare";
+    constructor(config: CloudflareTextConfig, model: TModel);
+    /**
+     * Workers AI validates `messages[].content` as a string, so a tool-call-only
+     * assistant turn (which OpenAI accepts as `content: null`) is sent as `''`.
+     */
+    protected convertMessage(message: ModelMessage): ChatCompletionMessageParam;
+    /**
+     * Workers AI accepts `response_format` next to `tools` but its models answer
+     * the tool follow-up turn in prose, so structured output with tools runs as
+     * a separate finalization request instead.
+     */
+    supportsCombinedToolsAndSchema(): boolean;
+    /** Workers AI reasoning models stream thinking as `reasoning_content` (some as `reasoning`). */
+    protected extractReasoning(chunk: ChatCompletionChunk): {
+        text: string;
+    } | undefined;
+}
+/**
+ * Creates a Cloudflare text adapter with explicit configuration.
+ *
+ * @example
+ * ```typescript
+ * // Inside a Worker
+ * const adapter = createCloudflareText('@cf/zai-org/glm-5.3-flash', { binding: env.AI })
+ * // Anywhere, over REST
+ * const adapter = createCloudflareText('@cf/zai-org/glm-5.3-flash', { accountId, apiKey })
+ * ```
+ */
+export declare function createCloudflareText<TModel extends CloudflareTextModel>(model: TModel, config: CloudflareTextConfig): CloudflareTextAdapter<TModel>;
+/**
+ * Creates a Cloudflare text adapter, reading `CLOUDFLARE_ACCOUNT_ID` and
+ * `CLOUDFLARE_API_TOKEN` from the environment unless a binding is passed.
+ */
+export declare function cloudflareText<TModel extends CloudflareTextModel>(model: TModel, config?: CloudflareConfigInput<CloudflareTextRestConfig>): CloudflareTextAdapter<TModel>;

package/dist/esm/adapters/text.js

@@ -0,0 +1,88 @@
+import { gatewayHeaders, isBindingConfig, resolveConfigFromEnv, restChatBaseURL } from "../utils/config.js";
+import { createBindingFetch, createRestFetch } from "../utils/fetch.js";
+import OpenAI from "openai";
+import { OpenAIBaseChatCompletionsTextAdapter } from "@tanstack/openai-base";
+//#region src/adapters/text.ts
+function createClient(config) {
+	if (isBindingConfig(config)) return new OpenAI({
+		apiKey: "cloudflare-binding",
+		fetch: createBindingFetch(config.binding, config.gateway)
+	});
+	const { accountId: _accountId, binding: _binding, gateway, ...clientOptions } = config;
+	return new OpenAI({
+		...clientOptions,
+		baseURL: restChatBaseURL(config),
+		defaultHeaders: {
+			...gatewayHeaders(gateway),
+			...clientOptions.defaultHeaders
+		},
+		fetch: createRestFetch(clientOptions.fetch)
+	});
+}
+/**
+* Cloudflare text (chat) adapter.
+*
+* Drives Workers AI's OpenAI-compatible Chat Completions surface with the
+* OpenAI SDK. Inside a Worker pass `{ binding: env.AI }`; anywhere else pass
+* `{ accountId, apiKey }`. Add `gateway` to route through AI Gateway. Any
+* catalog model works, including third-party `provider/model` ids billed
+* through AI Gateway.
+*/
+var CloudflareTextAdapter = class extends OpenAIBaseChatCompletionsTextAdapter {
+	kind = "text";
+	name = "cloudflare";
+	constructor(config, model) {
+		super(model, "cloudflare", createClient(config));
+	}
+	/**
+	* Workers AI validates `messages[].content` as a string, so a tool-call-only
+	* assistant turn (which OpenAI accepts as `content: null`) is sent as `''`.
+	*/
+	convertMessage(message) {
+		const converted = super.convertMessage(message);
+		if (converted.role === "assistant" && converted.content == null) return {
+			...converted,
+			content: ""
+		};
+		return converted;
+	}
+	/**
+	* Workers AI accepts `response_format` next to `tools` but its models answer
+	* the tool follow-up turn in prose, so structured output with tools runs as
+	* a separate finalization request instead.
+	*/
+	supportsCombinedToolsAndSchema() {
+		return false;
+	}
+	/** Workers AI reasoning models stream thinking as `reasoning_content` (some as `reasoning`). */
+	extractReasoning(chunk) {
+		const delta = chunk.choices[0]?.delta;
+		const raw = delta?.reasoning_content ?? delta?.reasoning;
+		return typeof raw === "string" && raw.length > 0 ? { text: raw } : void 0;
+	}
+};
+/**
+* Creates a Cloudflare text adapter with explicit configuration.
+*
+* @example
+* ```typescript
+* // Inside a Worker
+* const adapter = createCloudflareText('@cf/zai-org/glm-5.3-flash', { binding: env.AI })
+* // Anywhere, over REST
+* const adapter = createCloudflareText('@cf/zai-org/glm-5.3-flash', { accountId, apiKey })
+* ```
+*/
+function createCloudflareText(model, config) {
+	return new CloudflareTextAdapter(config, model);
+}
+/**
+* Creates a Cloudflare text adapter, reading `CLOUDFLARE_ACCOUNT_ID` and
+* `CLOUDFLARE_API_TOKEN` from the environment unless a binding is passed.
+*/
+function cloudflareText(model, config) {
+	return new CloudflareTextAdapter(resolveConfigFromEnv(config), model);
+}
+//#endregion
+export { CloudflareTextAdapter, cloudflareText, createCloudflareText };
+
+//# sourceMappingURL=text.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","names":[],"sources":["../../../src/adapters/text.ts"],"sourcesContent":["import OpenAI from 'openai'\nimport { OpenAIBaseChatCompletionsTextAdapter } from '@tanstack/openai-base'\nimport {\n  gatewayHeaders,\n  isBindingConfig,\n  resolveConfigFromEnv,\n  restChatBaseURL,\n} from '../utils/config'\nimport { createBindingFetch, createRestFetch } from '../utils/fetch'\nimport type {\n  ChatCompletionChunk,\n  ChatCompletionMessageParam,\n} from 'openai/resources/chat/completions/completions'\nimport type {\n  CloudflareConfigInput,\n  CloudflareTextConfig,\n  CloudflareTextRestConfig,\n} from '../utils/config'\nimport type { CloudflareTextModel } from '../utils/models'\nimport type { ModelMessage } from '@tanstack/ai'\n\n/**\n * Chat Completions parameters forwarded verbatim to Workers AI. Reasoning\n * models (GLM, Kimi, gpt-oss, QwQ) read `reasoning_effort` and\n * `chat_template_kwargs`; `null` for `reasoning_effort` turns reasoning off.\n */\nexport interface CloudflareTextProviderOptions {\n  temperature?: number\n  max_tokens?: number\n  top_p?: number\n  top_k?: number\n  seed?: number\n  repetition_penalty?: number\n  frequency_penalty?: number\n  presence_penalty?: number\n  reasoning_effort?: 'low' | 'medium' | 'high' | null\n  chat_template_kwargs?: {\n    enable_thinking?: boolean\n    clear_thinking?: boolean\n  }\n}\n\nfunction createClient(config: CloudflareTextConfig): OpenAI {\n  if (isBindingConfig(config)) {\n    return new OpenAI({\n      // The binding authenticates by itself; the SDK only requires a value.\n      apiKey: 'cloudflare-binding',\n      fetch: createBindingFetch(config.binding, config.gateway),\n    })\n  }\n  const {\n    accountId: _accountId,\n    binding: _binding,\n    gateway,\n    ...clientOptions\n  } = config\n  return new OpenAI({\n    ...clientOptions,\n    baseURL: restChatBaseURL(config),\n    defaultHeaders: {\n      ...gatewayHeaders(gateway),\n      ...clientOptions.defaultHeaders,\n    },\n    fetch: createRestFetch(clientOptions.fetch),\n  })\n}\n\n/**\n * Cloudflare text (chat) adapter.\n *\n * Drives Workers AI's OpenAI-compatible Chat Completions surface with the\n * OpenAI SDK. Inside a Worker pass `{ binding: env.AI }`; anywhere else pass\n * `{ accountId, apiKey }`. Add `gateway` to route through AI Gateway. Any\n * catalog model works, including third-party `provider/model` ids billed\n * through AI Gateway.\n */\nexport class CloudflareTextAdapter<\n  TModel extends CloudflareTextModel,\n  TProviderOptions extends Record<string, any> = CloudflareTextProviderOptions,\n> extends OpenAIBaseChatCompletionsTextAdapter<TModel, TProviderOptions> {\n  override readonly kind = 'text' as const\n  override readonly name = 'cloudflare' as const\n\n  constructor(config: CloudflareTextConfig, model: TModel) {\n    super(model, 'cloudflare', createClient(config))\n  }\n\n  /**\n   * Workers AI validates `messages[].content` as a string, so a tool-call-only\n   * assistant turn (which OpenAI accepts as `content: null`) is sent as `''`.\n   */\n  protected override convertMessage(\n    message: ModelMessage,\n  ): ChatCompletionMessageParam {\n    const converted = super.convertMessage(message)\n    if (converted.role === 'assistant' && converted.content == null) {\n      return { ...converted, content: '' }\n    }\n    return converted\n  }\n\n  /**\n   * Workers AI accepts `response_format` next to `tools` but its models answer\n   * the tool follow-up turn in prose, so structured output with tools runs as\n   * a separate finalization request instead.\n   */\n  override supportsCombinedToolsAndSchema(): boolean {\n    return false\n  }\n\n  /** Workers AI reasoning models stream thinking as `reasoning_content` (some as `reasoning`). */\n  protected override extractReasoning(\n    chunk: ChatCompletionChunk,\n  ): { text: string } | undefined {\n    const delta = chunk.choices[0]?.delta as\n      | { reasoning?: unknown; reasoning_content?: unknown }\n      | undefined\n    const raw = delta?.reasoning_content ?? delta?.reasoning\n    return typeof raw === 'string' && raw.length > 0 ? { text: raw } : undefined\n  }\n}\n\n/**\n * Creates a Cloudflare text adapter with explicit configuration.\n *\n * @example\n * ```typescript\n * // Inside a Worker\n * const adapter = createCloudflareText('@cf/zai-org/glm-5.3-flash', { binding: env.AI })\n * // Anywhere, over REST\n * const adapter = createCloudflareText('@cf/zai-org/glm-5.3-flash', { accountId, apiKey })\n * ```\n */\nexport function createCloudflareText<TModel extends CloudflareTextModel>(\n  model: TModel,\n  config: CloudflareTextConfig,\n): CloudflareTextAdapter<TModel> {\n  return new CloudflareTextAdapter(config, model)\n}\n\n/**\n * Creates a Cloudflare text adapter, reading `CLOUDFLARE_ACCOUNT_ID` and\n * `CLOUDFLARE_API_TOKEN` from the environment unless a binding is passed.\n */\nexport function cloudflareText<TModel extends CloudflareTextModel>(\n  model: TModel,\n  config?: CloudflareConfigInput<CloudflareTextRestConfig>,\n): CloudflareTextAdapter<TModel> {\n  return new CloudflareTextAdapter(resolveConfigFromEnv(config), model)\n}\n"],"mappings":";;;;;AA0CA,SAAS,aAAa,QAAsC;CAC1D,IAAI,gBAAgB,MAAM,GACxB,OAAO,IAAI,OAAO;EAEhB,QAAQ;EACR,OAAO,mBAAmB,OAAO,SAAS,OAAO,OAAO;CAC1D,CAAC;CAEH,MAAM,EACJ,WAAW,YACX,SAAS,UACT,SACA,GAAG,kBACD;CACJ,OAAO,IAAI,OAAO;EAChB,GAAG;EACH,SAAS,gBAAgB,MAAM;EAC/B,gBAAgB;GACd,GAAG,eAAe,OAAO;GACzB,GAAG,cAAc;EACnB;EACA,OAAO,gBAAgB,cAAc,KAAK;CAC5C,CAAC;AACH;;;;;;;;;;AAWA,IAAa,wBAAb,cAGU,qCAA+D;CACvE,OAAyB;CACzB,OAAyB;CAEzB,YAAY,QAA8B,OAAe;EACvD,MAAM,OAAO,cAAc,aAAa,MAAM,CAAC;CACjD;;;;;CAMA,eACE,SAC4B;EAC5B,MAAM,YAAY,MAAM,eAAe,OAAO;EAC9C,IAAI,UAAU,SAAS,eAAe,UAAU,WAAW,MACzD,OAAO;GAAE,GAAG;GAAW,SAAS;EAAG;EAErC,OAAO;CACT;;;;;;CAOA,iCAAmD;EACjD,OAAO;CACT;;CAGA,iBACE,OAC8B;EAC9B,MAAM,QAAQ,MAAM,QAAQ,EAAE,EAAE;EAGhC,MAAM,MAAM,OAAO,qBAAqB,OAAO;EAC/C,OAAO,OAAO,QAAQ,YAAY,IAAI,SAAS,IAAI,EAAE,MAAM,IAAI,IAAI,KAAA;CACrE;AACF;;;;;;;;;;;;AAaA,SAAgB,qBACd,OACA,QAC+B;CAC/B,OAAO,IAAI,sBAAsB,QAAQ,KAAK;AAChD;;;;;AAMA,SAAgB,eACd,OACA,QAC+B;CAC/B,OAAO,IAAI,sBAAsB,qBAAqB,MAAM,GAAG,KAAK;AACtE"}

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

@@ -0,0 +1,21 @@
+import { BaseTranscriptionAdapter } from '@tanstack/ai/adapters';
+import { TranscriptionOptions, TranscriptionResult } from '@tanstack/ai';
+import { CloudflareConfig, CloudflareConfigInput } from '../utils/config.js';
+import { CloudflareTranscriptionModel } from '../utils/models.js';
+/** Extra inputs forwarded to the transcription model (model specific). */
+export type CloudflareTranscriptionProviderOptions = Record<string, unknown>;
+/**
+ * Cloudflare transcription adapter. Whisper models take base64 audio in the
+ * `audio` input; Deepgram Nova takes the raw bytes. Both return text plus
+ * timed words, and Whisper also returns segments.
+ */
+export declare class CloudflareTranscriptionAdapter<TModel extends CloudflareTranscriptionModel> extends BaseTranscriptionAdapter<TModel, CloudflareTranscriptionProviderOptions> {
+    private readonly cfConfig;
+    readonly name: "cloudflare";
+    constructor(cfConfig: CloudflareConfig, model: TModel);
+    transcribe(options: TranscriptionOptions<CloudflareTranscriptionProviderOptions>): Promise<TranscriptionResult>;
+    private runWhisper;
+    private runNova;
+}
+export declare function createCloudflareTranscription<TModel extends CloudflareTranscriptionModel>(model: TModel, config: CloudflareConfig): CloudflareTranscriptionAdapter<TModel>;
+export declare function cloudflareTranscription<TModel extends CloudflareTranscriptionModel>(model: TModel, config?: CloudflareConfigInput): CloudflareTranscriptionAdapter<TModel>;

package/dist/esm/adapters/transcription.js

@@ -0,0 +1,134 @@
+import { isBindingConfig, resolveConfigFromEnv } from "../utils/config.js";
+import { runModel } from "../utils/run.js";
+import { arrayBufferToBase64, generateId } from "@tanstack/ai-utils";
+import { BaseTranscriptionAdapter } from "@tanstack/ai/adapters";
+import { toRunErrorPayload } from "@tanstack/ai/adapter-internals";
+//#region src/adapters/transcription.ts
+async function toBytes(audio, fetchImpl, signal) {
+	if (typeof audio === "string") {
+		if (/^https?:\/\//.test(audio)) {
+			const response = await fetchImpl(audio, { signal });
+			if (!response.ok) throw new Error(`Could not fetch audio from ${audio} (${response.status})`);
+			return {
+				bytes: await response.arrayBuffer(),
+				contentType: response.headers.get("content-type") ?? "audio/mpeg"
+			};
+		}
+		const match = /^data:([^;]+);base64,(.*)$/.exec(audio);
+		const base64 = match?.[2] ?? audio;
+		const binary = atob(base64);
+		const bytes = new Uint8Array(binary.length);
+		for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+		return {
+			bytes: bytes.buffer,
+			contentType: match?.[1] ?? "audio/mpeg"
+		};
+	}
+	if (audio instanceof ArrayBuffer) return {
+		bytes: audio,
+		contentType: "audio/mpeg"
+	};
+	return {
+		bytes: await audio.arrayBuffer(),
+		contentType: audio.type || "audio/mpeg"
+	};
+}
+/**
+* Cloudflare transcription adapter. Whisper models take base64 audio in the
+* `audio` input; Deepgram Nova takes the raw bytes. Both return text plus
+* timed words, and Whisper also returns segments.
+*/
+var CloudflareTranscriptionAdapter = class extends BaseTranscriptionAdapter {
+	cfConfig;
+	name = "cloudflare";
+	constructor(cfConfig, model) {
+		super(model, {});
+		this.cfConfig = cfConfig;
+	}
+	async transcribe(options) {
+		const { model, logger, language, prompt } = options;
+		try {
+			logger.request(`activity=transcription provider=${this.name} model=${model}`, {
+				provider: this.name,
+				model
+			});
+			const fetchImpl = (isBindingConfig(this.cfConfig) ? void 0 : this.cfConfig.fetch) ?? fetch;
+			const { bytes, contentType } = await toBytes(options.audio, fetchImpl, options.abortSignal);
+			const output = model.startsWith("@cf/deepgram/") ? await this.runNova(model, bytes, contentType, options) : await this.runWhisper(model, bytes, {
+				language,
+				prompt,
+				...options.modelOptions
+			}, options.abortSignal);
+			return {
+				id: generateId(this.name),
+				model,
+				...output
+			};
+		} catch (error) {
+			logger.errors(`${this.name}.transcribe fatal`, {
+				error: toRunErrorPayload(error, `${this.name}.transcribe failed`),
+				source: `${this.name}.transcribe`
+			});
+			throw error;
+		}
+	}
+	async runWhisper(model, bytes, inputs, signal) {
+		const { language, prompt, ...rest } = inputs;
+		const output = await runModel(this.cfConfig, model, {
+			...language && { language },
+			...prompt && { initial_prompt: prompt },
+			...rest,
+			audio: arrayBufferToBase64(bytes)
+		}, { signal });
+		if (typeof output.text !== "string") throw new Error(`Workers AI ${model} returned no transcript`);
+		return {
+			text: output.text,
+			language: output.transcription_info?.language,
+			duration: output.transcription_info?.duration,
+			segments: output.segments?.map((segment, id) => ({
+				id,
+				start: segment.start,
+				end: segment.end,
+				text: segment.text.trim()
+			})),
+			words: toWords(output.words)
+		};
+	}
+	async runNova(model, bytes, contentType, options) {
+		const output = await runModel(this.cfConfig, model, {
+			...options.language && { language: options.language },
+			...options.modelOptions
+		}, {
+			signal: options.abortSignal,
+			binary: {
+				field: "audio",
+				body: bytes,
+				contentType
+			}
+		});
+		const alternative = output.results?.channels?.[0]?.alternatives?.[0];
+		if (typeof alternative?.transcript !== "string") throw new Error(`Workers AI ${model} returned no transcript`);
+		return {
+			text: alternative.transcript,
+			duration: output.metadata?.duration,
+			words: toWords(alternative?.words)
+		};
+	}
+};
+function toWords(words) {
+	return words?.map((w) => ({
+		word: (w.word ?? "").trim(),
+		start: w.start ?? 0,
+		end: w.end ?? 0
+	}));
+}
+function createCloudflareTranscription(model, config) {
+	return new CloudflareTranscriptionAdapter(config, model);
+}
+function cloudflareTranscription(model, config) {
+	return new CloudflareTranscriptionAdapter(resolveConfigFromEnv(config), model);
+}
+//#endregion
+export { CloudflareTranscriptionAdapter, cloudflareTranscription, createCloudflareTranscription };
+
+//# sourceMappingURL=transcription.js.map