@assemble-dev/providers 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -44,11 +44,13 @@ __export(index_exports, {
   buildAzureOpenAiChatRequestBody: () => buildAzureOpenAiChatRequestBody,
   buildBedrockInvokeModelRequestBody: () => buildBedrockInvokeModelRequestBody,
   buildBedrockInvokeModelUrl: () => buildBedrockInvokeModelUrl,
+  buildCloudflareWorkersAiChatCompletionsUrl: () => buildCloudflareWorkersAiChatCompletionsUrl,
   buildGeminiResponseSchema: () => buildGeminiResponseSchema,
   buildOpenAiRequestBody: () => buildOpenAiRequestBody,
   buildOpenAiStructuredOutputJsonSchema: () => buildOpenAiStructuredOutputJsonSchema,
   buildProviderCanceledError: () => buildProviderCanceledError,
   calculateProviderRetryDelayMs: () => calculateProviderRetryDelayMs,
+  cloudflareWorkersAi: () => cloudflareWorkersAi,
   convertZodSchemaToJsonSchema: () => convertZodSchemaToJsonSchema,
   createAnthropicBatchClient: () => createAnthropicBatchClient,
   defaultAnthropicBaseUrl: () => defaultAnthropicBaseUrl,
@@ -57,8 +59,10 @@ __export(index_exports, {
   defaultAnthropicMaxOutputTokens: () => defaultAnthropicMaxOutputTokens,
   defaultAzureOpenAiApiVersion: () => defaultAzureOpenAiApiVersion,
   defaultBedrockMaxOutputTokens: () => defaultBedrockMaxOutputTokens,
+  defaultCloudflareApiBaseUrl: () => defaultCloudflareApiBaseUrl,
   defaultGeminiBaseUrl: () => defaultGeminiBaseUrl,
   defaultOpenAiBaseUrl: () => defaultOpenAiBaseUrl,
+  defaultOpenRouterBaseUrl: () => defaultOpenRouterBaseUrl,
   defaultProviderRetryInitialDelayMs: () => defaultProviderRetryInitialDelayMs,
   defaultProviderRetryMaxAttempts: () => defaultProviderRetryMaxAttempts,
   defaultProviderRetryMaxDelayMs: () => defaultProviderRetryMaxDelayMs,
@@ -72,7 +76,9 @@ __export(index_exports, {
   extractMessageText: () => extractMessageText,
   gemini: () => gemini,
   isAbortError: () => isAbortError,
+  isOpenAiReasoningModel: () => isOpenAiReasoningModel,
   isRetryableProviderAppError: () => isRetryableProviderAppError,
+  isZodV4Schema: () => isZodV4Schema,
   joinSystemMessageText: () => joinSystemMessageText,
   mapAnthropicResponseToChatCompletionResult: () => mapAnthropicResponseToChatCompletionResult,
   mapAnthropicUsageToTokenUsage: () => mapAnthropicUsageToTokenUsage,
@@ -90,20 +96,25 @@ __export(index_exports, {
   normalizeAzureOpenAiFinishReason: () => normalizeAzureOpenAiFinishReason,
   openAiStructuredOutputSchemaName: () => openAiStructuredOutputSchemaName,
   openai: () => openai,
+  openrouter: () => openrouter,
   parseAnthropicBatchStructuredContent: () => parseAnthropicBatchStructuredContent,
   parseAnthropicStreamEvents: () => parseAnthropicStreamEvents,
   parseAnthropicToolInputJson: () => parseAnthropicToolInputJson,
   parseAzureOpenAiStreamEvents: () => parseAzureOpenAiStreamEvents,
   parseAzureOpenAiToolArgumentsJson: () => parseAzureOpenAiToolArgumentsJson,
+  prependStructuredOutputJsonOnlySystemMessage: () => prependStructuredOutputJsonOnlySystemMessage,
   resolveAnthropicPromptCachingSettings: () => resolveAnthropicPromptCachingSettings,
   resolveBedrockCredentials: () => resolveBedrockCredentials,
+  resolveOpenAiStructuredOutputMode: () => resolveOpenAiStructuredOutputMode,
   resolveProviderApiKey: () => resolveProviderApiKey,
   sanitizeJsonSchemaForAnthropicStructuredOutput: () => sanitizeJsonSchemaForAnthropicStructuredOutput,
   sanitizeJsonSchemaForGeminiResponseSchema: () => sanitizeJsonSchemaForGeminiResponseSchema,
   sanitizeJsonSchemaForOpenAiStructuredOutput: () => sanitizeJsonSchemaForOpenAiStructuredOutput,
   signAwsRequestWithSigV4: () => signAwsRequestWithSigV4,
   streamAnthropicChatCompletion: () => streamAnthropicChatCompletion,
-  streamAzureOpenAiChatCompletion: () => streamAzureOpenAiChatCompletion
+  streamAzureOpenAiChatCompletion: () => streamAzureOpenAiChatCompletion,
+  structuredOutputJsonOnlySystemInstruction: () => structuredOutputJsonOnlySystemInstruction,
+  structuredOutputJsonOnlySystemMessage: () => structuredOutputJsonOnlySystemMessage
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -313,6 +324,9 @@ var openAiUnsupportedSchemaKeywords = [
   "uniqueItems",
   "default"
 ];
+function isZodV4Schema(schema) {
+  return "_zod" in schema;
+}
 function convertZodSchemaToJsonSchema(schema) {
   try {
     return import_json2.JsonObjectSchema.parse(import_zod2.z.toJSONSchema(schema, { io: "input" }));
@@ -377,18 +391,72 @@ function listSchemaPropertyNames(node) {
   return Object.keys(properties);
 }
 
+// src/structured-output-fallback.ts
+var structuredOutputJsonOnlySystemInstruction = "Respond with a single JSON object that satisfies the caller's requested structure. Output only valid JSON with no surrounding text.";
+var structuredOutputJsonOnlySystemMessage = {
+  role: "system",
+  content: structuredOutputJsonOnlySystemInstruction
+};
+function prependStructuredOutputJsonOnlySystemMessage(messages) {
+  return [structuredOutputJsonOnlySystemMessage, ...messages];
+}
+
 // src/openai-request-mapping.ts
+var openAiReasoningModelNamePrefixes = [
+  "gpt-5",
+  "o1",
+  "o3",
+  "o4"
+];
+function isOpenAiReasoningModel(model) {
+  return openAiReasoningModelNamePrefixes.some(
+    (prefix) => matchesOpenAiModelNamePrefix(model, prefix)
+  );
+}
+function matchesOpenAiModelNamePrefix(model, prefix) {
+  if (!model.startsWith(prefix)) {
+    return false;
+  }
+  const boundaryCharacter = model.charAt(prefix.length);
+  return boundaryCharacter === "" || boundaryCharacter === "-" || boundaryCharacter === ".";
+}
+function resolveOpenAiStructuredOutputMode(messages, schema) {
+  if (isZodV4Schema(schema)) {
+    return {
+      messages,
+      structuredOutputJsonSchema: buildOpenAiStructuredOutputJsonSchema(schema)
+    };
+  }
+  return {
+    messages: prependStructuredOutputJsonOnlySystemMessage(messages),
+    requireJsonObjectResponse: true
+  };
+}
 function buildOpenAiRequestBody(model, input) {
   const requestBody = {
     model,
     messages: input.messages.map(mapChatMessageToOpenAiRequestMessage)
   };
-  if (input.temperature !== void 0) {
+  applyOpenAiGenerationSettings(requestBody, model, input);
+  applyOpenAiResponseFormat(requestBody, input);
+  applyOpenAiToolFields(requestBody, input);
+  return requestBody;
+}
+function applyOpenAiGenerationSettings(requestBody, model, input) {
+  const reasoningModel = input.reasoningModel ?? isOpenAiReasoningModel(model);
+  if (input.temperature !== void 0 && !reasoningModel) {
     requestBody.temperature = input.temperature;
   }
-  if (input.maxOutputTokens !== void 0) {
-    requestBody.max_tokens = input.maxOutputTokens;
+  if (input.maxOutputTokens === void 0) {
+    return;
+  }
+  if (reasoningModel) {
+    requestBody.max_completion_tokens = input.maxOutputTokens;
+    return;
   }
+  requestBody.max_tokens = input.maxOutputTokens;
+}
+function applyOpenAiResponseFormat(requestBody, input) {
   if (input.structuredOutputJsonSchema !== void 0) {
     requestBody.response_format = {
       type: "json_schema",
@@ -398,9 +466,13 @@ function buildOpenAiRequestBody(model, input) {
         schema: input.structuredOutputJsonSchema
       }
     };
-  } else if (input.requireJsonObjectResponse === true) {
+    return;
+  }
+  if (input.requireJsonObjectResponse === true) {
     requestBody.response_format = { type: "json_object" };
   }
+}
+function applyOpenAiToolFields(requestBody, input) {
   if (input.tools !== void 0 && input.tools.length > 0) {
     requestBody.tools = input.tools.map(mapModelToolDefinitionToOpenAiTool);
   }
@@ -409,7 +481,6 @@ function buildOpenAiRequestBody(model, input) {
       input.toolChoice
     );
   }
-  return requestBody;
 }
 function mapModelToolDefinitionToOpenAiTool(tool) {
   return {
@@ -770,12 +841,9 @@ function openai(options) {
     },
     async generateStructuredOutput(request) {
       const completion = await executeOpenAiAdapterCall(options, {
-        messages: request.messages,
+        ...resolveOpenAiStructuredOutputMode(request.messages, request.schema),
         temperature: request.temperature ?? options.temperature,
         maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
-        structuredOutputJsonSchema: buildOpenAiStructuredOutputJsonSchema(
-          request.schema
-        ),
         abortSignal: request.abortSignal
       });
       return {
@@ -1543,15 +1611,10 @@ function anthropic(options) {
       );
     },
     async generateStructuredOutput(request) {
-      const completion = await executeAnthropicAdapterCall(options, {
-        messages: request.messages,
-        temperature: request.temperature ?? options.temperature,
-        maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
-        structuredOutputJsonSchema: buildAnthropicStructuredOutputJsonSchema(
-          request.schema
-        ),
-        abortSignal: request.abortSignal
-      });
+      const completion = await executeAnthropicAdapterCall(
+        options,
+        buildAnthropicStructuredOutputInput(options, request)
+      );
       return {
         value: parseStructuredJsonText(completion.content, request.schema),
         tokenUsage: completion.tokenUsage,
@@ -1565,6 +1628,26 @@ function anthropic(options) {
     }
   };
 }
+function buildAnthropicStructuredOutputInput(options, request) {
+  const baseInput = {
+    messages: request.messages,
+    temperature: request.temperature ?? options.temperature,
+    maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+    abortSignal: request.abortSignal
+  };
+  if (isZodV4Schema(request.schema)) {
+    return {
+      ...baseInput,
+      structuredOutputJsonSchema: buildAnthropicStructuredOutputJsonSchema(
+        request.schema
+      )
+    };
+  }
+  return {
+    ...baseInput,
+    messages: prependStructuredOutputJsonOnlySystemMessage(request.messages)
+  };
+}
 function buildAnthropicCallInput(options, request) {
   return {
     messages: request.messages,
@@ -1789,13 +1872,10 @@ function gemini(options) {
       });
     },
     async generateStructuredOutput(request) {
-      const completion = await executeGeminiAdapterCall(options, {
-        messages: request.messages,
-        temperature: request.temperature ?? options.temperature,
-        maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
-        responseSchema: buildGeminiResponseSchema(request.schema),
-        abortSignal: request.abortSignal
-      });
+      const completion = await executeGeminiAdapterCall(
+        options,
+        buildGeminiStructuredOutputInput(options, request)
+      );
       return {
         value: parseStructuredJsonText(completion.content, request.schema),
         tokenUsage: completion.tokenUsage,
@@ -1804,6 +1884,25 @@ function gemini(options) {
     }
   };
 }
+function buildGeminiStructuredOutputInput(options, request) {
+  const baseInput = {
+    messages: request.messages,
+    temperature: request.temperature ?? options.temperature,
+    maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+    abortSignal: request.abortSignal
+  };
+  if (isZodV4Schema(request.schema)) {
+    return {
+      ...baseInput,
+      responseSchema: buildGeminiResponseSchema(request.schema)
+    };
+  }
+  return {
+    ...baseInput,
+    messages: prependStructuredOutputJsonOnlySystemMessage(request.messages),
+    requireJsonResponse: true
+  };
+}
 async function executeGeminiAdapterCall(options, input) {
   return await executeProviderCallWithModelFallback(
     options.fallbackModel,
@@ -1921,6 +2020,8 @@ function buildGeminiGenerationConfig(input) {
   if (input.responseSchema !== void 0) {
     generationConfig.responseMimeType = "application/json";
     generationConfig.responseSchema = input.responseSchema;
+  } else if (input.requireJsonResponse === true) {
+    generationConfig.responseMimeType = "application/json";
   }
   if (Object.keys(generationConfig).length === 0) {
     return void 0;
@@ -2128,7 +2229,7 @@ var import_errors29 = require("@assemble-dev/shared-utils/errors");
 var import_errors26 = require("@assemble-dev/shared-types/errors");
 var import_json7 = require("@assemble-dev/shared-types/json");
 var import_errors27 = require("@assemble-dev/shared-utils/errors");
-var anthropicBatchJsonOnlySystemInstruction = "Respond with a single JSON object that satisfies the caller's requested structure. Output only valid JSON with no surrounding text.";
+var anthropicBatchJsonOnlySystemInstruction = structuredOutputJsonOnlySystemInstruction;
 function parseAnthropicBatchStructuredContent(content, schema) {
   const jsonValue = parseStructuredJsonText(
     content,
@@ -2935,6 +3036,7 @@ function azureOpenai(options) {
         messages: request.messages,
         temperature: request.temperature ?? options.temperature,
         maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+        reasoningModel: options.reasoningModel,
         tools: request.tools,
         toolChoice: request.toolChoice,
         abortSignal: request.abortSignal,
@@ -2943,12 +3045,10 @@ function azureOpenai(options) {
     },
     async generateStructuredOutput(request) {
       const completion = await executeAzureOpenAiAdapterCall(options, {
-        messages: request.messages,
+        ...resolveOpenAiStructuredOutputMode(request.messages, request.schema),
         temperature: request.temperature ?? options.temperature,
         maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
-        structuredOutputJsonSchema: buildOpenAiStructuredOutputJsonSchema(
-          request.schema
-        ),
+        reasoningModel: options.reasoningModel,
         abortSignal: request.abortSignal
       });
       return {
@@ -3047,6 +3147,7 @@ function buildAzureOpenAiStreamInput(options, request) {
       messages: request.messages,
       temperature: request.temperature ?? options.temperature,
       maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+      reasoningModel: options.reasoningModel,
       tools: request.tools,
       toolChoice: request.toolChoice,
       abortSignal: request.abortSignal,
@@ -3341,6 +3442,9 @@ function buildBedrockInvokeModelRequestBody(input) {
   };
 }
 function buildBedrockStructuredOutputSystemMessage(schema) {
+  if (!isZodV4Schema(schema)) {
+    return structuredOutputJsonOnlySystemMessage;
+  }
   return {
     role: "system",
     content: `Respond with a single JSON object that satisfies the following JSON Schema. Output only valid JSON with no surrounding text.
@@ -3349,6 +3453,425 @@ JSON Schema:
 ${JSON.stringify(convertZodSchemaToJsonSchema(schema))}`
   };
 }
+
+// src/openrouter-adapter.ts
+var import_zod12 = require("zod");
+var import_errors36 = require("@assemble-dev/shared-types/errors");
+var import_json10 = require("@assemble-dev/shared-types/json");
+var import_errors37 = require("@assemble-dev/shared-utils/errors");
+var defaultOpenRouterBaseUrl = "https://openrouter.ai/api/v1";
+var OpenRouterResponseToolCallSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  function: import_zod12.z.object({
+    name: import_zod12.z.string(),
+    arguments: import_zod12.z.string()
+  })
+});
+var OpenRouterChatCompletionResponseSchema = import_zod12.z.object({
+  choices: import_zod12.z.array(
+    import_zod12.z.object({
+      message: import_zod12.z.object({
+        content: import_zod12.z.string().nullable(),
+        tool_calls: import_zod12.z.array(OpenRouterResponseToolCallSchema).optional()
+      }),
+      finish_reason: import_zod12.z.string().nullable().optional()
+    })
+  ).min(1),
+  usage: import_zod12.z.object({
+    prompt_tokens: import_zod12.z.number().int().nonnegative(),
+    completion_tokens: import_zod12.z.number().int().nonnegative(),
+    total_tokens: import_zod12.z.number().int().nonnegative()
+  })
+});
+function openrouter(options) {
+  return {
+    name: `openrouter:${options.model}`,
+    async generateChatCompletion(request) {
+      return await executeOpenRouterAdapterCall(options, {
+        messages: request.messages,
+        temperature: request.temperature ?? options.temperature,
+        maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+        reasoningModel: options.reasoningModel,
+        tools: request.tools,
+        toolChoice: request.toolChoice,
+        abortSignal: request.abortSignal,
+        extraBody: request.extraBody
+      });
+    },
+    async generateStructuredOutput(request) {
+      const completion = await executeOpenRouterAdapterCall(options, {
+        ...resolveOpenAiStructuredOutputMode(request.messages, request.schema),
+        temperature: request.temperature ?? options.temperature,
+        maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+        reasoningModel: options.reasoningModel,
+        abortSignal: request.abortSignal
+      });
+      return {
+        value: parseStructuredJsonText(completion.content, request.schema),
+        tokenUsage: completion.tokenUsage,
+        latencyMs: completion.latencyMs
+      };
+    }
+  };
+}
+async function executeOpenRouterAdapterCall(options, input) {
+  return await executeProviderCallWithModelFallback(
+    options.fallbackModel,
+    async () => await executeProviderCallWithRetry(
+      options.retry,
+      async () => await requestOpenRouterChatCompletion(options, input)
+    ),
+    async (fallbackModelId) => await requestOpenRouterChatCompletion(
+      { ...options, model: fallbackModelId },
+      input
+    )
+  );
+}
+function buildOpenRouterRequestHeaders(options, apiKey) {
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${apiKey}`
+  };
+  if (options.appUrl !== void 0) {
+    headers["HTTP-Referer"] = options.appUrl;
+  }
+  if (options.appName !== void 0) {
+    headers["X-Title"] = options.appName;
+  }
+  return headers;
+}
+async function requestOpenRouterChatCompletion(options, input) {
+  const apiKey = resolveProviderApiKey({
+    providerLabel: "OpenRouter",
+    adapterFunctionName: "openrouter()",
+    baseEnvVarName: "OPENROUTER_API_KEY",
+    apiKey: options.apiKey,
+    apiKeyName: options.apiKeyName
+  });
+  const fetchImplementation = options.fetchImplementation ?? fetch;
+  const baseUrl = options.baseURL ?? defaultOpenRouterBaseUrl;
+  const requestBody = mergeProviderRequestExtraBody(
+    buildOpenAiRequestBody(options.model, input),
+    options.extraBody,
+    input.extraBody
+  );
+  const startedAt = Date.now();
+  const response = await executeAbortableProviderFetch(
+    "OpenRouter",
+    async () => await fetchImplementation(`${baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: buildOpenRouterRequestHeaders(options, apiKey),
+      body: JSON.stringify(requestBody),
+      signal: input.abortSignal
+    })
+  );
+  const latencyMs = Date.now() - startedAt;
+  if (!response.ok) {
+    throw buildProviderStatusError("OpenRouter", response.status);
+  }
+  const parseResult = OpenRouterChatCompletionResponseSchema.safeParse(
+    await response.json()
+  );
+  if (!parseResult.success) {
+    throw buildProviderInvalidResponseError("OpenRouter", "chat completion");
+  }
+  return mapOpenRouterResponseToChatCompletionResult(
+    parseResult.data,
+    latencyMs
+  );
+}
+function mapOpenRouterResponseToChatCompletionResult(response, latencyMs) {
+  const toolCalls = extractOpenRouterToolCalls(response);
+  const result = {
+    content: extractOpenRouterMessageContent(response, toolCalls.length > 0),
+    tokenUsage: mapOpenRouterUsageToTokenUsage(response),
+    latencyMs
+  };
+  const finishReason = response.choices[0]?.finish_reason;
+  if (toolCalls.length > 0) {
+    result.toolCalls = toolCalls;
+  }
+  if (finishReason !== null && finishReason !== void 0) {
+    result.stopReason = normalizeOpenRouterFinishReason(finishReason);
+  }
+  return result;
+}
+function extractOpenRouterToolCalls(response) {
+  const responseToolCalls = response.choices[0]?.message.tool_calls ?? [];
+  return responseToolCalls.map((responseToolCall) => ({
+    id: responseToolCall.id,
+    toolName: responseToolCall.function.name,
+    input: parseOpenRouterToolArgumentsJson(
+      responseToolCall.function.arguments
+    )
+  }));
+}
+function parseOpenRouterToolArgumentsJson(argumentsJsonText) {
+  if (argumentsJsonText.trim().length === 0) {
+    return {};
+  }
+  try {
+    return import_json10.JsonValueSchema.parse(JSON.parse(argumentsJsonText));
+  } catch (error) {
+    throw new import_errors37.AppError({
+      code: import_errors36.AppErrorCode.ValidationFailed,
+      message: "OpenRouter tool call arguments were not valid JSON",
+      statusCode: 502,
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+}
+function normalizeOpenRouterFinishReason(finishReason) {
+  if (finishReason === "tool_calls") {
+    return "tool_use";
+  }
+  if (finishReason === "length") {
+    return "max_tokens";
+  }
+  return "end_turn";
+}
+function extractOpenRouterMessageContent(response, allowEmptyContent) {
+  const content = response.choices[0]?.message.content;
+  if (content === void 0 || content === null) {
+    if (allowEmptyContent) {
+      return "";
+    }
+    throw new import_errors37.AppError({
+      code: import_errors36.AppErrorCode.ValidationFailed,
+      message: "OpenRouter response contained no message content",
+      statusCode: 502
+    });
+  }
+  return content;
+}
+function mapOpenRouterUsageToTokenUsage(response) {
+  return {
+    inputTokens: response.usage.prompt_tokens,
+    outputTokens: response.usage.completion_tokens,
+    totalTokens: response.usage.total_tokens
+  };
+}
+
+// src/cloudflare-workers-ai-adapter.ts
+var import_zod13 = require("zod");
+var import_errors38 = require("@assemble-dev/shared-types/errors");
+var import_json11 = require("@assemble-dev/shared-types/json");
+var import_errors39 = require("@assemble-dev/shared-utils/errors");
+var defaultCloudflareApiBaseUrl = "https://api.cloudflare.com/client/v4";
+var cloudflareAccountIdEnvVarName = "CLOUDFLARE_ACCOUNT_ID";
+var CloudflareWorkersAiResponseToolCallSchema = import_zod13.z.object({
+  id: import_zod13.z.string(),
+  function: import_zod13.z.object({
+    name: import_zod13.z.string(),
+    arguments: import_zod13.z.string()
+  })
+});
+var CloudflareWorkersAiChatCompletionResponseSchema = import_zod13.z.object({
+  choices: import_zod13.z.array(
+    import_zod13.z.object({
+      message: import_zod13.z.object({
+        content: import_zod13.z.string().nullable(),
+        tool_calls: import_zod13.z.array(CloudflareWorkersAiResponseToolCallSchema).optional()
+      }),
+      finish_reason: import_zod13.z.string().nullable().optional()
+    })
+  ).min(1),
+  usage: import_zod13.z.object({
+    prompt_tokens: import_zod13.z.number().int().nonnegative(),
+    completion_tokens: import_zod13.z.number().int().nonnegative(),
+    total_tokens: import_zod13.z.number().int().nonnegative()
+  }).optional()
+});
+function cloudflareWorkersAi(options) {
+  return {
+    name: `cloudflare-workers-ai:${options.model}`,
+    async generateChatCompletion(request) {
+      return await executeCloudflareWorkersAiAdapterCall(options, {
+        messages: request.messages,
+        temperature: request.temperature ?? options.temperature,
+        maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+        tools: request.tools,
+        toolChoice: request.toolChoice,
+        abortSignal: request.abortSignal,
+        extraBody: request.extraBody
+      });
+    },
+    async generateStructuredOutput(request) {
+      const completion = await executeCloudflareWorkersAiAdapterCall(options, {
+        ...resolveOpenAiStructuredOutputMode(request.messages, request.schema),
+        temperature: request.temperature ?? options.temperature,
+        maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+        abortSignal: request.abortSignal
+      });
+      return {
+        value: parseStructuredJsonText(completion.content, request.schema),
+        tokenUsage: completion.tokenUsage,
+        latencyMs: completion.latencyMs
+      };
+    }
+  };
+}
+function buildCloudflareWorkersAiChatCompletionsUrl(options) {
+  if (options.baseURL !== void 0 && options.baseURL.length > 0) {
+    return `${options.baseURL.replace(/\/+$/, "")}/chat/completions`;
+  }
+  const accountId = resolveCloudflareWorkersAiAccountId(options);
+  return `${defaultCloudflareApiBaseUrl}/accounts/${encodeURIComponent(accountId)}/ai/v1/chat/completions`;
+}
+function resolveCloudflareWorkersAiAccountId(options) {
+  if (options.accountId !== void 0 && options.accountId.length > 0) {
+    return options.accountId;
+  }
+  const envAccountId = readEnvironmentVariable2(cloudflareAccountIdEnvVarName);
+  if (envAccountId !== void 0 && envAccountId.length > 0) {
+    return envAccountId;
+  }
+  throw new import_errors39.AppError({
+    code: import_errors38.AppErrorCode.BadRequest,
+    message: "Cloudflare Workers AI account is missing. Pass accountId or baseURL to cloudflareWorkersAi() or set the CLOUDFLARE_ACCOUNT_ID environment variable.",
+    statusCode: 400
+  });
+}
+function readEnvironmentVariable2(envVarName) {
+  const parsedEnv = import_zod13.z.object({ [envVarName]: import_zod13.z.string().optional() }).parse(process.env);
+  return parsedEnv[envVarName];
+}
+async function executeCloudflareWorkersAiAdapterCall(options, input) {
+  return await executeProviderCallWithModelFallback(
+    options.fallbackModel,
+    async () => await executeProviderCallWithRetry(
+      options.retry,
+      async () => await requestCloudflareWorkersAiChatCompletion(options, input)
+    ),
+    async (fallbackModelId) => await requestCloudflareWorkersAiChatCompletion(
+      { ...options, model: fallbackModelId },
+      input
+    )
+  );
+}
+async function requestCloudflareWorkersAiChatCompletion(options, input) {
+  const apiToken = resolveProviderApiKey({
+    providerLabel: "Cloudflare Workers AI",
+    adapterFunctionName: "cloudflareWorkersAi()",
+    baseEnvVarName: "CLOUDFLARE_API_TOKEN",
+    apiKey: options.apiKey,
+    apiKeyName: options.apiKeyName
+  });
+  const fetchImplementation = options.fetchImplementation ?? fetch;
+  const requestUrl = buildCloudflareWorkersAiChatCompletionsUrl(options);
+  const requestBody = mergeProviderRequestExtraBody(
+    buildOpenAiRequestBody(options.model, input),
+    options.extraBody,
+    input.extraBody
+  );
+  const startedAt = Date.now();
+  const response = await executeAbortableProviderFetch(
+    "Cloudflare Workers AI",
+    async () => await fetchImplementation(requestUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiToken}`
+      },
+      body: JSON.stringify(requestBody),
+      signal: input.abortSignal
+    })
+  );
+  const latencyMs = Date.now() - startedAt;
+  if (!response.ok) {
+    throw buildProviderStatusError("Cloudflare Workers AI", response.status);
+  }
+  const parseResult = CloudflareWorkersAiChatCompletionResponseSchema.safeParse(
+    await response.json()
+  );
+  if (!parseResult.success) {
+    throw buildProviderInvalidResponseError(
+      "Cloudflare Workers AI",
+      "chat completion"
+    );
+  }
+  return mapCloudflareWorkersAiResponseToChatCompletionResult(
+    parseResult.data,
+    latencyMs
+  );
+}
+function mapCloudflareWorkersAiResponseToChatCompletionResult(response, latencyMs) {
+  const toolCalls = extractCloudflareWorkersAiToolCalls(response);
+  const result = {
+    content: extractCloudflareWorkersAiMessageContent(
+      response,
+      toolCalls.length > 0
+    ),
+    tokenUsage: mapCloudflareWorkersAiUsageToTokenUsage(response),
+    latencyMs
+  };
+  const finishReason = response.choices[0]?.finish_reason;
+  if (toolCalls.length > 0) {
+    result.toolCalls = toolCalls;
+  }
+  if (finishReason !== null && finishReason !== void 0) {
+    result.stopReason = normalizeCloudflareWorkersAiFinishReason(finishReason);
+  }
+  return result;
+}
+function extractCloudflareWorkersAiToolCalls(response) {
+  const responseToolCalls = response.choices[0]?.message.tool_calls ?? [];
+  return responseToolCalls.map((responseToolCall) => ({
+    id: responseToolCall.id,
+    toolName: responseToolCall.function.name,
+    input: parseCloudflareWorkersAiToolArgumentsJson(
+      responseToolCall.function.arguments
+    )
+  }));
+}
+function parseCloudflareWorkersAiToolArgumentsJson(argumentsJsonText) {
+  if (argumentsJsonText.trim().length === 0) {
+    return {};
+  }
+  try {
+    return import_json11.JsonValueSchema.parse(JSON.parse(argumentsJsonText));
+  } catch (error) {
+    throw new import_errors39.AppError({
+      code: import_errors38.AppErrorCode.ValidationFailed,
+      message: "Cloudflare Workers AI tool call arguments were not valid JSON",
+      statusCode: 502,
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+}
+function normalizeCloudflareWorkersAiFinishReason(finishReason) {
+  if (finishReason === "tool_calls") {
+    return "tool_use";
+  }
+  if (finishReason === "length") {
+    return "max_tokens";
+  }
+  return "end_turn";
+}
+function extractCloudflareWorkersAiMessageContent(response, allowEmptyContent) {
+  const content = response.choices[0]?.message.content;
+  if (content === void 0 || content === null) {
+    if (allowEmptyContent) {
+      return "";
+    }
+    throw new import_errors39.AppError({
+      code: import_errors38.AppErrorCode.ValidationFailed,
+      message: "Cloudflare Workers AI response contained no message content",
+      statusCode: 502
+    });
+  }
+  return content;
+}
+function mapCloudflareWorkersAiUsageToTokenUsage(response) {
+  if (response.usage === void 0) {
+    return { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+  }
+  return {
+    inputTokens: response.usage.prompt_tokens,
+    outputTokens: response.usage.completion_tokens,
+    totalTokens: response.usage.total_tokens
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AnthropicMessagesResponseSchema,
@@ -3375,11 +3898,13 @@ ${JSON.stringify(convertZodSchemaToJsonSchema(schema))}`
   buildAzureOpenAiChatRequestBody,
   buildBedrockInvokeModelRequestBody,
   buildBedrockInvokeModelUrl,
+  buildCloudflareWorkersAiChatCompletionsUrl,
   buildGeminiResponseSchema,
   buildOpenAiRequestBody,
   buildOpenAiStructuredOutputJsonSchema,
   buildProviderCanceledError,
   calculateProviderRetryDelayMs,
+  cloudflareWorkersAi,
   convertZodSchemaToJsonSchema,
   createAnthropicBatchClient,
   defaultAnthropicBaseUrl,
@@ -3388,8 +3913,10 @@ ${JSON.stringify(convertZodSchemaToJsonSchema(schema))}`
   defaultAnthropicMaxOutputTokens,
   defaultAzureOpenAiApiVersion,
   defaultBedrockMaxOutputTokens,
+  defaultCloudflareApiBaseUrl,
   defaultGeminiBaseUrl,
   defaultOpenAiBaseUrl,
+  defaultOpenRouterBaseUrl,
   defaultProviderRetryInitialDelayMs,
   defaultProviderRetryMaxAttempts,
   defaultProviderRetryMaxDelayMs,
@@ -3403,7 +3930,9 @@ ${JSON.stringify(convertZodSchemaToJsonSchema(schema))}`
   extractMessageText,
   gemini,
   isAbortError,
+  isOpenAiReasoningModel,
   isRetryableProviderAppError,
+  isZodV4Schema,
   joinSystemMessageText,
   mapAnthropicResponseToChatCompletionResult,
   mapAnthropicUsageToTokenUsage,
@@ -3421,18 +3950,23 @@ ${JSON.stringify(convertZodSchemaToJsonSchema(schema))}`
   normalizeAzureOpenAiFinishReason,
   openAiStructuredOutputSchemaName,
   openai,
+  openrouter,
   parseAnthropicBatchStructuredContent,
   parseAnthropicStreamEvents,
   parseAnthropicToolInputJson,
   parseAzureOpenAiStreamEvents,
   parseAzureOpenAiToolArgumentsJson,
+  prependStructuredOutputJsonOnlySystemMessage,
   resolveAnthropicPromptCachingSettings,
   resolveBedrockCredentials,
+  resolveOpenAiStructuredOutputMode,
   resolveProviderApiKey,
   sanitizeJsonSchemaForAnthropicStructuredOutput,
   sanitizeJsonSchemaForGeminiResponseSchema,
   sanitizeJsonSchemaForOpenAiStructuredOutput,
   signAwsRequestWithSigV4,
   streamAnthropicChatCompletion,
-  streamAzureOpenAiChatCompletion
+  streamAzureOpenAiChatCompletion,
+  structuredOutputJsonOnlySystemInstruction,
+  structuredOutputJsonOnlySystemMessage
 });