workers-ai-provider 3.2.1 → 3.3.1

package/src/resumable-stream.ts

@@ -1,223 +1,11 @@
-import { GatewayDelegateError } from "./gateway-delegate";
-
 /**
- * Resumable run-path stream (RFC §7.1).
- *
- * Wraps the byte stream from a run-path response (`env.AI.run(..., {
- * returnRawResponse })`) so a transient mid-stream drop is recovered
- * transparently: the wrapper reconnects to the gateway resume endpoint and keeps
- * feeding bytes to the same consumer, so the downstream `@ai-sdk/*` parser never
- * sees the break.
- *
- * Byte alignment is the one correctness subtlety. The gateway `resume?from=N`
- * endpoint takes an SSE *event index* (count of `\n\n` terminators) and replays
- * whole events from that index. So the wrapper only ever emits *complete* events
- * downstream and buffers any trailing partial event. On a drop the buffered
- * partial is discarded and resume starts from the count of complete events
- * already emitted — landing exactly on the next event boundary, with no
- * duplicated or truncated bytes.
- *
- * Expiry: once the gateway buffer TTL (~5.5 min) elapses, resume returns 404
- * `{"error":"Request not found"}`. Behavior is governed by `onResumeExpired`:
- * `"error"` (default) surfaces a `GatewayDelegateError("resume-expired")` into
- * the stream; `"accept-partial"` ends the stream cleanly with whatever was
- * already delivered (the caller's higher layer — e.g. Think — can then continue
- * or regenerate).
+ * The resumable run-path stream engine now lives in `@cloudflare/gateway-core`
+ * (shared with the other Cloudflare AI Gateway packages). This module re-exports
+ * it so the existing `workers-ai-provider/src/resumable-stream` import path keeps
+ * working unchanged.
  */
