workers-ai-provider 0.6.3 → 0.7.0

package/src/utils.ts

@@ -66,6 +66,7 @@ export function createRun(config: CreateRunConfig): AiRun {
 		inputs: AiModels[Name]["inputs"],
 		options?: AiOptions & Record<string, StringLike>,
 	): Promise<Response | ReadableStream<Uint8Array> | AiModels[Name]["postProcessedOutputs"]> {
+		// biome-ignore lint/correctness/noUnusedVariables: they need to be destructured
 		const { gateway, prefix, extraHeaders, returnRawResponse, ...passthroughOptions } =
 			options || {};
 
@@ -78,7 +79,7 @@ export function createRun(config: CreateRunConfig): AiRun {
 					continue;
 				}
 				urlParams.append(key, valueStr);
-			} catch (error) {
+			} catch (_error) {
 				throw new Error(
 					`Value for option '${key}' is not able to be coerced into a string.`,
 				);
@@ -91,17 +92,17 @@ export function createRun(config: CreateRunConfig): AiRun {
 
 		// Merge default and custom headers.
 		const headers = {
-			"Content-Type": "application/json",
 			Authorization: `Bearer ${apiKey}`,
+			"Content-Type": "application/json",
 		};
 
 		const body = JSON.stringify(inputs);
 
 		// Execute the POST request. The optional AbortSignal is applied here.
 		const response = await fetch(url, {
-			method: "POST",
-			headers,
 			body,
+			headers,
+			method: "POST",
 		});
 
 		// (1) If the user explicitly requests the raw Response, return it as-is.
@@ -134,42 +135,42 @@ export function prepareToolsAndToolChoice(
 	const tools = mode.tools?.length ? mode.tools : undefined;
 
 	if (tools == null) {
-		return { tools: undefined, tool_choice: undefined };
+		return { tool_choice: undefined, tools: undefined };
 	}
 
 	const mappedTools = tools.map((tool) => ({
-		type: "function",
 		function: {
-			name: tool.name,
 			// @ts-expect-error - description is not a property of tool
 			description: tool.description,
+			name: tool.name,
 			// @ts-expect-error - parameters is not a property of tool
 			parameters: tool.parameters,
 		},
+		type: "function",
 	}));
 
 	const toolChoice = mode.toolChoice;
 
 	if (toolChoice == null) {
-		return { tools: mappedTools, tool_choice: undefined };
+		return { tool_choice: undefined, tools: mappedTools };
 	}
 
 	const type = toolChoice.type;
 
 	switch (type) {
 		case "auto":
-			return { tools: mappedTools, tool_choice: type };
+			return { tool_choice: type, tools: mappedTools };
 		case "none":
-			return { tools: mappedTools, tool_choice: type };
+			return { tool_choice: type, tools: mappedTools };
 		case "required":
-			return { tools: mappedTools, tool_choice: "any" };
+			return { tool_choice: "any", tools: mappedTools };
 
 		// workersAI does not support tool mode directly,
 		// so we filter the tools and force the tool choice through 'any'
 		case "tool":
 			return {
-				tools: mappedTools.filter((tool) => tool.function.name === toolChoice.toolName),
 				tool_choice: "any",
+				tools: mappedTools.filter((tool) => tool.function.name === toolChoice.toolName),
 			};
 		default: {
 			const exhaustiveCheck = type satisfies never;
@@ -190,12 +191,12 @@ function mergePartialToolCalls(partialCalls: any[]) {
 
 		if (!mergedCallsByIndex[index]) {
 			mergedCallsByIndex[index] = {
-				id: partialCall.id || "",
-				type: partialCall.type || "",
 				function: {
-					name: partialCall.function?.name || "",
 					arguments: "",
+					name: partialCall.function?.name || "",
 				},
+				id: partialCall.id || "",
+				type: partialCall.type || "",
 			};
 		} else {
 			if (partialCall.id) {
@@ -223,23 +224,23 @@ function processToolCall(toolCall: any): LanguageModelV1FunctionToolCall {
 	// Check for OpenAI format tool calls first
 	if (toolCall.function && toolCall.id) {
 		return {
-			toolCallType: "function",
-			toolCallId: toolCall.id,
-			toolName: toolCall.function.name,
 			args:
 				typeof toolCall.function.arguments === "string"
 					? toolCall.function.arguments
 					: JSON.stringify(toolCall.function.arguments || {}),
+			toolCallId: toolCall.id,
+			toolCallType: "function",
+			toolName: toolCall.function.name,
 		};
 	}
 	return {
-		toolCallType: "function",
-		toolCallId: toolCall.name,
-		toolName: toolCall.name,
 		args:
 			typeof toolCall.arguments === "string"
 				? toolCall.arguments
 				: JSON.stringify(toolCall.arguments || {}),
+		toolCallId: toolCall.name,
+		toolCallType: "function",
+		toolName: toolCall.name,
 	};
 }
 
@@ -251,6 +252,16 @@ export function processToolCalls(output: any): LanguageModelV1FunctionToolCall[]
 		});
 	}
 
+	if (
+		output?.choices?.[0]?.message?.tool_calls &&
+		Array.isArray(output.choices[0].message.tool_calls)
+	) {
+		return output.choices[0].message.tool_calls.map((toolCall: any) => {
+			const processedToolCall = processToolCall(toolCall);
+			return processedToolCall;
+		});
+	}
+
 	return [];
 }
 

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

@@ -1,4 +1,4 @@
-import { TooManyEmbeddingValuesForCallError, type EmbeddingModelV1 } from "@ai-sdk/provider";
+import { type EmbeddingModelV1, TooManyEmbeddingValuesForCallError } from "@ai-sdk/provider";
 import type { StringLike } from "./utils";
 import type { EmbeddingModels } from "./workersai-models";
 
@@ -63,9 +63,9 @@ export class WorkersAIEmbeddingModel implements EmbeddingModelV1<string> {
 	> {
 		if (values.length > this.maxEmbeddingsPerCall) {
 			throw new TooManyEmbeddingValuesForCallError({
-				provider: this.provider,
-				modelId: this.modelId,
 				maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+				modelId: this.modelId,
+				provider: this.provider,
 				values,
 			});
 		}

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

@@ -5,13 +5,12 @@ import {
 	UnsupportedFunctionalityError,
 } from "@ai-sdk/provider";
 import { convertToWorkersAIChatMessages } from "./convert-to-workersai-chat-messages";
-import type { WorkersAIChatSettings } from "./workersai-chat-settings";
-import type { TextGenerationModels } from "./workersai-models";
-
+import { mapWorkersAIFinishReason } from "./map-workersai-finish-reason";
 import { mapWorkersAIUsage } from "./map-workersai-usage";
 import { getMappedStream } from "./streaming";
 import { lastMessageWasUser, prepareToolsAndToolChoice, processToolCalls } from "./utils";
-import { mapWorkersAIFinishReason } from "./map-workersai-finish-reason";
+import type { WorkersAIChatSettings } from "./workersai-chat-settings";
+import type { TextGenerationModels } from "./workersai-models";
 
 type WorkersAIChatConfig = {
 	provider: string;
@@ -57,30 +56,29 @@ export class WorkersAIChatLanguageModel implements LanguageModelV1 {
 
 		if (frequencyPenalty != null) {
 			warnings.push({
-				type: "unsupported-setting",
 				setting: "frequencyPenalty",
+				type: "unsupported-setting",
 			});
 		}
 
 		if (presencePenalty != null) {
 			warnings.push({
-				type: "unsupported-setting",
 				setting: "presencePenalty",
+				type: "unsupported-setting",
 			});
 		}
 
 		const baseArgs = {
+			// standardized settings:
+			max_tokens: maxTokens,
 			// model id:
 			model: this.modelId,
+			random_seed: seed,
 
 			// model specific settings:
 			safe_prompt: this.settings.safePrompt,
-
-			// standardized settings:
-			max_tokens: maxTokens,
 			temperature,
 			top_p: topP,
-			random_seed: seed,
 		};
 
 		switch (type) {
@@ -96,8 +94,8 @@ export class WorkersAIChatLanguageModel implements LanguageModelV1 {
 					args: {
 						...baseArgs,
 						response_format: {
-							type: "json_schema",
 							json_schema: mode.schema,
+							type: "json_schema",
 						},
 						tools: undefined,
 					},
@@ -110,7 +108,7 @@ export class WorkersAIChatLanguageModel implements LanguageModelV1 {
 					args: {
 						...baseArgs,
 						tool_choice: "any",
-						tools: [{ type: "function", function: mode.tool }],
+						tools: [{ function: mode.tool, type: "function" }],
 					},
 					warnings,
 				};
@@ -136,6 +134,7 @@ export class WorkersAIChatLanguageModel implements LanguageModelV1 {
 	): Promise<Awaited<ReturnType<LanguageModelV1["doGenerate"]>>> {
 		const { args, warnings } = this.getArgs(options);
 
+		// biome-ignore lint/correctness/noUnusedVariables: this needs to be destructured
 		const { gateway, safePrompt, ...passthroughOptions } = this.settings;
 
 		// Extract image from messages if present
@@ -151,8 +150,8 @@ export class WorkersAIChatLanguageModel implements LanguageModelV1 {
 		const output = await this.config.binding.run(
 			args.model,
 			{
-				messages: messages,
 				max_tokens: args.max_tokens,
+				messages: messages,
 				temperature: args.temperature,
 				tools: args.tools,
 				top_p: args.top_p,
@@ -170,14 +169,16 @@ export class WorkersAIChatLanguageModel implements LanguageModelV1 {
 		}
 
 		return {
+			finishReason: mapWorkersAIFinishReason(output),
+			rawCall: { rawPrompt: messages, rawSettings: args },
+			rawResponse: { body: output },
 			text:
 				typeof output.response === "object" && output.response !== null
 					? JSON.stringify(output.response) // ai-sdk expects a string here
 					: output.response,
 			toolCalls: processToolCalls(output),
-			finishReason: mapWorkersAIFinishReason(output),
-			rawCall: { rawPrompt: messages, rawSettings: args },
-			rawResponse: { body: output },
+			// @ts-ignore: Missing types
+			reasoning: output?.choices?.[0]?.message?.reasoning_content,
 			usage: mapWorkersAIUsage(output),
 			warnings,
 		};
@@ -202,12 +203,13 @@ export class WorkersAIChatLanguageModel implements LanguageModelV1 {
 			}
 
 			return {
+				rawCall: { rawPrompt: messages, rawSettings: args },
 				stream: new ReadableStream<LanguageModelV1StreamPart>({
 					async start(controller) {
 						if (response.text) {
 							controller.enqueue({
-								type: "text-delta",
 								textDelta: response.text,
+								type: "text-delta",
 							});
 						}
 						if (response.toolCalls) {
@@ -218,15 +220,20 @@ export class WorkersAIChatLanguageModel implements LanguageModelV1 {
 								});
 							}
 						}
+						if (response.reasoning && typeof response.reasoning === "string") {
+							controller.enqueue({
+								type: "reasoning",
+								textDelta: response.reasoning,
+							});
+						}
 						controller.enqueue({
-							type: "finish",
 							finishReason: mapWorkersAIFinishReason(response),
+							type: "finish",
 							usage: response.usage,
 						});
 						controller.close();
 					},
 				}),
-				rawCall: { rawPrompt: messages, rawSettings: args },
 				warnings,
 			};
 		}
@@ -244,8 +251,8 @@ export class WorkersAIChatLanguageModel implements LanguageModelV1 {
 		const response = await this.config.binding.run(
 			args.model,
 			{
-				messages: messages,
 				max_tokens: args.max_tokens,
+				messages: messages,
 				stream: true,
 				temperature: args.temperature,
 				tools: args.tools,
@@ -264,8 +271,8 @@ export class WorkersAIChatLanguageModel implements LanguageModelV1 {
 		}
 
 		return {
-			stream: getMappedStream(new Response(response)),
 			rawCall: { rawPrompt: messages, rawSettings: args },
+			stream: getMappedStream(new Response(response)),
 			warnings,
 		};
 	}

package/src/workersai-chat-settings.ts

@@ -9,7 +9,6 @@ export type WorkersAIChatSettings = {
 
 	/**
 	 * Optionally set Cloudflare AI Gateway options.
-	 * @deprecated
 	 */
 	gateway?: GatewayOptions;
 } & {

package/src/workersai-error.ts

@@ -2,11 +2,11 @@ import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
 import { z } from "zod";
 
 const workersAIErrorDataSchema = z.object({
-	object: z.literal("error"),
+	code: z.string().nullable(),
 	message: z.string(),
-	type: z.string(),
+	object: z.literal("error"),
 	param: z.string().nullable(),
-	code: z.string().nullable(),
+	type: z.string(),
 });
 
 export const workersAIFailedResponseHandler = createJsonErrorResponseHandler({

package/src/workersai-image-model.ts

@@ -36,9 +36,9 @@ export class WorkersAIImageModel implements ImageModelV1 {
 
 		if (aspectRatio != null) {
 			warnings.push({
-				type: "unsupported-setting",
-				setting: "aspectRatio",
 				details: "This model does not support aspect ratio. Use `size` instead.",
+				setting: "aspectRatio",
+				type: "unsupported-setting",
 			});
 		}
 
@@ -46,10 +46,10 @@ export class WorkersAIImageModel implements ImageModelV1 {
 			const outputStream: ReadableStream<Uint8Array> = await this.config.binding.run(
 				this.modelId,
 				{
+					height,
 					prompt,
 					seed,
 					width,
-					height,
 				},
 			);
 
@@ -65,12 +65,12 @@ export class WorkersAIImageModel implements ImageModelV1 {
 
 		return {
 			images,
-			warnings,
 			response: {
-				timestamp: new Date(),
-				modelId: this.modelId,
 				headers: {},
+				modelId: this.modelId,
+				timestamp: new Date(),
 			},
+			warnings,
 		};
 	}
 }
@@ -79,8 +79,8 @@ function getDimensionsFromSizeString(size: string | undefined) {
 	const [width, height] = size?.split("x") ?? [undefined, undefined];
 
 	return {
-		width: parseInteger(width),
 		height: parseInteger(height),
+		width: parseInteger(width),
 	};
 }