workers-ai-provider 0.7.5 → 2.0.1

package/src/workers-ai-embedding-model.ts

@@ -1,4 +1,4 @@
-import { type EmbeddingModelV1, TooManyEmbeddingValuesForCallError } from "@ai-sdk/provider";
+import { type EmbeddingModelV2, TooManyEmbeddingValuesForCallError } from "@ai-sdk/provider";
 import type { StringLike } from "./utils";
 import type { EmbeddingModels } from "./workersai-models";
 
@@ -19,12 +19,12 @@ export type WorkersAIEmbeddingSettings = {
 	[key: string]: StringLike;
 };
 
-export class WorkersAIEmbeddingModel implements EmbeddingModelV1<string> {
+export class WorkersAIEmbeddingModel implements EmbeddingModelV2<string> {
 	/**
 	 * Semantic version of the {@link EmbeddingModelV1} specification implemented
 	 * by this class. It never changes.
 	 */
-	readonly specificationVersion = "v1";
+	readonly specificationVersion = "v2";
 	readonly modelId: EmbeddingModels;
 	private readonly config: WorkersAIEmbeddingConfig;
 	private readonly settings: WorkersAIEmbeddingSettings;
@@ -38,7 +38,7 @@ export class WorkersAIEmbeddingModel implements EmbeddingModelV1<string> {
 
 	get maxEmbeddingsPerCall(): number {
 		// https://developers.cloudflare.com/workers-ai/platform/limits/#text-embeddings
-		const maxEmbeddingsPerCall = this.modelId === "@cf/baai/bge-large-en-v1.5" ? 1500 : 3000;
+		const maxEmbeddingsPerCall = 3000;
 		return this.settings.maxEmbeddingsPerCall ?? maxEmbeddingsPerCall;
 	}
 
@@ -58,8 +58,8 @@ export class WorkersAIEmbeddingModel implements EmbeddingModelV1<string> {
 
 	async doEmbed({
 		values,
-	}: Parameters<EmbeddingModelV1<string>["doEmbed"]>[0]): Promise<
-		Awaited<ReturnType<EmbeddingModelV1<string>["doEmbed"]>>
+	}: Parameters<EmbeddingModelV2<string>["doEmbed"]>[0]): Promise<
+		Awaited<ReturnType<EmbeddingModelV2<string>["doEmbed"]>>
 	> {
 		if (values.length > this.maxEmbeddingsPerCall) {
 			throw new TooManyEmbeddingValuesForCallError({
@@ -74,15 +74,17 @@ export class WorkersAIEmbeddingModel implements EmbeddingModelV1<string> {
 
 		const response = await this.config.binding.run(
 			this.modelId,
-			// @ts-ignore: Error introduced with "@cloudflare/workers-types": "^4.20250617.0"
 			{
 				text: values,
 			},
-			{ gateway: this.config.gateway ?? gateway, ...passthroughOptions },
+			{
+				gateway: this.config.gateway ?? gateway,
+				...passthroughOptions,
+				tags: [],
+			},
 		);
 
 		return {
-			// @ts-ignore: Error introduced with "@cloudflare/workers-types": "^4.20250617.0"
 			embeddings: response.data,
 		};
 	}

package/src/workersai-chat-language-model.ts

@@ -1,9 +1,9 @@
-import {
-	type LanguageModelV1,
-	type LanguageModelV1CallWarning,
-	type LanguageModelV1StreamPart,
-	UnsupportedFunctionalityError,
+import type {
+	LanguageModelV2,
+	LanguageModelV2CallWarning,
+	LanguageModelV2StreamPart,
 } from "@ai-sdk/provider";
+import { generateId } from "ai";
 import { convertToWorkersAIChatMessages } from "./convert-to-workersai-chat-messages";
 import { mapWorkersAIFinishReason } from "./map-workersai-finish-reason";
 import { mapWorkersAIUsage } from "./map-workersai-usage";
@@ -23,10 +23,14 @@ type WorkersAIChatConfig = {
 	gateway?: GatewayOptions;
 };
 
-export class WorkersAIChatLanguageModel implements LanguageModelV1 {
-	readonly specificationVersion = "v1";
+export class WorkersAIChatLanguageModel implements LanguageModelV2 {
+	readonly specificationVersion = "v2";
 	readonly defaultObjectGenerationMode = "json";
 
+	readonly supportedUrls: Record<string, RegExp[]> | PromiseLike<Record<string, RegExp[]>> = {
+		// Empty
+	};
+
 	readonly modelId: TextGenerationModels;
 	readonly settings: WorkersAIChatSettings;
 
@@ -47,17 +51,19 @@ export class WorkersAIChatLanguageModel implements LanguageModelV1 {
 	}
 
 	private getArgs({
-		mode,
-		maxTokens,
+		responseFormat,
+		tools,
+		toolChoice,
+		maxOutputTokens,
 		temperature,
 		topP,
 		frequencyPenalty,
 		presencePenalty,
 		seed,
-	}: Parameters<LanguageModelV1["doGenerate"]>[0]) {
-		const type = mode.type;
+	}: Parameters<LanguageModelV2["doGenerate"]>[0]) {
+		const type = responseFormat?.type ?? "text";
 
-		const warnings: LanguageModelV1CallWarning[] = [];
+		const warnings: LanguageModelV2CallWarning[] = [];
 
 		if (frequencyPenalty != null) {
 			warnings.push({
@@ -75,7 +81,7 @@ export class WorkersAIChatLanguageModel implements LanguageModelV1 {
 
 		const baseArgs = {
 			// standardized settings:
-			max_tokens: maxTokens,
+			max_tokens: maxOutputTokens,
 			// model id:
 			model: this.modelId,
 			random_seed: seed,
@@ -87,19 +93,22 @@ export class WorkersAIChatLanguageModel implements LanguageModelV1 {
 		};
 
 		switch (type) {
-			case "regular": {
+			case "text": {
 				return {
-					args: { ...baseArgs, ...prepareToolsAndToolChoice(mode) },
+					args: {
+						...baseArgs,
+						...prepareToolsAndToolChoice(tools, toolChoice),
+					},
 					warnings,
 				};
 			}
 
-			case "object-json": {
+			case "json": {
 				return {
 					args: {
 						...baseArgs,
 						response_format: {
-							json_schema: mode.schema,
+							json_schema: responseFormat?.type === "json" && responseFormat.schema,
 							type: "json_schema",
 						},
 						tools: undefined,
@@ -108,25 +117,6 @@ export class WorkersAIChatLanguageModel implements LanguageModelV1 {
 				};
 			}
 
-			case "object-tool": {
-				return {
-					args: {
-						...baseArgs,
-						tool_choice: "any",
-						tools: [{ function: mode.tool, type: "function" }],
-					},
-					warnings,
-				};
-			}
-
-			// @ts-expect-error - this is unreachable code
-			// TODO: fixme
-			case "object-grammar": {
-				throw new UnsupportedFunctionalityError({
-					functionality: "object-grammar mode",
-				});
-			}
-
 			default: {
 				const exhaustiveCheck = type satisfies never;
 				throw new Error(`Unsupported type: ${exhaustiveCheck}`);
@@ -135,8 +125,8 @@ export class WorkersAIChatLanguageModel implements LanguageModelV1 {
 	}
 
 	async doGenerate(
-		options: Parameters<LanguageModelV1["doGenerate"]>[0],
-	): Promise<Awaited<ReturnType<LanguageModelV1["doGenerate"]>>> {
+		options: Parameters<LanguageModelV2["doGenerate"]>[0],
+	): Promise<Awaited<ReturnType<LanguageModelV2["doGenerate"]>>> {
 		const { args, warnings } = this.getArgs(options);
 
 		// biome-ignore lint/correctness/noUnusedVariables: this needs to be destructured
@@ -166,29 +156,51 @@ export class WorkersAIChatLanguageModel implements LanguageModelV1 {
 				// @ts-expect-error response_format not yet added to types
 				response_format: args.response_format,
 			},
-			{ gateway: this.config.gateway ?? gateway, ...passthroughOptions },
+			{
+				gateway: this.config.gateway ?? gateway,
+				...passthroughOptions,
+				tags: [],
+			},
 		);
 
 		if (output instanceof ReadableStream) {
 			throw new Error("This shouldn't happen");
 		}
 
+		const reasoningContent = (output as any)?.choices?.[0]?.message?.reasoning_content;
+
 		return {
 			finishReason: mapWorkersAIFinishReason(output),
-			rawCall: { rawPrompt: messages, rawSettings: args },
-			rawResponse: { body: output },
-			text: processText(output),
-			toolCalls: processToolCalls(output),
-			// @ts-ignore: Missing types
-			reasoning: output?.choices?.[0]?.message?.reasoning_content,
+			// TODO: rawCall and rawResponse- not sure
+			// rawCall: { rawPrompt: messages, rawSettings: args },
+			// rawResponse: { body: output },
+			// maybe this?
+			// providerMetadata: {
+			// 	prompt: messages,
+			// 	settings: args,
+			// 	response: output,
+			// },
+			content: [
+				...(reasoningContent
+					? [{ type: "reasoning" as const, text: reasoningContent }]
+					: []),
+				{
+					type: "text",
+					text: processText(output) ?? "",
+				},
+				...processToolCalls(output),
+			],
+
+			// @ts-expect-error: Missing types
+			reasoningText: reasoningContent,
 			usage: mapWorkersAIUsage(output),
 			warnings,
 		};
 	}
 
 	async doStream(
-		options: Parameters<LanguageModelV1["doStream"]>[0],
-	): Promise<Awaited<ReturnType<LanguageModelV1["doStream"]>>> {
+		options: Parameters<LanguageModelV2["doStream"]>[0],
+	): Promise<Awaited<ReturnType<LanguageModelV2["doStream"]>>> {
 		const { args, warnings } = this.getArgs(options);
 
 		// Extract image from messages if present
@@ -204,29 +216,57 @@ export class WorkersAIChatLanguageModel implements LanguageModelV1 {
 				throw new Error("This shouldn't happen");
 			}
 
+			// Track start/delta/end IDs per v5 streaming protocol
+			let textId: string | null = null;
+			let reasoningId: string | null = null;
+
 			return {
-				rawCall: { rawPrompt: messages, rawSettings: args },
-				stream: new ReadableStream<LanguageModelV1StreamPart>({
+				// rawCall: { rawPrompt: messages, rawSettings: args },
+				stream: new ReadableStream<LanguageModelV2StreamPart>({
 					async start(controller) {
-						if (response.text) {
-							controller.enqueue({
-								textDelta: response.text,
-								type: "text-delta",
-							});
-						}
-						if (response.toolCalls) {
-							for (const toolCall of response.toolCalls) {
+						// Emit the stream-start part with warnings
+						controller.enqueue({
+							type: "stream-start",
+							warnings: warnings as LanguageModelV2CallWarning[],
+						});
+
+						for (const contentPart of response.content) {
+							if (contentPart.type === "text") {
+								if (!textId) {
+									textId = generateId();
+									controller.enqueue({ type: "text-start", id: textId });
+								}
 								controller.enqueue({
-									type: "tool-call",
-									...toolCall,
+									delta: contentPart.text,
+									type: "text-delta",
+									id: textId,
 								});
 							}
+							if (contentPart.type === "tool-call") {
+								controller.enqueue(contentPart);
+							}
+							if (contentPart.type === "reasoning") {
+								if (!reasoningId) {
+									reasoningId = generateId();
+									controller.enqueue({
+										type: "reasoning-start",
+										id: reasoningId,
+									});
+								}
+								controller.enqueue({
+									type: "reasoning-delta",
+									delta: contentPart.text,
+									id: generateId(),
+								});
+							}
+						}
+						if (reasoningId) {
+							controller.enqueue({ type: "reasoning-end", id: reasoningId });
+							reasoningId = null;
 						}
-						if (response.reasoning && typeof response.reasoning === "string") {
-							controller.enqueue({
-								type: "reasoning",
-								textDelta: response.reasoning,
-							});
+						if (textId) {
+							controller.enqueue({ type: "text-end", id: textId });
+							textId = null;
 						}
 						controller.enqueue({
 							finishReason: mapWorkersAIFinishReason(response),
@@ -236,7 +276,6 @@ export class WorkersAIChatLanguageModel implements LanguageModelV1 {
 						controller.close();
 					},
 				}),
-				warnings,
 			};
 		}
 
@@ -265,17 +304,48 @@ export class WorkersAIChatLanguageModel implements LanguageModelV1 {
 				// @ts-expect-error response_format not yet added to types
 				response_format: args.response_format,
 			},
-			{ gateway: this.config.gateway ?? gateway, ...passthroughOptions },
+			{
+				gateway: this.config.gateway ?? gateway,
+				...passthroughOptions,
+				tags: [],
+			},
 		);
 
 		if (!(response instanceof ReadableStream)) {
 			throw new Error("This shouldn't happen");
 		}
 
+		// Create a new stream that first emits the stream-start part with warnings,
+		// then pipes through the rest of the response stream
+		const stream = new ReadableStream<LanguageModelV2StreamPart>({
+			start(controller) {
+				// Emit the stream-start part with warnings
+				controller.enqueue({
+					type: "stream-start",
+					warnings: warnings as LanguageModelV2CallWarning[],
+				});
+
+				// Pipe the rest of the response stream
+				const reader = getMappedStream(new Response(response)).getReader();
+
+				function push() {
+					reader.read().then(({ done, value }) => {
+						if (done) {
+							controller.close();
+							return;
+						}
+						controller.enqueue(value);
+						push();
+					});
+				}
+				push();
+			},
+		});
+
 		return {
-			rawCall: { rawPrompt: messages, rawSettings: args },
-			stream: getMappedStream(new Response(response)),
-			warnings,
+			stream,
+			// TODO: not sure about rawCalls
+			// rawCall: { rawPrompt: messages, rawSettings: args },
 		};
 	}
 }

package/src/workersai-error.ts

@@ -1,5 +1,5 @@
 import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
-import { z } from "zod";
+import { z } from "zod/v4";
 
 const workersAIErrorDataSchema = z.object({
 	code: z.string().nullable(),

package/src/workersai-image-model.ts

@@ -1,10 +1,10 @@
-import type { ImageModelV1, ImageModelV1CallWarning } from "@ai-sdk/provider";
+import type { ImageModelV2, ImageModelV2CallWarning } from "@ai-sdk/provider";
 import type { WorkersAIImageConfig } from "./workersai-image-config";
 import type { WorkersAIImageSettings } from "./workersai-image-settings";
 import type { ImageGenerationModels } from "./workersai-models";
 
-export class WorkersAIImageModel implements ImageModelV1 {
-	readonly specificationVersion = "v1";
+export class WorkersAIImageModel implements ImageModelV2 {
+	readonly specificationVersion = "v2";
 
 	get maxImagesPerCall(): number {
 		return this.settings.maxImagesPerCall ?? 1;
@@ -27,12 +27,12 @@ export class WorkersAIImageModel implements ImageModelV1 {
 		seed,
 		// headers,
 		// abortSignal,
-	}: Parameters<ImageModelV1["doGenerate"]>[0]): Promise<
-		Awaited<ReturnType<ImageModelV1["doGenerate"]>>
+	}: Parameters<ImageModelV2["doGenerate"]>[0]): Promise<
+		Awaited<ReturnType<ImageModelV2["doGenerate"]>>
 	> {
 		const { width, height } = getDimensionsFromSizeString(size);
 
-		const warnings: Array<ImageModelV1CallWarning> = [];
+		const warnings: Array<ImageModelV2CallWarning> = [];
 
 		if (aspectRatio != null) {
 			warnings.push({