-
-type AiWithFetch = Ai & {
-	fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
-};
-
-export type ResumeExpiredPolicy = "error" | "accept-partial";
-
-export interface ResumableStreamOptions {
-	/** Cloudflare AI binding (e.g. `env.AI`) — used for the resume fetch. */
-	binding: Ai;
-	/** Gateway id the run was issued under. */
-	gateway: string;
-	/** The `cf-aig-run-id` of the run to resume. */
-	runId: string;
-	/**
-	 * Initial run-path response body. Omit for **cross-invocation re-attach**: the
-	 * stream then starts by fetching `resume?from={fromEvent}` directly (e.g. a new
-	 * Durable Object invocation re-attaching to a run after eviction).
-	 */
-	initial?: ReadableStream<Uint8Array>;
-	/**
-	 * SSE event index to (re-)attach from. Defaults to `0`. Used as the starting
-	 * `from` when `initial` is omitted, and as the base offset for the event
-	 * counter (so a later reconnect resumes from the correct absolute index).
-	 */
-	fromEvent?: number;
-	/** What to do when the resume buffer has expired (404). Defaults to `"error"`. */
-	onResumeExpired?: ResumeExpiredPolicy;
-	/** Max reconnect attempts before giving up. Defaults to 5. */
-	maxReconnects?: number;
-	/** Fired before each reconnect with the resume `from` index and attempt number. */
-	onReconnect?: (fromEvent: number, attempt: number) => void;
-	/**
-	 * Fired with the cumulative SSE event offset whenever complete events are
-	 * emitted. Use it to persist `{ runId, eventOffset }` for cross-invocation
-	 * re-attach (throttle your own writes — this can fire per chunk).
-	 */
-	onProgress?: (eventOffset: number) => void;
-}
-
-function concat(a: Uint8Array, b: Uint8Array): Uint8Array<ArrayBuffer> {
-	const out = new Uint8Array(new ArrayBuffer(a.length + b.length));
-	out.set(a, 0);
-	out.set(b, a.length);
-	return out;
-}
-
-/** Index just past the last `\n\n` in `buf`, or -1 if there is no complete event. */
-function lastEventBoundary(buf: Uint8Array): number {
-	for (let i = buf.length - 2; i >= 0; i--) {
-		if (buf[i] === 0x0a && buf[i + 1] === 0x0a) return i + 2;
-	}
-	return -1;
-}
-
-/** Count of `\n\n` terminators (= complete SSE events) in `buf`. */
-function countEvents(buf: Uint8Array): number {
-	let n = 0;
-	for (let i = 0; i + 1 < buf.length; i++) {
-		if (buf[i] === 0x0a && buf[i + 1] === 0x0a) {
-			n++;
-			i++; // don't double-count "\n\n\n"
-		}
-	}
-	return n;
-}
-
-function resumeUrl(gateway: string, runId: string, from: number): string {
-	return `https://workers-binding.ai/ai-gateway/gateways/${gateway}/run/${runId}/resume?from=${from}`;
-}
-
-export function createResumableStream(options: ResumableStreamOptions): ReadableStream<Uint8Array> {
-	const { binding, gateway, runId } = options;
-	const maxReconnects = options.maxReconnects ?? 5;
-	const onExpired = options.onResumeExpired ?? "error";
-
-	let emittedEvents = options.fromEvent ?? 0; // absolute SSE event index reached
-	let pending: Uint8Array<ArrayBuffer> = new Uint8Array(new ArrayBuffer(0));
-	let reconnects = 0;
-
-	// Fetch `resume?from={emittedEvents}`; on a terminal outcome (expiry / error /
-	// network throw) it settles the controller and returns null.
-	async function fetchResume(
-		controller: ReadableStreamDefaultController<Uint8Array>,
-	): Promise<ReadableStream<Uint8Array> | null> {
-		let res: Response;
-		try {
-			res = await (binding as AiWithFetch).fetch(resumeUrl(gateway, runId, emittedEvents), {
-				method: "GET",
-			});
-		} catch (fetchErr) {
-			controller.error(
-				new GatewayDelegateError(
-					"dispatch",
-					`Resume request threw at event ${emittedEvents}.`,
-					fetchErr,
-				),
-			);
-			return null;
-		}
-
-		if (res.status === 404) {
-			if (onExpired === "accept-partial") {
-				controller.close();
-				return null;
-			}
-			controller.error(
-				new GatewayDelegateError(
-					"resume-expired",
-					`Resume buffer expired (404) at event ${emittedEvents}. The gateway buffer ` +
-						"TTL (~5.5 min) elapsed; fall back to continuation or regeneration.",
-				),
-			);
-			return null;
-		}
-		if (!res.ok || !res.body) {
-			controller.error(
-				new GatewayDelegateError(
-					"dispatch",
-					`Resume failed (${res.status}) at event ${emittedEvents}.`,
-				),
-			);
-			return null;
-		}
-		return res.body;
-	}
-
-	return new ReadableStream<Uint8Array>({
-		async start(controller) {
-			// In-stream wrap starts from the live body; cross-invocation re-attach
-			// (no `initial`) starts by resuming from `fromEvent`. An initial-attach
-			// failure is terminal — it is not charged against the reconnect budget.
-			let current: ReadableStream<Uint8Array>;
-			if (options.initial) {
-				current = options.initial;
-			} else {
-				const body = await fetchResume(controller);
-				if (!body) return;
-				current = body;
-			}
-
-			for (;;) {
-				const reader = current.getReader();
-				try {
-					for (;;) {
-						const { done, value } = await reader.read();
-						if (done) {
-							if (pending.length > 0) {
-								controller.enqueue(pending);
-								pending = new Uint8Array(new ArrayBuffer(0));
-							}
-							controller.close();
-							return;
-						}
-						if (!value || value.length === 0) continue;
-
-						pending = concat(pending, value);
-						const boundary = lastEventBoundary(pending);
-						if (boundary > 0) {
-							const complete = pending.slice(0, boundary);
-							controller.enqueue(complete);
-							emittedEvents += countEvents(complete);
-							options.onProgress?.(emittedEvents);
-							pending = pending.slice(boundary);
-						}
-					}
-				} catch (err) {
-					try {
-						reader.releaseLock();
-					} catch {
-						// reader may already be released
-					}
-
-					if (reconnects >= maxReconnects) {
-						controller.error(
-							new GatewayDelegateError(
-								"resume-expired",
-								`Exceeded ${maxReconnects} reconnect attempts at event ${emittedEvents}.`,
-								err,
-							),
-						);
-						return;
-					}
-
-					// Discard the unfinished partial — resume realigns on the boundary.
-					pending = new Uint8Array(new ArrayBuffer(0));
-					reconnects++;
-					options.onReconnect?.(emittedEvents, reconnects);
-
-					const body = await fetchResume(controller);
-					if (!body) return;
-					current = body;
-				}
-			}
-		},
-	});
-}
+export {
+	createResumableStream,
+	type ResumableStreamOptions,
+	type ResumeExpiredPolicy,
+} from "@cloudflare/gateway-core";

package/src/streaming.ts

@@ -3,6 +3,7 @@ import type {
 	LanguageModelV3StreamPart,
 	LanguageModelV3Usage,
 } from "@ai-sdk/provider";
+import { SSEDecoder } from "@cloudflare/gateway-core";
 import { generateId } from "ai";
 import { mapWorkersAIFinishReason } from "./map-workersai-finish-reason";
 import { mapWorkersAIUsage } from "./map-workersai-usage";
