workers-ai-provider 0.7.5 → 2.0.1

package/dist/token-4SRL5WJU.js

@@ -0,0 +1,63 @@
+import {
+  require_token_error,
+  require_token_util
+} from "./chunk-H3ZBSMAH.js";
+import {
+  __commonJS
+} from "./chunk-LOLDRYLH.js";
+
+// ../../node_modules/.pnpm/@vercel+oidc@3.0.5/node_modules/@vercel/oidc/dist/token.js
+var require_token = __commonJS({
+  "../../node_modules/.pnpm/@vercel+oidc@3.0.5/node_modules/@vercel/oidc/dist/token.js"(exports, module) {
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+    var token_exports = {};
+    __export(token_exports, {
+      refreshToken: () => refreshToken
+    });
+    module.exports = __toCommonJS(token_exports);
+    var import_token_error = require_token_error();
+    var import_token_util = require_token_util();
+    async function refreshToken() {
+      const { projectId, teamId } = (0, import_token_util.findProjectInfo)();
+      let maybeToken = (0, import_token_util.loadToken)(projectId);
+      if (!maybeToken || (0, import_token_util.isExpired)((0, import_token_util.getTokenPayload)(maybeToken.token))) {
+        const authToken = (0, import_token_util.getVercelCliToken)();
+        if (!authToken) {
+          throw new import_token_error.VercelOidcTokenError(
+            "Failed to refresh OIDC token: login to vercel cli"
+          );
+        }
+        if (!projectId) {
+          throw new import_token_error.VercelOidcTokenError(
+            "Failed to refresh OIDC token: project id not found"
+          );
+        }
+        maybeToken = await (0, import_token_util.getVercelOidcToken)(authToken, projectId, teamId);
+        if (!maybeToken) {
+          throw new import_token_error.VercelOidcTokenError("Failed to refresh OIDC token");
+        }
+        (0, import_token_util.saveToken)(maybeToken, projectId);
+      }
+      process.env.VERCEL_OIDC_TOKEN = maybeToken.token;
+      return;
+    }
+  }
+});
+export default require_token();
+//# sourceMappingURL=token-4SRL5WJU.js.map

