@assemble-dev/providers 0.2.0 → 0.3.1

package/dist/index.cjs

@@ -22,6 +22,7 @@ var index_exports = {};
 __export(index_exports, {
   AnthropicMessagesResponseSchema: () => AnthropicMessagesResponseSchema,
   AnthropicStreamEventSchema: () => AnthropicStreamEventSchema,
+  AzureOpenAiChatCompletionResponseSchema: () => AzureOpenAiChatCompletionResponseSchema,
   ChatMessageCacheControlSchema: () => ChatMessageCacheControlSchema,
   ChatMessageRoleSchema: () => ChatMessageRoleSchema,
   ChatMessageSchema: () => ChatMessageSchema,
@@ -32,16 +33,30 @@ __export(index_exports, {
   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,
@@ -52,14 +67,19 @@ __export(index_exports, {
   executeProviderCallWithModelFallback: () => executeProviderCallWithModelFallback,
   executeProviderCallWithRetry: () => executeProviderCallWithRetry,
   extractAnthropicTextContent: () => extractAnthropicTextContent,
+  extractAnthropicThinkingText: () => extractAnthropicThinkingText,
   extractAnthropicToolCalls: () => extractAnthropicToolCalls,
   extractMessageText: () => extractMessageText,
   gemini: () => gemini,
   isAbortError: () => isAbortError,
+  isOpenAiReasoningModel: () => isOpenAiReasoningModel,
   isRetryableProviderAppError: () => isRetryableProviderAppError,
+  isZodV4Schema: () => isZodV4Schema,
   joinSystemMessageText: () => joinSystemMessageText,
   mapAnthropicResponseToChatCompletionResult: () => mapAnthropicResponseToChatCompletionResult,
   mapAnthropicUsageToTokenUsage: () => mapAnthropicUsageToTokenUsage,
+  mapAzureOpenAiResponseToChatCompletionResult: () => mapAzureOpenAiResponseToChatCompletionResult,
+  mapAzureOpenAiUsageToTokenUsage: () => mapAzureOpenAiUsageToTokenUsage,
   mapChatMessageToAnthropicRequestMessage: () => mapChatMessageToAnthropicRequestMessage,
   mapChatMessageToOpenAiRequestMessage: () => mapChatMessageToOpenAiRequestMessage,
   mapModelToolChoiceToAnthropicToolChoice: () => mapModelToolChoiceToAnthropicToolChoice,
@@ -69,13 +89,27 @@ __export(index_exports, {
   mergeProviderRequestExtraBody: () => mergeProviderRequestExtraBody,
   mockModel: () => mockModel,
   normalizeAnthropicStopReason: () => normalizeAnthropicStopReason,
+  normalizeAzureOpenAiFinishReason: () => normalizeAzureOpenAiFinishReason,
+  openAiStructuredOutputSchemaName: () => openAiStructuredOutputSchemaName,
   openai: () => openai,
   parseAnthropicBatchStructuredContent: () => parseAnthropicBatchStructuredContent,
   parseAnthropicStreamEvents: () => parseAnthropicStreamEvents,
   parseAnthropicToolInputJson: () => parseAnthropicToolInputJson,
+  parseAzureOpenAiStreamEvents: () => parseAzureOpenAiStreamEvents,
+  parseAzureOpenAiToolArgumentsJson: () => parseAzureOpenAiToolArgumentsJson,
+  prependStructuredOutputJsonOnlySystemMessage: () => prependStructuredOutputJsonOnlySystemMessage,
   resolveAnthropicPromptCachingSettings: () => resolveAnthropicPromptCachingSettings,
+  resolveBedrockCredentials: () => resolveBedrockCredentials,
+  resolveOpenAiStructuredOutputMode: () => resolveOpenAiStructuredOutputMode,
   resolveProviderApiKey: () => resolveProviderApiKey,
-  streamAnthropicChatCompletion: () => streamAnthropicChatCompletion
+  sanitizeJsonSchemaForAnthropicStructuredOutput: () => sanitizeJsonSchemaForAnthropicStructuredOutput,
+  sanitizeJsonSchemaForGeminiResponseSchema: () => sanitizeJsonSchemaForGeminiResponseSchema,
+  sanitizeJsonSchemaForOpenAiStructuredOutput: () => sanitizeJsonSchemaForOpenAiStructuredOutput,
+  signAwsRequestWithSigV4: () => signAwsRequestWithSigV4,
+  streamAnthropicChatCompletion: () => streamAnthropicChatCompletion,
+  streamAzureOpenAiChatCompletion: () => streamAzureOpenAiChatCompletion,
+  structuredOutputJsonOnlySystemInstruction: () => structuredOutputJsonOnlySystemInstruction,
+  structuredOutputJsonOnlySystemMessage: () => structuredOutputJsonOnlySystemMessage
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -134,28 +168,306 @@ 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 isZodV4Schema(schema) {
+  return "_zod" in schema;
+}
+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/structured-output-fallback.ts
+var structuredOutputJsonOnlySystemInstruction = "Respond with a single JSON object that satisfies the caller's requested structure. Output only valid JSON with no surrounding text.";
+var structuredOutputJsonOnlySystemMessage = {
+  role: "system",
+  content: structuredOutputJsonOnlySystemInstruction
+};
+function prependStructuredOutputJsonOnlySystemMessage(messages) {
+  return [structuredOutputJsonOnlySystemMessage, ...messages];
+}
+
+// src/openai-request-mapping.ts
+var openAiReasoningModelNamePrefixes = [
+  "gpt-5",
+  "o1",
+  "o3",
+  "o4"
+];
+function isOpenAiReasoningModel(model) {
+  return openAiReasoningModelNamePrefixes.some(
+    (prefix) => matchesOpenAiModelNamePrefix(model, prefix)
+  );
+}
+function matchesOpenAiModelNamePrefix(model, prefix) {
+  if (!model.startsWith(prefix)) {
+    return false;
+  }
+  const boundaryCharacter = model.charAt(prefix.length);
+  return boundaryCharacter === "" || boundaryCharacter === "-" || boundaryCharacter === ".";
+}
+function resolveOpenAiStructuredOutputMode(messages, schema) {
+  if (isZodV4Schema(schema)) {
+    return {
+      messages,
+      structuredOutputJsonSchema: buildOpenAiStructuredOutputJsonSchema(schema)
+    };
+  }
+  return {
+    messages: prependStructuredOutputJsonOnlySystemMessage(messages),
+    requireJsonObjectResponse: true
+  };
+}
 function buildOpenAiRequestBody(model, input) {
   const requestBody = {
     model,
     messages: input.messages.map(mapChatMessageToOpenAiRequestMessage)
   };
-  if (input.temperature !== void 0) {
+  applyOpenAiGenerationSettings(requestBody, model, input);
+  applyOpenAiResponseFormat(requestBody, input);
+  applyOpenAiToolFields(requestBody, input);
+  return requestBody;
+}
+function applyOpenAiGenerationSettings(requestBody, model, input) {
+  const reasoningModel = input.reasoningModel ?? isOpenAiReasoningModel(model);
+  if (input.temperature !== void 0 && !reasoningModel) {
     requestBody.temperature = input.temperature;
   }
-  if (input.maxOutputTokens !== void 0) {
-    requestBody.max_tokens = input.maxOutputTokens;
+  if (input.maxOutputTokens === void 0) {
+    return;
+  }
+  if (reasoningModel) {
+    requestBody.max_completion_tokens = input.maxOutputTokens;
+    return;
+  }
+  requestBody.max_tokens = input.maxOutputTokens;
+}
+function applyOpenAiResponseFormat(requestBody, input) {
+  if (input.structuredOutputJsonSchema !== void 0) {
+    requestBody.response_format = {
+      type: "json_schema",
+      json_schema: {
+        name: openAiStructuredOutputSchemaName,
+        strict: true,
+        schema: input.structuredOutputJsonSchema
+      }
+    };
+    return;
   }
-  if (input.requireJsonObjectResponse) {
+  if (input.requireJsonObjectResponse === true) {
     requestBody.response_format = { type: "json_object" };
   }
+}
+function applyOpenAiToolFields(requestBody, input) {
   if (input.tools !== void 0 && input.tools.length > 0) {
     requestBody.tools = input.tools.map(mapModelToolDefinitionToOpenAiTool);
   }
@@ -164,7 +476,6 @@ function buildOpenAiRequestBody(model, input) {
       input.toolChoice
     );
   }
-  return requestBody;
 }
 function mapModelToolDefinitionToOpenAiTool(tool) {
   return {
@@ -239,17 +550,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)));
@@ -264,10 +575,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
@@ -276,9 +587,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) {
@@ -291,8 +602,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
     });
@@ -300,8 +611,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
     });
@@ -311,8 +622,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
     });
@@ -320,19 +631,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
   });
@@ -358,18 +669,18 @@ function mergeProviderRequestExtraBody(requestBody, adapterExtraBody, requestExt
 }
 
 // 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);
@@ -384,7 +695,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)) {
@@ -418,7 +729,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)) {
@@ -429,11 +740,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),
@@ -441,44 +752,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;
@@ -486,33 +797,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}`,
@@ -521,7 +828,6 @@ 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,
@@ -530,10 +836,9 @@ function openai(options) {
     },
     async generateStructuredOutput(request) {
       const completion = await executeOpenAiAdapterCall(options, {
-        messages: [structuredOutputSystemMessage, ...request.messages],
+        ...resolveOpenAiStructuredOutputMode(request.messages, request.schema),
         temperature: request.temperature ?? options.temperature,
         maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
-        requireJsonObjectResponse: true,
         abortSignal: request.abortSignal
       });
       return {
@@ -626,10 +931,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
@@ -651,8 +956,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
     });
@@ -716,6 +1021,11 @@ 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) {
@@ -872,44 +1182,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),
@@ -918,6 +1229,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);
   }
@@ -930,13 +1244,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
     });
@@ -973,58 +1290,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() })
   })
 ]);
 
@@ -1110,6 +1437,7 @@ async function* readServerSentEventDataLines(body, abortSignal) {
 function createAnthropicStreamAccumulator() {
   return {
     contentText: "",
+    thinkingText: "",
     toolCallsByBlockIndex: /* @__PURE__ */ new Map(),
     inputTokens: 0,
     outputTokens: 0
@@ -1117,8 +1445,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
     });
@@ -1154,6 +1482,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,
@@ -1171,6 +1510,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
   );
@@ -1217,6 +1564,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) {
@@ -1231,10 +1581,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
@@ -1246,10 +1596,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}`,
@@ -1260,12 +1606,10 @@ function anthropic(options) {
       );
     },
     async generateStructuredOutput(request) {
-      const completion = await executeAnthropicAdapterCall(options, {
-        messages: [structuredOutputSystemMessage2, ...request.messages],
-        temperature: request.temperature ?? options.temperature,
-        maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
-        abortSignal: request.abortSignal
-      });
+      const completion = await executeAnthropicAdapterCall(
+        options,
+        buildAnthropicStructuredOutputInput(options, request)
+      );
       return {
         value: parseStructuredJsonText(completion.content, request.schema),
         tokenUsage: completion.tokenUsage,
@@ -1279,6 +1623,26 @@ function anthropic(options) {
     }
   };
 }
