@assemble-dev/providers 0.3.0 → 0.4.0

package/dist/index.js

@@ -204,6 +204,9 @@ var openAiUnsupportedSchemaKeywords = [
   "uniqueItems",
   "default"
 ];
+function isZodV4Schema(schema) {
+  return "_zod" in schema;
+}
 function convertZodSchemaToJsonSchema(schema) {
   try {
     return JsonObjectSchema.parse(z2.toJSONSchema(schema, { io: "input" }));
@@ -268,18 +271,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",
@@ -289,9 +346,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);
   }
@@ -300,7 +361,6 @@ function buildOpenAiRequestBody(model, input) {
       input.toolChoice
     );
   }
-  return requestBody;
 }
 function mapModelToolDefinitionToOpenAiTool(tool) {
   return {
@@ -665,12 +725,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 {
@@ -1438,15 +1495,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,
@@ -1460,6 +1512,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,
@@ -1684,13 +1756,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,
@@ -1699,6 +1768,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,
@@ -1816,6 +1904,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;
@@ -2023,7 +2113,7 @@ import { AppError as AppError15 } from "@assemble-dev/shared-utils/errors";
 import { AppErrorCode as AppErrorCode13 } from "@assemble-dev/shared-types/errors";
 import { JsonValueSchema as JsonValueSchema6 } from "@assemble-dev/shared-types/json";
 import { AppError as AppError14 } from "@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,
@@ -2833,6 +2923,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,
@@ -2841,12 +2932,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 {
@@ -2945,6 +3034,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,
@@ -3239,6 +3329,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.
@@ -3247,6 +3340,425 @@ JSON Schema:
 ${JSON.stringify(convertZodSchemaToJsonSchema(schema))}`
   };
 }
+
+// src/openrouter-adapter.ts
+import { z as z12 } from "zod";
+import { AppErrorCode as AppErrorCode18 } from "@assemble-dev/shared-types/errors";
+import { JsonValueSchema as JsonValueSchema9 } from "@assemble-dev/shared-types/json";
+import { AppError as AppError19 } from "@assemble-dev/shared-utils/errors";
+var defaultOpenRouterBaseUrl = "https://openrouter.ai/api/v1";
+var OpenRouterResponseToolCallSchema = z12.object({
+  id: z12.string(),
+  function: z12.object({
+    name: z12.string(),
+    arguments: z12.string()
+  })
+});
+var OpenRouterChatCompletionResponseSchema = z12.object({
+  choices: z12.array(
+    z12.object({
+      message: z12.object({
+        content: z12.string().nullable(),
+        tool_calls: z12.array(OpenRouterResponseToolCallSchema).optional()
+      }),
+      finish_reason: z12.string().nullable().optional()
+    })
+  ).min(1),
+  usage: z12.object({
+    prompt_tokens: z12.number().int().nonnegative(),
+    completion_tokens: z12.number().int().nonnegative(),
+    total_tokens: z12.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 JsonValueSchema9.parse(JSON.parse(argumentsJsonText));
+  } catch (error) {
+    throw new AppError19({
+      code: AppErrorCode18.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 AppError19({
+      code: AppErrorCode18.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
+import { z as z13 } from "zod";
+import { AppErrorCode as AppErrorCode19 } from "@assemble-dev/shared-types/errors";
+import { JsonValueSchema as JsonValueSchema10 } from "@assemble-dev/shared-types/json";
+import { AppError as AppError20 } from "@assemble-dev/shared-utils/errors";
+var defaultCloudflareApiBaseUrl = "https://api.cloudflare.com/client/v4";
+var cloudflareAccountIdEnvVarName = "CLOUDFLARE_ACCOUNT_ID";
+var CloudflareWorkersAiResponseToolCallSchema = z13.object({
+  id: z13.string(),
+  function: z13.object({
+    name: z13.string(),
+    arguments: z13.string()
+  })
+});
+var CloudflareWorkersAiChatCompletionResponseSchema = z13.object({
+  choices: z13.array(
+    z13.object({
+      message: z13.object({
+        content: z13.string().nullable(),
+        tool_calls: z13.array(CloudflareWorkersAiResponseToolCallSchema).optional()
+      }),
+      finish_reason: z13.string().nullable().optional()
+    })
+  ).min(1),
+  usage: z13.object({
+    prompt_tokens: z13.number().int().nonnegative(),
+    completion_tokens: z13.number().int().nonnegative(),
+    total_tokens: z13.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 AppError20({
+    code: AppErrorCode19.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 = z13.object({ [envVarName]: z13.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 JsonValueSchema10.parse(JSON.parse(argumentsJsonText));
+  } catch (error) {
+    throw new AppError20({
+      code: AppErrorCode19.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 AppError20({
+      code: AppErrorCode19.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
+  };
+}
 export {
   AnthropicMessagesResponseSchema,
   AnthropicStreamEventSchema,
@@ -3272,11 +3784,13 @@ export {
   buildAzureOpenAiChatRequestBody,
   buildBedrockInvokeModelRequestBody,
   buildBedrockInvokeModelUrl,
+  buildCloudflareWorkersAiChatCompletionsUrl,
   buildGeminiResponseSchema,
   buildOpenAiRequestBody,
   buildOpenAiStructuredOutputJsonSchema,
   buildProviderCanceledError,
   calculateProviderRetryDelayMs,
+  cloudflareWorkersAi,
   convertZodSchemaToJsonSchema,
   createAnthropicBatchClient,
   defaultAnthropicBaseUrl,
@@ -3285,8 +3799,10 @@ export {
   defaultAnthropicMaxOutputTokens,
   defaultAzureOpenAiApiVersion,
   defaultBedrockMaxOutputTokens,
+  defaultCloudflareApiBaseUrl,
   defaultGeminiBaseUrl,
   defaultOpenAiBaseUrl,
+  defaultOpenRouterBaseUrl,
   defaultProviderRetryInitialDelayMs,
   defaultProviderRetryMaxAttempts,
   defaultProviderRetryMaxDelayMs,
@@ -3300,7 +3816,9 @@ export {
   extractMessageText,
   gemini,
   isAbortError,
+  isOpenAiReasoningModel,
   isRetryableProviderAppError,
+  isZodV4Schema,
   joinSystemMessageText,
   mapAnthropicResponseToChatCompletionResult,
   mapAnthropicUsageToTokenUsage,
@@ -3318,18 +3836,23 @@ export {
   normalizeAzureOpenAiFinishReason,
   openAiStructuredOutputSchemaName,
   openai,
+  openrouter,
   parseAnthropicBatchStructuredContent,
   parseAnthropicStreamEvents,
   parseAnthropicToolInputJson,
   parseAzureOpenAiStreamEvents,
   parseAzureOpenAiToolArgumentsJson,
+  prependStructuredOutputJsonOnlySystemMessage,
   resolveAnthropicPromptCachingSettings,
   resolveBedrockCredentials,
+  resolveOpenAiStructuredOutputMode,
   resolveProviderApiKey,
   sanitizeJsonSchemaForAnthropicStructuredOutput,
   sanitizeJsonSchemaForGeminiResponseSchema,
   sanitizeJsonSchemaForOpenAiStructuredOutput,
   signAwsRequestWithSigV4,
   streamAnthropicChatCompletion,
-  streamAzureOpenAiChatCompletion
+  streamAzureOpenAiChatCompletion,
+  structuredOutputJsonOnlySystemInstruction,
+  structuredOutputJsonOnlySystemMessage
 };