@assemble-dev/providers 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1989 @@
+"use strict";
+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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AnthropicMessagesResponseSchema: () => AnthropicMessagesResponseSchema,
+  AnthropicStreamEventSchema: () => AnthropicStreamEventSchema,
+  ChatMessageRoleSchema: () => ChatMessageRoleSchema,
+  ChatMessageSchema: () => ChatMessageSchema,
+  ChatStopReasonSchema: () => ChatStopReasonSchema,
+  MessageContentBlockSchema: () => MessageContentBlockSchema,
+  ModelToolCallSchema: () => ModelToolCallSchema,
+  anthropic: () => anthropic,
+  buildAnthropicRequestBody: () => buildAnthropicRequestBody,
+  buildOpenAiRequestBody: () => buildOpenAiRequestBody,
+  buildProviderCanceledError: () => buildProviderCanceledError,
+  calculateProviderRetryDelayMs: () => calculateProviderRetryDelayMs,
+  createAnthropicBatchClient: () => createAnthropicBatchClient,
+  defaultAnthropicBaseUrl: () => defaultAnthropicBaseUrl,
+  defaultAnthropicBatchPollIntervalMs: () => defaultAnthropicBatchPollIntervalMs,
+  defaultAnthropicBatchTimeoutMs: () => defaultAnthropicBatchTimeoutMs,
+  defaultAnthropicMaxOutputTokens: () => defaultAnthropicMaxOutputTokens,
+  defaultGeminiBaseUrl: () => defaultGeminiBaseUrl,
+  defaultOpenAiBaseUrl: () => defaultOpenAiBaseUrl,
+  defaultProviderRetryInitialDelayMs: () => defaultProviderRetryInitialDelayMs,
+  defaultProviderRetryMaxAttempts: () => defaultProviderRetryMaxAttempts,
+  defaultProviderRetryMaxDelayMs: () => defaultProviderRetryMaxDelayMs,
+  estimateModelCallCostUsd: () => estimateModelCallCostUsd,
+  executeAbortableProviderFetch: () => executeAbortableProviderFetch,
+  executeProviderCallWithModelFallback: () => executeProviderCallWithModelFallback,
+  executeProviderCallWithRetry: () => executeProviderCallWithRetry,
+  extractAnthropicTextContent: () => extractAnthropicTextContent,
+  extractAnthropicToolCalls: () => extractAnthropicToolCalls,
+  extractMessageText: () => extractMessageText,
+  gemini: () => gemini,
+  isAbortError: () => isAbortError,
+  isRetryableProviderAppError: () => isRetryableProviderAppError,
+  joinSystemMessageText: () => joinSystemMessageText,
+  mapAnthropicResponseToChatCompletionResult: () => mapAnthropicResponseToChatCompletionResult,
+  mapAnthropicUsageToTokenUsage: () => mapAnthropicUsageToTokenUsage,
+  mapChatMessageToAnthropicRequestMessage: () => mapChatMessageToAnthropicRequestMessage,
+  mapChatMessageToOpenAiRequestMessage: () => mapChatMessageToOpenAiRequestMessage,
+  mapModelToolChoiceToAnthropicToolChoice: () => mapModelToolChoiceToAnthropicToolChoice,
+  mapModelToolChoiceToOpenAiToolChoice: () => mapModelToolChoiceToOpenAiToolChoice,
+  mapModelToolDefinitionToOpenAiTool: () => mapModelToolDefinitionToOpenAiTool,
+  mapModelToolDefinitionsToAnthropicTools: () => mapModelToolDefinitionsToAnthropicTools,
+  mockModel: () => mockModel,
+  normalizeAnthropicStopReason: () => normalizeAnthropicStopReason,
+  openai: () => openai,
+  parseAnthropicStreamEvents: () => parseAnthropicStreamEvents,
+  parseAnthropicToolInputJson: () => parseAnthropicToolInputJson,
+  resolveProviderApiKey: () => resolveProviderApiKey,
+  streamAnthropicChatCompletion: () => streamAnthropicChatCompletion
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/model-adapter.ts
+var import_zod = require("zod");
+var import_json = require("@assemble-dev/shared-types/json");
+var ChatMessageRoleSchema = import_zod.z.enum([
+  "system",
+  "user",
+  "assistant",
+  "tool"
+]);
+var MessageContentBlockSchema = import_zod.z.discriminatedUnion("type", [
+  import_zod.z.object({
+    type: import_zod.z.literal("text"),
+    text: import_zod.z.string()
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("image"),
+    mediaType: import_zod.z.string(),
+    dataBase64: import_zod.z.string()
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("document"),
+    mediaType: import_zod.z.string(),
+    dataBase64: import_zod.z.string()
+  })
+]);
+var ModelToolCallSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  toolName: import_zod.z.string(),
+  input: import_json.JsonValueSchema
+});
+var ChatMessageSchema = import_zod.z.object({
+  role: ChatMessageRoleSchema,
+  content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(MessageContentBlockSchema)]),
+  toolName: import_zod.z.string().optional(),
+  toolCallId: import_zod.z.string().optional(),
+  toolCalls: import_zod.z.array(ModelToolCallSchema).optional()
+});
+var ChatStopReasonSchema = import_zod.z.enum([
+  "end_turn",
+  "tool_use",
+  "max_tokens",
+  "stop_sequence"
+]);
+function extractMessageText(message) {
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  return message.content.filter((contentBlock) => contentBlock.type === "text").map((contentBlock) => contentBlock.text).join("");
+}
+
+// src/openai-adapter.ts
+var import_zod3 = require("zod");
+var import_errors14 = require("@assemble-dev/shared-types/errors");
+var import_json3 = require("@assemble-dev/shared-types/json");
+var import_errors15 = require("@assemble-dev/shared-utils/errors");
+
+// src/openai-request-mapping.ts
+var import_errors = require("@assemble-dev/shared-types/errors");
+var import_errors2 = require("@assemble-dev/shared-utils/errors");
+function buildOpenAiRequestBody(model, input) {
+  const requestBody = {
+    model,
+    messages: input.messages.map(mapChatMessageToOpenAiRequestMessage)
+  };
+  if (input.temperature !== void 0) {
+    requestBody.temperature = input.temperature;
+  }
+  if (input.maxOutputTokens !== void 0) {
+    requestBody.max_tokens = input.maxOutputTokens;
+  }
+  if (input.requireJsonObjectResponse) {
+    requestBody.response_format = { type: "json_object" };
+  }
+  if (input.tools !== void 0 && input.tools.length > 0) {
+    requestBody.tools = input.tools.map(mapModelToolDefinitionToOpenAiTool);
+  }
+  if (input.toolChoice !== void 0) {
+    requestBody.tool_choice = mapModelToolChoiceToOpenAiToolChoice(
+      input.toolChoice
+    );
+  }
+  return requestBody;
+}
+function mapModelToolDefinitionToOpenAiTool(tool) {
+  return {
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputJsonSchema
+    }
+  };
+}
+function mapModelToolChoiceToOpenAiToolChoice(toolChoice) {
+  if (toolChoice === "auto" || toolChoice === "required" || toolChoice === "none") {
+    return toolChoice;
+  }
+  return { type: "function", function: { name: toolChoice.toolName } };
+}
+function mapChatMessageToOpenAiRequestMessage(message) {
+  if (message.role === "tool" && message.toolCallId !== void 0) {
+    return {
+      role: "tool",
+      tool_call_id: message.toolCallId,
+      content: extractMessageText(message)
+    };
+  }
+  if (message.role === "assistant" && message.toolCalls !== void 0 && message.toolCalls.length > 0) {
+    return mapAssistantToolCallMessageToOpenAiRequestMessage(message);
+  }
+  const requestMessage = {
+    role: message.role,
+    content: mapMessageContentToOpenAi(message)
+  };
+  if (message.toolName !== void 0) {
+    requestMessage.name = message.toolName;
+  }
+  return requestMessage;
+}
+function mapAssistantToolCallMessageToOpenAiRequestMessage(message) {
+  const assistantText = extractMessageText(message);
+  const toolCalls = message.toolCalls ?? [];
+  return {
+    role: "assistant",
+    content: assistantText.length > 0 ? assistantText : null,
+    tool_calls: toolCalls.map(mapModelToolCallToOpenAiRequestToolCall)
+  };
+}
+function mapModelToolCallToOpenAiRequestToolCall(toolCall) {
+  return {
+    id: toolCall.id,
+    type: "function",
+    function: {
+      name: toolCall.toolName,
+      arguments: JSON.stringify(toolCall.input)
+    }
+  };
+}
+function mapMessageContentToOpenAi(message) {
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  return message.content.map(mapMessageContentBlockToOpenAiContentPart);
+}
+function mapMessageContentBlockToOpenAiContentPart(contentBlock) {
+  if (contentBlock.type === "text") {
+    return { type: "text", text: contentBlock.text };
+  }
+  if (contentBlock.type === "image") {
+    return {
+      type: "image_url",
+      image_url: {
+        url: `data:${contentBlock.mediaType};base64,${contentBlock.dataBase64}`
+      }
+    };
+  }
+  throw new import_errors2.AppError({
+    code: import_errors.AppErrorCode.ValidationFailed,
+    message: "OpenAI adapter does not support document content blocks in chat messages",
+    statusCode: 400
+  });
+}
+
+// src/parse-structured-json.ts
+var import_errors3 = require("@assemble-dev/shared-types/errors");
+var import_json2 = require("@assemble-dev/shared-types/json");
+var import_errors4 = require("@assemble-dev/shared-utils/errors");
+var markdownCodeFencePattern = /^```[A-Za-z]*\s*\n?([\s\S]*?)\n?```$/;
+function parseStructuredJsonText(text, schema) {
+  return schema.parse(parseJsonText(stripMarkdownCodeFences(text)));
+}
+function stripMarkdownCodeFences(text) {
+  const trimmedText = text.trim();
+  const fenceMatch = markdownCodeFencePattern.exec(trimmedText);
+  if (fenceMatch?.[1] === void 0) {
+    return trimmedText;
+  }
+  return fenceMatch[1].trim();
+}
+function parseJsonText(text) {
+  try {
+    return import_json2.JsonValueSchema.parse(JSON.parse(text));
+  } catch (error) {
+    throw new import_errors4.AppError({
+      code: import_errors3.AppErrorCode.ValidationFailed,
+      message: "Structured output was not valid JSON",
+      statusCode: 422,
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+}
+
+// src/provider-api-key.ts
+var import_zod2 = require("zod");
+var import_errors5 = require("@assemble-dev/shared-types/errors");
+var import_errors6 = require("@assemble-dev/shared-utils/errors");
+var import_provider_keys = require("@assemble-dev/shared-utils/provider-keys");
+function resolveProviderApiKey(input) {
+  if (input.apiKey !== void 0 && input.apiKey.length > 0) {
+    return input.apiKey;
+  }
+  if (input.apiKeyName !== void 0) {
+    return resolveNamedProviderApiKeyFromEnv(input, input.apiKeyName);
+  }
+  return resolveBaseProviderApiKeyFromEnv(input);
+}
+function resolveNamedProviderApiKeyFromEnv(input, apiKeyName) {
+  if (!(0, import_provider_keys.validateProviderApiKeyName)(apiKeyName)) {
+    throw new import_errors6.AppError({
+      code: import_errors5.AppErrorCode.BadRequest,
+      message: `Invalid ${input.providerLabel} apiKeyName "${apiKeyName}". Expected ${import_provider_keys.expectedProviderApiKeyNameFormat}.`,
+      statusCode: 400
+    });
+  }
+  const envVarName = (0, import_provider_keys.buildNamedApiKeyEnvVarName)(input.baseEnvVarName, apiKeyName);
+  const envApiKey = readEnvironmentVariable(envVarName);
+  if (envApiKey === void 0 || envApiKey.length === 0) {
+    throw new import_errors6.AppError({
+      code: import_errors5.AppErrorCode.Unauthorized,
+      message: `${input.providerLabel} API key named "${apiKeyName}" is missing. Set the ${envVarName} environment variable or pass apiKey to ${input.adapterFunctionName}.`,
+      statusCode: 401
+    });
+  }
+  return envApiKey;
+}
+function resolveBaseProviderApiKeyFromEnv(input) {
+  const envApiKey = readEnvironmentVariable(input.baseEnvVarName);
+  if (envApiKey === void 0 || envApiKey.length === 0) {
+    throw new import_errors6.AppError({
+      code: import_errors5.AppErrorCode.Unauthorized,
+      message: `${input.providerLabel} API key is missing. Pass apiKey to ${input.adapterFunctionName} or set the ${input.baseEnvVarName} environment variable.`,
+      statusCode: 401
+    });
+  }
+  return envApiKey;
+}
+function readEnvironmentVariable(envVarName) {
+  const parsedEnv = import_zod2.z.object({ [envVarName]: import_zod2.z.string().optional() }).parse(process.env);
+  return parsedEnv[envVarName];
+}
+
+// src/provider-cancellation.ts
+var import_errors7 = require("@assemble-dev/shared-types/errors");
+var import_errors8 = require("@assemble-dev/shared-utils/errors");
+function isAbortError(error) {
+  return error.name === "AbortError";
+}
+function buildProviderCanceledError(providerLabel) {
+  return new import_errors8.AppError({
+    code: import_errors7.AppErrorCode.Canceled,
+    message: `${providerLabel} request was canceled`,
+    statusCode: 499
+  });
+}
+async function executeAbortableProviderFetch(providerLabel, performFetch) {
+  try {
+    return await performFetch();
+  } catch (error) {
+    if (error instanceof Error && isAbortError(error)) {
+      throw buildProviderCanceledError(providerLabel);
+    }
+    throw error;
+  }
+}
+
+// src/provider-fallback.ts
+var import_errors11 = require("@assemble-dev/shared-utils/errors");
+
+// src/provider-retry.ts
+var import_errors9 = require("@assemble-dev/shared-types/errors");
+var import_errors10 = require("@assemble-dev/shared-utils/errors");
+var defaultProviderRetryMaxAttempts = 3;
+var defaultProviderRetryInitialDelayMs = 500;
+var defaultProviderRetryMaxDelayMs = 8e3;
+var retryableAppErrorCodes = /* @__PURE__ */ new Set([
+  import_errors9.AppErrorCode.RateLimited,
+  import_errors9.AppErrorCode.ServiceUnavailable,
+  import_errors9.AppErrorCode.InternalServerError
+]);
+function isRetryableProviderAppError(appError) {
+  return retryableAppErrorCodes.has(appError.code);
+}
+async function executeProviderCallWithRetry(retryOptions, executeCall, waitFor) {
+  if (retryOptions === void 0) {
+    return await executeCall();
+  }
+  const maxAttempts = retryOptions.maxAttempts ?? defaultProviderRetryMaxAttempts;
+  const waitForRetryDelay = waitFor ?? waitForMilliseconds;
+  for (let attemptNumber = 1; ; attemptNumber += 1) {
+    try {
+      return await executeCall();
+    } catch (error) {
+      if (error instanceof import_errors10.AppError && !isRetryableProviderAppError(error)) {
+        throw error;
+      }
+      if (error instanceof Error && isAbortError(error)) {
+        throw error;
+      }
+      if (attemptNumber >= maxAttempts) {
+        throw error;
+      }
+      await waitForRetryDelay(
+        calculateProviderRetryDelayMs(retryOptions, attemptNumber)
+      );
+    }
+  }
+}
+function calculateProviderRetryDelayMs(retryOptions, attemptNumber) {
+  const initialDelayMs = retryOptions.initialDelayMs ?? defaultProviderRetryInitialDelayMs;
+  const maxDelayMs = retryOptions.maxDelayMs ?? defaultProviderRetryMaxDelayMs;
+  return Math.min(initialDelayMs * 2 ** (attemptNumber - 1), maxDelayMs);
+}
+async function waitForMilliseconds(ms) {
+  await new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+// src/provider-fallback.ts
+async function executeProviderCallWithModelFallback(fallbackModel, executePrimaryCall, executeFallbackCall) {
+  try {
+    return await executePrimaryCall();
+  } catch (error) {
+    if (fallbackModel === void 0) {
+      throw error;
+    }
+    if (error instanceof import_errors11.AppError && !isRetryableProviderAppError(error)) {
+      throw error;
+    }
+    if (error instanceof Error && isAbortError(error)) {
+      throw error;
+    }
+    return await executeFallbackCall(fallbackModel);
+  }
+}
+
+// src/provider-status-error.ts
+var import_errors12 = require("@assemble-dev/shared-types/errors");
+var import_errors13 = require("@assemble-dev/shared-utils/errors");
+function buildProviderStatusError(providerLabel, providerStatus) {
+  const code = mapProviderStatusToAppErrorCode(providerStatus);
+  return new import_errors13.AppError({
+    code,
+    message: `${providerLabel} request failed with status ${String(providerStatus)}`,
+    statusCode: mapAppErrorCodeToStatusCode(code),
+    details: { providerStatus }
+  });
+}
+function buildProviderInvalidResponseError(providerLabel, expectedShapeDescription) {
+  return new import_errors13.AppError({
+    code: import_errors12.AppErrorCode.ValidationFailed,
+    message: `${providerLabel} response did not match the expected ${expectedShapeDescription} shape`,
+    statusCode: 502
+  });
+}
+function mapProviderStatusToAppErrorCode(providerStatus) {
+  if (providerStatus === 400) {
+    return import_errors12.AppErrorCode.BadRequest;
+  }
+  if (providerStatus === 401) {
+    return import_errors12.AppErrorCode.Unauthorized;
+  }
+  if (providerStatus === 403) {
+    return import_errors12.AppErrorCode.Forbidden;
+  }
+  if (providerStatus === 404) {
+    return import_errors12.AppErrorCode.NotFound;
+  }
+  if (providerStatus === 429) {
+    return import_errors12.AppErrorCode.RateLimited;
+  }
+  return import_errors12.AppErrorCode.InternalServerError;
+}
+function mapAppErrorCodeToStatusCode(code) {
+  if (code === import_errors12.AppErrorCode.BadRequest) {
+    return 400;
+  }
+  if (code === import_errors12.AppErrorCode.Unauthorized) {
+    return 401;
+  }
+  if (code === import_errors12.AppErrorCode.Forbidden) {
+    return 403;
+  }
+  if (code === import_errors12.AppErrorCode.NotFound) {
+    return 404;
+  }
+  if (code === import_errors12.AppErrorCode.RateLimited) {
+    return 429;
+  }
+  return 500;
+}
+
+// src/openai-adapter.ts
+var defaultOpenAiBaseUrl = "https://api.openai.com/v1";
+var OpenAiResponseToolCallSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  function: import_zod3.z.object({
+    name: import_zod3.z.string(),
+    arguments: import_zod3.z.string()
+  })
+});
+var OpenAiChatCompletionResponseSchema = import_zod3.z.object({
+  choices: import_zod3.z.array(
+    import_zod3.z.object({
+      message: import_zod3.z.object({
+        content: import_zod3.z.string().nullable(),
+        tool_calls: import_zod3.z.array(OpenAiResponseToolCallSchema).optional()
+      }),
+      finish_reason: import_zod3.z.string().nullable().optional()
+    })
+  ).min(1),
+  usage: import_zod3.z.object({
+    prompt_tokens: import_zod3.z.number().int().nonnegative(),
+    completion_tokens: import_zod3.z.number().int().nonnegative(),
+    total_tokens: import_zod3.z.number().int().nonnegative()
+  })
+});
+var structuredOutputSystemMessage = {
+  role: "system",
+  content: "Respond with a single JSON object that satisfies the caller's requested structure. Output only valid JSON with no surrounding text."
+};
+function openai(options) {
+  return {
+    name: `openai:${options.model}`,
+    async generateChatCompletion(request) {
+      return await executeOpenAiAdapterCall(options, {
+        messages: request.messages,
+        temperature: request.temperature ?? options.temperature,
+        maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+        requireJsonObjectResponse: false,
+        tools: request.tools,
+        toolChoice: request.toolChoice,
+        abortSignal: request.abortSignal
+      });
+    },
+    async generateStructuredOutput(request) {
+      const completion = await executeOpenAiAdapterCall(options, {
+        messages: [structuredOutputSystemMessage, ...request.messages],
+        temperature: request.temperature ?? options.temperature,
+        maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+        requireJsonObjectResponse: true,
+        abortSignal: request.abortSignal
+      });
+      return {
+        value: parseStructuredJsonText(completion.content, request.schema),
+        tokenUsage: completion.tokenUsage,
+        latencyMs: completion.latencyMs
+      };
+    }
+  };
+}
+async function executeOpenAiAdapterCall(options, input) {
+  return await executeProviderCallWithModelFallback(
+    options.fallbackModel,
+    async () => await executeProviderCallWithRetry(
+      options.retry,
+      async () => await requestOpenAiChatCompletion(options, input)
+    ),
+    async (fallbackModelId) => await requestOpenAiChatCompletion(
+      { ...options, model: fallbackModelId },
+      input
+    )
+  );
+}
+async function requestOpenAiChatCompletion(options, input) {
+  const apiKey = resolveProviderApiKey({
+    providerLabel: "OpenAI",
+    adapterFunctionName: "openai()",
+    baseEnvVarName: "OPENAI_API_KEY",
+    apiKey: options.apiKey,
+    apiKeyName: options.apiKeyName
+  });
+  const fetchImplementation = options.fetchImplementation ?? fetch;
+  const baseUrl = options.baseURL ?? defaultOpenAiBaseUrl;
+  const requestBody = buildOpenAiRequestBody(options.model, input);
+  const startedAt = Date.now();
+  const response = await executeAbortableProviderFetch(
+    "OpenAI",
+    async () => await fetchImplementation(`${baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(requestBody),
+      signal: input.abortSignal
+    })
+  );
+  const latencyMs = Date.now() - startedAt;
+  if (!response.ok) {
+    throw buildProviderStatusError("OpenAI", response.status);
+  }
+  const parseResult = OpenAiChatCompletionResponseSchema.safeParse(
+    await response.json()
+  );
+  if (!parseResult.success) {
+    throw buildProviderInvalidResponseError("OpenAI", "chat completion");
+  }
+  return mapOpenAiResponseToChatCompletionResult(parseResult.data, latencyMs);
+}
+function mapOpenAiResponseToChatCompletionResult(response, latencyMs) {
+  const toolCalls = extractOpenAiToolCalls(response);
+  const result = {
+    content: extractOpenAiMessageContent(response, toolCalls.length > 0),
+    tokenUsage: mapOpenAiUsageToTokenUsage(response),
+    latencyMs
+  };
+  const finishReason = response.choices[0]?.finish_reason;
+  if (toolCalls.length > 0) {
+    result.toolCalls = toolCalls;
+  }
+  if (finishReason !== null && finishReason !== void 0) {
+    result.stopReason = normalizeOpenAiFinishReason(finishReason);
+  }
+  return result;
+}
+function extractOpenAiToolCalls(response) {
+  const responseToolCalls = response.choices[0]?.message.tool_calls ?? [];
+  return responseToolCalls.map((responseToolCall) => ({
+    id: responseToolCall.id,
+    toolName: responseToolCall.function.name,
+    input: parseOpenAiToolArgumentsJson(responseToolCall.function.arguments)
+  }));
+}
+function parseOpenAiToolArgumentsJson(argumentsJsonText) {
+  if (argumentsJsonText.trim().length === 0) {
+    return {};
+  }
+  try {
+    return import_json3.JsonValueSchema.parse(JSON.parse(argumentsJsonText));
+  } catch (error) {
+    throw new import_errors15.AppError({
+      code: import_errors14.AppErrorCode.ValidationFailed,
+      message: "OpenAI tool call arguments were not valid JSON",
+      statusCode: 502,
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+}
+function normalizeOpenAiFinishReason(finishReason) {
+  if (finishReason === "tool_calls") {
+    return "tool_use";
+  }
+  if (finishReason === "length") {
+    return "max_tokens";
+  }
+  return "end_turn";
+}
+function extractOpenAiMessageContent(response, allowEmptyContent) {
+  const content = response.choices[0]?.message.content;
+  if (content === void 0 || content === null) {
+    if (allowEmptyContent) {
+      return "";
+    }
+    throw new import_errors15.AppError({
+      code: import_errors14.AppErrorCode.ValidationFailed,
+      message: "OpenAI response contained no message content",
+      statusCode: 502
+    });
+  }
+  return content;
+}
+function mapOpenAiUsageToTokenUsage(response) {
+  return {
+    inputTokens: response.usage.prompt_tokens,
+    outputTokens: response.usage.completion_tokens,
+    totalTokens: response.usage.total_tokens
+  };
+}
+
+// src/anthropic-request-mapping.ts
+function buildAnthropicRequestBody(settings, input) {
+  const requestBody = {
+    model: settings.model,
+    max_tokens: input.maxOutputTokens ?? settings.defaultMaxOutputTokens,
+    messages: input.messages.filter((message) => message.role !== "system").map(mapChatMessageToAnthropicRequestMessage)
+  };
+  applyAnthropicSystemField(requestBody, settings, input);
+  applyAnthropicToolFields(requestBody, settings, input);
+  if (input.temperature !== void 0) {
+    requestBody.temperature = input.temperature;
+  }
+  if (settings.thinking !== void 0) {
+    requestBody.thinking = {
+      type: "enabled",
+      budget_tokens: settings.thinking.budgetTokens
+    };
+  }
+  return requestBody;
+}
+function applyAnthropicSystemField(requestBody, settings, input) {
+  const systemText = joinSystemMessageText(input.messages);
+  if (systemText.length === 0) {
+    return;
+  }
+  if (settings.promptCaching !== "auto") {
+    requestBody.system = systemText;
+    return;
+  }
+  requestBody.system = [
+    { type: "text", text: systemText, cache_control: { type: "ephemeral" } }
+  ];
+}
+function applyAnthropicToolFields(requestBody, settings, input) {
+  if (input.tools !== void 0 && input.tools.length > 0) {
+    requestBody.tools = mapModelToolDefinitionsToAnthropicTools(
+      input.tools,
+      settings.promptCaching
+    );
+  }
+  if (input.toolChoice !== void 0) {
+    requestBody.tool_choice = mapModelToolChoiceToAnthropicToolChoice(
+      input.toolChoice
+    );
+  }
+}
+function mapModelToolDefinitionsToAnthropicTools(tools, promptCaching) {
+  return tools.map((tool, toolIndex) => {
+    const anthropicTool = {
+      name: tool.name,
+      description: tool.description,
+      input_schema: tool.inputJsonSchema
+    };
+    if (promptCaching === "auto" && toolIndex === tools.length - 1) {
+      anthropicTool.cache_control = { type: "ephemeral" };
+    }
+    return anthropicTool;
+  });
+}
+function mapModelToolChoiceToAnthropicToolChoice(toolChoice) {
+  if (toolChoice === "auto") {
+    return { type: "auto" };
+  }
+  if (toolChoice === "required") {
+    return { type: "any" };
+  }
+  if (toolChoice === "none") {
+    return { type: "none" };
+  }
+  return { type: "tool", name: toolChoice.toolName };
+}
+function joinSystemMessageText(messages) {
+  return messages.filter((message) => message.role === "system").map(extractMessageText).join("\n\n");
+}
+function mapChatMessageToAnthropicRequestMessage(message) {
+  if (message.role === "assistant") {
+    return mapAssistantMessageToAnthropicRequestMessage(message);
+  }
+  if (message.role === "tool") {
+    return mapToolMessageToAnthropicRequestMessage(message);
+  }
+  return { role: "user", content: mapMessageContentToAnthropic(message) };
+}
+function mapAssistantMessageToAnthropicRequestMessage(message) {
+  if (message.toolCalls === void 0 || message.toolCalls.length === 0) {
+    return { role: "assistant", content: mapMessageContentToAnthropic(message) };
+  }
+  const contentBlocks = [];
+  const assistantText = extractMessageText(message);
+  if (assistantText.length > 0) {
+    contentBlocks.push({ type: "text", text: assistantText });
+  }
+  for (const toolCall of message.toolCalls) {
+    contentBlocks.push({
+      type: "tool_use",
+      id: toolCall.id,
+      name: toolCall.toolName,
+      input: toolCall.input
+    });
+  }
+  return { role: "assistant", content: contentBlocks };
+}
+function mapToolMessageToAnthropicRequestMessage(message) {
+  if (message.toolCallId !== void 0) {
+    return {
+      role: "user",
+      content: [
+        {
+          type: "tool_result",
+          tool_use_id: message.toolCallId,
+          content: extractMessageText(message)
+        }
+      ]
+    };
+  }
+  return { role: "user", content: buildAnthropicToolResultText(message) };
+}
+function buildAnthropicToolResultText(message) {
+  const messageText = extractMessageText(message);
+  if (message.toolName === void 0) {
+    return `Tool result: ${messageText}`;
+  }
+  return `Tool result (${message.toolName}): ${messageText}`;
+}
+function mapMessageContentToAnthropic(message) {
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  return message.content.map(mapMessageContentBlockToAnthropic);
+}
+function mapMessageContentBlockToAnthropic(contentBlock) {
+  if (contentBlock.type === "text") {
+    return { type: "text", text: contentBlock.text };
+  }
+  return {
+    type: contentBlock.type,
+    source: {
+      type: "base64",
+      media_type: contentBlock.mediaType,
+      data: contentBlock.dataBase64
+    }
+  };
+}
+
+// src/anthropic-response-parsing.ts
+var import_zod4 = require("zod");
+var import_errors16 = require("@assemble-dev/shared-types/errors");
+var import_json4 = require("@assemble-dev/shared-types/json");
+var import_errors17 = require("@assemble-dev/shared-utils/errors");
+var AnthropicUsageSchema = import_zod4.z.object({
+  input_tokens: import_zod4.z.number().int().nonnegative(),
+  output_tokens: import_zod4.z.number().int().nonnegative(),
+  cache_creation_input_tokens: import_zod4.z.number().int().nonnegative().optional(),
+  cache_read_input_tokens: import_zod4.z.number().int().nonnegative().optional()
+});
+var AnthropicContentBlockSchema = import_zod4.z.discriminatedUnion("type", [
+  import_zod4.z.object({
+    type: import_zod4.z.literal("text"),
+    text: import_zod4.z.string()
+  }),
+  import_zod4.z.object({
+    type: import_zod4.z.literal("tool_use"),
+    id: import_zod4.z.string(),
+    name: import_zod4.z.string(),
+    input: import_json4.JsonValueSchema
+  }),
+  import_zod4.z.object({
+    type: import_zod4.z.literal("thinking"),
+    thinking: import_zod4.z.string().optional(),
+    signature: import_zod4.z.string().optional()
+  }),
+  import_zod4.z.object({
+    type: import_zod4.z.literal("redacted_thinking"),
+    data: import_zod4.z.string().optional()
+  })
+]);
+var AnthropicMessagesResponseSchema = import_zod4.z.object({
+  content: import_zod4.z.array(AnthropicContentBlockSchema),
+  stop_reason: import_zod4.z.string().nullable().optional(),
+  usage: AnthropicUsageSchema
+});
+function mapAnthropicResponseToChatCompletionResult(response, latencyMs) {
+  const toolCalls = extractAnthropicToolCalls(response);
+  const result = {
+    content: extractAnthropicTextContent(response, toolCalls.length > 0),
+    tokenUsage: mapAnthropicUsageToTokenUsage(response.usage),
+    latencyMs
+  };
+  if (toolCalls.length > 0) {
+    result.toolCalls = toolCalls;
+  }
+  if (response.stop_reason !== null && response.stop_reason !== void 0) {
+    result.stopReason = normalizeAnthropicStopReason(response.stop_reason);
+  }
+  return result;
+}
+function extractAnthropicToolCalls(response) {
+  return response.content.filter((contentBlock) => contentBlock.type === "tool_use").map((contentBlock) => ({
+    id: contentBlock.id,
+    toolName: contentBlock.name,
+    input: contentBlock.input
+  }));
+}
+function extractAnthropicTextContent(response, allowEmptyText) {
+  const textBlocks = response.content.filter(
+    (contentBlock) => contentBlock.type === "text"
+  );
+  if (textBlocks.length === 0 && !allowEmptyText) {
+    throw new import_errors17.AppError({
+      code: import_errors16.AppErrorCode.ValidationFailed,
+      message: "Anthropic response contained no text content",
+      statusCode: 502
+    });
+  }
+  return textBlocks.map((textBlock) => textBlock.text).join("");
+}
+function normalizeAnthropicStopReason(providerStopReason) {
+  if (providerStopReason === "tool_use") {
+    return "tool_use";
+  }
+  if (providerStopReason === "max_tokens") {
+    return "max_tokens";
+  }
+  if (providerStopReason === "stop_sequence") {
+    return "stop_sequence";
+  }
+  return "end_turn";
+}
+function mapAnthropicUsageToTokenUsage(usage) {
+  const cacheCreationInputTokens = usage.cache_creation_input_tokens;
+  const cacheReadInputTokens = usage.cache_read_input_tokens;
+  const tokenUsage = {
+    inputTokens: usage.input_tokens,
+    outputTokens: usage.output_tokens,
+    totalTokens: usage.input_tokens + usage.output_tokens + (cacheCreationInputTokens ?? 0) + (cacheReadInputTokens ?? 0)
+  };
+  if (cacheCreationInputTokens !== void 0) {
+    tokenUsage.cacheCreationInputTokens = cacheCreationInputTokens;
+  }
+  if (cacheReadInputTokens !== void 0) {
+    tokenUsage.cacheReadInputTokens = cacheReadInputTokens;
+  }
+  return tokenUsage;
+}
+
+// src/anthropic-stream.ts
+var import_errors18 = require("@assemble-dev/shared-types/errors");
+var import_json5 = require("@assemble-dev/shared-types/json");
+var import_errors19 = require("@assemble-dev/shared-utils/errors");
+
+// src/anthropic-stream-events.ts
+var import_zod5 = require("zod");
+var AnthropicStreamEventSchema = import_zod5.z.discriminatedUnion("type", [
+  import_zod5.z.object({
+    type: import_zod5.z.literal("message_start"),
+    message: import_zod5.z.object({
+      usage: import_zod5.z.object({
+        input_tokens: import_zod5.z.number().int().nonnegative(),
+        output_tokens: import_zod5.z.number().int().nonnegative().optional(),
+        cache_creation_input_tokens: import_zod5.z.number().int().nonnegative().optional(),
+        cache_read_input_tokens: import_zod5.z.number().int().nonnegative().optional()
+      })
+    })
+  }),
+  import_zod5.z.object({
+    type: import_zod5.z.literal("content_block_start"),
+    index: import_zod5.z.number().int().nonnegative(),
+    content_block: import_zod5.z.discriminatedUnion("type", [
+      import_zod5.z.object({ type: import_zod5.z.literal("text"), text: import_zod5.z.string().optional() }),
+      import_zod5.z.object({
+        type: import_zod5.z.literal("tool_use"),
+        id: import_zod5.z.string(),
+        name: import_zod5.z.string()
+      })
+    ])
+  }),
+  import_zod5.z.object({
+    type: import_zod5.z.literal("content_block_delta"),
+    index: import_zod5.z.number().int().nonnegative(),
+    delta: import_zod5.z.discriminatedUnion("type", [
+      import_zod5.z.object({ type: import_zod5.z.literal("text_delta"), text: import_zod5.z.string() }),
+      import_zod5.z.object({
+        type: import_zod5.z.literal("input_json_delta"),
+        partial_json: import_zod5.z.string()
+      })
+    ])
+  }),
+  import_zod5.z.object({ type: import_zod5.z.literal("content_block_stop") }),
+  import_zod5.z.object({
+    type: import_zod5.z.literal("message_delta"),
+    delta: import_zod5.z.object({ stop_reason: import_zod5.z.string().nullable().optional() }),
+    usage: import_zod5.z.object({ output_tokens: import_zod5.z.number().int().nonnegative() }).optional()
+  }),
+  import_zod5.z.object({ type: import_zod5.z.literal("message_stop") }),
+  import_zod5.z.object({ type: import_zod5.z.literal("ping") }),
+  import_zod5.z.object({
+    type: import_zod5.z.literal("error"),
+    error: import_zod5.z.object({ message: import_zod5.z.string() })
+  })
+]);
+
+// src/anthropic-stream.ts
+async function* streamAnthropicChatCompletion(input) {
+  const startedAt = Date.now();
+  const response = await establishAnthropicStreamResponse(input);
+  if (response.body === null) {
+    throw buildProviderInvalidResponseError("Anthropic", "stream body");
+  }
+  yield* parseAnthropicStreamEvents(response.body, startedAt, input.abortSignal);
+}
+async function establishAnthropicStreamResponse(input) {
+  return await executeProviderCallWithRetry(input.retry, async () => {
+    const response = await executeAbortableProviderFetch(
+      "Anthropic",
+      async () => await input.fetchImplementation(input.url, {
+        method: "POST",
+        headers: input.headers,
+        body: JSON.stringify(input.body),
+        signal: input.abortSignal
+      })
+    );
+    if (!response.ok) {
+      throw buildProviderStatusError("Anthropic", response.status);
+    }
+    return response;
+  });
+}
+async function* parseAnthropicStreamEvents(body, startedAt, abortSignal) {
+  const accumulator = createAnthropicStreamAccumulator();
+  for await (const dataLine of readServerSentEventDataLines(body, abortSignal)) {
+    const parsedEvent = AnthropicStreamEventSchema.safeParse(
+      JSON.parse(dataLine)
+    );
+    if (!parsedEvent.success) {
+      continue;
+    }
+    yield* applyAnthropicStreamEvent(parsedEvent.data, accumulator);
+    if (parsedEvent.data.type === "message_stop") {
+      yield {
+        type: "completed",
+        result: buildAnthropicStreamResult(accumulator, Date.now() - startedAt)
+      };
+      return;
+    }
+  }
+  throw buildProviderInvalidResponseError("Anthropic", "stream termination");
+}
+async function* readServerSentEventDataLines(body, abortSignal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let bufferedText = "";
+  try {
+    for (; ; ) {
+      if (abortSignal?.aborted === true) {
+        await reader.cancel();
+        throw buildProviderCanceledError("Anthropic");
+      }
+      const readResult = await reader.read();
+      if (readResult.done) {
+        return;
+      }
+      bufferedText += decoder.decode(readResult.value, { stream: true });
+      const lines = bufferedText.split("\n");
+      bufferedText = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line.startsWith("data:")) {
+          const dataText = line.slice("data:".length).trim();
+          if (dataText.length > 0) {
+            yield dataText;
+          }
+        }
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error && isAbortError(error)) {
+      throw buildProviderCanceledError("Anthropic");
+    }
+    throw error;
+  }
+}
+function createAnthropicStreamAccumulator() {
+  return {
+    contentText: "",
+    toolCallsByBlockIndex: /* @__PURE__ */ new Map(),
+    inputTokens: 0,
+    outputTokens: 0
+  };
+}
+function* applyAnthropicStreamEvent(event, accumulator) {
+  if (event.type === "error") {
+    throw new import_errors19.AppError({
+      code: import_errors18.AppErrorCode.InternalServerError,
+      message: `Anthropic stream reported an error: ${event.error.message}`,
+      statusCode: 502
+    });
+  }
+  if (event.type === "message_start") {
+    applyAnthropicMessageStartUsage(event.message.usage, accumulator);
+    return;
+  }
+  if (event.type === "content_block_start") {
+    yield* applyAnthropicContentBlockStart(event, accumulator);
+    return;
+  }
+  if (event.type === "content_block_delta") {
+    yield* applyAnthropicContentBlockDelta(event, accumulator);
+    return;
+  }
+  if (event.type === "message_delta") {
+    applyAnthropicMessageDelta(event, accumulator);
+  }
+}
+function applyAnthropicMessageStartUsage(usage, accumulator) {
+  accumulator.inputTokens = usage.input_tokens;
+  accumulator.outputTokens = usage.output_tokens ?? 0;
+  accumulator.cacheCreationInputTokens = usage.cache_creation_input_tokens;
+  accumulator.cacheReadInputTokens = usage.cache_read_input_tokens;
+}
+function* applyAnthropicContentBlockStart(event, accumulator) {
+  if (event.content_block.type === "text") {
+    const initialText = event.content_block.text ?? "";
+    if (initialText.length > 0) {
+      accumulator.contentText += initialText;
+      yield { type: "text_delta", text: initialText };
+    }
+    return;
+  }
+  accumulator.toolCallsByBlockIndex.set(event.index, {
+    id: event.content_block.id,
+    toolName: event.content_block.name,
+    inputJsonText: ""
+  });
+  yield {
+    type: "tool_call_started",
+    id: event.content_block.id,
+    toolName: event.content_block.name
+  };
+}
+function* applyAnthropicContentBlockDelta(event, accumulator) {
+  if (event.delta.type === "text_delta") {
+    accumulator.contentText += event.delta.text;
+    yield { type: "text_delta", text: event.delta.text };
+    return;
+  }
+  const toolCallAccumulation = accumulator.toolCallsByBlockIndex.get(
+    event.index
+  );
+  if (toolCallAccumulation === void 0) {
+    throw buildProviderInvalidResponseError(
+      "Anthropic",
+      "stream tool input delta"
+    );
+  }
+  toolCallAccumulation.inputJsonText += event.delta.partial_json;
+  yield {
+    type: "tool_call_input_delta",
+    id: toolCallAccumulation.id,
+    inputJsonText: event.delta.partial_json
+  };
+}
+function applyAnthropicMessageDelta(event, accumulator) {
+  if (event.usage !== void 0) {
+    accumulator.outputTokens = event.usage.output_tokens;
+  }
+  if (event.delta.stop_reason !== null && event.delta.stop_reason !== void 0) {
+    accumulator.stopReason = normalizeAnthropicStopReason(
+      event.delta.stop_reason
+    );
+  }
+}
+function buildAnthropicStreamResult(accumulator, latencyMs) {
+  const result = {
+    content: accumulator.contentText,
+    tokenUsage: mapAnthropicUsageToTokenUsage({
+      input_tokens: accumulator.inputTokens,
+      output_tokens: accumulator.outputTokens,
+      cache_creation_input_tokens: accumulator.cacheCreationInputTokens,
+      cache_read_input_tokens: accumulator.cacheReadInputTokens
+    }),
+    latencyMs
+  };
+  const toolCalls = [...accumulator.toolCallsByBlockIndex.values()].map(
+    mapAccumulatedToolCallToModelToolCall
+  );
+  if (toolCalls.length > 0) {
+    result.toolCalls = toolCalls;
+  }
+  if (accumulator.stopReason !== void 0) {
+    result.stopReason = accumulator.stopReason;
+  }
+  return result;
+}
+function mapAccumulatedToolCallToModelToolCall(toolCallAccumulation) {
+  return {
+    id: toolCallAccumulation.id,
+    toolName: toolCallAccumulation.toolName,
+    input: parseAnthropicToolInputJson(toolCallAccumulation.inputJsonText)
+  };
+}
+function parseAnthropicToolInputJson(inputJsonText) {
+  if (inputJsonText.trim().length === 0) {
+    return {};
+  }
+  try {
+    return import_json5.JsonValueSchema.parse(JSON.parse(inputJsonText));
+  } catch (error) {
+    throw new import_errors19.AppError({
+      code: import_errors18.AppErrorCode.ValidationFailed,
+      message: "Anthropic tool input was not valid JSON",
+      statusCode: 502,
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+}
+
+// src/anthropic-adapter.ts
+var defaultAnthropicBaseUrl = "https://api.anthropic.com";
+var defaultAnthropicMaxOutputTokens = 1024;
+var anthropicApiVersion = "2023-06-01";
+var structuredOutputSystemMessage2 = {
+  role: "system",
+  content: "Respond with a single JSON object that satisfies the caller's requested structure. Output only valid JSON with no surrounding text."
+};
+function anthropic(options) {
+  return {
+    name: `anthropic:${options.model}`,
+    async generateChatCompletion(request) {
+      return await executeAnthropicAdapterCall(
+        options,
+        buildAnthropicCallInput(options, request)
+      );
+    },
+    async generateStructuredOutput(request) {
+      const completion = await executeAnthropicAdapterCall(options, {
+        messages: [structuredOutputSystemMessage2, ...request.messages],
+        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
+      };
+    },
+    streamChatCompletion(request) {
+      return streamAnthropicChatCompletion(
+        buildAnthropicStreamInput(options, request)
+      );
+    }
+  };
+}
+function buildAnthropicCallInput(options, request) {
+  return {
+    messages: request.messages,
+    temperature: request.temperature ?? options.temperature,
+    maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+    tools: request.tools,
+    toolChoice: request.toolChoice,
+    abortSignal: request.abortSignal
+  };
+}
+async function executeAnthropicAdapterCall(options, input) {
+  return await executeProviderCallWithModelFallback(
+    options.fallbackModel,
+    async () => await executeProviderCallWithRetry(
+      options.retry,
+      async () => await requestAnthropicMessages(options, input)
+    ),
+    async (fallbackModelId) => await requestAnthropicMessages(
+      { ...options, model: fallbackModelId },
+      input
+    )
+  );
+}
+async function requestAnthropicMessages(options, input) {
+  const requestBody = buildAnthropicRequestBody(
+    buildAnthropicRequestSettings(options),
+    input
+  );
+  const startedAt = Date.now();
+  const response = await executeAbortableProviderFetch(
+    "Anthropic",
+    async () => await resolveAnthropicFetch(options)(
+      `${resolveAnthropicBaseUrl(options)}/v1/messages`,
+      {
+        method: "POST",
+        headers: buildAnthropicRequestHeaders(options),
+        body: JSON.stringify(requestBody),
+        signal: input.abortSignal
+      }
+    )
+  );
+  const latencyMs = Date.now() - startedAt;
+  if (!response.ok) {
+    throw buildProviderStatusError("Anthropic", response.status);
+  }
+  const parseResult = AnthropicMessagesResponseSchema.safeParse(
+    await response.json()
+  );
+  if (!parseResult.success) {
+    throw buildProviderInvalidResponseError("Anthropic", "messages");
+  }
+  return mapAnthropicResponseToChatCompletionResult(parseResult.data, latencyMs);
+}
+function buildAnthropicStreamInput(options, request) {
+  const input = buildAnthropicCallInput(options, request);
+  const requestBody = buildAnthropicRequestBody(
+    buildAnthropicRequestSettings(options),
+    input
+  );
+  return {
+    url: `${resolveAnthropicBaseUrl(options)}/v1/messages`,
+    headers: buildAnthropicRequestHeaders(options),
+    body: { ...requestBody, stream: true },
+    fetchImplementation: resolveAnthropicFetch(options),
+    retry: options.retry,
+    abortSignal: request.abortSignal
+  };
+}
+function buildAnthropicRequestSettings(options) {
+  return {
+    model: options.model,
+    defaultMaxOutputTokens: defaultAnthropicMaxOutputTokens,
+    promptCaching: options.promptCaching,
+    thinking: options.thinking
+  };
+}
+function buildAnthropicRequestHeaders(options) {
+  return {
+    "content-type": "application/json",
+    "x-api-key": resolveProviderApiKey({
+      providerLabel: "Anthropic",
+      adapterFunctionName: "anthropic()",
+      baseEnvVarName: "ANTHROPIC_API_KEY",
+      apiKey: options.apiKey,
+      apiKeyName: options.apiKeyName
+    }),
+    "anthropic-version": anthropicApiVersion
+  };
+}
+function resolveAnthropicBaseUrl(options) {
+  return options.baseURL ?? defaultAnthropicBaseUrl;
+}
+function resolveAnthropicFetch(options) {
+  return options.fetchImplementation ?? fetch;
+}
+
+// src/gemini-adapter.ts
+var import_zod6 = require("zod");
+var import_errors20 = require("@assemble-dev/shared-types/errors");
+var import_errors21 = require("@assemble-dev/shared-utils/errors");
+var defaultGeminiBaseUrl = "https://generativelanguage.googleapis.com";
+var GeminiGenerateContentResponseSchema = import_zod6.z.object({
+  candidates: import_zod6.z.array(
+    import_zod6.z.object({
+      content: import_zod6.z.object({
+        parts: import_zod6.z.array(import_zod6.z.object({ text: import_zod6.z.string() }))
+      })
+    })
+  ).optional(),
+  usageMetadata: import_zod6.z.object({
+    promptTokenCount: import_zod6.z.number().int().nonnegative().optional(),
+    candidatesTokenCount: import_zod6.z.number().int().nonnegative().optional(),
+    totalTokenCount: import_zod6.z.number().int().nonnegative().optional()
+  }).optional()
+});
+var structuredOutputSystemMessage3 = {
+  role: "system",
+  content: "Respond with a single JSON object that satisfies the caller's requested structure. Output only valid JSON with no surrounding text."
+};
+function gemini(options) {
+  return {
+    name: `gemini:${options.model}`,
+    async generateChatCompletion(request) {
+      ensureGeminiRequestHasNoTools(request);
+      return await executeGeminiAdapterCall(options, {
+        messages: request.messages,
+        temperature: request.temperature ?? options.temperature,
+        maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+        requireJsonResponse: false,
+        abortSignal: request.abortSignal
+      });
+    },
+    async generateStructuredOutput(request) {
+      const completion = await executeGeminiAdapterCall(options, {
+        messages: [structuredOutputSystemMessage3, ...request.messages],
+        temperature: request.temperature ?? options.temperature,
+        maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+        requireJsonResponse: true,
+        abortSignal: request.abortSignal
+      });
+      return {
+        value: parseStructuredJsonText(completion.content, request.schema),
+        tokenUsage: completion.tokenUsage,
+        latencyMs: completion.latencyMs
+      };
+    }
+  };
+}
+async function executeGeminiAdapterCall(options, input) {
+  return await executeProviderCallWithModelFallback(
+    options.fallbackModel,
+    async () => await executeProviderCallWithRetry(
+      options.retry,
+      async () => await requestGeminiGenerateContent(options, input)
+    ),
+    async (fallbackModelId) => await requestGeminiGenerateContent(
+      { ...options, model: fallbackModelId },
+      input
+    )
+  );
+}
+async function requestGeminiGenerateContent(options, input) {
+  const apiKey = resolveProviderApiKey({
+    providerLabel: "Gemini",
+    adapterFunctionName: "gemini()",
+    baseEnvVarName: "GOOGLE_API_KEY",
+    apiKey: options.apiKey,
+    apiKeyName: options.apiKeyName
+  });
+  const fetchImplementation = options.fetchImplementation ?? fetch;
+  const baseUrl = options.baseURL ?? defaultGeminiBaseUrl;
+  const requestBody = buildGeminiRequestBody(input);
+  const requestUrl = `${baseUrl}/v1beta/models/${options.model}:generateContent`;
+  const startedAt = Date.now();
+  const response = await executeAbortableProviderFetch(
+    "Gemini",
+    async () => await fetchImplementation(requestUrl, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-goog-api-key": apiKey
+      },
+      body: JSON.stringify(requestBody),
+      signal: input.abortSignal
+    })
+  );
+  const latencyMs = Date.now() - startedAt;
+  if (!response.ok) {
+    throw buildProviderStatusError("Gemini", response.status);
+  }
+  const parseResult = GeminiGenerateContentResponseSchema.safeParse(
+    await response.json()
+  );
+  if (!parseResult.success) {
+    throw buildProviderInvalidResponseError("Gemini", "generateContent");
+  }
+  return {
+    content: extractGeminiCandidateText(parseResult.data),
+    tokenUsage: mapGeminiUsageToTokenUsage(parseResult.data),
+    latencyMs
+  };
+}
+function buildGeminiRequestBody(input) {
+  const systemText = joinSystemMessageText2(input.messages);
+  const generationConfig = buildGeminiGenerationConfig(input);
+  const requestBody = {
+    contents: input.messages.filter((message) => message.role !== "system").map(mapChatMessageToGeminiContent)
+  };
+  if (systemText.length > 0) {
+    requestBody.systemInstruction = { parts: [{ text: systemText }] };
+  }
+  if (generationConfig !== void 0) {
+    requestBody.generationConfig = generationConfig;
+  }
+  return requestBody;
+}
+function ensureGeminiRequestHasNoTools(request) {
+  if (request.tools === void 0 || request.tools.length === 0) {
+    return;
+  }
+  throw new import_errors21.AppError({
+    code: import_errors20.AppErrorCode.ValidationFailed,
+    message: "gemini adapter does not support model-driven tool use; remove tools from the request or use another adapter",
+    statusCode: 400
+  });
+}
+function joinSystemMessageText2(messages) {
+  return messages.filter((message) => message.role === "system").map(extractMessageText).join("\n\n");
+}
+function mapChatMessageToGeminiContent(message) {
+  const role = message.role === "assistant" ? "model" : "user";
+  return { role, parts: mapMessageContentToGeminiParts(message) };
+}
+function mapMessageContentToGeminiParts(message) {
+  if (typeof message.content === "string") {
+    return [{ text: message.content }];
+  }
+  return message.content.map(mapMessageContentBlockToGeminiPart);
+}
+function mapMessageContentBlockToGeminiPart(contentBlock) {
+  if (contentBlock.type === "text") {
+    return { text: contentBlock.text };
+  }
+  return {
+    inline_data: {
+      mime_type: contentBlock.mediaType,
+      data: contentBlock.dataBase64
+    }
+  };
+}
+function buildGeminiGenerationConfig(input) {
+  const generationConfig = {};
+  if (input.temperature !== void 0) {
+    generationConfig.temperature = input.temperature;
+  }
+  if (input.maxOutputTokens !== void 0) {
+    generationConfig.maxOutputTokens = input.maxOutputTokens;
+  }
+  if (input.requireJsonResponse) {
+    generationConfig.responseMimeType = "application/json";
+  }
+  if (Object.keys(generationConfig).length === 0) {
+    return void 0;
+  }
+  return generationConfig;
+}
+function extractGeminiCandidateText(response) {
+  const firstCandidate = response.candidates?.[0];
+  if (firstCandidate === void 0) {
+    throw new import_errors21.AppError({
+      code: import_errors20.AppErrorCode.ValidationFailed,
+      message: "Gemini response contained no candidates",
+      statusCode: 502
+    });
+  }
+  return firstCandidate.content.parts.map((part) => part.text).join("");
+}
+function mapGeminiUsageToTokenUsage(response) {
+  const inputTokens = response.usageMetadata?.promptTokenCount ?? 0;
+  const outputTokens = response.usageMetadata?.candidatesTokenCount ?? 0;
+  const totalTokens = response.usageMetadata?.totalTokenCount ?? inputTokens + outputTokens;
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens
+  };
+}
+
+// src/mock-adapter.ts
+var import_errors22 = require("@assemble-dev/shared-types/errors");
+var import_errors23 = require("@assemble-dev/shared-utils/errors");
+var mockStreamChunkCount = 3;
+function mockModel(options = {}) {
+  const remainingScriptedResponses = [...options.scriptedResponses ?? []];
+  const adapterName = options.name ?? "mock";
+  return {
+    name: adapterName,
+    async generateChatCompletion(request) {
+      return await resolveMockChatCompletion(
+        request,
+        remainingScriptedResponses,
+        options.respond
+      );
+    },
+    async generateStructuredOutput(request) {
+      const completion = await resolveMockChatCompletion(
+        {
+          messages: request.messages,
+          temperature: request.temperature,
+          maxOutputTokens: request.maxOutputTokens
+        },
+        remainingScriptedResponses,
+        options.respond
+      );
+      return {
+        value: parseStructuredJsonText(completion.content, request.schema),
+        tokenUsage: completion.tokenUsage,
+        latencyMs: completion.latencyMs
+      };
+    },
+    streamChatCompletion(request) {
+      return streamMockChatCompletion(
+        request,
+        remainingScriptedResponses,
+        options.respond
+      );
+    }
+  };
+}
+async function* streamMockChatCompletion(request, remainingScriptedResponses, respond) {
+  const completion = await resolveMockChatCompletion(
+    request,
+    remainingScriptedResponses,
+    respond
+  );
+  for (const chunkText of splitTextIntoStreamChunks(completion.content)) {
+    yield { type: "text_delta", text: chunkText };
+  }
+  yield { type: "completed", result: completion };
+}
+function splitTextIntoStreamChunks(text) {
+  if (text.length === 0) {
+    return [];
+  }
+  const chunkSize = Math.max(1, Math.ceil(text.length / mockStreamChunkCount));
+  const chunks = [];
+  for (let startIndex = 0; startIndex < text.length; startIndex += chunkSize) {
+    chunks.push(text.slice(startIndex, startIndex + chunkSize));
+  }
+  return chunks;
+}
+async function resolveMockChatCompletion(request, remainingScriptedResponses, respond) {
+  const startedAt = Date.now();
+  const content = await Promise.resolve(
+    resolveNextMockResponseText(request, remainingScriptedResponses, respond)
+  );
+  return {
+    content,
+    tokenUsage: calculateMockTokenUsage(request.messages, content),
+    latencyMs: Date.now() - startedAt
+  };
+}
+function resolveNextMockResponseText(request, remainingScriptedResponses, respond) {
+  const nextScriptedResponse = remainingScriptedResponses.shift();
+  if (nextScriptedResponse !== void 0) {
+    return nextScriptedResponse;
+  }
+  if (respond !== void 0) {
+    return respond(request);
+  }
+  throw new import_errors23.AppError({
+    code: import_errors22.AppErrorCode.BadRequest,
+    message: "Mock model has no scripted responses left and no respond function was provided",
+    statusCode: 400
+  });
+}
+function calculateMockTokenUsage(messages, outputText) {
+  const inputCharacterCount = messages.reduce(
+    (characterCount, message) => characterCount + extractMessageText(message).length,
+    0
+  );
+  const inputTokens = Math.max(1, Math.ceil(inputCharacterCount / 4));
+  const outputTokens = Math.max(1, Math.ceil(outputText.length / 4));
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: inputTokens + outputTokens
+  };
+}
+
+// src/provider-pricing.ts
+var modelPricingByModelIdPrefix = {
+  "claude-sonnet-4": {
+    inputUsdPerMillionTokens: 3,
+    outputUsdPerMillionTokens: 15,
+    cacheWriteUsdPerMillionTokens: 3.75,
+    cacheReadUsdPerMillionTokens: 0.3
+  },
+  "claude-haiku-4": {
+    inputUsdPerMillionTokens: 1,
+    outputUsdPerMillionTokens: 5,
+    cacheWriteUsdPerMillionTokens: 1.25,
+    cacheReadUsdPerMillionTokens: 0.1
+  },
+  "claude-opus-4": {
+    inputUsdPerMillionTokens: 15,
+    outputUsdPerMillionTokens: 75,
+    cacheWriteUsdPerMillionTokens: 18.75,
+    cacheReadUsdPerMillionTokens: 1.5
+  },
+  "gpt-4o-mini": {
+    inputUsdPerMillionTokens: 0.15,
+    outputUsdPerMillionTokens: 0.6
+  },
+  "gpt-4o": {
+    inputUsdPerMillionTokens: 2.5,
+    outputUsdPerMillionTokens: 10
+  },
+  "gemini-2.0-flash": {
+    inputUsdPerMillionTokens: 0.1,
+    outputUsdPerMillionTokens: 0.4
+  }
+};
+function estimateModelCallCostUsd(modelName, tokenUsage) {
+  const modelId = stripAdapterPrefixFromModelName(modelName);
+  const pricing = findModelPricingByLongestPrefix(modelId);
+  if (pricing === null) {
+    return null;
+  }
+  return calculateModelCallCostUsd(pricing, tokenUsage);
+}
+function stripAdapterPrefixFromModelName(modelName) {
+  const separatorIndex = modelName.indexOf(":");
+  if (separatorIndex === -1) {
+    return modelName;
+  }
+  return modelName.slice(separatorIndex + 1);
+}
+function findModelPricingByLongestPrefix(modelId) {
+  const matchingPrefixes = Object.keys(modelPricingByModelIdPrefix).filter((modelIdPrefix) => modelId.startsWith(modelIdPrefix)).sort(
+    (firstPrefix, secondPrefix) => secondPrefix.length - firstPrefix.length
+  );
+  const longestMatchingPrefix = matchingPrefixes[0];
+  if (longestMatchingPrefix === void 0) {
+    return null;
+  }
+  return modelPricingByModelIdPrefix[longestMatchingPrefix] ?? null;
+}
+function calculateModelCallCostUsd(pricing, tokenUsage) {
+  const cacheWriteRate = pricing.cacheWriteUsdPerMillionTokens ?? pricing.inputUsdPerMillionTokens;
+  const cacheReadRate = pricing.cacheReadUsdPerMillionTokens ?? pricing.inputUsdPerMillionTokens;
+  const inputCostUsd = tokenUsage.inputTokens * pricing.inputUsdPerMillionTokens;
+  const outputCostUsd = tokenUsage.outputTokens * pricing.outputUsdPerMillionTokens;
+  const cacheWriteCostUsd = (tokenUsage.cacheCreationInputTokens ?? 0) * cacheWriteRate;
+  const cacheReadCostUsd = (tokenUsage.cacheReadInputTokens ?? 0) * cacheReadRate;
+  return (inputCostUsd + outputCostUsd + cacheWriteCostUsd + cacheReadCostUsd) / 1e6;
+}
+
+// src/anthropic-batch.ts
+var import_errors24 = require("@assemble-dev/shared-types/errors");
+var import_json6 = require("@assemble-dev/shared-types/json");
+var import_errors25 = require("@assemble-dev/shared-utils/errors");
+
+// src/anthropic-batch-types.ts
+var import_zod7 = require("zod");
+var AnthropicMessageBatchResponseSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  processing_status: import_zod7.z.enum(["in_progress", "canceling", "ended"]),
+  request_counts: import_zod7.z.object({
+    processing: import_zod7.z.number().int().nonnegative(),
+    succeeded: import_zod7.z.number().int().nonnegative(),
+    errored: import_zod7.z.number().int().nonnegative(),
+    canceled: import_zod7.z.number().int().nonnegative(),
+    expired: import_zod7.z.number().int().nonnegative()
+  }),
+  results_url: import_zod7.z.string().nullable(),
+  created_at: import_zod7.z.string(),
+  ended_at: import_zod7.z.string().nullable()
+});
+var AnthropicBatchContentBlockSchema = import_zod7.z.discriminatedUnion("type", [
+  import_zod7.z.object({
+    type: import_zod7.z.literal("text"),
+    text: import_zod7.z.string()
+  }),
+  import_zod7.z.object({
+    type: import_zod7.z.literal("thinking"),
+    thinking: import_zod7.z.string().optional(),
+    signature: import_zod7.z.string().optional()
+  }),
+  import_zod7.z.object({
+    type: import_zod7.z.literal("redacted_thinking"),
+    data: import_zod7.z.string().optional()
+  })
+]);
+var AnthropicBatchResultLineSchema = import_zod7.z.object({
+  custom_id: import_zod7.z.string(),
+  result: import_zod7.z.discriminatedUnion("type", [
+    import_zod7.z.object({
+      type: import_zod7.z.literal("succeeded"),
+      message: import_zod7.z.object({
+        content: import_zod7.z.array(AnthropicBatchContentBlockSchema),
+        usage: AnthropicUsageSchema
+      })
+    }),
+    import_zod7.z.object({
+      type: import_zod7.z.literal("errored"),
+      error: import_zod7.z.object({
+        type: import_zod7.z.string(),
+        message: import_zod7.z.string()
+      })
+    }),
+    import_zod7.z.object({ type: import_zod7.z.literal("canceled") }),
+    import_zod7.z.object({ type: import_zod7.z.literal("expired") })
+  ])
+});
+function mapAnthropicMessageBatchResponseToMessageBatch(response) {
+  return {
+    id: response.id,
+    processingStatus: response.processing_status,
+    requestCounts: {
+      processing: response.request_counts.processing,
+      succeeded: response.request_counts.succeeded,
+      errored: response.request_counts.errored,
+      canceled: response.request_counts.canceled,
+      expired: response.request_counts.expired
+    },
+    resultsUrl: response.results_url,
+    createdAt: response.created_at,
+    endedAt: response.ended_at
+  };
+}
+function mapAnthropicBatchResultLineToBatchResult(resultLine) {
+  return {
+    customId: resultLine.custom_id,
+    outcome: mapAnthropicBatchResultToOutcome(resultLine.result)
+  };
+}
+function mapAnthropicBatchResultToOutcome(result) {
+  if (result.type === "succeeded") {
+    return {
+      type: "succeeded",
+      content: joinAnthropicBatchTextBlocks(result.message.content),
+      tokenUsage: mapAnthropicUsageToTokenUsage(result.message.usage)
+    };
+  }
+  if (result.type === "errored") {
+    return {
+      type: "errored",
+      errorType: result.error.type,
+      errorMessage: result.error.message
+    };
+  }
+  if (result.type === "canceled") {
+    return { type: "canceled" };
+  }
+  return { type: "expired" };
+}
+function joinAnthropicBatchTextBlocks(contentBlocks) {
+  return contentBlocks.filter((contentBlock) => contentBlock.type === "text").map((contentBlock) => contentBlock.text).join("");
+}
+
+// src/anthropic-batch.ts
+var defaultAnthropicBatchPollIntervalMs = 5e3;
+var defaultAnthropicBatchTimeoutMs = 36e5;
+var anthropicBatchApiVersion = "2023-06-01";
+function createAnthropicBatchClient(options) {
+  return {
+    async submitMessageBatch(requests) {
+      return await submitAnthropicMessageBatch(options, requests);
+    },
+    async fetchMessageBatch(batchId) {
+      return await fetchAnthropicMessageBatch(options, batchId);
+    },
+    async listMessageBatchResults(batchId) {
+      return await listAnthropicMessageBatchResults(options, batchId);
+    },
+    async waitForMessageBatchCompletion(batchId, waitOptions) {
+      return await waitForAnthropicMessageBatchCompletion(
+        options,
+        batchId,
+        waitOptions
+      );
+    }
+  };
+}
+function resolveAnthropicBatchRequestContext(options) {
+  return {
+    apiKey: resolveProviderApiKey({
+      providerLabel: "Anthropic",
+      adapterFunctionName: "createAnthropicBatchClient()",
+      baseEnvVarName: "ANTHROPIC_API_KEY",
+      apiKey: options.apiKey,
+      apiKeyName: options.apiKeyName
+    }),
+    baseUrl: options.baseURL ?? defaultAnthropicBaseUrl,
+    fetchImplementation: options.fetchImplementation ?? fetch
+  };
+}
+function buildAnthropicBatchRequestHeaders(apiKey) {
+  return {
+    "content-type": "application/json",
+    "x-api-key": apiKey,
+    "anthropic-version": anthropicBatchApiVersion
+  };
+}
+async function submitAnthropicMessageBatch(options, requests) {
+  const context = resolveAnthropicBatchRequestContext(options);
+  const response = await context.fetchImplementation(
+    `${context.baseUrl}/v1/messages/batches`,
+    {
+      method: "POST",
+      headers: buildAnthropicBatchRequestHeaders(context.apiKey),
+      body: JSON.stringify({
+        requests: requests.map(mapBatchMessageRequestToApiBatchRequest)
+      })
+    }
+  );
+  return await parseAnthropicMessageBatchHttpResponse(response);
+}
+async function fetchAnthropicMessageBatch(options, batchId) {
+  const context = resolveAnthropicBatchRequestContext(options);
+  const response = await context.fetchImplementation(
+    `${context.baseUrl}/v1/messages/batches/${batchId}`,
+    {
+      method: "GET",
+      headers: buildAnthropicBatchRequestHeaders(context.apiKey)
+    }
+  );
+  return await parseAnthropicMessageBatchHttpResponse(response);
+}
+async function parseAnthropicMessageBatchHttpResponse(response) {
+  if (!response.ok) {
+    throw buildProviderStatusError("Anthropic", response.status);
+  }
+  const parseResult = AnthropicMessageBatchResponseSchema.safeParse(
+    await response.json()
+  );
+  if (!parseResult.success) {
+    throw buildProviderInvalidResponseError("Anthropic", "message batch");
+  }
+  return mapAnthropicMessageBatchResponseToMessageBatch(parseResult.data);
+}
+async function listAnthropicMessageBatchResults(options, batchId) {
+  const batch = await fetchAnthropicMessageBatch(options, batchId);
+  if (batch.resultsUrl === null) {
+    throw new import_errors25.AppError({
+      code: import_errors24.AppErrorCode.Conflict,
+      message: `Anthropic message batch ${batchId} has no results because processing has not ended`,
+      statusCode: 409,
+      details: { batchId, processingStatus: batch.processingStatus }
+    });
+  }
+  const context = resolveAnthropicBatchRequestContext(options);
+  const response = await context.fetchImplementation(batch.resultsUrl, {
+    method: "GET",
+    headers: buildAnthropicBatchRequestHeaders(context.apiKey)
+  });
+  if (!response.ok) {
+    throw buildProviderStatusError("Anthropic", response.status);
+  }
+  return parseAnthropicBatchResultsJsonl(await response.text());
+}
+function parseAnthropicBatchResultsJsonl(jsonlText) {
+  return jsonlText.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map(parseAnthropicBatchResultLine);
+}
+function parseAnthropicBatchResultLine(line) {
+  const parseResult = AnthropicBatchResultLineSchema.safeParse(
+    parseAnthropicBatchResultLineJson(line)
+  );
+  if (!parseResult.success) {
+    throw buildProviderInvalidResponseError(
+      "Anthropic",
+      "message batch results"
+    );
+  }
+  return mapAnthropicBatchResultLineToBatchResult(parseResult.data);
+}
+function parseAnthropicBatchResultLineJson(line) {
+  try {
+    return import_json6.JsonValueSchema.parse(JSON.parse(line));
+  } catch {
+    throw buildProviderInvalidResponseError(
+      "Anthropic",
+      "message batch results"
+    );
+  }
+}
+async function waitForAnthropicMessageBatchCompletion(options, batchId, waitOptions) {
+  const pollIntervalMs = waitOptions?.pollIntervalMs ?? defaultAnthropicBatchPollIntervalMs;
+  const timeoutMs = waitOptions?.timeoutMs ?? defaultAnthropicBatchTimeoutMs;
+  const waitFor = waitOptions?.waitFor ?? waitForMilliseconds;
+  const startedAt = Date.now();
+  let batch = await fetchAnthropicMessageBatch(options, batchId);
+  while (batch.processingStatus !== "ended") {
+    if (Date.now() - startedAt >= timeoutMs) {
+      throw buildAnthropicBatchTimeoutError(batchId, timeoutMs);
+    }
+    await waitFor(pollIntervalMs);
+    batch = await fetchAnthropicMessageBatch(options, batchId);
+  }
+  return batch;
+}
+function buildAnthropicBatchTimeoutError(batchId, timeoutMs) {
+  return new import_errors25.AppError({
+    code: import_errors24.AppErrorCode.ServiceUnavailable,
+    message: `Anthropic message batch ${batchId} did not complete within ${String(timeoutMs)}ms`,
+    statusCode: 504,
+    details: { batchId, timeoutMs }
+  });
+}
+function mapBatchMessageRequestToApiBatchRequest(request) {
+  const params = {
+    model: request.model,
+    max_tokens: request.maxOutputTokens ?? defaultAnthropicMaxOutputTokens,
+    messages: request.messages.filter((message) => message.role !== "system").map(mapChatMessageToBatchApiRequestMessage)
+  };
+  const systemText = joinBatchSystemMessageText(request.messages);
+  if (systemText.length > 0) {
+    params.system = systemText;
+  }
+  if (request.temperature !== void 0) {
+    params.temperature = request.temperature;
+  }
+  return { custom_id: request.customId, params };
+}
+function joinBatchSystemMessageText(messages) {
+  return messages.filter((message) => message.role === "system").map(extractMessageText).join("\n\n");
+}
+function mapChatMessageToBatchApiRequestMessage(message) {
+  if (message.role === "assistant") {
+    return { role: "assistant", content: extractMessageText(message) };
+  }
+  if (message.role === "tool") {
+    return { role: "user", content: buildBatchToolResultText(message) };
+  }
+  return { role: "user", content: extractMessageText(message) };
+}
+function buildBatchToolResultText(message) {
+  if (message.toolName === void 0) {
+    return `Tool result: ${extractMessageText(message)}`;
+  }
+  return `Tool result (${message.toolName}): ${extractMessageText(message)}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnthropicMessagesResponseSchema,
+  AnthropicStreamEventSchema,
+  ChatMessageRoleSchema,
+  ChatMessageSchema,
+  ChatStopReasonSchema,
+  MessageContentBlockSchema,
+  ModelToolCallSchema,
+  anthropic,
+  buildAnthropicRequestBody,
+  buildOpenAiRequestBody,
+  buildProviderCanceledError,
+  calculateProviderRetryDelayMs,
+  createAnthropicBatchClient,
+  defaultAnthropicBaseUrl,
+  defaultAnthropicBatchPollIntervalMs,
+  defaultAnthropicBatchTimeoutMs,
+  defaultAnthropicMaxOutputTokens,
+  defaultGeminiBaseUrl,
+  defaultOpenAiBaseUrl,
+  defaultProviderRetryInitialDelayMs,
+  defaultProviderRetryMaxAttempts,
+  defaultProviderRetryMaxDelayMs,
+  estimateModelCallCostUsd,
+  executeAbortableProviderFetch,
+  executeProviderCallWithModelFallback,
+  executeProviderCallWithRetry,
+  extractAnthropicTextContent,
+  extractAnthropicToolCalls,
+  extractMessageText,
+  gemini,
+  isAbortError,
+  isRetryableProviderAppError,
+  joinSystemMessageText,
+  mapAnthropicResponseToChatCompletionResult,
+  mapAnthropicUsageToTokenUsage,
+  mapChatMessageToAnthropicRequestMessage,
+  mapChatMessageToOpenAiRequestMessage,
+  mapModelToolChoiceToAnthropicToolChoice,
+  mapModelToolChoiceToOpenAiToolChoice,
+  mapModelToolDefinitionToOpenAiTool,
+  mapModelToolDefinitionsToAnthropicTools,
+  mockModel,
+  normalizeAnthropicStopReason,
+  openai,
+  parseAnthropicStreamEvents,
+  parseAnthropicToolInputJson,
+  resolveProviderApiKey,
+  streamAnthropicChatCompletion
+});