@@ -426,44 +427,3 @@ export function getMappedStream(
 		}
 	}
 }
-
-/**
- * TransformStream that decodes a raw byte stream into SSE `data:` payloads.
- * Each output chunk is the string content after "data: " (one per SSE event).
- * Handles line buffering for partial chunks.
- */
-class SSEDecoder extends TransformStream<Uint8Array, string> {
-	constructor() {
-		let buffer = "";
-		const decoder = new TextDecoder();
-
-		super({
-			transform(chunk, controller) {
-				buffer += decoder.decode(chunk, { stream: true });
-				const lines = buffer.split("\n");
-				buffer = lines.pop() || "";
-
-				for (const line of lines) {
-					const trimmed = line.trim();
-					if (!trimmed) continue;
-					if (trimmed.startsWith("data: ")) {
-						controller.enqueue(trimmed.slice(6));
-					} else if (trimmed.startsWith("data:")) {
-						controller.enqueue(trimmed.slice(5));
-					}
-				}
-			},
-
-			flush(controller) {
-				if (buffer.trim()) {
-					const trimmed = buffer.trim();
-					if (trimmed.startsWith("data: ")) {
-						controller.enqueue(trimmed.slice(6));
-					} else if (trimmed.startsWith("data:")) {
-						controller.enqueue(trimmed.slice(5));
-					}
-				}
-			},
-		});
-	}
-}

package/src/utils.ts

@@ -1,6 +1,18 @@
 import type { LanguageModelV3, LanguageModelV3ToolCall } from "@ai-sdk/provider";
+import {
+	getToolNames,
+	isForcedToolChoice,
+	normalizeMessagesForBinding as coreNormalizeMessagesForBinding,
+	parseLeakedToolCalls as coreParseLeakedToolCalls,
+	processText,
+} from "@cloudflare/gateway-core";
 import { generateId } from "ai";
 import type { WorkersAIChatPrompt } from "./workersai-chat-prompt";
+import { apiCallErrorFromResponse } from "./workersai-error";
+
+// Re-exported from `@cloudflare/gateway-core` (single source of truth) so the
+// existing `workers-ai-provider/src/utils` import paths keep working unchanged.
+export { getToolNames, isForcedToolChoice, processText } from "@cloudflare/gateway-core";
 
 // ---------------------------------------------------------------------------
 // Workers AI quirk workarounds
@@ -13,16 +25,9 @@ import type { WorkersAIChatPrompt } from "./workersai-chat-prompt";
  * - `content` must not be null
  */
 export function normalizeMessagesForBinding(messages: WorkersAIChatPrompt): WorkersAIChatPrompt {
-	return messages.map((msg) => {
-		const normalized = { ...msg };
-
-		// content: null → content: ""
-		if (normalized.content === null || normalized.content === undefined) {
-			(normalized as { content: string }).content = "";
-		}
-
-		return normalized;
-	});
+	return coreNormalizeMessagesForBinding(
+		messages as unknown as Record<string, unknown>[],
+	) as unknown as WorkersAIChatPrompt;
 }
 
 // ---------------------------------------------------------------------------
@@ -151,7 +156,9 @@ export function createRun(config: CreateRunConfig): AiRun {
 			signal: signal as AbortSignal | undefined,
 		});
 
