workers-ai-provider 3.3.1 → 4.0.0

package/src/utils.ts

@@ -1,4 +1,4 @@
-import type { LanguageModelV3, LanguageModelV3ToolCall } from "@ai-sdk/provider";
+import type { LanguageModelV4, LanguageModelV4ToolCall } from "@ai-sdk/provider";
 import {
 	getToolNames,
 	isForcedToolChoice,
@@ -332,8 +332,8 @@ export function buildJsonSchemaPayload(
 // ---------------------------------------------------------------------------
 
 export function prepareToolsAndToolChoice(
-	tools: Parameters<LanguageModelV3["doGenerate"]>[0]["tools"],
-	toolChoice: Parameters<LanguageModelV3["doGenerate"]>[0]["toolChoice"],
+	tools: Parameters<LanguageModelV4["doGenerate"]>[0]["tools"],
+	toolChoice: Parameters<LanguageModelV4["doGenerate"]>[0]["toolChoice"],
 ) {
 	if (tools == null) {
 		return { tool_choice: undefined, tools: undefined };
@@ -476,7 +476,7 @@ function mergePartialToolCalls(partialCalls: PartialToolCall[]) {
 	return Object.values(mergedCallsByIndex);
 }
 
-function processToolCall(toolCall: FlatToolCall | OpenAIToolCall): LanguageModelV3ToolCall {
+function processToolCall(toolCall: FlatToolCall | OpenAIToolCall): LanguageModelV4ToolCall {
 	// OpenAI format: has function.name (the key discriminator)
 	const fn =
 		"function" in toolCall && typeof toolCall.function === "object" && toolCall.function
@@ -508,7 +508,7 @@ function processToolCall(toolCall: FlatToolCall | OpenAIToolCall): LanguageModel
 	};
 }
 
-export function processToolCalls(output: Record<string, unknown>): LanguageModelV3ToolCall[] {
+export function processToolCalls(output: Record<string, unknown>): LanguageModelV4ToolCall[] {
 	if (output.tool_calls && Array.isArray(output.tool_calls)) {
 		return output.tool_calls.map((toolCall: FlatToolCall | OpenAIToolCall) =>
 			processToolCall(toolCall),
@@ -540,12 +540,12 @@ export function processPartialToolCalls(partialToolCalls: PartialToolCall[]) {
  *
  * The recovery logic (which JSON shapes count as a leaked call) lives in
  * `@cloudflare/gateway-core`; this wrapper only layers the framework id on each
- * neutral result so the existing `LanguageModelV3ToolCall` shape is preserved.
+ * neutral result so the existing `LanguageModelV4ToolCall` shape is preserved.
  */
 export function parseLeakedToolCalls(
 	text: string,
 	knownToolNames: Set<string>,
-): LanguageModelV3ToolCall[] {
+): LanguageModelV4ToolCall[] {
 	return coreParseLeakedToolCalls(text, knownToolNames).map((call) => ({
 		input: call.input,
 		toolCallId: createAISDKToolCallId(undefined),
@@ -584,7 +584,7 @@ export function salvageToolCallsFromText(
 		tools: Array<{ function: { name?: string } }> | undefined;
 		toolChoice: unknown;
 	},
-): LanguageModelV3ToolCall[] | null {
+): LanguageModelV4ToolCall[] | null {
 	if (!isForcedToolChoice(context.toolChoice)) return null;
 
 	// Never override real tool calls.

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

@@ -1,4 +1,4 @@
-import type { LanguageModelV3, SharedV3Warning, LanguageModelV3StreamPart } from "@ai-sdk/provider";
+import type { LanguageModelV4, SharedV4Warning, LanguageModelV4StreamPart } from "@ai-sdk/provider";
 import { generateId } from "ai";
 import { convertToWorkersAIChatMessages } from "./convert-to-workersai-chat-messages";
 import { mapWorkersAIFinishReason } from "./map-workersai-finish-reason";
@@ -24,8 +24,33 @@ type WorkersAIChatConfig = {
 	isBinding: boolean;
 };
 
-export class WorkersAIChatLanguageModel implements LanguageModelV3 {
-	readonly specificationVersion = "v3";
+/**
+ * Map the unified `reasoning` call option (spec v4) to Workers AI's
+ * `reasoning_effort`. Workers AI accepts "low" | "medium" | "high" | null
+ * (null disables reasoning), so `minimal` and `xhigh` are clamped to the
+ * nearest supported effort. `provider-default` (and absence) returns
+ * undefined so the settings-level `reasoning_effort` still applies.
+ */
+function mapUnifiedReasoningEffort(
+	reasoning: Parameters<LanguageModelV4["doGenerate"]>[0]["reasoning"],
+): "low" | "medium" | "high" | null | undefined {
+	switch (reasoning) {
+		case undefined:
+		case "provider-default":
+			return undefined;
+		case "none":
+			return null;
+		case "minimal":
+			return "low";
+		case "xhigh":
+			return "high";
+		default:
+			return reasoning;
+	}
+}
+
+export class WorkersAIChatLanguageModel implements LanguageModelV4 {
+	readonly specificationVersion = "v4";
 	readonly defaultObjectGenerationMode = "json";
 
 	readonly supportedUrls: Record<string, RegExp[]> | PromiseLike<Record<string, RegExp[]>> = {};
@@ -59,10 +84,11 @@ export class WorkersAIChatLanguageModel implements LanguageModelV3 {
 		frequencyPenalty,
 		presencePenalty,
 		seed,
-	}: Parameters<LanguageModelV3["doGenerate"]>[0]) {
+		reasoning,
+	}: Parameters<LanguageModelV4["doGenerate"]>[0]) {
 		const type = responseFormat?.type ?? "text";
 
-		const warnings: SharedV3Warning[] = [];
+		const warnings: SharedV4Warning[] = [];
 
 		if (frequencyPenalty != null) {
 			warnings.push({ feature: "frequencyPenalty", type: "unsupported" });
@@ -72,6 +98,16 @@ export class WorkersAIChatLanguageModel implements LanguageModelV3 {
 			warnings.push({ feature: "presencePenalty", type: "unsupported" });
 		}
 
+		if (reasoning === "minimal" || reasoning === "xhigh") {
+			warnings.push({
+				type: "compatibility",
+				feature: "reasoning",
+				details:
+					`Workers AI supports reasoning_effort "low" | "medium" | "high"; ` +
+					`"${reasoning}" was mapped to "${reasoning === "minimal" ? "low" : "high"}".`,
+			});
+		}
+
 		const baseArgs = {
 			max_tokens: maxOutputTokens,
 			model: this.modelId,
@@ -145,11 +181,20 @@ export class WorkersAIChatLanguageModel implements LanguageModelV3 {
 	 *
 	 * `reasoning_effort: null` is a valid value ("disable reasoning"), so we
 	 * check `!== undefined` rather than truthiness.
+	 *
+	 * The unified `reasoning` call option (spec v4) is mapped onto
+	 * `reasoning_effort` between the two: an explicit per-call
+	 * `providerOptions["workers-ai"].reasoning_effort` wins, then the unified
+	 * option, then settings.
 	 */
 	private buildRunInputs(
 		args: ReturnType<typeof this.getArgs>["args"],
 		messages: ReturnType<typeof convertToWorkersAIChatMessages>["messages"],
-		options?: { stream?: boolean; providerOptions?: Record<string, unknown> },
+		options?: {
+			stream?: boolean;
+			providerOptions?: Record<string, unknown>;
+			reasoning?: Parameters<LanguageModelV4["doGenerate"]>[0]["reasoning"];
+		},
 	) {
 		// The AI SDK types this as `Record<string, JSONObject>` but we defensively
 		// accept anything and only treat it as a lookup if it's a plain object.
@@ -159,10 +204,13 @@ export class WorkersAIChatLanguageModel implements LanguageModelV3 {
 			rawPerCall !== null && typeof rawPerCall === "object" && !Array.isArray(rawPerCall)
 				? (rawPerCall as Record<string, unknown>)
 				: {};
+		const unifiedReasoningEffort = mapUnifiedReasoningEffort(options?.reasoning);
 		const reasoningEffort =
 			"reasoning_effort" in perCall
 				? perCall.reasoning_effort
-				: this.settings.reasoning_effort;
+				: unifiedReasoningEffort !== undefined
+					? unifiedReasoningEffort
+					: this.settings.reasoning_effort;
 		const chatTemplateKwargs =
 			"chat_template_kwargs" in perCall
 				? perCall.chat_template_kwargs
@@ -229,7 +277,7 @@ export class WorkersAIChatLanguageModel implements LanguageModelV3 {
 	private extractContent(
 		outputRecord: Record<string, unknown>,
 		args: ReturnType<typeof this.getArgs>["args"],
-		warnings: SharedV3Warning[],
+		warnings: SharedV4Warning[],
 	) {
 		const choices = outputRecord.choices as
 			| Array<{ message?: { reasoning_content?: string; reasoning?: string } }>
@@ -268,13 +316,14 @@ export class WorkersAIChatLanguageModel implements LanguageModelV3 {
 	}
 
 	async doGenerate(
-		options: Parameters<LanguageModelV3["doGenerate"]>[0],
-	): Promise<Awaited<ReturnType<LanguageModelV3["doGenerate"]>>> {
+		options: Parameters<LanguageModelV4["doGenerate"]>[0],
+	): Promise<Awaited<ReturnType<LanguageModelV4["doGenerate"]>>> {
 		const { args, warnings } = this.getArgs(options);
 		const { messages } = convertToWorkersAIChatMessages(options.prompt);
 
 		const inputs = this.buildRunInputs(args, messages, {
 			providerOptions: options.providerOptions,
+			reasoning: options.reasoning,
 		});
 		const runOptions = this.getRunOptions();
 
@@ -325,14 +374,15 @@ export class WorkersAIChatLanguageModel implements LanguageModelV3 {
 	}
 
 	async doStream(
-		options: Parameters<LanguageModelV3["doStream"]>[0],
-	): Promise<Awaited<ReturnType<LanguageModelV3["doStream"]>>> {
+		options: Parameters<LanguageModelV4["doStream"]>[0],
+	): Promise<Awaited<ReturnType<LanguageModelV4["doStream"]>>> {
 		const { args, warnings } = this.getArgs(options);
 		const { messages } = convertToWorkersAIChatMessages(options.prompt);
 
 		const inputs = this.buildRunInputs(args, messages, {
 			stream: true,
 			providerOptions: options.providerOptions,
+			reasoning: options.reasoning,
 		});
 		const runOptions = this.getRunOptions();
 
@@ -381,11 +431,11 @@ export class WorkersAIChatLanguageModel implements LanguageModelV3 {
 		let reasoningId: string | null = null;
 
 		return {
-			stream: new ReadableStream<LanguageModelV3StreamPart>({
+			stream: new ReadableStream<LanguageModelV4StreamPart>({
 				start(controller) {
 					controller.enqueue({
 						type: "stream-start",
-						warnings: warnings as SharedV3Warning[],
+						warnings: warnings as SharedV4Warning[],
 					});
 
 					if (reasoningContent) {

package/src/workersai-embedding-model.ts

@@ -1,7 +1,7 @@
 import type {
-	EmbeddingModelV3,
-	EmbeddingModelV3CallOptions,
-	EmbeddingModelV3Result,
+	EmbeddingModelV4,
+	EmbeddingModelV4CallOptions,
+	EmbeddingModelV4Result,
 } from "@ai-sdk/provider";
 import { TooManyEmbeddingValuesForCallError } from "@ai-sdk/provider";
 import { normalizeBindingError } from "./workersai-error";
@@ -24,8 +24,8 @@ export type WorkersAIEmbeddingSettings = {
 	[key: string]: unknown;
 };
 
-export class WorkersAIEmbeddingModel implements EmbeddingModelV3 {
-	readonly specificationVersion = "v3";
+export class WorkersAIEmbeddingModel implements EmbeddingModelV4 {
+	readonly specificationVersion = "v4";
 	readonly modelId: EmbeddingModels;
 	private readonly config: WorkersAIEmbeddingConfig;
 	private readonly settings: WorkersAIEmbeddingSettings;
@@ -56,7 +56,7 @@ export class WorkersAIEmbeddingModel implements EmbeddingModelV3 {
 	async doEmbed({
 		values,
 		abortSignal,
-	}: EmbeddingModelV3CallOptions): Promise<EmbeddingModelV3Result> {
+	}: EmbeddingModelV4CallOptions): Promise<EmbeddingModelV4Result> {
 		if (values.length > this.maxEmbeddingsPerCall) {
 			throw new TooManyEmbeddingValuesForCallError({
 				maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,

package/src/workersai-image-model.ts

@@ -1,4 +1,4 @@
-import type { ImageModelV3, SharedV3Warning } from "@ai-sdk/provider";
+import type { ImageModelV4, SharedV4Warning } from "@ai-sdk/provider";
 import { normalizeBindingError } from "./workersai-error";
 import type { WorkersAIImageSettings } from "./workersai-image-settings";
 import type { ImageGenerationModels } from "./workersai-models";
@@ -9,8 +9,8 @@ export type WorkersAIImageConfig = {
 	gateway?: GatewayOptions;
 };
 
-export class WorkersAIImageModel implements ImageModelV3 {
-	readonly specificationVersion = "v3";
+export class WorkersAIImageModel implements ImageModelV4 {
+	readonly specificationVersion = "v4";
 
 	get maxImagesPerCall(): number {
 		return this.settings.maxImagesPerCall ?? 1;
@@ -33,12 +33,12 @@ export class WorkersAIImageModel implements ImageModelV3 {
 		aspectRatio,
 		seed,
 		abortSignal,
-	}: Parameters<ImageModelV3["doGenerate"]>[0]): Promise<
-		Awaited<ReturnType<ImageModelV3["doGenerate"]>>
+	}: Parameters<ImageModelV4["doGenerate"]>[0]): Promise<
+		Awaited<ReturnType<ImageModelV4["doGenerate"]>>
 	> {
 		const { width, height } = getDimensionsFromSizeString(size);
 
-		const warnings: Array<SharedV3Warning> = [];
+		const warnings: Array<SharedV4Warning> = [];
 
 		if (aspectRatio != null) {
 			warnings.push({

package/src/workersai-reranking-model.ts

@@ -1,4 +1,4 @@
-import type { RerankingModelV3, SharedV3Warning } from "@ai-sdk/provider";
+import type { RerankingModelV4, SharedV4Warning } from "@ai-sdk/provider";
 import { normalizeBindingError } from "./workersai-error";
 import type { WorkersAIRerankingSettings } from "./workersai-reranking-settings";
 import type { RerankingModels } from "./workersai-models";
@@ -10,7 +10,7 @@ export type WorkersAIRerankingConfig = {
 };
 
 /**
- * Workers AI reranking model implementing the AI SDK's `RerankingModelV3` interface.
+ * Workers AI reranking model implementing the AI SDK's `RerankingModelV4` interface.
  *
  * Supports BGE reranker models (`@cf/baai/bge-reranker-base`, `bge-reranker-v2-m3`).
  *
@@ -18,8 +18,8 @@ export type WorkersAIRerankingConfig = {
  * - Input: `{ query, contexts: [{ text }], top_k? }`
  * - Output: `{ response: [{ id, score }] }`
  */
-export class WorkersAIRerankingModel implements RerankingModelV3 {
-	readonly specificationVersion = "v3";
+export class WorkersAIRerankingModel implements RerankingModelV4 {
+	readonly specificationVersion = "v4";
 
 	get provider(): string {
 		return this.config.provider;
@@ -32,11 +32,11 @@ export class WorkersAIRerankingModel implements RerankingModelV3 {
 	) {}
 
 	async doRerank(
-		options: Parameters<RerankingModelV3["doRerank"]>[0],
-	): Promise<Awaited<ReturnType<RerankingModelV3["doRerank"]>>> {
+		options: Parameters<RerankingModelV4["doRerank"]>[0],
+	): Promise<Awaited<ReturnType<RerankingModelV4["doRerank"]>>> {
 		const { documents, query, topN, abortSignal } = options;
 
-		const warnings: Array<SharedV3Warning> = [];
+		const warnings: Array<SharedV4Warning> = [];
 
 		// Convert AI SDK documents to Workers AI contexts format
 		const contexts = documentsToContexts(documents, warnings);
@@ -100,8 +100,8 @@ export class WorkersAIRerankingModel implements RerankingModelV3 {
  * - `{ type: 'object', values: JSONObject[] }` — JSON objects (stringified for Workers AI)
  */
 function documentsToContexts(
-	documents: Parameters<RerankingModelV3["doRerank"]>[0]["documents"],
-	warnings: Array<SharedV3Warning>,
+	documents: Parameters<RerankingModelV4["doRerank"]>[0]["documents"],
+	warnings: Array<SharedV4Warning>,
 ): Array<{ text: string }> {
 	if (documents.type === "text") {
 		return documents.values.map((text) => ({ text }));

package/src/workersai-speech-model.ts

@@ -1,4 +1,4 @@
-import type { SpeechModelV3, SharedV3Warning } from "@ai-sdk/provider";
+import type { SpeechModelV4, SharedV4Warning } from "@ai-sdk/provider";
 import { apiCallErrorFromResponse, normalizeBindingError } from "./workersai-error";
 import type { WorkersAISpeechSettings } from "./workersai-speech-settings";
 import type { SpeechModels } from "./workersai-models";
@@ -10,13 +10,13 @@ export type WorkersAISpeechConfig = {
 };
 
 /**
- * Workers AI speech (text-to-speech) model implementing the AI SDK's `SpeechModelV3` interface.
+ * Workers AI speech (text-to-speech) model implementing the AI SDK's `SpeechModelV4` interface.
  *
  * Currently supports Deepgram Aura-1 (`@cf/deepgram/aura-1`).
  * The model accepts `{ text, voice?, speed? }` and returns raw audio bytes.
  */
-export class WorkersAISpeechModel implements SpeechModelV3 {
-	readonly specificationVersion = "v3";
+export class WorkersAISpeechModel implements SpeechModelV4 {
+	readonly specificationVersion = "v4";
 
 	get provider(): string {
 		return this.config.provider;
@@ -29,11 +29,11 @@ export class WorkersAISpeechModel implements SpeechModelV3 {
 	) {}
 
 	async doGenerate(
-		options: Parameters<SpeechModelV3["doGenerate"]>[0],
-	): Promise<Awaited<ReturnType<SpeechModelV3["doGenerate"]>>> {
+		options: Parameters<SpeechModelV4["doGenerate"]>[0],
+	): Promise<Awaited<ReturnType<SpeechModelV4["doGenerate"]>>> {
 		const { text, voice, speed, abortSignal } = options;
 
-		const warnings: Array<SharedV3Warning> = [];
+		const warnings: Array<SharedV4Warning> = [];
 
 		if (options.instructions) {
 			warnings.push({

package/src/workersai-transcription-model.ts

@@ -1,4 +1,4 @@
-import type { TranscriptionModelV3, SharedV3Warning } from "@ai-sdk/provider";
+import type { TranscriptionModelV4, SharedV4Warning } from "@ai-sdk/provider";
 import type { WorkersAITranscriptionSettings } from "./workersai-transcription-settings";
 import type { TranscriptionModels } from "./workersai-models";
 import { createRunBinary, type CreateRunConfig } from "./utils";
@@ -21,14 +21,14 @@ export type WorkersAITranscriptionConfig = {
 };
 
 /**
- * Workers AI transcription model implementing the AI SDK's `TranscriptionModelV3` interface.
+ * Workers AI transcription model implementing the AI SDK's `TranscriptionModelV4` interface.
  *
  * Supports:
  * - Whisper models (`@cf/openai/whisper`, `whisper-tiny-en`, `whisper-large-v3-turbo`)
  * - Deepgram Nova-3 (`@cf/deepgram/nova-3`) — uses a different input/output format
  */
-export class WorkersAITranscriptionModel implements TranscriptionModelV3 {
-	readonly specificationVersion = "v3";
+export class WorkersAITranscriptionModel implements TranscriptionModelV4 {
+	readonly specificationVersion = "v4";
 
 	get provider(): string {
 		return this.config.provider;
@@ -41,11 +41,11 @@ export class WorkersAITranscriptionModel implements TranscriptionModelV3 {
 	) {}
 
 	async doGenerate(
-		options: Parameters<TranscriptionModelV3["doGenerate"]>[0],
-	): Promise<Awaited<ReturnType<TranscriptionModelV3["doGenerate"]>>> {
+		options: Parameters<TranscriptionModelV4["doGenerate"]>[0],
+	): Promise<Awaited<ReturnType<TranscriptionModelV4["doGenerate"]>>> {
 		const { audio, mediaType, abortSignal } = options;
 
-		const warnings: Array<SharedV3Warning> = [];
+		const warnings: Array<SharedV4Warning> = [];
 
 		// The AI SDK always converts audio to Uint8Array via
 		// convertDataContentToUint8Array before calling doGenerate.
@@ -114,8 +114,8 @@ export class WorkersAITranscriptionModel implements TranscriptionModelV3 {
 
 	private normalizeWhisperResponse(
 		raw: Record<string, unknown>,
-		warnings: Array<SharedV3Warning>,
-	): Awaited<ReturnType<TranscriptionModelV3["doGenerate"]>> {
+		warnings: Array<SharedV4Warning>,
+	): Awaited<ReturnType<TranscriptionModelV4["doGenerate"]>> {
 		const text = (raw.text as string) ?? "";
 
 		// Build segments from Whisper's various formats
@@ -199,8 +199,8 @@ export class WorkersAITranscriptionModel implements TranscriptionModelV3 {
 
 	private normalizeNova3Response(
 		raw: Record<string, unknown>,
-		warnings: Array<SharedV3Warning>,
-	): Awaited<ReturnType<TranscriptionModelV3["doGenerate"]>> {
+		warnings: Array<SharedV4Warning>,
+	): Awaited<ReturnType<TranscriptionModelV4["doGenerate"]>> {
 		// Nova-3 format: { results: { channels: [{ alternatives: [{ transcript, words }] }] } }
 		const results = raw.results as Record<string, unknown> | undefined;
 		const channels = results?.channels as