package/dist/token-4SRL5WJU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../node_modules/.pnpm/@vercel+oidc@3.0.5/node_modules/@vercel/oidc/dist/token.js"],"sourcesContent":["\"use strict\";\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar token_exports = {};\n__export(token_exports, {\n  refreshToken: () => refreshToken\n});\nmodule.exports = __toCommonJS(token_exports);\nvar import_token_error = require(\"./token-error\");\nvar import_token_util = require(\"./token-util\");\nasync function refreshToken() {\n  const { projectId, teamId } = (0, import_token_util.findProjectInfo)();\n  let maybeToken = (0, import_token_util.loadToken)(projectId);\n  if (!maybeToken || (0, import_token_util.isExpired)((0, import_token_util.getTokenPayload)(maybeToken.token))) {\n    const authToken = (0, import_token_util.getVercelCliToken)();\n    if (!authToken) {\n      throw new import_token_error.VercelOidcTokenError(\n        \"Failed to refresh OIDC token: login to vercel cli\"\n      );\n    }\n    if (!projectId) {\n      throw new import_token_error.VercelOidcTokenError(\n        \"Failed to refresh OIDC token: project id not found\"\n      );\n    }\n    maybeToken = await (0, import_token_util.getVercelOidcToken)(authToken, projectId, teamId);\n    if (!maybeToken) {\n      throw new import_token_error.VercelOidcTokenError(\"Failed to refresh OIDC token\");\n    }\n    (0, import_token_util.saveToken)(maybeToken, projectId);\n  }\n  process.env.VERCEL_OIDC_TOKEN = maybeToken.token;\n  return;\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (module.exports = {\n  refreshToken\n});\n"],"mappings":";;;;;;;;;AAAA;AAAA;AACA,QAAI,YAAY,OAAO;AACvB,QAAI,mBAAmB,OAAO;AAC9B,QAAI,oBAAoB,OAAO;AAC/B,QAAI,eAAe,OAAO,UAAU;AACpC,QAAI,WAAW,CAAC,QAAQ,QAAQ;AAC9B,eAAS,QAAQ;AACf,kBAAU,QAAQ,MAAM,EAAE,KAAK,IAAI,IAAI,GAAG,YAAY,KAAK,CAAC;AAAA,IAChE;AACA,QAAI,cAAc,CAAC,IAAI,MAAM,QAAQ,SAAS;AAC5C,UAAI,QAAQ,OAAO,SAAS,YAAY,OAAO,SAAS,YAAY;AAClE,iBAAS,OAAO,kBAAkB,IAAI;AACpC,cAAI,CAAC,aAAa,KAAK,IAAI,GAAG,KAAK,QAAQ;AACzC,sBAAU,IAAI,KAAK,EAAE,KAAK,MAAM,KAAK,GAAG,GAAG,YAAY,EAAE,OAAO,iBAAiB,MAAM,GAAG,MAAM,KAAK,WAAW,CAAC;AAAA,MACvH;AACA,aAAO;AAAA,IACT;AACA,QAAI,eAAe,CAAC,QAAQ,YAAY,UAAU,CAAC,GAAG,cAAc,EAAE,OAAO,KAAK,CAAC,GAAG,GAAG;AACzF,QAAI,gBAAgB,CAAC;AACrB,aAAS,eAAe;AAAA,MACtB,cAAc,MAAM;AAAA,IACtB,CAAC;AACD,WAAO,UAAU,aAAa,aAAa;AAC3C,QAAI,qBAAqB;AACzB,QAAI,oBAAoB;AACxB,mBAAe,eAAe;AAC5B,YAAM,EAAE,WAAW,OAAO,KAAK,GAAG,kBAAkB,iBAAiB;AACrE,UAAI,cAAc,GAAG,kBAAkB,WAAW,SAAS;AAC3D,UAAI,CAAC,eAAe,GAAG,kBAAkB,YAAY,GAAG,kBAAkB,iBAAiB,WAAW,KAAK,CAAC,GAAG;AAC7G,cAAM,aAAa,GAAG,kBAAkB,mBAAmB;AAC3D,YAAI,CAAC,WAAW;AACd,gBAAM,IAAI,mBAAmB;AAAA,YAC3B;AAAA,UACF;AAAA,QACF;AACA,YAAI,CAAC,WAAW;AACd,gBAAM,IAAI,mBAAmB;AAAA,YAC3B;AAAA,UACF;AAAA,QACF;AACA,qBAAa,OAAO,GAAG,kBAAkB,oBAAoB,WAAW,WAAW,MAAM;AACzF,YAAI,CAAC,YAAY;AACf,gBAAM,IAAI,mBAAmB,qBAAqB,8BAA8B;AAAA,QAClF;AACA,SAAC,GAAG,kBAAkB,WAAW,YAAY,SAAS;AAAA,MACxD;AACA,cAAQ,IAAI,oBAAoB,WAAW;AAC3C;AAAA,IACF;AAAA;AAAA;","names":[]}

package/dist/token-util-24B4MTMT.js

@@ -0,0 +1,6 @@
+import {
+  require_token_util
+} from "./chunk-H3ZBSMAH.js";
+import "./chunk-LOLDRYLH.js";
+export default require_token_util();
+//# sourceMappingURL=token-util-24B4MTMT.js.map

package/dist/token-util-24B4MTMT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -2,7 +2,7 @@
   "name": "workers-ai-provider",
   "description": "Workers AI Provider for the vercel AI SDK",
   "type": "module",