-		// Check for HTTP errors before processing
+		// Check for HTTP errors before processing. Surface as an APICallError so
+		// the AI SDK can classify retryability from the status (429 / 5xx → retry)
+		// and honor any Retry-After header.
 		if (!response.ok && !returnRawResponse) {
 			let errorBody: string;
 			try {
@@ -159,9 +166,10 @@ export function createRun(config: CreateRunConfig): AiRun {
 			} catch {
 				errorBody = "<unable to read response body>";
 			}
-			throw new Error(
-				`Workers AI API error (${response.status} ${response.statusText}): ${errorBody}`,
-			);
+			throw apiCallErrorFromResponse(response, errorBody, {
+				url,
+				requestBodyValues: inputs,
+			});
 		}
 
 		if (returnRawResponse) {
@@ -200,9 +208,10 @@ export function createRun(config: CreateRunConfig): AiRun {
 				} catch {
 					errorBody = "<unable to read response body>";
 				}
-				throw new Error(
-					`Workers AI API error (${retryResponse.status} ${retryResponse.statusText}): ${errorBody}`,
-				);
+				throw apiCallErrorFromResponse(retryResponse, errorBody, {
+					url,
+					requestBodyValues: inputs,
+				});
 			}
 
 			const retryData = await retryResponse.json<{
@@ -257,9 +266,10 @@ export async function createRunBinary(
 		} catch {
 			errorBody = "<unable to read response body>";
 		}
-		throw new Error(
-			`Workers AI API error (${response.status} ${response.statusText}): ${errorBody}`,
-		);
+		throw apiCallErrorFromResponse(response, errorBody, {
+			url,
+			requestBodyValues: { contentType, byteLength: audioBytes.byteLength },
+		});
 	}
 
 	const data = await response.json<{ result?: Record<string, unknown> }>();
@@ -524,81 +534,24 @@ export function processPartialToolCalls(partialToolCalls: PartialToolCall[]) {
 // Forced tool-call salvage (gpt-oss harmony quirk)
 // ---------------------------------------------------------------------------
 
-/**
- * Was a specific tool forced for this request?
- *
- * True for both `tool_choice: "required"` and the named-function form
- * `{ type: "function", function: { name } }`.
- */
-export function isForcedToolChoice(toolChoice: unknown): boolean {
-	if (toolChoice === "required") return true;
-	return (
-		typeof toolChoice === "object" &&
-		toolChoice !== null &&
-		(toolChoice as { type?: unknown }).type === "function"
-	);
-}
-
 /**
  * Parse tool calls that a model leaked as JSON text instead of structured
- * `tool_calls`. Shared by the non-streaming salvage and the streaming buffer.
+ * `tool_calls`, assigning AI-SDK tool-call ids.
  *
- * Only JSON objects whose `name` is one of `knownToolNames` are recovered;
- * everything else (prose, harmony channel/role leaks like `{"name":"analysis"}`,
- * hallucinated names) is ignored to avoid fabricating bogus calls.
+ * 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.
  */
 export function parseLeakedToolCalls(
 	text: string,
 	knownToolNames: Set<string>,
 ): LanguageModelV3ToolCall[] {
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(text.trim());
-	} catch {
-		return [];
-	}
-
-	const candidates = Array.isArray(parsed) ? parsed : [parsed];
-	const salvaged: LanguageModelV3ToolCall[] = [];
-
-	for (const candidate of candidates) {
-		if (typeof candidate !== "object" || candidate === null) continue;
-		const obj = candidate as Record<string, unknown>;
-		const name = obj.name;
-		if (typeof name !== "string" || !knownToolNames.has(name)) continue;
-
-		// Arguments may be wrapped (`arguments`/`parameters`) or flattened as
-		// siblings of `name`.
-		let args: unknown;
-		if ("arguments" in obj) {
-			args = obj.arguments;
-		} else if ("parameters" in obj) {
-			args = obj.parameters;
-		} else {
-			const { name: _name, ...rest } = obj;
-			args = rest;
-		}
-
-		salvaged.push({
-			input: typeof args === "string" ? args : JSON.stringify(args ?? {}),
-			toolCallId: createAISDKToolCallId(undefined),
-			type: "tool-call",
-			toolName: name,
-		});
-	}
-
-	return salvaged;
-}
-
-/** Collect the requested tool names from mapped tools. */
-export function getToolNames(
-	tools: Array<{ function: { name?: string } }> | undefined,
-): Set<string> {
-	return new Set(
-		(tools ?? [])
-			.map((tool) => tool.function?.name)
-			.filter((name): name is string => typeof name === "string"),
-	);
+	return coreParseLeakedToolCalls(text, knownToolNames).map((call) => ({
+		input: call.input,
+		toolCallId: createAISDKToolCallId(undefined),
+		type: "tool-call",
+		toolName: call.toolName,
+	}));
 }
 
 /**
@@ -646,41 +599,3 @@ export function salvageToolCallsFromText(
 	const salvaged = parseLeakedToolCalls(text, knownToolNames);
 	return salvaged.length > 0 ? salvaged : null;
 }
-
-// ---------------------------------------------------------------------------
-// Text extraction
-// ---------------------------------------------------------------------------
-
-/**
- * Extract text from a Workers AI response, handling multiple response formats:
- * - OpenAI format: { choices: [{ message: { content: "..." } }] }
- * - Native format: { response: "..." }
- * - Structured output quirk: { response: { ... } } (object instead of string)
- * - Structured output quirk: { response: "{ ... }" } (JSON string)
- */
-export function processText(output: Record<string, unknown>): string | undefined {
-	// OpenAI format
-	const choices = output.choices as Array<{ message?: { content?: string | null } }> | undefined;
-	const choiceContent = choices?.[0]?.message?.content;
-	if (choiceContent != null && String(choiceContent).length > 0) {
-		return String(choiceContent);
-	}
-
-	if ("response" in output) {
-		const response = output.response;
-		// Object response (structured output quirk #2)
-		if (typeof response === "object" && response !== null) {
-			return JSON.stringify(response);
-		}
-		// Numeric response (quirk #9)
-		if (typeof response === "number") {
-			return String(response);
-		}
-		// Null response (e.g., tool-call-only responses)
-		if (response === null || response === undefined) {
-			return undefined;
-		}
-		return String(response);
-	}
-	return undefined;
-}

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

@@ -13,6 +13,7 @@ import {
 	salvageToolCallsFromText,
 } from "./utils";
 import type { WorkersAIChatSettings } from "./workersai-chat-settings";
+import { normalizeBindingError } from "./workersai-error";
 import type { TextGenerationModels } from "./workersai-models";
 
 type WorkersAIChatConfig = {
@@ -277,14 +278,24 @@ export class WorkersAIChatLanguageModel implements LanguageModelV3 {
 		});
 		const runOptions = this.getRunOptions();
 
-		const output = await this.config.binding.run(
-			args.model as keyof AiModels,
-			inputs as AiModels[keyof AiModels]["inputs"],
-			{
-				...runOptions,
-				signal: options.abortSignal,
-			} as AiOptions,
-		);
+		let output: unknown;
+		try {
+			output = await this.config.binding.run(
+				args.model as keyof AiModels,
+				inputs as AiModels[keyof AiModels]["inputs"],
+				{
+					...runOptions,
+					signal: options.abortSignal,
+				} as AiOptions,
+			);
+		} catch (error) {
+			// Normalize binding failures (e.g. 3040 "out of capacity" → 429) into a
+			// retryable APICallError so the AI SDK's maxRetries can engage.
+			throw normalizeBindingError(error, {
+				model: args.model,
+				requestBodyValues: inputs,
+			});
+		}
 
 		if (output instanceof ReadableStream) {
 			throw new Error(
@@ -325,14 +336,24 @@ export class WorkersAIChatLanguageModel implements LanguageModelV3 {
 		});
 		const runOptions = this.getRunOptions();
 
-		const response = await this.config.binding.run(
-			args.model as keyof AiModels,
-			inputs as AiModels[keyof AiModels]["inputs"],
-			{
-				...runOptions,
-				signal: options.abortSignal,
-			} as AiOptions,
-		);
+		let response: unknown;
+		try {
+			response = await this.config.binding.run(
+				args.model as keyof AiModels,
+				inputs as AiModels[keyof AiModels]["inputs"],
+				{
+					...runOptions,
+					signal: options.abortSignal,
+				} as AiOptions,
+			);
+		} catch (error) {
+			// Normalize binding failures (e.g. 3040 "out of capacity" → 429) into a
+			// retryable APICallError so the AI SDK's maxRetries can engage.
+			throw normalizeBindingError(error, {
+				model: args.model,
+				requestBodyValues: inputs,
+			});
+		}
 
 		// If the binding returned a stream, pipe it through the SSE mapper
 		if (response instanceof ReadableStream) {

package/src/workersai-embedding-model.ts

@@ -4,6 +4,7 @@ import type {
 	EmbeddingModelV3Result,
 } from "@ai-sdk/provider";
 import { TooManyEmbeddingValuesForCallError } from "@ai-sdk/provider";
+import { normalizeBindingError } from "./workersai-error";
 import type { EmbeddingModels } from "./workersai-models";
 
 export type WorkersAIEmbeddingConfig = {
@@ -72,17 +73,27 @@ export class WorkersAIEmbeddingModel implements EmbeddingModelV3 {
 			...passthroughOptions
 		} = this.settings;
 
-		const response = await this.config.binding.run(
-			this.modelId as keyof AiModels,
-			{
-				text: values,
-			},
-			{
-				gateway: this.config.gateway ?? gateway,
-				signal: abortSignal,
-				...passthroughOptions,
-			} as AiOptions,
-		);
+		let response: unknown;
+		try {
+			response = await this.config.binding.run(
+				this.modelId as keyof AiModels,
+				{
+					text: values,
+				},
+				{
+					gateway: this.config.gateway ?? gateway,
+					signal: abortSignal,
+					...passthroughOptions,
+				} as AiOptions,
+			);
+		} catch (error) {
+			// Normalize binding failures (e.g. 3040 "out of capacity" → 429) into a
+			// retryable APICallError so the AI SDK's maxRetries can engage.
+			throw normalizeBindingError(error, {
+				model: this.modelId,
+				requestBodyValues: { text: values },
+			});
+		}
 
 		return {
 			embeddings: (response as { data: number[][] }).data,