@assemble-dev/providers 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -22,12 +22,17 @@ var index_exports = {};
 __export(index_exports, {
   AnthropicMessagesResponseSchema: () => AnthropicMessagesResponseSchema,
   AnthropicStreamEventSchema: () => AnthropicStreamEventSchema,
+  ChatMessageCacheControlSchema: () => ChatMessageCacheControlSchema,
   ChatMessageRoleSchema: () => ChatMessageRoleSchema,
   ChatMessageSchema: () => ChatMessageSchema,
   ChatStopReasonSchema: () => ChatStopReasonSchema,
   MessageContentBlockSchema: () => MessageContentBlockSchema,
   ModelToolCallSchema: () => ModelToolCallSchema,
   anthropic: () => anthropic,
+  anthropicBatchJsonOnlySystemInstruction: () => anthropicBatchJsonOnlySystemInstruction,
+  anthropicBatchTraceWorkflowName: () => anthropicBatchTraceWorkflowName,
+  applyCacheControlToLastContentBlock: () => applyCacheControlToLastContentBlock,
+  buildAnthropicCacheControl: () => buildAnthropicCacheControl,
   buildAnthropicRequestBody: () => buildAnthropicRequestBody,
   buildOpenAiRequestBody: () => buildOpenAiRequestBody,
   buildProviderCanceledError: () => buildProviderCanceledError,
@@ -61,11 +66,14 @@ __export(index_exports, {
   mapModelToolChoiceToOpenAiToolChoice: () => mapModelToolChoiceToOpenAiToolChoice,
   mapModelToolDefinitionToOpenAiTool: () => mapModelToolDefinitionToOpenAiTool,
   mapModelToolDefinitionsToAnthropicTools: () => mapModelToolDefinitionsToAnthropicTools,
+  mergeProviderRequestExtraBody: () => mergeProviderRequestExtraBody,
   mockModel: () => mockModel,
   normalizeAnthropicStopReason: () => normalizeAnthropicStopReason,
   openai: () => openai,
+  parseAnthropicBatchStructuredContent: () => parseAnthropicBatchStructuredContent,
   parseAnthropicStreamEvents: () => parseAnthropicStreamEvents,
   parseAnthropicToolInputJson: () => parseAnthropicToolInputJson,
+  resolveAnthropicPromptCachingSettings: () => resolveAnthropicPromptCachingSettings,
   resolveProviderApiKey: () => resolveProviderApiKey,
   streamAnthropicChatCompletion: () => streamAnthropicChatCompletion
 });
@@ -101,12 +109,16 @@ var ModelToolCallSchema = import_zod.z.object({
   toolName: import_zod.z.string(),
   input: import_json.JsonValueSchema
 });
+var ChatMessageCacheControlSchema = import_zod.z.object({
+  ttl: import_zod.z.enum(["5m", "1h"]).optional()
+});
 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()
+  toolCalls: import_zod.z.array(ModelToolCallSchema).optional(),
+  cacheControl: ChatMessageCacheControlSchema.optional()
 });
 var ChatStopReasonSchema = import_zod.z.enum([
   "end_turn",
@@ -336,6 +348,15 @@ async function executeAbortableProviderFetch(providerLabel, performFetch) {
   }
 }
 
+// src/provider-extra-body.ts
+function mergeProviderRequestExtraBody(requestBody, adapterExtraBody, requestExtraBody) {
+  return {
+    ...requestBody,
+    ...adapterExtraBody ?? {},
+    ...requestExtraBody ?? {}
+  };
+}
+
 // src/provider-fallback.ts
 var import_errors11 = require("@assemble-dev/shared-utils/errors");
 
@@ -503,7 +524,8 @@ function openai(options) {
         requireJsonObjectResponse: false,
         tools: request.tools,
         toolChoice: request.toolChoice,
-        abortSignal: request.abortSignal
+        abortSignal: request.abortSignal,
+        extraBody: request.extraBody
       });
     },
     async generateStructuredOutput(request) {
@@ -545,7 +567,11 @@ async function requestOpenAiChatCompletion(options, input) {
   });
   const fetchImplementation = options.fetchImplementation ?? fetch;
   const baseUrl = options.baseURL ?? defaultOpenAiBaseUrl;
