@assemble-dev/providers 0.1.0 → 0.3.0

package/dist/index.cjs

@@ -22,21 +22,41 @@ var index_exports = {};
 __export(index_exports, {
   AnthropicMessagesResponseSchema: () => AnthropicMessagesResponseSchema,
   AnthropicStreamEventSchema: () => AnthropicStreamEventSchema,
+  AzureOpenAiChatCompletionResponseSchema: () => AzureOpenAiChatCompletionResponseSchema,
+  ChatMessageCacheControlSchema: () => ChatMessageCacheControlSchema,
   ChatMessageRoleSchema: () => ChatMessageRoleSchema,
   ChatMessageSchema: () => ChatMessageSchema,
   ChatStopReasonSchema: () => ChatStopReasonSchema,
   MessageContentBlockSchema: () => MessageContentBlockSchema,
   ModelToolCallSchema: () => ModelToolCallSchema,
   anthropic: () => anthropic,
+  anthropicBatchJsonOnlySystemInstruction: () => anthropicBatchJsonOnlySystemInstruction,
+  anthropicBatchTraceWorkflowName: () => anthropicBatchTraceWorkflowName,
+  applyCacheControlToLastContentBlock: () => applyCacheControlToLastContentBlock,
+  awsSigV4Algorithm: () => awsSigV4Algorithm,
+  azureOpenai: () => azureOpenai,
+  bedrock: () => bedrock,
+  bedrockAnthropicVersion: () => bedrockAnthropicVersion,
+  buildAnthropicCacheControl: () => buildAnthropicCacheControl,
   buildAnthropicRequestBody: () => buildAnthropicRequestBody,
+  buildAnthropicStructuredOutputJsonSchema: () => buildAnthropicStructuredOutputJsonSchema,
+  buildAzureOpenAiChatCompletionsUrl: () => buildAzureOpenAiChatCompletionsUrl,
+  buildAzureOpenAiChatRequestBody: () => buildAzureOpenAiChatRequestBody,
+  buildBedrockInvokeModelRequestBody: () => buildBedrockInvokeModelRequestBody,
+  buildBedrockInvokeModelUrl: () => buildBedrockInvokeModelUrl,
+  buildGeminiResponseSchema: () => buildGeminiResponseSchema,
   buildOpenAiRequestBody: () => buildOpenAiRequestBody,
+  buildOpenAiStructuredOutputJsonSchema: () => buildOpenAiStructuredOutputJsonSchema,
   buildProviderCanceledError: () => buildProviderCanceledError,
   calculateProviderRetryDelayMs: () => calculateProviderRetryDelayMs,
+  convertZodSchemaToJsonSchema: () => convertZodSchemaToJsonSchema,
   createAnthropicBatchClient: () => createAnthropicBatchClient,
   defaultAnthropicBaseUrl: () => defaultAnthropicBaseUrl,
   defaultAnthropicBatchPollIntervalMs: () => defaultAnthropicBatchPollIntervalMs,
   defaultAnthropicBatchTimeoutMs: () => defaultAnthropicBatchTimeoutMs,
   defaultAnthropicMaxOutputTokens: () => defaultAnthropicMaxOutputTokens,
+  defaultAzureOpenAiApiVersion: () => defaultAzureOpenAiApiVersion,
+  defaultBedrockMaxOutputTokens: () => defaultBedrockMaxOutputTokens,
   defaultGeminiBaseUrl: () => defaultGeminiBaseUrl,
   defaultOpenAiBaseUrl: () => defaultOpenAiBaseUrl,
   defaultProviderRetryInitialDelayMs: () => defaultProviderRetryInitialDelayMs,
@@ -47,6 +67,7 @@ __export(index_exports, {
   executeProviderCallWithModelFallback: () => executeProviderCallWithModelFallback,
   executeProviderCallWithRetry: () => executeProviderCallWithRetry,
   extractAnthropicTextContent: () => extractAnthropicTextContent,
+  extractAnthropicThinkingText: () => extractAnthropicThinkingText,
   extractAnthropicToolCalls: () => extractAnthropicToolCalls,
   extractMessageText: () => extractMessageText,
   gemini: () => gemini,
@@ -55,19 +76,34 @@ __export(index_exports, {
   joinSystemMessageText: () => joinSystemMessageText,
   mapAnthropicResponseToChatCompletionResult: () => mapAnthropicResponseToChatCompletionResult,
   mapAnthropicUsageToTokenUsage: () => mapAnthropicUsageToTokenUsage,
+  mapAzureOpenAiResponseToChatCompletionResult: () => mapAzureOpenAiResponseToChatCompletionResult,
+  mapAzureOpenAiUsageToTokenUsage: () => mapAzureOpenAiUsageToTokenUsage,
   mapChatMessageToAnthropicRequestMessage: () => mapChatMessageToAnthropicRequestMessage,
   mapChatMessageToOpenAiRequestMessage: () => mapChatMessageToOpenAiRequestMessage,
   mapModelToolChoiceToAnthropicToolChoice: () => mapModelToolChoiceToAnthropicToolChoice,
   mapModelToolChoiceToOpenAiToolChoice: () => mapModelToolChoiceToOpenAiToolChoice,
   mapModelToolDefinitionToOpenAiTool: () => mapModelToolDefinitionToOpenAiTool,
   mapModelToolDefinitionsToAnthropicTools: () => mapModelToolDefinitionsToAnthropicTools,
+  mergeProviderRequestExtraBody: () => mergeProviderRequestExtraBody,
   mockModel: () => mockModel,
   normalizeAnthropicStopReason: () => normalizeAnthropicStopReason,
+  normalizeAzureOpenAiFinishReason: () => normalizeAzureOpenAiFinishReason,
+  openAiStructuredOutputSchemaName: () => openAiStructuredOutputSchemaName,
   openai: () => openai,
+  parseAnthropicBatchStructuredContent: () => parseAnthropicBatchStructuredContent,
   parseAnthropicStreamEvents: () => parseAnthropicStreamEvents,
   parseAnthropicToolInputJson: () => parseAnthropicToolInputJson,
+  parseAzureOpenAiStreamEvents: () => parseAzureOpenAiStreamEvents,
+  parseAzureOpenAiToolArgumentsJson: () => parseAzureOpenAiToolArgumentsJson,
+  resolveAnthropicPromptCachingSettings: () => resolveAnthropicPromptCachingSettings,
+  resolveBedrockCredentials: () => resolveBedrockCredentials,
   resolveProviderApiKey: () => resolveProviderApiKey,
-  streamAnthropicChatCompletion: () => streamAnthropicChatCompletion
+  sanitizeJsonSchemaForAnthropicStructuredOutput: () => sanitizeJsonSchemaForAnthropicStructuredOutput,
+  sanitizeJsonSchemaForGeminiResponseSchema: () => sanitizeJsonSchemaForGeminiResponseSchema,
+  sanitizeJsonSchemaForOpenAiStructuredOutput: () => sanitizeJsonSchemaForOpenAiStructuredOutput,
+  signAwsRequestWithSigV4: () => signAwsRequestWithSigV4,
+  streamAnthropicChatCompletion: () => streamAnthropicChatCompletion,
+  streamAzureOpenAiChatCompletion: () => streamAzureOpenAiChatCompletion
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -101,12 +137,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",
@@ -122,14 +162,222 @@ function extractMessageText(message) {
 }
 
 // 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");
+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");
 
 // src/openai-request-mapping.ts
+var import_errors3 = require("@assemble-dev/shared-types/errors");
+var import_errors4 = require("@assemble-dev/shared-utils/errors");
+
+// src/structured-output-json-schema.ts
+var import_zod2 = require("zod");
 var import_errors = require("@assemble-dev/shared-types/errors");
+var import_json2 = require("@assemble-dev/shared-types/json");
 var import_errors2 = require("@assemble-dev/shared-utils/errors");
+
+// src/json-schema-tree.ts
+var schemaMapKeywords = ["properties", "$defs"];
+var schemaListKeywords = ["anyOf", "oneOf", "allOf", "prefixItems"];
+var schemaValueKeywords = [
+  "items",
+  "additionalProperties",
+  "not",
+  "if",
+  "then",
+  "else",
+  "contains",
+  "propertyNames"
+];
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function transformJsonSchemaNode(node, transformNode) {
+  const result = { ...transformNode({ ...node }) };
+  for (const keyword of schemaMapKeywords) {
+    const mapValue = result[keyword];
+    if (mapValue !== void 0 && isJsonObject(mapValue)) {
+      result[keyword] = transformJsonSchemaMap(mapValue, transformNode);
+    }
+  }
+  for (const keyword of schemaListKeywords) {
+    const listValue = result[keyword];
+    if (Array.isArray(listValue)) {
+      result[keyword] = listValue.map(
+        (entry) => isJsonObject(entry) ? transformJsonSchemaNode(entry, transformNode) : entry
+      );
+    }
+  }
+  for (const keyword of schemaValueKeywords) {
+    const schemaValue = result[keyword];
+    if (schemaValue !== void 0 && isJsonObject(schemaValue)) {
+      result[keyword] = transformJsonSchemaNode(schemaValue, transformNode);
+    }
+  }
+  return result;
+}
+function transformJsonSchemaMap(schemaMap, transformNode) {
+  const result = {};
+  for (const [schemaName, schemaValue] of Object.entries(schemaMap)) {
+    result[schemaName] = isJsonObject(schemaValue) ? transformJsonSchemaNode(schemaValue, transformNode) : schemaValue;
+  }
+  return result;
+}
+function inlineJsonSchemaReferences(root) {
+  const rootDefinitions = root["$defs"];
+  const definitions = rootDefinitions !== void 0 && isJsonObject(rootDefinitions) ? rootDefinitions : {};
+  const resolvedRoot = resolveJsonSchemaReferences(
+    root,
+    definitions,
+    /* @__PURE__ */ new Set()
+  );
+  return isJsonObject(resolvedRoot) ? resolvedRoot : {};
+}
+function resolveJsonSchemaReferences(value, definitions, activeReferences) {
+  if (Array.isArray(value)) {
+    return value.map(
+      (entry) => resolveJsonSchemaReferences(entry, definitions, activeReferences)
+    );
+  }
+  if (!isJsonObject(value)) {
+    return value;
+  }
+  const referenceTarget = value["$ref"];
+  if (typeof referenceTarget === "string") {
+    return resolveJsonSchemaReferenceTarget(
+      referenceTarget,
+      definitions,
+      activeReferences
+    );
+  }
+  const result = {};
+  for (const [key, entryValue] of Object.entries(value)) {
+    if (key !== "$defs") {
+      result[key] = resolveJsonSchemaReferences(
+        entryValue,
+        definitions,
+        activeReferences
+      );
+    }
+  }
+  return result;
+}
+function resolveJsonSchemaReferenceTarget(referenceTarget, definitions, activeReferences) {
+  if (activeReferences.has(referenceTarget)) {
+    return {};
+  }
+  const definitionsPrefix = "#/$defs/";
+  if (!referenceTarget.startsWith(definitionsPrefix)) {
+    return {};
+  }
+  const definition = definitions[referenceTarget.slice(definitionsPrefix.length)];
+  if (definition === void 0 || !isJsonObject(definition)) {
+    return {};
+  }
+  return resolveJsonSchemaReferences(
+    definition,
+    definitions,
+    /* @__PURE__ */ new Set([...activeReferences, referenceTarget])
+  );
+}
+function removeJsonSchemaKeywords(node, keywords) {
+  const result = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (!keywords.includes(key)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/structured-output-json-schema.ts
+var openAiStructuredOutputSchemaName = "structured_output";
+var schemaMetadataKeywords = ["$schema", "$id"];
+var anthropicUnsupportedSchemaKeywords = [
+  ...schemaMetadataKeywords,
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "minLength",
+  "maxLength",
+  "multipleOf"
+];
+var openAiUnsupportedSchemaKeywords = [
+  ...anthropicUnsupportedSchemaKeywords,
+  "pattern",
+  "format",
+  "minItems",
+  "maxItems",
+  "uniqueItems",
+  "default"
+];
+function convertZodSchemaToJsonSchema(schema) {
+  try {
+    return import_json2.JsonObjectSchema.parse(import_zod2.z.toJSONSchema(schema, { io: "input" }));
+  } catch (error) {
+    throw new import_errors2.AppError({
+      code: import_errors.AppErrorCode.BadRequest,
+      message: "Structured output schema could not be converted to JSON Schema",
+      statusCode: 400,
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+}
+function buildAnthropicStructuredOutputJsonSchema(schema) {
+  return sanitizeJsonSchemaForAnthropicStructuredOutput(
+    convertZodSchemaToJsonSchema(schema)
+  );
+}
+function sanitizeJsonSchemaForAnthropicStructuredOutput(jsonSchema) {
+  return transformJsonSchemaNode(
+    inlineJsonSchemaReferences(jsonSchema),
+    sanitizeAnthropicSchemaNode
+  );
+}
+function buildOpenAiStructuredOutputJsonSchema(schema) {
+  return sanitizeJsonSchemaForOpenAiStructuredOutput(
+    convertZodSchemaToJsonSchema(schema)
+  );
+}
+function sanitizeJsonSchemaForOpenAiStructuredOutput(jsonSchema) {
+  return transformJsonSchemaNode(jsonSchema, sanitizeOpenAiSchemaNode);
+}
+function sanitizeAnthropicSchemaNode(node) {
+  const sanitized = removeJsonSchemaKeywords(
+    node,
+    anthropicUnsupportedSchemaKeywords
+  );
+  if (sanitized["type"] === "object") {
+    sanitized["additionalProperties"] = false;
+  }
+  return sanitized;
+}
+function sanitizeOpenAiSchemaNode(node) {
+  const sanitized = removeJsonSchemaKeywords(
+    node,
+    openAiUnsupportedSchemaKeywords
+  );
+  if (sanitized["type"] !== "object") {
+    return sanitized;
+  }
+  sanitized["additionalProperties"] = false;
+  const propertyNames = listSchemaPropertyNames(sanitized);
+  if (propertyNames.length > 0) {
+    sanitized["required"] = propertyNames;
+  }
+  return sanitized;
+}
+function listSchemaPropertyNames(node) {
+  const properties = node["properties"];
+  if (properties === void 0 || !isJsonObject(properties)) {
+    return [];
+  }
+  return Object.keys(properties);
+}
+
+// src/openai-request-mapping.ts
 function buildOpenAiRequestBody(model, input) {
   const requestBody = {
     model,
@@ -141,7 +389,16 @@ function buildOpenAiRequestBody(model, input) {
   if (input.maxOutputTokens !== void 0) {
     requestBody.max_tokens = input.maxOutputTokens;
   }
-  if (input.requireJsonObjectResponse) {
+  if (input.structuredOutputJsonSchema !== void 0) {
+    requestBody.response_format = {
+      type: "json_schema",
+      json_schema: {
+        name: openAiStructuredOutputSchemaName,
+        strict: true,
+        schema: input.structuredOutputJsonSchema
+      }
+    };
+  } else if (input.requireJsonObjectResponse === true) {
     requestBody.response_format = { type: "json_object" };
   }
   if (input.tools !== void 0 && input.tools.length > 0) {
@@ -227,17 +484,17 @@ function mapMessageContentBlockToOpenAiContentPart(contentBlock) {
       }
     };
   }
-  throw new import_errors2.AppError({
-    code: import_errors.AppErrorCode.ValidationFailed,
+  throw new import_errors4.AppError({
+    code: import_errors3.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 import_errors5 = require("@assemble-dev/shared-types/errors");
+var import_json3 = require("@assemble-dev/shared-types/json");
+var import_errors6 = 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)));
@@ -252,10 +509,10 @@ function stripMarkdownCodeFences(text) {
 }
 function parseJsonText(text) {
   try {
-    return import_json2.JsonValueSchema.parse(JSON.parse(text));
+    return import_json3.JsonValueSchema.parse(JSON.parse(text));
   } catch (error) {
-    throw new import_errors4.AppError({
-      code: import_errors3.AppErrorCode.ValidationFailed,
+    throw new import_errors6.AppError({
+      code: import_errors5.AppErrorCode.ValidationFailed,
       message: "Structured output was not valid JSON",
       statusCode: 422,
       cause: error instanceof Error ? error : void 0
@@ -264,9 +521,9 @@ function parseJsonText(text) {
 }
 
 // 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_zod3 = require("zod");
+var import_errors7 = require("@assemble-dev/shared-types/errors");
+var import_errors8 = 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) {
@@ -279,8 +536,8 @@ function resolveProviderApiKey(input) {
 }
 function resolveNamedProviderApiKeyFromEnv(input, apiKeyName) {
   if (!(0, import_provider_keys.validateProviderApiKeyName)(apiKeyName)) {
-    throw new import_errors6.AppError({
-      code: import_errors5.AppErrorCode.BadRequest,
+    throw new import_errors8.AppError({
+      code: import_errors7.AppErrorCode.BadRequest,
       message: `Invalid ${input.providerLabel} apiKeyName "${apiKeyName}". Expected ${import_provider_keys.expectedProviderApiKeyNameFormat}.`,
       statusCode: 400
     });
@@ -288,8 +545,8 @@ function resolveNamedProviderApiKeyFromEnv(input, apiKeyName) {
   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,
+    throw new import_errors8.AppError({
+      code: import_errors7.AppErrorCode.Unauthorized,
       message: `${input.providerLabel} API key named "${apiKeyName}" is missing. Set the ${envVarName} environment variable or pass apiKey to ${input.adapterFunctionName}.`,
       statusCode: 401
     });
@@ -299,8 +556,8 @@ function resolveNamedProviderApiKeyFromEnv(input, apiKeyName) {
 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,
+    throw new import_errors8.AppError({
+      code: import_errors7.AppErrorCode.Unauthorized,
       message: `${input.providerLabel} API key is missing. Pass apiKey to ${input.adapterFunctionName} or set the ${input.baseEnvVarName} environment variable.`,
       statusCode: 401
     });
@@ -308,19 +565,19 @@ function resolveBaseProviderApiKeyFromEnv(input) {
   return envApiKey;
 }
 function readEnvironmentVariable(envVarName) {
-  const parsedEnv = import_zod2.z.object({ [envVarName]: import_zod2.z.string().optional() }).parse(process.env);
+  const parsedEnv = import_zod3.z.object({ [envVarName]: import_zod3.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");
+var import_errors9 = require("@assemble-dev/shared-types/errors");
+var import_errors10 = 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,
+  return new import_errors10.AppError({
+    code: import_errors9.AppErrorCode.Canceled,
     message: `${providerLabel} request was canceled`,
     statusCode: 499
   });
@@ -336,19 +593,28 @@ 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");
+var import_errors13 = 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 import_errors11 = require("@assemble-dev/shared-types/errors");
+var import_errors12 = 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
+  import_errors11.AppErrorCode.RateLimited,
+  import_errors11.AppErrorCode.ServiceUnavailable,
+  import_errors11.AppErrorCode.InternalServerError
 ]);
 function isRetryableProviderAppError(appError) {
   return retryableAppErrorCodes.has(appError.code);
@@ -363,7 +629,7 @@ async function executeProviderCallWithRetry(retryOptions, executeCall, waitFor)
     try {
       return await executeCall();
     } catch (error) {
-      if (error instanceof import_errors10.AppError && !isRetryableProviderAppError(error)) {
+      if (error instanceof import_errors12.AppError && !isRetryableProviderAppError(error)) {
         throw error;
       }
       if (error instanceof Error && isAbortError(error)) {
@@ -397,7 +663,7 @@ async function executeProviderCallWithModelFallback(fallbackModel, executePrimar
     if (fallbackModel === void 0) {
       throw error;
     }
-    if (error instanceof import_errors11.AppError && !isRetryableProviderAppError(error)) {
+    if (error instanceof import_errors13.AppError && !isRetryableProviderAppError(error)) {
       throw error;
     }
     if (error instanceof Error && isAbortError(error)) {
@@ -408,11 +674,11 @@ async function executeProviderCallWithModelFallback(fallbackModel, executePrimar
 }
 
 // src/provider-status-error.ts
-var import_errors12 = require("@assemble-dev/shared-types/errors");
-var import_errors13 = require("@assemble-dev/shared-utils/errors");
+var import_errors14 = require("@assemble-dev/shared-types/errors");
+var import_errors15 = require("@assemble-dev/shared-utils/errors");
 function buildProviderStatusError(providerLabel, providerStatus) {
   const code = mapProviderStatusToAppErrorCode(providerStatus);
-  return new import_errors13.AppError({
+  return new import_errors15.AppError({
     code,
     message: `${providerLabel} request failed with status ${String(providerStatus)}`,
     statusCode: mapAppErrorCodeToStatusCode(code),
@@ -420,44 +686,44 @@ function buildProviderStatusError(providerLabel, providerStatus) {
   });
 }
 function buildProviderInvalidResponseError(providerLabel, expectedShapeDescription) {
-  return new import_errors13.AppError({
-    code: import_errors12.AppErrorCode.ValidationFailed,
+  return new import_errors15.AppError({
+    code: import_errors14.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;
+    return import_errors14.AppErrorCode.BadRequest;
   }
   if (providerStatus === 401) {
-    return import_errors12.AppErrorCode.Unauthorized;
+    return import_errors14.AppErrorCode.Unauthorized;
   }
   if (providerStatus === 403) {
-    return import_errors12.AppErrorCode.Forbidden;
+    return import_errors14.AppErrorCode.Forbidden;
   }
   if (providerStatus === 404) {
-    return import_errors12.AppErrorCode.NotFound;
+    return import_errors14.AppErrorCode.NotFound;
   }
   if (providerStatus === 429) {
-    return import_errors12.AppErrorCode.RateLimited;
+    return import_errors14.AppErrorCode.RateLimited;
   }
-  return import_errors12.AppErrorCode.InternalServerError;
+  return import_errors14.AppErrorCode.InternalServerError;
 }
 function mapAppErrorCodeToStatusCode(code) {
-  if (code === import_errors12.AppErrorCode.BadRequest) {
+  if (code === import_errors14.AppErrorCode.BadRequest) {
     return 400;
   }
-  if (code === import_errors12.AppErrorCode.Unauthorized) {
+  if (code === import_errors14.AppErrorCode.Unauthorized) {
     return 401;
   }
-  if (code === import_errors12.AppErrorCode.Forbidden) {
+  if (code === import_errors14.AppErrorCode.Forbidden) {
     return 403;
   }
-  if (code === import_errors12.AppErrorCode.NotFound) {
+  if (code === import_errors14.AppErrorCode.NotFound) {
     return 404;
   }
-  if (code === import_errors12.AppErrorCode.RateLimited) {
+  if (code === import_errors14.AppErrorCode.RateLimited) {
     return 429;
   }
   return 500;
@@ -465,33 +731,29 @@ function mapAppErrorCodeToStatusCode(code) {
 
 // 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 OpenAiResponseToolCallSchema = import_zod4.z.object({
+  id: import_zod4.z.string(),
+  function: import_zod4.z.object({
+    name: import_zod4.z.string(),
+    arguments: import_zod4.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()
+var OpenAiChatCompletionResponseSchema = import_zod4.z.object({
+  choices: import_zod4.z.array(
+    import_zod4.z.object({
+      message: import_zod4.z.object({
+        content: import_zod4.z.string().nullable(),
+        tool_calls: import_zod4.z.array(OpenAiResponseToolCallSchema).optional()
       }),
-      finish_reason: import_zod3.z.string().nullable().optional()
+      finish_reason: import_zod4.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()
+  usage: import_zod4.z.object({
+    prompt_tokens: import_zod4.z.number().int().nonnegative(),
+    completion_tokens: import_zod4.z.number().int().nonnegative(),
+    total_tokens: import_zod4.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}`,
@@ -500,18 +762,20 @@ function openai(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
+        abortSignal: request.abortSignal,
+        extraBody: request.extraBody
       });
     },
     async generateStructuredOutput(request) {
       const completion = await executeOpenAiAdapterCall(options, {
-        messages: [structuredOutputSystemMessage, ...request.messages],
+        messages: request.messages,
         temperature: request.temperature ?? options.temperature,
         maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
-        requireJsonObjectResponse: true,
+        structuredOutputJsonSchema: buildOpenAiStructuredOutputJsonSchema(
+          request.schema
+        ),
         abortSignal: request.abortSignal
       });
       return {
@@ -545,7 +809,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",
@@ -600,10 +868,10 @@ function parseOpenAiToolArgumentsJson(argumentsJsonText) {
     return {};
   }
   try {
-    return import_json3.JsonValueSchema.parse(JSON.parse(argumentsJsonText));
+    return import_json4.JsonValueSchema.parse(JSON.parse(argumentsJsonText));
   } catch (error) {
-    throw new import_errors15.AppError({
-      code: import_errors14.AppErrorCode.ValidationFailed,
+    throw new import_errors17.AppError({
+      code: import_errors16.AppErrorCode.ValidationFailed,
       message: "OpenAI tool call arguments were not valid JSON",
       statusCode: 502,
       cause: error instanceof Error ? error : void 0
@@ -625,8 +893,8 @@ function extractOpenAiMessageContent(response, allowEmptyContent) {
     if (allowEmptyContent) {
       return "";
     }
-    throw new import_errors15.AppError({
-      code: import_errors14.AppErrorCode.ValidationFailed,
+    throw new import_errors17.AppError({
+      code: import_errors16.AppErrorCode.ValidationFailed,
       message: "OpenAI response contained no message content",
       statusCode: 502
     });
@@ -641,6 +909,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 +948,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;
   }
@@ -659,21 +958,54 @@ function buildAnthropicRequestBody(settings, input) {
       budget_tokens: settings.thinking.budgetTokens
     };
   }
+  if (input.structuredOutputJsonSchema !== void 0) {
+    requestBody.output_config = {
+      format: { type: "json_schema", schema: input.structuredOutputJsonSchema }
+    };
+  }
   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 +1020,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;
   });
@@ -786,44 +1119,45 @@ function mapMessageContentBlockToAnthropic(contentBlock) {
 }
 
 // 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 import_zod5 = require("zod");
+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");
+var AnthropicUsageSchema = import_zod5.z.object({
+  input_tokens: import_zod5.z.number().int().nonnegative(),
+  output_tokens: import_zod5.z.number().int().nonnegative(),
+  cache_creation_input_tokens: import_zod5.z.number().int().nonnegative().optional(),
+  cache_read_input_tokens: import_zod5.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()
+var AnthropicContentBlockSchema = import_zod5.z.discriminatedUnion("type", [
+  import_zod5.z.object({
+    type: import_zod5.z.literal("text"),
+    text: import_zod5.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_zod5.z.object({
+    type: import_zod5.z.literal("tool_use"),
+    id: import_zod5.z.string(),
+    name: import_zod5.z.string(),
+    input: import_json5.JsonValueSchema
   }),
-  import_zod4.z.object({
-    type: import_zod4.z.literal("thinking"),
-    thinking: import_zod4.z.string().optional(),
-    signature: import_zod4.z.string().optional()
+  import_zod5.z.object({
+    type: import_zod5.z.literal("thinking"),
+    thinking: import_zod5.z.string().optional(),
+    signature: import_zod5.z.string().optional()
   }),
-  import_zod4.z.object({
-    type: import_zod4.z.literal("redacted_thinking"),
-    data: import_zod4.z.string().optional()
+  import_zod5.z.object({
+    type: import_zod5.z.literal("redacted_thinking"),
+    data: import_zod5.z.string().optional()
   })
 ]);
-var AnthropicMessagesResponseSchema = import_zod4.z.object({
-  content: import_zod4.z.array(AnthropicContentBlockSchema),
-  stop_reason: import_zod4.z.string().nullable().optional(),
+var AnthropicMessagesResponseSchema = import_zod5.z.object({
+  content: import_zod5.z.array(AnthropicContentBlockSchema),
+  stop_reason: import_zod5.z.string().nullable().optional(),
   usage: AnthropicUsageSchema
 });
 function mapAnthropicResponseToChatCompletionResult(response, latencyMs) {
   const toolCalls = extractAnthropicToolCalls(response);
+  const thinkingText = extractAnthropicThinkingText(response);
   const result = {
     content: extractAnthropicTextContent(response, toolCalls.length > 0),
     tokenUsage: mapAnthropicUsageToTokenUsage(response.usage),
@@ -832,6 +1166,9 @@ function mapAnthropicResponseToChatCompletionResult(response, latencyMs) {
   if (toolCalls.length > 0) {
     result.toolCalls = toolCalls;
   }
+  if (thinkingText.length > 0) {
+    result.thinkingText = thinkingText;
+  }
   if (response.stop_reason !== null && response.stop_reason !== void 0) {
     result.stopReason = normalizeAnthropicStopReason(response.stop_reason);
   }
@@ -844,13 +1181,16 @@ function extractAnthropicToolCalls(response) {
     input: contentBlock.input
   }));
 }
+function extractAnthropicThinkingText(response) {
+  return response.content.filter((contentBlock) => contentBlock.type === "thinking").map((contentBlock) => contentBlock.thinking ?? "").join("");
+}
 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,
+    throw new import_errors19.AppError({
+      code: import_errors18.AppErrorCode.ValidationFailed,
       message: "Anthropic response contained no text content",
       statusCode: 502
     });
@@ -887,58 +1227,68 @@ function mapAnthropicUsageToTokenUsage(usage) {
 }
 
 // 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");
+var import_errors20 = require("@assemble-dev/shared-types/errors");
+var import_json6 = require("@assemble-dev/shared-types/json");
+var import_errors21 = 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()
+var import_zod6 = require("zod");
+var AnthropicStreamEventSchema = import_zod6.z.discriminatedUnion("type", [
+  import_zod6.z.object({
+    type: import_zod6.z.literal("message_start"),
+    message: import_zod6.z.object({
+      usage: import_zod6.z.object({
+        input_tokens: import_zod6.z.number().int().nonnegative(),
+        output_tokens: import_zod6.z.number().int().nonnegative().optional(),
+        cache_creation_input_tokens: import_zod6.z.number().int().nonnegative().optional(),
+        cache_read_input_tokens: import_zod6.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_zod6.z.object({
+    type: import_zod6.z.literal("content_block_start"),
+    index: import_zod6.z.number().int().nonnegative(),
+    content_block: import_zod6.z.discriminatedUnion("type", [
+      import_zod6.z.object({ type: import_zod6.z.literal("text"), text: import_zod6.z.string().optional() }),
+      import_zod6.z.object({
+        type: import_zod6.z.literal("thinking"),
+        thinking: import_zod6.z.string().optional()
+      }),
+      import_zod6.z.object({
+        type: import_zod6.z.literal("redacted_thinking"),
+        data: import_zod6.z.string().optional()
+      }),
+      import_zod6.z.object({
+        type: import_zod6.z.literal("tool_use"),
+        id: import_zod6.z.string(),
+        name: import_zod6.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_zod6.z.object({
+    type: import_zod6.z.literal("content_block_delta"),
+    index: import_zod6.z.number().int().nonnegative(),
+    delta: import_zod6.z.discriminatedUnion("type", [
+      import_zod6.z.object({ type: import_zod6.z.literal("text_delta"), text: import_zod6.z.string() }),
+      import_zod6.z.object({ type: import_zod6.z.literal("thinking_delta"), thinking: import_zod6.z.string() }),
+      import_zod6.z.object({ type: import_zod6.z.literal("signature_delta"), signature: import_zod6.z.string() }),
+      import_zod6.z.object({
+        type: import_zod6.z.literal("input_json_delta"),
+        partial_json: import_zod6.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_zod6.z.object({ type: import_zod6.z.literal("content_block_stop") }),
+  import_zod6.z.object({
+    type: import_zod6.z.literal("message_delta"),
+    delta: import_zod6.z.object({ stop_reason: import_zod6.z.string().nullable().optional() }),
+    usage: import_zod6.z.object({ output_tokens: import_zod6.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() })
+  import_zod6.z.object({ type: import_zod6.z.literal("message_stop") }),
+  import_zod6.z.object({ type: import_zod6.z.literal("ping") }),
+  import_zod6.z.object({
+    type: import_zod6.z.literal("error"),
+    error: import_zod6.z.object({ message: import_zod6.z.string() })
   })
 ]);
 
@@ -1024,6 +1374,7 @@ async function* readServerSentEventDataLines(body, abortSignal) {
 function createAnthropicStreamAccumulator() {
   return {
     contentText: "",
+    thinkingText: "",
     toolCallsByBlockIndex: /* @__PURE__ */ new Map(),
     inputTokens: 0,
     outputTokens: 0
@@ -1031,8 +1382,8 @@ function createAnthropicStreamAccumulator() {
 }
 function* applyAnthropicStreamEvent(event, accumulator) {
   if (event.type === "error") {
-    throw new import_errors19.AppError({
-      code: import_errors18.AppErrorCode.InternalServerError,
+    throw new import_errors21.AppError({
+      code: import_errors20.AppErrorCode.InternalServerError,
       message: `Anthropic stream reported an error: ${event.error.message}`,
       statusCode: 502
     });
@@ -1068,6 +1419,17 @@ function* applyAnthropicContentBlockStart(event, accumulator) {
     }
     return;
   }
+  if (event.content_block.type === "thinking") {
+    const initialThinkingText = event.content_block.thinking ?? "";
+    if (initialThinkingText.length > 0) {
+      accumulator.thinkingText += initialThinkingText;
+      yield { type: "thinking_delta", text: initialThinkingText };
+    }
+    return;
+  }
+  if (event.content_block.type === "redacted_thinking") {
+    return;
+  }
   accumulator.toolCallsByBlockIndex.set(event.index, {
     id: event.content_block.id,
     toolName: event.content_block.name,
@@ -1085,6 +1447,14 @@ function* applyAnthropicContentBlockDelta(event, accumulator) {
     yield { type: "text_delta", text: event.delta.text };
     return;
   }
+  if (event.delta.type === "thinking_delta") {
+    accumulator.thinkingText += event.delta.thinking;
+    yield { type: "thinking_delta", text: event.delta.thinking };
+    return;
+  }
+  if (event.delta.type === "signature_delta") {
+    return;
+  }
   const toolCallAccumulation = accumulator.toolCallsByBlockIndex.get(
     event.index
   );
@@ -1131,6 +1501,9 @@ function buildAnthropicStreamResult(accumulator, latencyMs) {
   if (accumulator.stopReason !== void 0) {
     result.stopReason = accumulator.stopReason;
   }
+  if (accumulator.thinkingText.length > 0) {
+    result.thinkingText = accumulator.thinkingText;
+  }
   return result;
 }
 function mapAccumulatedToolCallToModelToolCall(toolCallAccumulation) {
@@ -1145,10 +1518,10 @@ function parseAnthropicToolInputJson(inputJsonText) {
     return {};
   }
   try {
-    return import_json5.JsonValueSchema.parse(JSON.parse(inputJsonText));
+    return import_json6.JsonValueSchema.parse(JSON.parse(inputJsonText));
   } catch (error) {
-    throw new import_errors19.AppError({
-      code: import_errors18.AppErrorCode.ValidationFailed,
+    throw new import_errors21.AppError({
+      code: import_errors20.AppErrorCode.ValidationFailed,
       message: "Anthropic tool input was not valid JSON",
       statusCode: 502,
       cause: error instanceof Error ? error : void 0
@@ -1160,10 +1533,6 @@ function parseAnthropicToolInputJson(inputJsonText) {
 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}`,
@@ -1175,9 +1544,12 @@ function anthropic(options) {
     },
     async generateStructuredOutput(request) {
       const completion = await executeAnthropicAdapterCall(options, {
-        messages: [structuredOutputSystemMessage2, ...request.messages],
+        messages: request.messages,
         temperature: request.temperature ?? options.temperature,
         maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+        structuredOutputJsonSchema: buildAnthropicStructuredOutputJsonSchema(
+          request.schema
+        ),
         abortSignal: request.abortSignal
       });
       return {
@@ -1200,7 +1572,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 +1590,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 +1622,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`,
@@ -1290,28 +1665,116 @@ function resolveAnthropicFetch(options) {
 }
 
 // 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 import_zod7 = require("zod");
+var import_errors22 = require("@assemble-dev/shared-types/errors");
+var import_errors23 = require("@assemble-dev/shared-utils/errors");
+
+// src/gemini-response-schema.ts
+var geminiAllowedSchemaKeywords = [
+  "type",
+  "format",
+  "description",
+  "nullable",
+  "enum",
+  "properties",
+  "required",
+  "items",
+  "minItems",
+  "maxItems",
+  "anyOf"
+];
+var geminiAllowedFormats = [
+  "date-time",
+  "int32",
+  "int64",
+  "float",
+  "double"
+];
+function buildGeminiResponseSchema(schema) {
+  return sanitizeJsonSchemaForGeminiResponseSchema(
+    convertZodSchemaToJsonSchema(schema)
+  );
+}
+function sanitizeJsonSchemaForGeminiResponseSchema(jsonSchema) {
+  return transformJsonSchemaNode(
+    inlineJsonSchemaReferences(jsonSchema),
+    sanitizeGeminiSchemaNode
+  );
+}
+function sanitizeGeminiSchemaNode(node) {
+  const normalized = normalizeGeminiNullableType(
+    mergeNullUnionIntoNullableNode(node)
+  );
+  const sanitized = {};
+  for (const [key, value] of Object.entries(normalized)) {
+    if (geminiAllowedSchemaKeywords.includes(key)) {
+      sanitized[key] = value;
+    }
+  }
+  return removeUnsupportedGeminiFormat(sanitized);
+}
+function mergeNullUnionIntoNullableNode(node) {
+  const unionKeyword = Array.isArray(node["anyOf"]) ? "anyOf" : "oneOf";
+  const unionMembers = node[unionKeyword];
+  if (!Array.isArray(unionMembers)) {
+    return node;
+  }
+  const nonNullMembers = unionMembers.filter(
+    (member) => !isNullTypeSchemaNode(member)
+  );
+  if (nonNullMembers.length === unionMembers.length) {
+    return node;
+  }
+  const merged = { ...node };
+  delete merged[unionKeyword];
+  const singleMember = nonNullMembers.length === 1 ? nonNullMembers[0] : void 0;
+  if (singleMember !== void 0 && isJsonObject(singleMember)) {
+    return { ...merged, ...singleMember, nullable: true };
+  }
+  return { ...merged, anyOf: nonNullMembers, nullable: true };
+}
+function normalizeGeminiNullableType(node) {
+  const typeValue = node["type"];
+  if (!Array.isArray(typeValue)) {
+    return node;
+  }
+  const nonNullTypes = typeValue.filter((typeName) => typeName !== "null");
+  const normalized = { ...node };
+  if (nonNullTypes.length < typeValue.length) {
+    normalized["nullable"] = true;
+  }
+  normalized["type"] = nonNullTypes[0] ?? "string";
+  return normalized;
+}
+function removeUnsupportedGeminiFormat(node) {
+  const formatValue = node["format"];
+  if (typeof formatValue === "string" && !geminiAllowedFormats.includes(formatValue)) {
+    const withoutFormat = { ...node };
+    delete withoutFormat["format"];
+    return withoutFormat;
+  }
+  return node;
+}
+function isNullTypeSchemaNode(value) {
+  return isJsonObject(value) && value["type"] === "null";
+}
+
+// src/gemini-adapter.ts
 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() }))
+var GeminiGenerateContentResponseSchema = import_zod7.z.object({
+  candidates: import_zod7.z.array(
+    import_zod7.z.object({
+      content: import_zod7.z.object({
+        parts: import_zod7.z.array(import_zod7.z.object({ text: import_zod7.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()
+  usageMetadata: import_zod7.z.object({
+    promptTokenCount: import_zod7.z.number().int().nonnegative().optional(),
+    candidatesTokenCount: import_zod7.z.number().int().nonnegative().optional(),
+    totalTokenCount: import_zod7.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}`,
@@ -1321,16 +1784,16 @@ function gemini(options) {
         messages: request.messages,
         temperature: request.temperature ?? options.temperature,
         maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
-        requireJsonResponse: false,
-        abortSignal: request.abortSignal
+        abortSignal: request.abortSignal,
+        extraBody: request.extraBody
       });
     },
     async generateStructuredOutput(request) {
       const completion = await executeGeminiAdapterCall(options, {
-        messages: [structuredOutputSystemMessage3, ...request.messages],
+        messages: request.messages,
         temperature: request.temperature ?? options.temperature,
         maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
-        requireJsonResponse: true,
+        responseSchema: buildGeminiResponseSchema(request.schema),
         abortSignal: request.abortSignal
       });
       return {
@@ -1364,7 +1827,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(
@@ -1413,8 +1880,8 @@ function ensureGeminiRequestHasNoTools(request) {
   if (request.tools === void 0 || request.tools.length === 0) {
     return;
   }
-  throw new import_errors21.AppError({
-    code: import_errors20.AppErrorCode.ValidationFailed,
+  throw new import_errors23.AppError({
+    code: import_errors22.AppErrorCode.ValidationFailed,
     message: "gemini adapter does not support model-driven tool use; remove tools from the request or use another adapter",
     statusCode: 400
   });
@@ -1451,8 +1918,9 @@ function buildGeminiGenerationConfig(input) {
   if (input.maxOutputTokens !== void 0) {
     generationConfig.maxOutputTokens = input.maxOutputTokens;
   }
-  if (input.requireJsonResponse) {
+  if (input.responseSchema !== void 0) {
     generationConfig.responseMimeType = "application/json";
+    generationConfig.responseSchema = input.responseSchema;
   }
   if (Object.keys(generationConfig).length === 0) {
     return void 0;
@@ -1462,8 +1930,8 @@ function buildGeminiGenerationConfig(input) {
 function extractGeminiCandidateText(response) {
   const firstCandidate = response.candidates?.[0];
   if (firstCandidate === void 0) {
-    throw new import_errors21.AppError({
-      code: import_errors20.AppErrorCode.ValidationFailed,
+    throw new import_errors23.AppError({
+      code: import_errors22.AppErrorCode.ValidationFailed,
       message: "Gemini response contained no candidates",
       statusCode: 502
     });
@@ -1482,8 +1950,8 @@ function mapGeminiUsageToTokenUsage(response) {
 }
 
 // src/mock-adapter.ts
-var import_errors22 = require("@assemble-dev/shared-types/errors");
-var import_errors23 = require("@assemble-dev/shared-utils/errors");
+var import_errors24 = require("@assemble-dev/shared-types/errors");
+var import_errors25 = require("@assemble-dev/shared-utils/errors");
 var mockStreamChunkCount = 3;
 function mockModel(options = {}) {
   const remainingScriptedResponses = [...options.scriptedResponses ?? []];
@@ -1563,8 +2031,8 @@ function resolveNextMockResponseText(request, remainingScriptedResponses, respon
   if (respond !== void 0) {
     return respond(request);
   }
-  throw new import_errors23.AppError({
-    code: import_errors22.AppErrorCode.BadRequest,
+  throw new import_errors25.AppError({
+    code: import_errors24.AppErrorCode.BadRequest,
     message: "Mock model has no scripted responses left and no respond function was provided",
     statusCode: 400
   });
@@ -1652,60 +2120,274 @@ function calculateModelCallCostUsd(pricing, tokenUsage) {
 }
 
 // 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");
+var import_errors28 = require("@assemble-dev/shared-types/errors");
+var import_json8 = require("@assemble-dev/shared-types/json");
+var import_errors29 = 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()
-      })
+// src/anthropic-batch-structured.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");
+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_json7.JsonValueSchema
+  );
+  const validationResult = schema.safeParse(jsonValue);
+  if (!validationResult.success) {
+    throw new import_errors27.AppError({
+      code: import_errors26.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);
+  applyBatchStructuredOutputConfig(params, request);
+  if (request.temperature !== void 0) {
+    params.temperature = request.temperature;
+  }
+  return { custom_id: request.customId, params };
+}
+function applyBatchStructuredOutputConfig(params, request) {
+  if (request.structuredOutputJsonSchema === void 0) {
+    return;
+  }
+  params.output_config = {
+    format: {
+      type: "json_schema",
+      schema: sanitizeJsonSchemaForAnthropicStructuredOutput(
+        request.structuredOutputJsonSchema
+      )
+    }
+  };
+}
+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 || request.structuredOutputJsonSchema !== void 0) {
+    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_zod8 = require("zod");
+var AnthropicMessageBatchResponseSchema = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  processing_status: import_zod8.z.enum(["in_progress", "canceling", "ended"]),
+  request_counts: import_zod8.z.object({
+    processing: import_zod8.z.number().int().nonnegative(),
+    succeeded: import_zod8.z.number().int().nonnegative(),
+    errored: import_zod8.z.number().int().nonnegative(),
+    canceled: import_zod8.z.number().int().nonnegative(),
+    expired: import_zod8.z.number().int().nonnegative()
+  }),
+  results_url: import_zod8.z.string().nullable(),
+  created_at: import_zod8.z.string(),
+  ended_at: import_zod8.z.string().nullable()
+});
+var AnthropicBatchContentBlockSchema = import_zod8.z.discriminatedUnion("type", [
+  import_zod8.z.object({
+    type: import_zod8.z.literal("text"),
+    text: import_zod8.z.string()
+  }),
+  import_zod8.z.object({
+    type: import_zod8.z.literal("thinking"),
+    thinking: import_zod8.z.string().optional(),
+    signature: import_zod8.z.string().optional()
+  }),
+  import_zod8.z.object({
+    type: import_zod8.z.literal("redacted_thinking"),
+    data: import_zod8.z.string().optional()
+  })
+]);
+var AnthropicBatchResultLineSchema = import_zod8.z.object({
+  custom_id: import_zod8.z.string(),
+  result: import_zod8.z.discriminatedUnion("type", [
+    import_zod8.z.object({
+      type: import_zod8.z.literal("succeeded"),
+      message: import_zod8.z.object({
+        content: import_zod8.z.array(AnthropicBatchContentBlockSchema),
+        usage: AnthropicUsageSchema
+      })
     }),
-    import_zod7.z.object({ type: import_zod7.z.literal("canceled") }),
-    import_zod7.z.object({ type: import_zod7.z.literal("expired") })
+    import_zod8.z.object({
+      type: import_zod8.z.literal("errored"),
+      error: import_zod8.z.object({
+        type: import_zod8.z.string(),
+        message: import_zod8.z.string()
+      })
+    }),
+    import_zod8.z.object({ type: import_zod8.z.literal("canceled") }),
+    import_zod8.z.object({ type: import_zod8.z.literal("expired") })
   ])
 });
 function mapAnthropicMessageBatchResponseToMessageBatch(response) {
@@ -1759,19 +2441,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 +2487,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 +2499,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 +2518,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 +2534,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_errors29.AppError({
+      code: import_errors28.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 +2552,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 +2575,7 @@ function parseAnthropicBatchResultLine(line) {
 }
 function parseAnthropicBatchResultLineJson(line) {
   try {
-    return import_json6.JsonValueSchema.parse(JSON.parse(line));
+    return import_json8.JsonValueSchema.parse(JSON.parse(line));
   } catch {
     throw buildProviderInvalidResponseError(
       "Anthropic",
@@ -1880,81 +2583,811 @@ 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_errors29.AppError({
+    code: import_errors28.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)
+
+// src/azure-openai-adapter.ts
+var import_errors32 = require("@assemble-dev/shared-types/errors");
+var import_errors33 = require("@assemble-dev/shared-utils/errors");
+
+// src/azure-openai-response-parsing.ts
+var import_zod9 = require("zod");
+var import_errors30 = require("@assemble-dev/shared-types/errors");
+var import_json9 = require("@assemble-dev/shared-types/json");
+var import_errors31 = require("@assemble-dev/shared-utils/errors");
+var AzureOpenAiUsageSchema = import_zod9.z.object({
+  prompt_tokens: import_zod9.z.number().int().nonnegative(),
+  completion_tokens: import_zod9.z.number().int().nonnegative(),
+  total_tokens: import_zod9.z.number().int().nonnegative()
+});
+var AzureOpenAiResponseToolCallSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  function: import_zod9.z.object({
+    name: import_zod9.z.string(),
+    arguments: import_zod9.z.string()
+  })
+});
+var AzureOpenAiChatCompletionResponseSchema = import_zod9.z.object({
+  choices: import_zod9.z.array(
+    import_zod9.z.object({
+      message: import_zod9.z.object({
+        content: import_zod9.z.string().nullable(),
+        tool_calls: import_zod9.z.array(AzureOpenAiResponseToolCallSchema).optional()
+      }),
+      finish_reason: import_zod9.z.string().nullable().optional()
+    })
+  ).min(1),
+  usage: AzureOpenAiUsageSchema
+});
+function mapAzureOpenAiResponseToChatCompletionResult(response, latencyMs) {
+  const toolCalls = extractAzureOpenAiToolCalls(response);
+  const result = {
+    content: extractAzureOpenAiMessageContent(response, toolCalls.length > 0),
+    tokenUsage: mapAzureOpenAiUsageToTokenUsage(response.usage),
+    latencyMs
   };
-  const systemText = joinBatchSystemMessageText(request.messages);
-  if (systemText.length > 0) {
-    params.system = systemText;
+  const finishReason = response.choices[0]?.finish_reason;
+  if (toolCalls.length > 0) {
+    result.toolCalls = toolCalls;
   }
-  if (request.temperature !== void 0) {
-    params.temperature = request.temperature;
+  if (finishReason !== null && finishReason !== void 0) {
+    result.stopReason = normalizeAzureOpenAiFinishReason(finishReason);
   }
-  return { custom_id: request.customId, params };
+  return result;
 }
-function joinBatchSystemMessageText(messages) {
-  return messages.filter((message) => message.role === "system").map(extractMessageText).join("\n\n");
+function extractAzureOpenAiToolCalls(response) {
+  const responseToolCalls = response.choices[0]?.message.tool_calls ?? [];
+  return responseToolCalls.map((responseToolCall) => ({
+    id: responseToolCall.id,
+    toolName: responseToolCall.function.name,
+    input: parseAzureOpenAiToolArgumentsJson(responseToolCall.function.arguments)
+  }));
 }
-function mapChatMessageToBatchApiRequestMessage(message) {
-  if (message.role === "assistant") {
-    return { role: "assistant", content: extractMessageText(message) };
+function parseAzureOpenAiToolArgumentsJson(argumentsJsonText) {
+  if (argumentsJsonText.trim().length === 0) {
+    return {};
   }
-  if (message.role === "tool") {
-    return { role: "user", content: buildBatchToolResultText(message) };
+  try {
+    return import_json9.JsonValueSchema.parse(JSON.parse(argumentsJsonText));
+  } catch (error) {
+    throw new import_errors31.AppError({
+      code: import_errors30.AppErrorCode.ValidationFailed,
+      message: "Azure OpenAI tool call arguments were not valid JSON",
+      statusCode: 502,
+      cause: error instanceof Error ? error : void 0
+    });
   }
-  return { role: "user", content: extractMessageText(message) };
 }
-function buildBatchToolResultText(message) {
-  if (message.toolName === void 0) {
-    return `Tool result: ${extractMessageText(message)}`;
+function normalizeAzureOpenAiFinishReason(finishReason) {
+  if (finishReason === "tool_calls") {
+    return "tool_use";
   }
-  return `Tool result (${message.toolName}): ${extractMessageText(message)}`;
+  if (finishReason === "length") {
+    return "max_tokens";
+  }
+  return "end_turn";
+}
+function extractAzureOpenAiMessageContent(response, allowEmptyContent) {
+  const content = response.choices[0]?.message.content;
+  if (content === void 0 || content === null) {
+    if (allowEmptyContent) {
+      return "";
+    }
+    throw new import_errors31.AppError({
+      code: import_errors30.AppErrorCode.ValidationFailed,
+      message: "Azure OpenAI response contained no message content",
+      statusCode: 502
+    });
+  }
+  return content;
+}
+function mapAzureOpenAiUsageToTokenUsage(usage) {
+  return {
+    inputTokens: usage.prompt_tokens,
+    outputTokens: usage.completion_tokens,
+    totalTokens: usage.total_tokens
+  };
+}
+
+// src/azure-openai-stream.ts
+var import_zod10 = require("zod");
+var AzureOpenAiStreamToolCallDeltaSchema = import_zod10.z.object({
+  index: import_zod10.z.number().int().nonnegative(),
+  id: import_zod10.z.string().optional(),
+  function: import_zod10.z.object({
+    name: import_zod10.z.string().optional(),
+    arguments: import_zod10.z.string().optional()
+  }).optional()
+});
+var AzureOpenAiStreamChunkSchema = import_zod10.z.object({
+  choices: import_zod10.z.array(
+    import_zod10.z.object({
+      delta: import_zod10.z.object({
+        content: import_zod10.z.string().nullable().optional(),
+        tool_calls: import_zod10.z.array(AzureOpenAiStreamToolCallDeltaSchema).optional()
+      }).optional(),
+      finish_reason: import_zod10.z.string().nullable().optional()
+    })
+  ).optional(),
+  usage: AzureOpenAiUsageSchema.nullable().optional()
+});
+async function* streamAzureOpenAiChatCompletion(input) {
+  const startedAt = Date.now();
+  const response = await establishAzureOpenAiStreamResponse(input);
+  if (response.body === null) {
+    throw buildProviderInvalidResponseError("Azure OpenAI", "stream body");
+  }
+  yield* parseAzureOpenAiStreamEvents(
+    response.body,
+    startedAt,
+    input.abortSignal
+  );
+}
+async function establishAzureOpenAiStreamResponse(input) {
+  return await executeProviderCallWithRetry(input.retry, async () => {
+    const response = await executeAbortableProviderFetch(
+      "Azure OpenAI",
+      async () => await input.fetchImplementation(input.url, {
+        method: "POST",
+        headers: input.headers,
+        body: JSON.stringify(input.body),
+        signal: input.abortSignal
+      })
+    );
+    if (!response.ok) {
+      throw buildProviderStatusError("Azure OpenAI", response.status);
+    }
+    return response;
+  });
+}
+async function* parseAzureOpenAiStreamEvents(body, startedAt, abortSignal) {
+  const accumulator = createAzureOpenAiStreamAccumulator();
+  for await (const dataText of readServerSentEventDataLines2(body, abortSignal)) {
+    if (dataText === "[DONE]") {
+      yield {
+        type: "completed",
+        result: buildAzureOpenAiStreamResult(
+          accumulator,
+          Date.now() - startedAt
+        )
+      };
+      return;
+    }
+    const parsedChunk = AzureOpenAiStreamChunkSchema.safeParse(
+      JSON.parse(dataText)
+    );
+    if (!parsedChunk.success) {
+      continue;
+    }
+    yield* applyAzureOpenAiStreamChunk(parsedChunk.data, accumulator);
+  }
+  throw buildProviderInvalidResponseError("Azure OpenAI", "stream termination");
+}
+async function* readServerSentEventDataLines2(body, abortSignal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let bufferedText = "";
+  try {
+    for (; ; ) {
+      if (abortSignal?.aborted === true) {
+        await reader.cancel();
+        throw buildProviderCanceledError("Azure OpenAI");
+      }
+      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("Azure OpenAI");
+    }
+    throw error;
+  }
+}
+function createAzureOpenAiStreamAccumulator() {
+  return {
+    contentText: "",
+    toolCallsByIndex: /* @__PURE__ */ new Map()
+  };
+}
+function* applyAzureOpenAiStreamChunk(chunk, accumulator) {
+  if (chunk.usage !== null && chunk.usage !== void 0) {
+    accumulator.usage = chunk.usage;
+  }
+  const choice = chunk.choices?.[0];
+  if (choice === void 0) {
+    return;
+  }
+  if (choice.finish_reason !== null && choice.finish_reason !== void 0) {
+    accumulator.finishReason = choice.finish_reason;
+  }
+  if (choice.delta === void 0) {
+    return;
+  }
+  const contentDelta = choice.delta.content;
+  if (contentDelta !== null && contentDelta !== void 0 && contentDelta.length > 0) {
+    accumulator.contentText += contentDelta;
+    yield { type: "text_delta", text: contentDelta };
+  }
+  for (const toolCallDelta of choice.delta.tool_calls ?? []) {
+    yield* applyAzureOpenAiToolCallDelta(toolCallDelta, accumulator);
+  }
+}
+function* applyAzureOpenAiToolCallDelta(toolCallDelta, accumulator) {
+  const existingToolCall = accumulator.toolCallsByIndex.get(toolCallDelta.index);
+  if (existingToolCall === void 0) {
+    yield* startAzureOpenAiToolCallAccumulation(toolCallDelta, accumulator);
+    return;
+  }
+  const argumentsDelta = toolCallDelta.function?.arguments;
+  if (argumentsDelta !== void 0 && argumentsDelta.length > 0) {
+    existingToolCall.argumentsJsonText += argumentsDelta;
+    yield {
+      type: "tool_call_input_delta",
+      id: existingToolCall.id,
+      inputJsonText: argumentsDelta
+    };
+  }
+}
+function* startAzureOpenAiToolCallAccumulation(toolCallDelta, accumulator) {
+  const toolName = toolCallDelta.function?.name;
+  if (toolCallDelta.id === void 0 || toolName === void 0) {
+    throw buildProviderInvalidResponseError(
+      "Azure OpenAI",
+      "stream tool call start"
+    );
+  }
+  const startedToolCall = {
+    id: toolCallDelta.id,
+    toolName,
+    argumentsJsonText: toolCallDelta.function?.arguments ?? ""
+  };
+  accumulator.toolCallsByIndex.set(toolCallDelta.index, startedToolCall);
+  yield {
+    type: "tool_call_started",
+    id: startedToolCall.id,
+    toolName: startedToolCall.toolName
+  };
+  if (startedToolCall.argumentsJsonText.length > 0) {
+    yield {
+      type: "tool_call_input_delta",
+      id: startedToolCall.id,
+      inputJsonText: startedToolCall.argumentsJsonText
+    };
+  }
+}
+function buildAzureOpenAiStreamResult(accumulator, latencyMs) {
+  const result = {
+    content: accumulator.contentText,
+    tokenUsage: mapAzureOpenAiUsageToTokenUsage(
+      accumulator.usage ?? {
+        prompt_tokens: 0,
+        completion_tokens: 0,
+        total_tokens: 0
+      }
+    ),
+    latencyMs
+  };
+  const toolCalls = [...accumulator.toolCallsByIndex.values()].map(
+    mapAccumulatedToolCallToModelToolCall2
+  );
+  if (toolCalls.length > 0) {
+    result.toolCalls = toolCalls;
+  }
+  if (accumulator.finishReason !== void 0) {
+    result.stopReason = normalizeAzureOpenAiFinishReason(
+      accumulator.finishReason
+    );
+  }
+  return result;
+}
+function mapAccumulatedToolCallToModelToolCall2(toolCallAccumulation) {
+  return {
+    id: toolCallAccumulation.id,
+    toolName: toolCallAccumulation.toolName,
+    input: parseAzureOpenAiToolArgumentsJson(
+      toolCallAccumulation.argumentsJsonText
+    )
+  };
+}
+
+// src/azure-openai-adapter.ts
+var defaultAzureOpenAiApiVersion = "2024-10-21";
+var azureDeploymentModelPlaceholder = "azure-deployment";
+function azureOpenai(options) {
+  return {
+    name: `azure-openai:${options.deployment}`,
+    async generateChatCompletion(request) {
+      return await executeAzureOpenAiAdapterCall(options, {
+        messages: request.messages,
+        temperature: request.temperature ?? options.temperature,
+        maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+        tools: request.tools,
+        toolChoice: request.toolChoice,
+        abortSignal: request.abortSignal,
+        extraBody: request.extraBody
+      });
+    },
+    async generateStructuredOutput(request) {
+      const completion = await executeAzureOpenAiAdapterCall(options, {
+        messages: request.messages,
+        temperature: request.temperature ?? options.temperature,
+        maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+        structuredOutputJsonSchema: buildOpenAiStructuredOutputJsonSchema(
+          request.schema
+        ),
+        abortSignal: request.abortSignal
+      });
+      return {
+        value: parseStructuredJsonText(completion.content, request.schema),
+        tokenUsage: completion.tokenUsage,
+        latencyMs: completion.latencyMs
+      };
+    },
+    streamChatCompletion(request) {
+      return streamAzureOpenAiChatCompletion(
+        buildAzureOpenAiStreamInput(options, request)
+      );
+    }
+  };
+}
+function buildAzureOpenAiChatCompletionsUrl(options) {
+  const endpoint = resolveAzureOpenAiEndpoint(options);
+  const apiVersion = options.apiVersion ?? defaultAzureOpenAiApiVersion;
+  return `${endpoint}/openai/deployments/${encodeURIComponent(options.deployment)}/chat/completions?api-version=${encodeURIComponent(apiVersion)}`;
+}
+function resolveAzureOpenAiEndpoint(options) {
+  if (options.baseURL !== void 0 && options.baseURL.length > 0) {
+    return options.baseURL.replace(/\/+$/, "");
+  }
+  if (options.resourceName !== void 0 && options.resourceName.length > 0) {
+    return `https://${options.resourceName}.openai.azure.com`;
+  }
+  throw new import_errors33.AppError({
+    code: import_errors32.AppErrorCode.BadRequest,
+    message: "Azure OpenAI endpoint is missing. Pass resourceName or baseURL to azureOpenai().",
+    statusCode: 400
+  });
+}
+function buildAzureOpenAiRequestHeaders(options) {
+  return {
+    "content-type": "application/json",
+    "api-key": resolveProviderApiKey({
+      providerLabel: "Azure OpenAI",
+      adapterFunctionName: "azureOpenai()",
+      baseEnvVarName: "AZURE_OPENAI_API_KEY",
+      apiKey: options.apiKey,
+      apiKeyName: options.apiKeyName
+    })
+  };
+}
+function buildAzureOpenAiChatRequestBody(input) {
+  const requestBody = buildOpenAiRequestBody(
+    azureDeploymentModelPlaceholder,
+    input
+  );
+  const { model: ignoredModel, ...requestBodyWithoutModel } = requestBody;
+  void ignoredModel;
+  return requestBodyWithoutModel;
+}
+async function executeAzureOpenAiAdapterCall(options, input) {
+  return await executeProviderCallWithRetry(
+    options.retry,
+    async () => await requestAzureOpenAiChatCompletion(options, input)
+  );
+}
+async function requestAzureOpenAiChatCompletion(options, input) {
+  const fetchImplementation = options.fetchImplementation ?? fetch;
+  const requestBody = mergeProviderRequestExtraBody(
+    buildAzureOpenAiChatRequestBody(input),
+    options.extraBody,
+    input.extraBody
+  );
+  const startedAt = Date.now();
+  const response = await executeAbortableProviderFetch(
+    "Azure OpenAI",
+    async () => await fetchImplementation(buildAzureOpenAiChatCompletionsUrl(options), {
+      method: "POST",
+      headers: buildAzureOpenAiRequestHeaders(options),
+      body: JSON.stringify(requestBody),
+      signal: input.abortSignal
+    })
+  );
+  const latencyMs = Date.now() - startedAt;
+  if (!response.ok) {
+    throw buildProviderStatusError("Azure OpenAI", response.status);
+  }
+  const parseResult = AzureOpenAiChatCompletionResponseSchema.safeParse(
+    await response.json()
+  );
+  if (!parseResult.success) {
+    throw buildProviderInvalidResponseError("Azure OpenAI", "chat completion");
+  }
+  return mapAzureOpenAiResponseToChatCompletionResult(
+    parseResult.data,
+    latencyMs
+  );
+}
+function buildAzureOpenAiStreamInput(options, request) {
+  const requestBody = mergeProviderRequestExtraBody(
+    buildAzureOpenAiChatRequestBody({
+      messages: request.messages,
+      temperature: request.temperature ?? options.temperature,
+      maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+      tools: request.tools,
+      toolChoice: request.toolChoice,
+      abortSignal: request.abortSignal,
+      extraBody: request.extraBody
+    }),
+    options.extraBody,
+    request.extraBody
+  );
+  return {
+    url: buildAzureOpenAiChatCompletionsUrl(options),
+    headers: buildAzureOpenAiRequestHeaders(options),
+    body: {
+      ...requestBody,
+      stream: true,
+      stream_options: { include_usage: true }
+    },
+    fetchImplementation: options.fetchImplementation ?? fetch,
+    retry: options.retry,
+    abortSignal: request.abortSignal
+  };
+}
+
+// src/bedrock-adapter.ts
+var import_zod11 = require("zod");
+var import_errors34 = require("@assemble-dev/shared-types/errors");
+var import_errors35 = require("@assemble-dev/shared-utils/errors");
+
+// src/bedrock-sigv4.ts
+var awsSigV4Algorithm = "AWS4-HMAC-SHA256";
+async function signAwsRequestWithSigV4(input) {
+  const amzDate = formatAmzDateTime(input.signingDate ?? /* @__PURE__ */ new Date());
+  const dateStamp = amzDate.slice(0, 8);
+  const headersToSign = buildHeadersToSign(input, amzDate);
+  const canonicalHeaderEntries = buildCanonicalHeaderEntries(headersToSign);
+  const signedHeaderNames = canonicalHeaderEntries.map(([headerName]) => headerName).join(";");
+  const credentialScope = `${dateStamp}/${input.region}/${input.service}/aws4_request`;
+  const signatureHex = await computeAwsSigV4Signature(
+    input,
+    amzDate,
+    credentialScope,
+    canonicalHeaderEntries,
+    signedHeaderNames
+  );
+  return {
+    ...headersToSign,
+    authorization: `${awsSigV4Algorithm} Credential=${input.credentials.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaderNames}, Signature=${signatureHex}`
+  };
+}
+async function computeAwsSigV4Signature(input, amzDate, credentialScope, canonicalHeaderEntries, signedHeaderNames) {
+  const canonicalRequest = await buildCanonicalRequest(
+    input,
+    canonicalHeaderEntries,
+    signedHeaderNames
+  );
+  const stringToSign = [
+    awsSigV4Algorithm,
+    amzDate,
+    credentialScope,
+    await hashSha256Hex(canonicalRequest)
+  ].join("\n");
+  const signingKey = await deriveAwsSigningKey(
+    input.credentials.secretAccessKey,
+    amzDate.slice(0, 8),
+    input.region,
+    input.service
+  );
+  return bytesToHex(await computeHmacSha256(signingKey, stringToSign));
+}
+function buildHeadersToSign(input, amzDate) {
+  const headersToSign = {};
+  for (const [headerName, headerValue] of Object.entries(input.headers)) {
+    headersToSign[headerName.toLowerCase()] = headerValue;
+  }
+  headersToSign.host = input.url.host;
+  headersToSign["x-amz-date"] = amzDate;
+  if (input.credentials.sessionToken !== void 0) {
+    headersToSign["x-amz-security-token"] = input.credentials.sessionToken;
+  }
+  return headersToSign;
+}
+function buildCanonicalHeaderEntries(headersToSign) {
+  return Object.entries(headersToSign).map(([headerName, headerValue]) => [
+    headerName.toLowerCase(),
+    headerValue.trim().replace(/\s+/g, " ")
+  ]).sort(([leftName], [rightName]) => leftName.localeCompare(rightName));
+}
+async function buildCanonicalRequest(input, canonicalHeaderEntries, signedHeaderNames) {
+  const canonicalHeadersText = canonicalHeaderEntries.map(([headerName, headerValue]) => `${headerName}:${headerValue}`).join("\n");
+  return [
+    input.method.toUpperCase(),
+    buildCanonicalUri(input.url.pathname),
+    buildCanonicalQueryString(input.url.searchParams),
+    `${canonicalHeadersText}
+`,
+    signedHeaderNames,
+    await hashSha256Hex(input.bodyText)
+  ].join("\n");
+}
+function buildCanonicalUri(pathname) {
+  if (pathname.length === 0) {
+    return "/";
+  }
+  return pathname.split("/").map(encodeRfc3986UriComponent).join("/");
+}
+function buildCanonicalQueryString(searchParams) {
+  const encodedEntries = [];
+  searchParams.forEach((parameterValue, parameterName) => {
+    encodedEntries.push([
+      encodeRfc3986UriComponent(parameterName),
+      encodeRfc3986UriComponent(parameterValue)
+    ]);
+  });
+  return encodedEntries.sort(
+    ([leftName, leftValue], [rightName, rightValue]) => leftName.localeCompare(rightName) || leftValue.localeCompare(rightValue)
+  ).map(([parameterName, parameterValue]) => `${parameterName}=${parameterValue}`).join("&");
+}
+function encodeRfc3986UriComponent(value) {
+  return encodeURIComponent(value).replace(
+    /[!'()*]/g,
+    (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+}
+function formatAmzDateTime(date) {
+  return date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+async function deriveAwsSigningKey(secretAccessKey, dateStamp, region, service) {
+  const dateKey = await computeHmacSha256(
+    new TextEncoder().encode(`AWS4${secretAccessKey}`),
+    dateStamp
+  );
+  const regionKey = await computeHmacSha256(dateKey, region);
+  const serviceKey = await computeHmacSha256(regionKey, service);
+  return await computeHmacSha256(serviceKey, "aws4_request");
+}
+async function hashSha256Hex(text) {
+  const digest = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(text)
+  );
+  return bytesToHex(new Uint8Array(digest));
+}
+async function computeHmacSha256(keyBytes, text) {
+  const hmacKey = await crypto.subtle.importKey(
+    "raw",
+    keyBytes,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign(
+    "HMAC",
+    hmacKey,
+    new TextEncoder().encode(text)
+  );
+  return new Uint8Array(signature);
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((byteValue) => byteValue.toString(16).padStart(2, "0")).join("");
+}
+
+// src/bedrock-adapter.ts
+var bedrockAnthropicVersion = "bedrock-2023-05-31";
+var defaultBedrockMaxOutputTokens = 1024;
+var bedrockSigningServiceName = "bedrock";
+var bedrockModelPlaceholder = "bedrock-invoke-model";
+var BedrockEnvCredentialsSchema = import_zod11.z.object({
+  AWS_ACCESS_KEY_ID: import_zod11.z.string().optional(),
+  AWS_SECRET_ACCESS_KEY: import_zod11.z.string().optional(),
+  AWS_SESSION_TOKEN: import_zod11.z.string().optional()
+});
+function bedrock(options) {
+  return {
+    name: `bedrock:${options.modelId}`,
+    async generateChatCompletion(request) {
+      return await executeBedrockAdapterCall(options, {
+        messages: request.messages,
+        temperature: request.temperature ?? options.temperature,
+        maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+        tools: request.tools,
+        toolChoice: request.toolChoice,
+        abortSignal: request.abortSignal,
+        extraBody: request.extraBody
+      });
+    },
+    async generateStructuredOutput(request) {
+      const completion = await executeBedrockAdapterCall(options, {
+        messages: [
+          buildBedrockStructuredOutputSystemMessage(request.schema),
+          ...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
+      };
+    }
+  };
+}
+function buildBedrockInvokeModelUrl(region, modelId) {
+  return `https://bedrock-runtime.${region}.amazonaws.com/model/${encodeURIComponent(modelId)}/invoke`;
+}
+function resolveBedrockCredentials(options) {
+  if (options.credentials !== void 0) {
+    return options.credentials;
+  }
+  const parsedEnv = BedrockEnvCredentialsSchema.parse(process.env);
+  const accessKeyId = parsedEnv.AWS_ACCESS_KEY_ID;
+  const secretAccessKey = parsedEnv.AWS_SECRET_ACCESS_KEY;
+  if (accessKeyId === void 0 || accessKeyId.length === 0 || secretAccessKey === void 0 || secretAccessKey.length === 0) {
+    throw new import_errors35.AppError({
+      code: import_errors34.AppErrorCode.Unauthorized,
+      message: "AWS credentials are missing. Pass credentials to bedrock() or set the AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables.",
+      statusCode: 401
+    });
+  }
+  const credentials = { accessKeyId, secretAccessKey };
+  const sessionToken = parsedEnv.AWS_SESSION_TOKEN;
+  if (sessionToken !== void 0 && sessionToken.length > 0) {
+    credentials.sessionToken = sessionToken;
+  }
+  return credentials;
+}
+async function executeBedrockAdapterCall(options, input) {
+  return await executeProviderCallWithRetry(
+    options.retry,
+    async () => await requestBedrockInvokeModel(options, input)
+  );
+}
+async function requestBedrockInvokeModel(options, input) {
+  const credentials = resolveBedrockCredentials(options);
+  const fetchImplementation = options.fetchImplementation ?? fetch;
+  const requestBody = mergeProviderRequestExtraBody(
+    buildBedrockInvokeModelRequestBody(input),
+    options.extraBody,
+    input.extraBody
+  );
+  const bodyText = JSON.stringify(requestBody);
+  const url = new URL(buildBedrockInvokeModelUrl(options.region, options.modelId));
+  const signedHeaders = await signAwsRequestWithSigV4({
+    method: "POST",
+    url,
+    headers: { "content-type": "application/json" },
+    bodyText,
+    region: options.region,
+    service: bedrockSigningServiceName,
+    credentials
+  });
+  const startedAt = Date.now();
+  const response = await executeAbortableProviderFetch(
+    "Bedrock",
+    async () => await fetchImplementation(url.toString(), {
+      method: "POST",
+      headers: signedHeaders,
+      body: bodyText,
+      signal: input.abortSignal
+    })
+  );
+  const latencyMs = Date.now() - startedAt;
+  if (!response.ok) {
+    throw buildProviderStatusError("Bedrock", response.status);
+  }
+  const parseResult = AnthropicMessagesResponseSchema.safeParse(
+    await response.json()
+  );
+  if (!parseResult.success) {
+    throw buildProviderInvalidResponseError("Bedrock", "invoke model");
+  }
+  return mapAnthropicResponseToChatCompletionResult(parseResult.data, latencyMs);
+}
+function buildBedrockInvokeModelRequestBody(input) {
+  const anthropicRequestBody = buildAnthropicRequestBody(
+    {
+      model: bedrockModelPlaceholder,
+      defaultMaxOutputTokens: defaultBedrockMaxOutputTokens
+    },
+    input
+  );
+  const {
+    model: ignoredModel,
+    stream: ignoredStream,
+    ...requestBodyWithoutModel
+  } = anthropicRequestBody;
+  void ignoredModel;
+  void ignoredStream;
+  return {
+    ...requestBodyWithoutModel,
+    anthropic_version: bedrockAnthropicVersion
+  };
+}
+function buildBedrockStructuredOutputSystemMessage(schema) {
+  return {
+    role: "system",
+    content: `Respond with a single JSON object that satisfies the following JSON Schema. Output only valid JSON with no surrounding text.
+
+JSON Schema:
+${JSON.stringify(convertZodSchemaToJsonSchema(schema))}`
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AnthropicMessagesResponseSchema,
   AnthropicStreamEventSchema,
+  AzureOpenAiChatCompletionResponseSchema,
+  ChatMessageCacheControlSchema,
   ChatMessageRoleSchema,
   ChatMessageSchema,
   ChatStopReasonSchema,
   MessageContentBlockSchema,
   ModelToolCallSchema,
   anthropic,
+  anthropicBatchJsonOnlySystemInstruction,
+  anthropicBatchTraceWorkflowName,
+  applyCacheControlToLastContentBlock,
+  awsSigV4Algorithm,
+  azureOpenai,
+  bedrock,
+  bedrockAnthropicVersion,
+  buildAnthropicCacheControl,
   buildAnthropicRequestBody,
+  buildAnthropicStructuredOutputJsonSchema,
+  buildAzureOpenAiChatCompletionsUrl,
+  buildAzureOpenAiChatRequestBody,
+  buildBedrockInvokeModelRequestBody,
+  buildBedrockInvokeModelUrl,
+  buildGeminiResponseSchema,
   buildOpenAiRequestBody,
+  buildOpenAiStructuredOutputJsonSchema,
   buildProviderCanceledError,
   calculateProviderRetryDelayMs,
+  convertZodSchemaToJsonSchema,
   createAnthropicBatchClient,
   defaultAnthropicBaseUrl,
   defaultAnthropicBatchPollIntervalMs,
   defaultAnthropicBatchTimeoutMs,
   defaultAnthropicMaxOutputTokens,
+  defaultAzureOpenAiApiVersion,
+  defaultBedrockMaxOutputTokens,
   defaultGeminiBaseUrl,
   defaultOpenAiBaseUrl,
   defaultProviderRetryInitialDelayMs,
@@ -1965,6 +3398,7 @@ function buildBatchToolResultText(message) {
   executeProviderCallWithModelFallback,
   executeProviderCallWithRetry,
   extractAnthropicTextContent,
+  extractAnthropicThinkingText,
   extractAnthropicToolCalls,
   extractMessageText,
   gemini,
@@ -1973,17 +3407,32 @@ function buildBatchToolResultText(message) {
   joinSystemMessageText,
   mapAnthropicResponseToChatCompletionResult,
   mapAnthropicUsageToTokenUsage,
+  mapAzureOpenAiResponseToChatCompletionResult,
+  mapAzureOpenAiUsageToTokenUsage,
   mapChatMessageToAnthropicRequestMessage,
   mapChatMessageToOpenAiRequestMessage,
   mapModelToolChoiceToAnthropicToolChoice,
   mapModelToolChoiceToOpenAiToolChoice,
   mapModelToolDefinitionToOpenAiTool,
   mapModelToolDefinitionsToAnthropicTools,
+  mergeProviderRequestExtraBody,
   mockModel,
   normalizeAnthropicStopReason,
+  normalizeAzureOpenAiFinishReason,
+  openAiStructuredOutputSchemaName,
   openai,
+  parseAnthropicBatchStructuredContent,
   parseAnthropicStreamEvents,
   parseAnthropicToolInputJson,
+  parseAzureOpenAiStreamEvents,
+  parseAzureOpenAiToolArgumentsJson,
+  resolveAnthropicPromptCachingSettings,
+  resolveBedrockCredentials,
   resolveProviderApiKey,
-  streamAnthropicChatCompletion
+  sanitizeJsonSchemaForAnthropicStructuredOutput,
+  sanitizeJsonSchemaForGeminiResponseSchema,
+  sanitizeJsonSchemaForOpenAiStructuredOutput,
+  signAwsRequestWithSigV4,
+  streamAnthropicChatCompletion,
+  streamAzureOpenAiChatCompletion
 });