@assemble-dev/providers 0.1.0 → 0.2.0

package/dist/index.js

@@ -28,12 +28,16 @@ var ModelToolCallSchema = z.object({
   toolName: z.string(),
   input: JsonValueSchema
 });
+var ChatMessageCacheControlSchema = z.object({
+  ttl: z.enum(["5m", "1h"]).optional()
+});
 var ChatMessageSchema = z.object({
   role: ChatMessageRoleSchema,
   content: z.union([z.string(), z.array(MessageContentBlockSchema)]),
   toolName: z.string().optional(),
   toolCallId: z.string().optional(),
-  toolCalls: z.array(ModelToolCallSchema).optional()
+  toolCalls: z.array(ModelToolCallSchema).optional(),
+  cacheControl: ChatMessageCacheControlSchema.optional()
 });
 var ChatStopReasonSchema = z.enum([
   "end_turn",
@@ -267,6 +271,15 @@ async function executeAbortableProviderFetch(providerLabel, performFetch) {
   }
 }
 
+// src/provider-extra-body.ts
+function mergeProviderRequestExtraBody(requestBody, adapterExtraBody, requestExtraBody) {
+  return {
+    ...requestBody,
+    ...adapterExtraBody ?? {},
+    ...requestExtraBody ?? {}
+  };
+}
+
 // src/provider-fallback.ts
 import { AppError as AppError6 } from "@assemble-dev/shared-utils/errors";
 
@@ -434,7 +447,8 @@ function openai(options) {
         requireJsonObjectResponse: false,
         tools: request.tools,
         toolChoice: request.toolChoice,
-        abortSignal: request.abortSignal
+        abortSignal: request.abortSignal,
+        extraBody: request.extraBody
       });
     },
     async generateStructuredOutput(request) {
@@ -476,7 +490,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",
@@ -572,6 +590,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 = {
@@ -581,6 +629,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;
   }
@@ -593,18 +642,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(
@@ -619,14 +696,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;
   });
@@ -1131,7 +1209,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) {
@@ -1148,9 +1227,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(
@@ -1179,9 +1259,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`,
@@ -1253,7 +1334,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) {
@@ -1295,7 +1377,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(
@@ -1583,9 +1669,212 @@ function calculateModelCallCostUsd(pricing, tokenUsage) {
 }
 
 // src/anthropic-batch.ts
+import { AppErrorCode as AppErrorCode13 } from "@assemble-dev/shared-types/errors";
+import { JsonValueSchema as JsonValueSchema7 } from "@assemble-dev/shared-types/json";
+import { AppError as AppError14 } from "@assemble-dev/shared-utils/errors";
+
+// src/anthropic-batch-structured.ts
 import { AppErrorCode as AppErrorCode12 } from "@assemble-dev/shared-types/errors";
 import { JsonValueSchema as JsonValueSchema6 } from "@assemble-dev/shared-types/json";
 import { AppError as AppError13 } from "@assemble-dev/shared-utils/errors";
+var anthropicBatchJsonOnlySystemInstruction = "Respond with a single JSON object that satisfies the caller's requested structure. Output only valid JSON with no surrounding text.";
+function parseAnthropicBatchStructuredContent(content, schema) {
+  const jsonValue = parseStructuredJsonText(
+    content,
+    JsonValueSchema6
+  );
+  const validationResult = schema.safeParse(jsonValue);
+  if (!validationResult.success) {
+    throw new AppError13({
+      code: AppErrorCode12.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
+import {
+  generateRunId,
+  generateTraceEventId
+} from "@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 = generateRunId();
+  const completedBatchIds = /* @__PURE__ */ new Set();
+  const submittedEventIdByBatchId = /* @__PURE__ */ new Map();
+  const modelByBatchScopedCustomId = /* @__PURE__ */ new Map();
+  function buildBatchTraceEventBase(parentEventId) {
+    return {
+      id: 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
 import { z as z7 } from "zod";
@@ -1690,19 +1979,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
       );
@@ -1729,8 +2025,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`,
     {
@@ -1741,10 +2037,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}`,
     {
@@ -1752,7 +2056,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) {
@@ -1766,17 +2072,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 AppError13({
-      code: AppErrorCode12.Conflict,
+    throw new AppError14({
+      code: AppErrorCode13.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)
@@ -1784,7 +2090,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);
@@ -1803,7 +2113,7 @@ function parseAnthropicBatchResultLine(line) {
 }
 function parseAnthropicBatchResultLineJson(line) {
   try {
-    return JsonValueSchema6.parse(JSON.parse(line));
+    return JsonValueSchema7.parse(JSON.parse(line));
   } catch {
     throw buildProviderInvalidResponseError(
       "Anthropic",
@@ -1811,71 +2121,43 @@ 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 AppError13({
-    code: AppErrorCode12.ServiceUnavailable,
+  return new AppError14({
+    code: AppErrorCode13.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)}`;
-}
 export {
   AnthropicMessagesResponseSchema,
   AnthropicStreamEventSchema,
+  ChatMessageCacheControlSchema,
   ChatMessageRoleSchema,
   ChatMessageSchema,
   ChatStopReasonSchema,
   MessageContentBlockSchema,
   ModelToolCallSchema,
   anthropic,
+  anthropicBatchJsonOnlySystemInstruction,
+  anthropicBatchTraceWorkflowName,
+  applyCacheControlToLastContentBlock,
+  buildAnthropicCacheControl,
   buildAnthropicRequestBody,
   buildOpenAiRequestBody,
   buildProviderCanceledError,
@@ -1909,11 +2191,14 @@ export {
   mapModelToolChoiceToOpenAiToolChoice,
   mapModelToolDefinitionToOpenAiTool,
   mapModelToolDefinitionsToAnthropicTools,
+  mergeProviderRequestExtraBody,
   mockModel,
   normalizeAnthropicStopReason,
   openai,
+  parseAnthropicBatchStructuredContent,
   parseAnthropicStreamEvents,
   parseAnthropicToolInputJson,
+  resolveAnthropicPromptCachingSettings,
   resolveProviderApiKey,
   streamAnthropicChatCompletion
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assemble-dev/providers",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "Elastic-2.0",
   "description": "Model provider adapters for the Assemble SDK",
   "repository": {
@@ -27,8 +27,8 @@
   ],
   "dependencies": {
     "zod": "^4.1.13",
-    "@assemble-dev/shared-types": "0.1.0",
-    "@assemble-dev/shared-utils": "0.1.0"
+    "@assemble-dev/shared-types": "0.2.0",
+    "@assemble-dev/shared-utils": "0.2.0"
   },
   "devDependencies": {
     "@types/node": "^20.19.0",