-  const requestBody = buildOpenAiRequestBody(options.model, input);
+  const requestBody = mergeProviderRequestExtraBody(
+    buildOpenAiRequestBody(options.model, input),
+    options.extraBody,
+    input.extraBody
+  );
   const startedAt = Date.now();
   const response = await executeAbortableProviderFetch(
     "OpenAI",
@@ -641,6 +667,36 @@ function mapOpenAiUsageToTokenUsage(response) {
   };
 }
 
+// src/anthropic-cache-control.ts
+function resolveAnthropicPromptCachingSettings(promptCaching) {
+  if (promptCaching === void 0) {
+    return { mode: "off" };
+  }
+  if (typeof promptCaching === "string") {
+    return { mode: promptCaching };
+  }
+  return promptCaching;
+}
+function buildAnthropicCacheControl(ttl) {
+  if (ttl === void 0) {
+    return { type: "ephemeral" };
+  }
+  return { type: "ephemeral", ttl };
+}
+function applyCacheControlToLastContentBlock(requestMessage, cacheControl) {
+  if (typeof requestMessage.content === "string") {
+    if (requestMessage.content.length === 0) {
+      return;
+    }
+    requestMessage.content = [{ type: "text", text: requestMessage.content }];
+  }
+  const lastContentBlock = requestMessage.content[requestMessage.content.length - 1];
+  if (lastContentBlock === void 0) {
+    return;
+  }
+  lastContentBlock.cache_control = cacheControl;
+}
+
 // src/anthropic-request-mapping.ts
 function buildAnthropicRequestBody(settings, input) {
   const requestBody = {
@@ -650,6 +706,7 @@ function buildAnthropicRequestBody(settings, input) {
   };
   applyAnthropicSystemField(requestBody, settings, input);
   applyAnthropicToolFields(requestBody, settings, input);
+  applyAnthropicMessageCacheBreakpoints(requestBody, settings, input);
   if (input.temperature !== void 0) {
     requestBody.temperature = input.temperature;
   }
@@ -662,18 +719,46 @@ function buildAnthropicRequestBody(settings, input) {
   return requestBody;
 }
 function applyAnthropicSystemField(requestBody, settings, input) {
+  const caching = resolveAnthropicPromptCachingSettings(settings.promptCaching);
   const systemText = joinSystemMessageText(input.messages);
   if (systemText.length === 0) {
     return;
   }
-  if (settings.promptCaching !== "auto") {
+  if (caching.mode === "off") {
     requestBody.system = systemText;
     return;
   }
   requestBody.system = [
-    { type: "text", text: systemText, cache_control: { type: "ephemeral" } }
+    {
+      type: "text",
+      text: systemText,
+      cache_control: buildAnthropicCacheControl(caching.ttl)
+    }
   ];
 }
+function applyAnthropicMessageCacheBreakpoints(requestBody, settings, input) {
+  const caching = resolveAnthropicPromptCachingSettings(settings.promptCaching);
+  const finalRequestMessage = requestBody.messages[requestBody.messages.length - 1];
+  if (caching.mode === "messages" && finalRequestMessage !== void 0) {
+    applyCacheControlToLastContentBlock(
+      finalRequestMessage,
+      buildAnthropicCacheControl(caching.ttl)
+    );
+  }
+  const nonSystemMessages = input.messages.filter(
+    (message) => message.role !== "system"
+  );
+  nonSystemMessages.forEach((message, messageIndex) => {
+    const requestMessage = requestBody.messages[messageIndex];
+    if (message.cacheControl === void 0 || requestMessage === void 0) {
+      return;
+    }
+    applyCacheControlToLastContentBlock(
+      requestMessage,
+      buildAnthropicCacheControl(message.cacheControl.ttl ?? caching.ttl)
+    );
+  });
+}
 function applyAnthropicToolFields(requestBody, settings, input) {
   if (input.tools !== void 0 && input.tools.length > 0) {
     requestBody.tools = mapModelToolDefinitionsToAnthropicTools(
@@ -688,14 +773,15 @@ function applyAnthropicToolFields(requestBody, settings, input) {
   }
 }
 function mapModelToolDefinitionsToAnthropicTools(tools, promptCaching) {
+  const caching = resolveAnthropicPromptCachingSettings(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" };
+    if (caching.mode !== "off" && toolIndex === tools.length - 1) {
+      anthropicTool.cache_control = buildAnthropicCacheControl(caching.ttl);
     }
     return anthropicTool;
   });
@@ -1200,7 +1286,8 @@ function buildAnthropicCallInput(options, request) {
     maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
     tools: request.tools,
     toolChoice: request.toolChoice,
-    abortSignal: request.abortSignal
+    abortSignal: request.abortSignal,
+    extraBody: request.extraBody
   };
 }
 async function executeAnthropicAdapterCall(options, input) {
@@ -1217,9 +1304,10 @@ async function executeAnthropicAdapterCall(options, input) {
   );
 }
 async function requestAnthropicMessages(options, input) {
-  const requestBody = buildAnthropicRequestBody(
-    buildAnthropicRequestSettings(options),
-    input
+  const requestBody = mergeProviderRequestExtraBody(
+    buildAnthropicRequestBody(buildAnthropicRequestSettings(options), input),
+    options.extraBody,
+    input.extraBody
   );
   const startedAt = Date.now();
   const response = await executeAbortableProviderFetch(
@@ -1248,9 +1336,10 @@ async function requestAnthropicMessages(options, input) {
 }
 function buildAnthropicStreamInput(options, request) {
   const input = buildAnthropicCallInput(options, request);
-  const requestBody = buildAnthropicRequestBody(
-    buildAnthropicRequestSettings(options),
-    input
+  const requestBody = mergeProviderRequestExtraBody(
+    buildAnthropicRequestBody(buildAnthropicRequestSettings(options), input),
+    options.extraBody,
+    input.extraBody
   );
   return {
     url: `${resolveAnthropicBaseUrl(options)}/v1/messages`,
@@ -1322,7 +1411,8 @@ function gemini(options) {
         temperature: request.temperature ?? options.temperature,
         maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
         requireJsonResponse: false,
-        abortSignal: request.abortSignal
+        abortSignal: request.abortSignal,
+        extraBody: request.extraBody
       });
     },
     async generateStructuredOutput(request) {
@@ -1364,7 +1454,11 @@ async function requestGeminiGenerateContent(options, input) {
   });
   const fetchImplementation = options.fetchImplementation ?? fetch;
   const baseUrl = options.baseURL ?? defaultGeminiBaseUrl;
-  const requestBody = buildGeminiRequestBody(input);
+  const requestBody = mergeProviderRequestExtraBody(
+    buildGeminiRequestBody(input),
+    options.extraBody,
+    input.extraBody
+  );
   const requestUrl = `${baseUrl}/v1beta/models/${options.model}:generateContent`;
   const startedAt = Date.now();
   const response = await executeAbortableProviderFetch(
@@ -1652,9 +1746,209 @@ function calculateModelCallCostUsd(pricing, tokenUsage) {
 }
 
 // src/anthropic-batch.ts
+var import_errors26 = require("@assemble-dev/shared-types/errors");
+var import_json7 = require("@assemble-dev/shared-types/json");
+var import_errors27 = require("@assemble-dev/shared-utils/errors");
+
+// src/anthropic-batch-structured.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");
+var anthropicBatchJsonOnlySystemInstruction = "Respond with a single JSON object that satisfies the caller's requested structure. Output only valid JSON with no surrounding text.";
+function parseAnthropicBatchStructuredContent(content, schema) {
+  const jsonValue = parseStructuredJsonText(
+    content,
+    import_json6.JsonValueSchema
+  );
+  const validationResult = schema.safeParse(jsonValue);
+  if (!validationResult.success) {
+    throw new import_errors25.AppError({
+      code: import_errors24.AppErrorCode.ValidationFailed,
+      message: "Anthropic batch structured output did not match the expected schema",
+      statusCode: 422,
+      details: { validationErrorMessage: validationResult.error.message }
+    });
+  }
+  return validationResult.data;
+}
+
+// src/anthropic-batch-request.ts
+function mapBatchMessageRequestToApiBatchRequest(request) {
+  const params = {
+    model: request.model,
+    max_tokens: request.maxOutputTokens ?? defaultAnthropicMaxOutputTokens,
+    messages: request.messages.filter((message) => message.role !== "system").map(mapChatMessageToBatchApiRequestMessage)
+  };
+  applyBatchSystemField(params, request);
+  if (request.temperature !== void 0) {
+    params.temperature = request.temperature;
+  }
+  return { custom_id: request.customId, params };
+}
+function applyBatchSystemField(params, request) {
+  const systemText = buildBatchSystemText(request);
+  if (systemText.length === 0) {
+    return;
+  }
+  if (request.promptCaching !== "auto") {
+    params.system = systemText;
+    return;
+  }
+  params.system = [
+    { type: "text", text: systemText, cache_control: { type: "ephemeral" } }
+  ];
+}
+function buildBatchSystemText(request) {
+  const joinedSystemText = joinBatchSystemMessageText(request.messages);
+  if (request.requireJsonResponse !== true) {
+    return joinedSystemText;
+  }
+  if (joinedSystemText.length === 0) {
+    return anthropicBatchJsonOnlySystemInstruction;
+  }
+  return `${anthropicBatchJsonOnlySystemInstruction}
+
+${joinedSystemText}`;
+}
+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)}`;
+}
+
+// src/anthropic-batch-trace-events.ts
+var import_ids = require("@assemble-dev/shared-utils/ids");
+var anthropicBatchTraceWorkflowName = "anthropic-message-batch";
+function createAnthropicBatchTraceEmitter(input) {
+  if (input.onTraceEvent === void 0) {
+    return createNoopAnthropicBatchTraceEmitter();
+  }
+  const onTraceEvent = input.onTraceEvent;
+  const runId = (0, import_ids.generateRunId)();
+  const completedBatchIds = /* @__PURE__ */ new Set();
+  const submittedEventIdByBatchId = /* @__PURE__ */ new Map();
+  const modelByBatchScopedCustomId = /* @__PURE__ */ new Map();
+  function buildBatchTraceEventBase(parentEventId) {
+    return {
+      id: (0, import_ids.generateTraceEventId)(),
+      runId,
+      workflowName: anthropicBatchTraceWorkflowName,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      parentEventId,
+      redacted: false
+    };
+  }
+  function stampMetadataOntoEvent(event) {
+    if (input.metadata === void 0) {
+      return event;
+    }
+    return { ...event, metadata: input.metadata };
+  }
+  function emitBatchSubmittedEvent(batch, requestSummaries) {
+    const submittedEvent = {
+      ...buildBatchTraceEventBase(null),
+      type: "batch.submitted",
+      batchId: batch.id,
+      requestCount: requestSummaries.length,
+      models: requestSummaries.map((requestSummary) => requestSummary.model)
+    };
+    submittedEventIdByBatchId.set(batch.id, submittedEvent.id);
+    for (const requestSummary of requestSummaries) {
+      modelByBatchScopedCustomId.set(
+        buildBatchScopedCustomIdKey(batch.id, requestSummary.customId),
+        requestSummary.model
+      );
+    }
+    onTraceEvent(stampMetadataOntoEvent(submittedEvent));
+  }
+  function emitBatchCompletedEventOnce(batch) {
+    if (batch.processingStatus !== "ended" || completedBatchIds.has(batch.id)) {
+      return;
+    }
+    completedBatchIds.add(batch.id);
+    const completedEvent = {
+      ...buildBatchTraceEventBase(
+        submittedEventIdByBatchId.get(batch.id) ?? null
+      ),
+      type: "batch.completed",
+      batchId: batch.id,
+      requestCounts: batch.requestCounts,
+      latencyMs: calculateBatchLatencyMs(batch)
+    };
+    onTraceEvent(stampMetadataOntoEvent(completedEvent));
+  }
+  function emitBatchResultEvent(batchId, result) {
+    const resultEvent = buildBatchResultEvent(
+      buildBatchTraceEventBase(submittedEventIdByBatchId.get(batchId) ?? null),
+      batchId,
+      result,
+      modelByBatchScopedCustomId.get(
+        buildBatchScopedCustomIdKey(batchId, result.customId)
+      )
+    );
+    onTraceEvent(stampMetadataOntoEvent(resultEvent));
+  }
+  return {
+    emitBatchSubmittedEvent,
+    emitBatchCompletedEventOnce,
+    emitBatchResultEvent
+  };
+}
+function createNoopAnthropicBatchTraceEmitter() {
+  return {
+    emitBatchSubmittedEvent() {
+    },
+    emitBatchCompletedEventOnce() {
+    },
+    emitBatchResultEvent() {
+    }
+  };
+}
+function buildBatchScopedCustomIdKey(batchId, customId) {
+  return `${batchId}:${customId}`;
+}
+function calculateBatchLatencyMs(batch) {
+  const createdAtMs = Date.parse(batch.createdAt);
+  const endedAtMs = batch.endedAt === null ? Date.now() : Date.parse(batch.endedAt);
+  if (Number.isNaN(createdAtMs) || Number.isNaN(endedAtMs)) {
+    return 0;
+  }
+  return Math.max(0, endedAtMs - createdAtMs);
+}
+function buildBatchResultEvent(eventBase, batchId, result, modelName) {
+  if (result.outcome.type !== "succeeded") {
+    return {
+      ...eventBase,
+      type: "batch.result",
+      batchId,
+      customId: result.customId,
+      outcomeType: result.outcome.type,
+      costUsd: null
+    };
+  }
+  return {
+    ...eventBase,
+    type: "batch.result",
+    batchId,
+    customId: result.customId,
+    outcomeType: "succeeded",
+    tokenUsage: result.outcome.tokenUsage,
+    costUsd: modelName === void 0 ? null : estimateModelCallCostUsd(modelName, result.outcome.tokenUsage)
+  };
+}
 
 // src/anthropic-batch-types.ts
 var import_zod7 = require("zod");
@@ -1759,19 +2053,26 @@ var defaultAnthropicBatchPollIntervalMs = 5e3;
 var defaultAnthropicBatchTimeoutMs = 36e5;
 var anthropicBatchApiVersion = "2023-06-01";
 function createAnthropicBatchClient(options) {
+  const clientContext = {
+    options,
+    traceEmitter: createAnthropicBatchTraceEmitter({
+      onTraceEvent: options.onTraceEvent,
+      metadata: options.metadata
+    })
+  };
   return {
     async submitMessageBatch(requests) {
-      return await submitAnthropicMessageBatch(options, requests);
+      return await submitAnthropicMessageBatch(clientContext, requests);
     },
     async fetchMessageBatch(batchId) {
-      return await fetchAnthropicMessageBatch(options, batchId);
+      return await fetchAnthropicMessageBatch(clientContext, batchId);
     },
     async listMessageBatchResults(batchId) {
-      return await listAnthropicMessageBatchResults(options, batchId);
+      return await listAnthropicMessageBatchResults(clientContext, batchId);
     },
     async waitForMessageBatchCompletion(batchId, waitOptions) {
       return await waitForAnthropicMessageBatchCompletion(
-        options,
+        clientContext,
         batchId,
         waitOptions
       );
@@ -1798,8 +2099,8 @@ function buildAnthropicBatchRequestHeaders(apiKey) {
     "anthropic-version": anthropicBatchApiVersion
   };
 }
-async function submitAnthropicMessageBatch(options, requests) {
-  const context = resolveAnthropicBatchRequestContext(options);
+async function submitAnthropicMessageBatch(clientContext, requests) {
+  const context = resolveAnthropicBatchRequestContext(clientContext.options);
   const response = await context.fetchImplementation(
     `${context.baseUrl}/v1/messages/batches`,
     {
@@ -1810,10 +2111,18 @@ async function submitAnthropicMessageBatch(options, requests) {
       })
     }
   );
-  return await parseAnthropicMessageBatchHttpResponse(response);
+  const batch = await parseAnthropicMessageBatchHttpResponse(response);
+  clientContext.traceEmitter.emitBatchSubmittedEvent(
+    batch,
+    requests.map((request) => ({
+      customId: request.customId,
+      model: request.model
+    }))
+  );
+  return batch;
 }
-async function fetchAnthropicMessageBatch(options, batchId) {
-  const context = resolveAnthropicBatchRequestContext(options);
+async function fetchAnthropicMessageBatch(clientContext, batchId) {
+  const context = resolveAnthropicBatchRequestContext(clientContext.options);
   const response = await context.fetchImplementation(
     `${context.baseUrl}/v1/messages/batches/${batchId}`,
     {
@@ -1821,7 +2130,9 @@ async function fetchAnthropicMessageBatch(options, batchId) {
       headers: buildAnthropicBatchRequestHeaders(context.apiKey)
     }
   );
-  return await parseAnthropicMessageBatchHttpResponse(response);
+  const batch = await parseAnthropicMessageBatchHttpResponse(response);
+  clientContext.traceEmitter.emitBatchCompletedEventOnce(batch);
+  return batch;
 }
 async function parseAnthropicMessageBatchHttpResponse(response) {
   if (!response.ok) {
@@ -1835,17 +2146,17 @@ async function parseAnthropicMessageBatchHttpResponse(response) {
   }
   return mapAnthropicMessageBatchResponseToMessageBatch(parseResult.data);
 }
-async function listAnthropicMessageBatchResults(options, batchId) {
-  const batch = await fetchAnthropicMessageBatch(options, batchId);
+async function listAnthropicMessageBatchResults(clientContext, batchId) {
+  const batch = await fetchAnthropicMessageBatch(clientContext, batchId);
   if (batch.resultsUrl === null) {
-    throw new import_errors25.AppError({
-      code: import_errors24.AppErrorCode.Conflict,
+    throw new import_errors27.AppError({
+      code: import_errors26.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 context = resolveAnthropicBatchRequestContext(clientContext.options);
   const response = await context.fetchImplementation(batch.resultsUrl, {
     method: "GET",
     headers: buildAnthropicBatchRequestHeaders(context.apiKey)
@@ -1853,7 +2164,11 @@ async function listAnthropicMessageBatchResults(options, batchId) {
   if (!response.ok) {
     throw buildProviderStatusError("Anthropic", response.status);
   }
-  return parseAnthropicBatchResultsJsonl(await response.text());
+  const results = parseAnthropicBatchResultsJsonl(await response.text());
+  for (const result of results) {
+    clientContext.traceEmitter.emitBatchResultEvent(batchId, result);
+  }
+  return results;
 }
 function parseAnthropicBatchResultsJsonl(jsonlText) {
   return jsonlText.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map(parseAnthropicBatchResultLine);
@@ -1872,7 +2187,7 @@ function parseAnthropicBatchResultLine(line) {
 }
 function parseAnthropicBatchResultLineJson(line) {
   try {
-    return import_json6.JsonValueSchema.parse(JSON.parse(line));
+    return import_json7.JsonValueSchema.parse(JSON.parse(line));
   } catch {
     throw buildProviderInvalidResponseError(
       "Anthropic",
@@ -1880,72 +2195,44 @@ function parseAnthropicBatchResultLineJson(line) {
     );
   }
 }
-async function waitForAnthropicMessageBatchCompletion(options, batchId, waitOptions) {
+async function waitForAnthropicMessageBatchCompletion(clientContext, 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);
+  let batch = await fetchAnthropicMessageBatch(clientContext, batchId);
   while (batch.processingStatus !== "ended") {
     if (Date.now() - startedAt >= timeoutMs) {
       throw buildAnthropicBatchTimeoutError(batchId, timeoutMs);
     }
     await waitFor(pollIntervalMs);
-    batch = await fetchAnthropicMessageBatch(options, batchId);
+    batch = await fetchAnthropicMessageBatch(clientContext, batchId);
   }
   return batch;
 }
 function buildAnthropicBatchTimeoutError(batchId, timeoutMs) {
-  return new import_errors25.AppError({
-    code: import_errors24.AppErrorCode.ServiceUnavailable,
+  return new import_errors27.AppError({
+    code: import_errors26.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,
+  ChatMessageCacheControlSchema,
   ChatMessageRoleSchema,
   ChatMessageSchema,
   ChatStopReasonSchema,
   MessageContentBlockSchema,
   ModelToolCallSchema,
   anthropic,
+  anthropicBatchJsonOnlySystemInstruction,
+  anthropicBatchTraceWorkflowName,
+  applyCacheControlToLastContentBlock,
+  buildAnthropicCacheControl,
   buildAnthropicRequestBody,
   buildOpenAiRequestBody,
   buildProviderCanceledError,
@@ -1979,11 +2266,14 @@ function buildBatchToolResultText(message) {
   mapModelToolChoiceToOpenAiToolChoice,
   mapModelToolDefinitionToOpenAiTool,
   mapModelToolDefinitionsToAnthropicTools,
+  mergeProviderRequestExtraBody,
   mockModel,
   normalizeAnthropicStopReason,
   openai,
+  parseAnthropicBatchStructuredContent,
   parseAnthropicStreamEvents,
   parseAnthropicToolInputJson,
+  resolveAnthropicPromptCachingSettings,
   resolveProviderApiKey,
   streamAnthropicChatCompletion
 });