-  "version": "0.7.5",
+  "version": "2.0.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {
@@ -31,12 +31,12 @@
     "serverless"
   ],
   "dependencies": {
-    "@ai-sdk/provider": "^1.1.3",
-    "@ai-sdk/provider-utils": "^2.2.8"
+    "@ai-sdk/provider": "^2.0.0",
+    "@ai-sdk/provider-utils": "^3.0.19"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20250803.0",
-    "zod": "^3.25.67"
+    "@cloudflare/workers-types": "^4.20251221.0",
+    "zod": "^3.25.76"
   },
   "scripts": {
     "build": "rm -rf dist && tsup src/index.ts --dts --sourcemap --format esm --target es2020",

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

@@ -1,7 +1,7 @@
-import {
-	type LanguageModelV1,
-	type LanguageModelV1CallWarning,
-	UnsupportedFunctionalityError,
+import type {
+	LanguageModelV2,
+	LanguageModelV2CallWarning,
+	LanguageModelV2StreamPart,
 } from "@ai-sdk/provider";
 
 import type { AutoRAGChatSettings } from "./autorag-chat-settings";
@@ -17,10 +17,14 @@ type AutoRAGChatConfig = {
 	gateway?: GatewayOptions;
 };
 
-export class AutoRAGChatLanguageModel implements LanguageModelV1 {
-	readonly specificationVersion = "v1";
+export class AutoRAGChatLanguageModel implements LanguageModelV2 {
+	readonly specificationVersion = "v2";
 	readonly defaultObjectGenerationMode = "json";
 
+	readonly supportedUrls: Record<string, RegExp[]> | PromiseLike<Record<string, RegExp[]>> = {
+		// TODO: I think No Supported URLs?
+	};
+
 	readonly modelId: TextGenerationModels;
 	readonly settings: AutoRAGChatSettings;
 
@@ -41,14 +45,14 @@ export class AutoRAGChatLanguageModel implements LanguageModelV1 {
 	}
 
 	private getArgs({
-		mode,
+		responseFormat,
 		prompt,
+		tools,
+		toolChoice,
 		frequencyPenalty,
 		presencePenalty,
-	}: Parameters<LanguageModelV1["doGenerate"]>[0]) {
-		const type = mode.type;
-
-		const warnings: LanguageModelV1CallWarning[] = [];
+	}: Parameters<LanguageModelV2["doGenerate"]>[0]) {
+		const warnings: LanguageModelV2CallWarning[] = [];
 
 		if (frequencyPenalty != null) {
 			warnings.push({
@@ -71,20 +75,21 @@ export class AutoRAGChatLanguageModel implements LanguageModelV1 {
 			model: this.modelId,
 		};
 
+		const type = responseFormat?.type ?? "text";
 		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,
@@ -93,25 +98,6 @@ export class AutoRAGChatLanguageModel 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}`);
@@ -120,10 +106,9 @@ export class AutoRAGChatLanguageModel implements LanguageModelV1 {
 	}
 
 	async doGenerate(
-		options: Parameters<LanguageModelV1["doGenerate"]>[0],
-	): Promise<Awaited<ReturnType<LanguageModelV1["doGenerate"]>>> {
-		const { args, warnings } = this.getArgs(options);
-
+		options: Parameters<LanguageModelV2["doGenerate"]>[0],
+	): Promise<Awaited<ReturnType<LanguageModelV2["doGenerate"]>>> {
+		const { warnings } = this.getArgs(options);
 		const { messages } = convertToWorkersAIChatMessages(options.prompt);
 
 		const output = await this.config.binding.aiSearch({
@@ -132,40 +117,77 @@ export class AutoRAGChatLanguageModel implements LanguageModelV1 {
 
 		return {
 			finishReason: "stop",
-			rawCall: { rawPrompt: args.messages, rawSettings: args },
-			sources: output.data.map(({ file_id, filename, score }) => ({
-				id: file_id,
-				providerMetadata: {
-					attributes: { score },
+
+			content: [
+				...output.data.map(({ file_id, filename, score }) => ({
+					type: "source" as const,
+					sourceType: "url" as const,
+					id: file_id,
+					url: filename,
+					providerMetadata: {
+						attributes: { score },
+					},
+				})),
+				{
+					type: "text" as const,
+					text: output.response,
 				},
-				sourceType: "url",
-				url: filename,
-			})), // TODO: mapWorkersAIFinishReason(response.finish_reason),
-			text: output.response,
-			toolCalls: processToolCalls(output),
+				...processToolCalls(output),
+			],
 			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);
-
 		const { messages } = convertToWorkersAIChatMessages(options.prompt);
 
 		const query = messages.map(({ content, role }) => `${role}: ${content}`).join("\n\n");
 
+		// Get the underlying streaming response (assume this returns a ReadableStream<LanguageModelV2StreamPart>)
 		const response = await this.config.binding.aiSearch({
 			query,
 			stream: true,
 		});
 
+		// 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(response).getReader();
+
+				function push() {
+					reader.read().then(({ done, value }) => {
+						if (done) {
+							controller.close();
+							return;
+						}
+						controller.enqueue(value);
+						push();
+					});
+				}
+				push();
+			},
+		});
+
 		return {
-			rawCall: { rawPrompt: args.messages, rawSettings: args },
-			stream: getMappedStream(response),
-			warnings,
+			stream,
+			request: {
+				body: {
+					rawPrompt: args.messages,
+					rawSettings: args,
+				},
+			},
 		};
 	}
 }

package/src/convert-to-workersai-chat-messages.ts

@@ -1,19 +1,19 @@
-import type { LanguageModelV1Prompt, LanguageModelV1ProviderMetadata } from "@ai-sdk/provider";
+import type { LanguageModelV2Prompt, SharedV2ProviderMetadata } from "@ai-sdk/provider";
 import type { WorkersAIChatPrompt } from "./workersai-chat-prompt";
 
-export function convertToWorkersAIChatMessages(prompt: LanguageModelV1Prompt): {
+export function convertToWorkersAIChatMessages(prompt: LanguageModelV2Prompt): {
 	messages: WorkersAIChatPrompt;
 	images: {
 		mimeType: string | undefined;
 		image: Uint8Array;
-		providerMetadata: LanguageModelV1ProviderMetadata | undefined;
+		providerOptions: SharedV2ProviderMetadata | undefined;
 	}[];
 } {
 	const messages: WorkersAIChatPrompt = [];
 	const images: {
 		mimeType: string | undefined;
 		image: Uint8Array;
-		providerMetadata: LanguageModelV1ProviderMetadata | undefined;
+		providerOptions: SharedV2ProviderMetadata | undefined;
 	}[] = [];
 
 	for (const { role, content } of prompt) {
@@ -31,20 +31,22 @@ export function convertToWorkersAIChatMessages(prompt: LanguageModelV1Prompt): {
 								case "text": {
 									return part.text;
 								}
-								case "image": {
+								case "file": {
 									// Extract image from this part
-									if (part.image instanceof Uint8Array) {
+									if (part.data instanceof Uint8Array) {
 										// Store the image data directly as Uint8Array
 										// For Llama 3.2 Vision model, which needs array of integers
 										images.push({
-											image: part.image,
-											mimeType: part.mimeType,
-											providerMetadata: part.providerMetadata,
+											image: part.data,
+											mimeType: part.mediaType,
+											providerOptions: part.providerOptions,
 										});
 									}
 									return ""; // No text for the image part
 								}
 							}
+
+							return undefined;
 						})
 						.join("\n"),
 					role: "user",
@@ -75,12 +77,12 @@ export function convertToWorkersAIChatMessages(prompt: LanguageModelV1Prompt): {
 						case "tool-call": {
 							text = JSON.stringify({
 								name: part.toolName,
-								parameters: part.args,
+								parameters: part.input,
 							});
 
 							toolCalls.push({
 								function: {
-									arguments: JSON.stringify(part.args),
+									arguments: JSON.stringify(part.input),
 									name: part.toolName,
 								},
 								id: part.toolCallId,
@@ -114,7 +116,7 @@ export function convertToWorkersAIChatMessages(prompt: LanguageModelV1Prompt): {
 			case "tool": {
 				for (const [index, toolResponse] of content.entries()) {
 					messages.push({
-						content: JSON.stringify(toolResponse.result),
+						content: JSON.stringify(toolResponse.output),
 						name: toolResponse.toolName,
 						tool_call_id: `functions.${toolResponse.toolName}:${index}`,
 						role: "tool",

package/src/index.ts

@@ -160,11 +160,15 @@ export function createAutoRAG(options: AutoRAGSettings): AutoRAGProvider {
 	const binding = options.binding;
 
 	const createChatModel = (settings: AutoRAGChatSettings = {}) =>
-		// @ts-ignore Needs fix from @cloudflare/workers-types for custom types
-		new AutoRAGChatLanguageModel("@cf/meta/llama-3.3-70b-instruct-fp8-fast", settings, {
-			binding,
-			provider: "autorag.chat",
-		});
+		new AutoRAGChatLanguageModel(
+			// @ts-expect-error Needs fix from @cloudflare/workers-types for custom types
+			"@cf/meta/llama-3.3-70b-instruct-fp8-fast",
+			settings,
+			{
+				binding,
+				provider: "autorag.chat",
+			},
+		);
 
 	const provider = (settings?: AutoRAGChatSettings) => {
 		if (new.target) {

package/src/map-workersai-finish-reason.ts

@@ -1,6 +1,6 @@
-import type { LanguageModelV1FinishReason } from "@ai-sdk/provider";
+import type { LanguageModelV2FinishReason } from "@ai-sdk/provider";
 
-export function mapWorkersAIFinishReason(finishReasonOrResponse: any): LanguageModelV1FinishReason {
+export function mapWorkersAIFinishReason(finishReasonOrResponse: any): LanguageModelV2FinishReason {
 	let finishReason: string | null | undefined;
 
 	// If it's a string/null/undefined, use it directly (original behavior)

package/src/map-workersai-usage.ts

@@ -9,7 +9,8 @@ export function mapWorkersAIUsage(output: AiTextGenerationOutput | AiTextToImage
 	};
 
 	return {
-		completionTokens: usage.completion_tokens,
-		promptTokens: usage.prompt_tokens,
+		outputTokens: usage.completion_tokens,
+		inputTokens: usage.prompt_tokens,
+		totalTokens: usage.prompt_tokens + usage.completion_tokens,
 	};
 }

package/src/streaming.ts

@@ -1,14 +1,19 @@
-import type { LanguageModelV1StreamPart } from "@ai-sdk/provider";
+import type { LanguageModelV2StreamPart } from "@ai-sdk/provider";
+import { generateId } from "ai";
 import { events } from "fetch-event-stream";
 import { mapWorkersAIUsage } from "./map-workersai-usage";
 import { processPartialToolCalls } from "./utils";
 
 export function getMappedStream(response: Response) {
 	const chunkEvent = events(response);
-	let usage = { completionTokens: 0, promptTokens: 0 };
+	let usage = { outputTokens: 0, inputTokens: 0, totalTokens: 0 };
 	const partialToolCalls: any[] = [];
 
-	return new ReadableStream<LanguageModelV1StreamPart>({
+	// Track start/delta/end IDs per v5 streaming protocol
+	let textId: string | null = null;
+	let reasoningId: string | null = null;
+
+	return new ReadableStream<LanguageModelV2StreamPart>({
 		async start(controller) {
 			for await (const event of chunkEvent) {
 				if (!event.data) {
@@ -24,33 +29,66 @@ export function getMappedStream(response: Response) {
 				if (chunk.tool_calls) {
 					partialToolCalls.push(...chunk.tool_calls);
 				}
-				chunk.response?.length &&
+
+				// Handle top-level response text
+				if (chunk.response?.length) {
+					if (!textId) {
+						textId = generateId();
+						controller.enqueue({ type: "text-start", id: textId });
+					}
 					controller.enqueue({
-						textDelta: chunk.response,
 						type: "text-delta",
+						id: textId,
+						delta: chunk.response,
 					});
-				chunk?.choices?.[0]?.delta?.reasoning_content?.length &&
+				}
+
+				// Handle reasoning content
+				const reasoningDelta = chunk?.choices?.[0]?.delta?.reasoning_content;
+				if (reasoningDelta?.length) {
+					if (!reasoningId) {
+						reasoningId = generateId();
+						controller.enqueue({ type: "reasoning-start", id: reasoningId });
+					}
 					controller.enqueue({
-						type: "reasoning",
-						textDelta: chunk.choices[0].delta.reasoning_content,
+						type: "reasoning-delta",
+						id: reasoningId,
+						delta: reasoningDelta,
 					});
-				chunk?.choices?.[0]?.delta?.content?.length &&
+				}
+
+				// Handle text content from choices
+				const textDelta = chunk?.choices?.[0]?.delta?.content;
+				if (textDelta?.length) {
+					if (!textId) {
+						textId = generateId();
+						controller.enqueue({ type: "text-start", id: textId });
+					}
 					controller.enqueue({
 						type: "text-delta",
-						textDelta: chunk.choices[0].delta.content,
+						id: textId,
+						delta: textDelta,
 					});
+				}
 			}
 
 			if (partialToolCalls.length > 0) {
 				const toolCalls = processPartialToolCalls(partialToolCalls);
-				toolCalls.map((toolCall) => {
-					controller.enqueue({
-						type: "tool-call",
-						...toolCall,
-					});
+				toolCalls.forEach((toolCall) => {
+					controller.enqueue(toolCall);
 				});
 			}
 
+			// Close any open blocks
+			if (reasoningId) {
+				controller.enqueue({ type: "reasoning-end", id: reasoningId });
+				reasoningId = null;
+			}
+			if (textId) {
+				controller.enqueue({ type: "text-end", id: textId });
+				textId = null;
+			}
+
 			controller.enqueue({
 				finishReason: "stop",
 				type: "finish",

package/src/utils.ts

@@ -1,4 +1,5 @@
-import type { LanguageModelV1, LanguageModelV1FunctionToolCall } from "@ai-sdk/provider";
+import type { LanguageModelV2, LanguageModelV2ToolCall } from "@ai-sdk/provider";
+import { generateId } from "ai";
 
 /**
  * General AI run interface with overloads to handle distinct return types.
@@ -127,30 +128,22 @@ export function createRun(config: CreateRunConfig): AiRun {
 }
 
 export function prepareToolsAndToolChoice(
-	mode: Parameters<LanguageModelV1["doGenerate"]>[0]["mode"] & {
-		type: "regular";
-	},
+	tools: Parameters<LanguageModelV2["doGenerate"]>[0]["tools"],
+	toolChoice: Parameters<LanguageModelV2["doGenerate"]>[0]["toolChoice"],
 ) {
-	// when the tools array is empty, change it to undefined to prevent errors:
-	const tools = mode.tools?.length ? mode.tools : undefined;
-
 	if (tools == null) {
 		return { tool_choice: undefined, tools: undefined };
 	}
 
 	const mappedTools = tools.map((tool) => ({
 		function: {
-			// @ts-expect-error - description is not a property of tool
-			description: tool.description,
+			description: tool.type === "function" && tool.description,
 			name: tool.name,
-			// @ts-expect-error - parameters is not a property of tool
-			parameters: tool.parameters,
+			parameters: tool.type === "function" && tool.inputSchema,
 		},
 		type: "function",
 	}));
 
-	const toolChoice = mode.toolChoice;
-
 	if (toolChoice == null) {
 		return { tool_choice: undefined, tools: mappedTools };
 	}
@@ -220,31 +213,31 @@ function mergePartialToolCalls(partialCalls: any[]) {
 	return Object.values(mergedCallsByIndex);
 }
 
-function processToolCall(toolCall: any): LanguageModelV1FunctionToolCall {
+function processToolCall(toolCall: any): LanguageModelV2ToolCall {
 	// Check for OpenAI format tool calls first
 	if (toolCall.function && toolCall.id) {
 		return {
-			args:
+			input:
 				typeof toolCall.function.arguments === "string"
 					? toolCall.function.arguments
 					: JSON.stringify(toolCall.function.arguments || {}),
-			toolCallId: toolCall.id,
-			toolCallType: "function",
+			toolCallId: toolCall.id || generateId(),
+			type: "tool-call",
 			toolName: toolCall.function.name,
 		};
 	}
 	return {
-		args:
+		input:
 			typeof toolCall.arguments === "string"
 				? toolCall.arguments
 				: JSON.stringify(toolCall.arguments || {}),
-		toolCallId: toolCall.name,
-		toolCallType: "function",
+		toolCallId: toolCall.id || generateId(),
+		type: "tool-call",
 		toolName: toolCall.name,
 	};
 }
 
-export function processToolCalls(output: any): LanguageModelV1FunctionToolCall[] {
+export function processToolCalls(output: any): LanguageModelV2ToolCall[] {
 	if (output.tool_calls && Array.isArray(output.tool_calls)) {
 		return output.tool_calls.map((toolCall: any) => {
 			const processedToolCall = processToolCall(toolCall);