+function buildAnthropicStructuredOutputInput(options, request) {
+  const baseInput = {
+    messages: request.messages,
+    temperature: request.temperature ?? options.temperature,
+    maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+    abortSignal: request.abortSignal
+  };
+  if (isZodV4Schema(request.schema)) {
+    return {
+      ...baseInput,
+      structuredOutputJsonSchema: buildAnthropicStructuredOutputJsonSchema(
+        request.schema
+      )
+    };
+  }
+  return {
+    ...baseInput,
+    messages: prependStructuredOutputJsonOnlySystemMessage(request.messages)
+  };
+}
 function buildAnthropicCallInput(options, request) {
   return {
     messages: request.messages,
@@ -1379,28 +1743,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}`,
@@ -1410,19 +1862,15 @@ function gemini(options) {
         messages: request.messages,
         temperature: request.temperature ?? options.temperature,
         maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
-        requireJsonResponse: false,
         abortSignal: request.abortSignal,
         extraBody: request.extraBody
       });
     },
     async generateStructuredOutput(request) {
-      const completion = await executeGeminiAdapterCall(options, {
-        messages: [structuredOutputSystemMessage3, ...request.messages],
-        temperature: request.temperature ?? options.temperature,
-        maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
-        requireJsonResponse: true,
-        abortSignal: request.abortSignal
-      });
+      const completion = await executeGeminiAdapterCall(
+        options,
+        buildGeminiStructuredOutputInput(options, request)
+      );
       return {
         value: parseStructuredJsonText(completion.content, request.schema),
         tokenUsage: completion.tokenUsage,
@@ -1431,16 +1879,35 @@ function gemini(options) {
     }
   };
 }
-async function executeGeminiAdapterCall(options, input) {
-  return await executeProviderCallWithModelFallback(
-    options.fallbackModel,
-    async () => await executeProviderCallWithRetry(
-      options.retry,
-      async () => await requestGeminiGenerateContent(options, input)
-    ),
-    async (fallbackModelId) => await requestGeminiGenerateContent(
-      { ...options, model: fallbackModelId },
-      input
+function buildGeminiStructuredOutputInput(options, request) {
+  const baseInput = {
+    messages: request.messages,
+    temperature: request.temperature ?? options.temperature,
+    maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+    abortSignal: request.abortSignal
+  };
+  if (isZodV4Schema(request.schema)) {
+    return {
+      ...baseInput,
+      responseSchema: buildGeminiResponseSchema(request.schema)
+    };
+  }
+  return {
+    ...baseInput,
+    messages: prependStructuredOutputJsonOnlySystemMessage(request.messages),
+    requireJsonResponse: true
+  };
+}
+async function executeGeminiAdapterCall(options, input) {
+  return await executeProviderCallWithModelFallback(
+    options.fallbackModel,
+    async () => await executeProviderCallWithRetry(
+      options.retry,
+      async () => await requestGeminiGenerateContent(options, input)
+    ),
+    async (fallbackModelId) => await requestGeminiGenerateContent(
+      { ...options, model: fallbackModelId },
+      input
     )
   );
 }
@@ -1507,8 +1974,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
   });
@@ -1545,7 +2012,10 @@ 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;
+  } else if (input.requireJsonResponse === true) {
     generationConfig.responseMimeType = "application/json";
   }
   if (Object.keys(generationConfig).length === 0) {
@@ -1556,8 +2026,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
     });
@@ -1576,8 +2046,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 ?? []];
@@ -1657,8 +2127,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
   });
@@ -1746,24 +2216,24 @@ function calculateModelCallCostUsd(pricing, tokenUsage) {
 }
 
 // src/anthropic-batch.ts
+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-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");
-
-// src/anthropic-batch-structured.ts
-var import_errors24 = require("@assemble-dev/shared-types/errors");
-var import_json6 = require("@assemble-dev/shared-types/json");
-var import_errors25 = require("@assemble-dev/shared-utils/errors");
-var anthropicBatchJsonOnlySystemInstruction = "Respond with a single JSON object that satisfies the caller's requested structure. Output only valid JSON with no surrounding text.";
+var anthropicBatchJsonOnlySystemInstruction = structuredOutputJsonOnlySystemInstruction;
 function parseAnthropicBatchStructuredContent(content, schema) {
   const jsonValue = parseStructuredJsonText(
     content,
-    import_json6.JsonValueSchema
+    import_json7.JsonValueSchema
   );
   const validationResult = schema.safeParse(jsonValue);
   if (!validationResult.success) {
-    throw new import_errors25.AppError({
-      code: import_errors24.AppErrorCode.ValidationFailed,
+    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 }
@@ -1780,11 +2250,25 @@ function mapBatchMessageRequestToApiBatchRequest(request) {
     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) {
@@ -1800,7 +2284,7 @@ function applyBatchSystemField(params, request) {
 }
 function buildBatchSystemText(request) {
   const joinedSystemText = joinBatchSystemMessageText(request.messages);
-  if (request.requireJsonResponse !== true) {
+  if (request.requireJsonResponse !== true || request.structuredOutputJsonSchema !== void 0) {
     return joinedSystemText;
   }
   if (joinedSystemText.length === 0) {
@@ -1951,55 +2435,55 @@ function buildBatchResultEvent(eventBase, batchId, result, modelName) {
 }
 
 // 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()
+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_zod7.z.string().nullable(),
-  created_at: import_zod7.z.string(),
-  ended_at: import_zod7.z.string().nullable()
+  results_url: import_zod8.z.string().nullable(),
+  created_at: import_zod8.z.string(),
+  ended_at: import_zod8.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()
+var AnthropicBatchContentBlockSchema = import_zod8.z.discriminatedUnion("type", [
+  import_zod8.z.object({
+    type: import_zod8.z.literal("text"),
+    text: import_zod8.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_zod8.z.object({
+    type: import_zod8.z.literal("thinking"),
+    thinking: import_zod8.z.string().optional(),
+    signature: import_zod8.z.string().optional()
   }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("redacted_thinking"),
-    data: import_zod7.z.string().optional()
+  import_zod8.z.object({
+    type: import_zod8.z.literal("redacted_thinking"),
+    data: import_zod8.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),
+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("errored"),
-      error: import_zod7.z.object({
-        type: import_zod7.z.string(),
-        message: import_zod7.z.string()
+    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_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("canceled") }),
+    import_zod8.z.object({ type: import_zod8.z.literal("expired") })
   ])
 });
 function mapAnthropicMessageBatchResponseToMessageBatch(response) {
@@ -2149,8 +2633,8 @@ async function parseAnthropicMessageBatchHttpResponse(response) {
 async function listAnthropicMessageBatchResults(clientContext, batchId) {
   const batch = await fetchAnthropicMessageBatch(clientContext, batchId);
   if (batch.resultsUrl === null) {
-    throw new import_errors27.AppError({
-      code: import_errors26.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 }
@@ -2187,7 +2671,7 @@ function parseAnthropicBatchResultLine(line) {
 }
 function parseAnthropicBatchResultLineJson(line) {
   try {
-    return import_json7.JsonValueSchema.parse(JSON.parse(line));
+    return import_json8.JsonValueSchema.parse(JSON.parse(line));
   } catch {
     throw buildProviderInvalidResponseError(
       "Anthropic",
@@ -2211,17 +2695,764 @@ async function waitForAnthropicMessageBatchCompletion(clientContext, batchId, wa
   return batch;
 }
 function buildAnthropicBatchTimeoutError(batchId, timeoutMs) {
-  return new import_errors27.AppError({
-    code: import_errors26.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 }
   });
 }
+
+// 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 finishReason = response.choices[0]?.finish_reason;
+  if (toolCalls.length > 0) {
+    result.toolCalls = toolCalls;
+  }
+  if (finishReason !== null && finishReason !== void 0) {
+    result.stopReason = normalizeAzureOpenAiFinishReason(finishReason);
+  }
+  return result;
+}
+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 parseAzureOpenAiToolArgumentsJson(argumentsJsonText) {
+  if (argumentsJsonText.trim().length === 0) {
+    return {};
+  }
+  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
+    });
+  }
+}
+function normalizeAzureOpenAiFinishReason(finishReason) {
+  if (finishReason === "tool_calls") {
+    return "tool_use";
+  }
+  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,
+        reasoningModel: options.reasoningModel,
+        tools: request.tools,
+        toolChoice: request.toolChoice,
+        abortSignal: request.abortSignal,
+        extraBody: request.extraBody
+      });
+    },
+    async generateStructuredOutput(request) {
+      const completion = await executeAzureOpenAiAdapterCall(options, {
+        ...resolveOpenAiStructuredOutputMode(request.messages, request.schema),
+        temperature: request.temperature ?? options.temperature,
+        maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+        reasoningModel: options.reasoningModel,
+        abortSignal: request.abortSignal
+      });
+      return {
+        value: parseStructuredJsonText(completion.content, request.schema),
+        tokenUsage: completion.tokenUsage,
+        latencyMs: completion.latencyMs
+      };
+    },
+    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,
+      reasoningModel: options.reasoningModel,
+      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) {
+  if (!isZodV4Schema(schema)) {
+    return structuredOutputJsonOnlySystemMessage;
+  }
+  return {
+    role: "system",
+    content: `Respond with a single JSON object that satisfies the following JSON Schema. Output only valid JSON with no surrounding text.
+
+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,
@@ -2232,16 +3463,30 @@ function buildAnthropicBatchTimeoutError(batchId, timeoutMs) {
   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,
@@ -2252,14 +3497,19 @@ function buildAnthropicBatchTimeoutError(batchId, timeoutMs) {
   executeProviderCallWithModelFallback,
   executeProviderCallWithRetry,
   extractAnthropicTextContent,
+  extractAnthropicThinkingText,
   extractAnthropicToolCalls,
   extractMessageText,
   gemini,
   isAbortError,
+  isOpenAiReasoningModel,
   isRetryableProviderAppError,
+  isZodV4Schema,
   joinSystemMessageText,
   mapAnthropicResponseToChatCompletionResult,
   mapAnthropicUsageToTokenUsage,
+  mapAzureOpenAiResponseToChatCompletionResult,
+  mapAzureOpenAiUsageToTokenUsage,
   mapChatMessageToAnthropicRequestMessage,
   mapChatMessageToOpenAiRequestMessage,
   mapModelToolChoiceToAnthropicToolChoice,
@@ -2269,11 +3519,25 @@ function buildAnthropicBatchTimeoutError(batchId, timeoutMs) {
   mergeProviderRequestExtraBody,
   mockModel,
   normalizeAnthropicStopReason,
+  normalizeAzureOpenAiFinishReason,
+  openAiStructuredOutputSchemaName,
   openai,
   parseAnthropicBatchStructuredContent,
   parseAnthropicStreamEvents,
   parseAnthropicToolInputJson,
+  parseAzureOpenAiStreamEvents,
+  parseAzureOpenAiToolArgumentsJson,
+  prependStructuredOutputJsonOnlySystemMessage,
   resolveAnthropicPromptCachingSettings,
+  resolveBedrockCredentials,
+  resolveOpenAiStructuredOutputMode,
   resolveProviderApiKey,
-  streamAnthropicChatCompletion
+  sanitizeJsonSchemaForAnthropicStructuredOutput,
+  sanitizeJsonSchemaForGeminiResponseSchema,
+  sanitizeJsonSchemaForOpenAiStructuredOutput,
+  signAwsRequestWithSigV4,
+  streamAnthropicChatCompletion,
+  streamAzureOpenAiChatCompletion,
+  structuredOutputJsonOnlySystemInstruction,
+  structuredOutputJsonOnlySystemMessage
 });