@assemble-dev/providers 0.2.0 → 0.3.0

package/dist/index.js

@@ -53,14 +53,222 @@ function extractMessageText(message) {
 }
 
 // src/openai-adapter.ts
-import { z as z3 } from "zod";
-import { AppErrorCode as AppErrorCode7 } from "@assemble-dev/shared-types/errors";
+import { z as z4 } from "zod";
+import { AppErrorCode as AppErrorCode8 } from "@assemble-dev/shared-types/errors";
 import { JsonValueSchema as JsonValueSchema3 } from "@assemble-dev/shared-types/json";
-import { AppError as AppError8 } from "@assemble-dev/shared-utils/errors";
+import { AppError as AppError9 } from "@assemble-dev/shared-utils/errors";
 
 // src/openai-request-mapping.ts
+import { AppErrorCode as AppErrorCode2 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError2 } from "@assemble-dev/shared-utils/errors";
+
+// src/structured-output-json-schema.ts
+import { z as z2 } from "zod";
 import { AppErrorCode } from "@assemble-dev/shared-types/errors";
+import { JsonObjectSchema } from "@assemble-dev/shared-types/json";
 import { AppError } from "@assemble-dev/shared-utils/errors";
+
+// src/json-schema-tree.ts
+var schemaMapKeywords = ["properties", "$defs"];
+var schemaListKeywords = ["anyOf", "oneOf", "allOf", "prefixItems"];
+var schemaValueKeywords = [
+  "items",
+  "additionalProperties",
+  "not",
+  "if",
+  "then",
+  "else",
+  "contains",
+  "propertyNames"
+];
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function transformJsonSchemaNode(node, transformNode) {
+  const result = { ...transformNode({ ...node }) };
+  for (const keyword of schemaMapKeywords) {
+    const mapValue = result[keyword];
+    if (mapValue !== void 0 && isJsonObject(mapValue)) {
+      result[keyword] = transformJsonSchemaMap(mapValue, transformNode);
+    }
+  }
+  for (const keyword of schemaListKeywords) {
+    const listValue = result[keyword];
+    if (Array.isArray(listValue)) {
+      result[keyword] = listValue.map(
+        (entry) => isJsonObject(entry) ? transformJsonSchemaNode(entry, transformNode) : entry
+      );
+    }
+  }
+  for (const keyword of schemaValueKeywords) {
+    const schemaValue = result[keyword];
+    if (schemaValue !== void 0 && isJsonObject(schemaValue)) {
+      result[keyword] = transformJsonSchemaNode(schemaValue, transformNode);
+    }
+  }
+  return result;
+}
+function transformJsonSchemaMap(schemaMap, transformNode) {
+  const result = {};
+  for (const [schemaName, schemaValue] of Object.entries(schemaMap)) {
+    result[schemaName] = isJsonObject(schemaValue) ? transformJsonSchemaNode(schemaValue, transformNode) : schemaValue;
+  }
+  return result;
+}
+function inlineJsonSchemaReferences(root) {
+  const rootDefinitions = root["$defs"];
+  const definitions = rootDefinitions !== void 0 && isJsonObject(rootDefinitions) ? rootDefinitions : {};
+  const resolvedRoot = resolveJsonSchemaReferences(
+    root,
+    definitions,
+    /* @__PURE__ */ new Set()
+  );
+  return isJsonObject(resolvedRoot) ? resolvedRoot : {};
+}
+function resolveJsonSchemaReferences(value, definitions, activeReferences) {
+  if (Array.isArray(value)) {
+    return value.map(
+      (entry) => resolveJsonSchemaReferences(entry, definitions, activeReferences)
+    );
+  }
+  if (!isJsonObject(value)) {
+    return value;
+  }
+  const referenceTarget = value["$ref"];
+  if (typeof referenceTarget === "string") {
+    return resolveJsonSchemaReferenceTarget(
+      referenceTarget,
+      definitions,
+      activeReferences
+    );
+  }
+  const result = {};
+  for (const [key, entryValue] of Object.entries(value)) {
+    if (key !== "$defs") {
+      result[key] = resolveJsonSchemaReferences(
+        entryValue,
+        definitions,
+        activeReferences
+      );
+    }
+  }
+  return result;
+}
+function resolveJsonSchemaReferenceTarget(referenceTarget, definitions, activeReferences) {
+  if (activeReferences.has(referenceTarget)) {
+    return {};
+  }
+  const definitionsPrefix = "#/$defs/";
+  if (!referenceTarget.startsWith(definitionsPrefix)) {
+    return {};
+  }
+  const definition = definitions[referenceTarget.slice(definitionsPrefix.length)];
+  if (definition === void 0 || !isJsonObject(definition)) {
+    return {};
+  }
+  return resolveJsonSchemaReferences(
+    definition,
+    definitions,
+    /* @__PURE__ */ new Set([...activeReferences, referenceTarget])
+  );
+}
+function removeJsonSchemaKeywords(node, keywords) {
+  const result = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (!keywords.includes(key)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/structured-output-json-schema.ts
+var openAiStructuredOutputSchemaName = "structured_output";
+var schemaMetadataKeywords = ["$schema", "$id"];
+var anthropicUnsupportedSchemaKeywords = [
+  ...schemaMetadataKeywords,
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "minLength",
+  "maxLength",
+  "multipleOf"
+];
+var openAiUnsupportedSchemaKeywords = [
+  ...anthropicUnsupportedSchemaKeywords,
+  "pattern",
+  "format",
+  "minItems",
+  "maxItems",
+  "uniqueItems",
+  "default"
+];
+function convertZodSchemaToJsonSchema(schema) {
+  try {
+    return JsonObjectSchema.parse(z2.toJSONSchema(schema, { io: "input" }));
+  } catch (error) {
+    throw new AppError({
+      code: AppErrorCode.BadRequest,
+      message: "Structured output schema could not be converted to JSON Schema",
+      statusCode: 400,
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+}
+function buildAnthropicStructuredOutputJsonSchema(schema) {
+  return sanitizeJsonSchemaForAnthropicStructuredOutput(
+    convertZodSchemaToJsonSchema(schema)
+  );
+}
+function sanitizeJsonSchemaForAnthropicStructuredOutput(jsonSchema) {
+  return transformJsonSchemaNode(
+    inlineJsonSchemaReferences(jsonSchema),
+    sanitizeAnthropicSchemaNode
+  );
+}
+function buildOpenAiStructuredOutputJsonSchema(schema) {
+  return sanitizeJsonSchemaForOpenAiStructuredOutput(
+    convertZodSchemaToJsonSchema(schema)
+  );
+}
+function sanitizeJsonSchemaForOpenAiStructuredOutput(jsonSchema) {
+  return transformJsonSchemaNode(jsonSchema, sanitizeOpenAiSchemaNode);
+}
+function sanitizeAnthropicSchemaNode(node) {
+  const sanitized = removeJsonSchemaKeywords(
+    node,
+    anthropicUnsupportedSchemaKeywords
+  );
+  if (sanitized["type"] === "object") {
+    sanitized["additionalProperties"] = false;
+  }
+  return sanitized;
+}
+function sanitizeOpenAiSchemaNode(node) {
+  const sanitized = removeJsonSchemaKeywords(
+    node,
+    openAiUnsupportedSchemaKeywords
+  );
+  if (sanitized["type"] !== "object") {
+    return sanitized;
+  }
+  sanitized["additionalProperties"] = false;
+  const propertyNames = listSchemaPropertyNames(sanitized);
+  if (propertyNames.length > 0) {
+    sanitized["required"] = propertyNames;
+  }
+  return sanitized;
+}
+function listSchemaPropertyNames(node) {
+  const properties = node["properties"];
+  if (properties === void 0 || !isJsonObject(properties)) {
+    return [];
+  }
+  return Object.keys(properties);
+}
+
+// src/openai-request-mapping.ts
 function buildOpenAiRequestBody(model, input) {
   const requestBody = {
     model,
@@ -72,7 +280,16 @@ function buildOpenAiRequestBody(model, input) {
   if (input.maxOutputTokens !== void 0) {
     requestBody.max_tokens = input.maxOutputTokens;
   }
-  if (input.requireJsonObjectResponse) {
+  if (input.structuredOutputJsonSchema !== void 0) {
+    requestBody.response_format = {
+      type: "json_schema",
+      json_schema: {
+        name: openAiStructuredOutputSchemaName,
+        strict: true,
+        schema: input.structuredOutputJsonSchema
+      }
+    };
+  } else if (input.requireJsonObjectResponse === true) {
     requestBody.response_format = { type: "json_object" };
   }
   if (input.tools !== void 0 && input.tools.length > 0) {
@@ -158,17 +375,17 @@ function mapMessageContentBlockToOpenAiContentPart(contentBlock) {
       }
     };
   }
-  throw new AppError({
-    code: AppErrorCode.ValidationFailed,
+  throw new AppError2({
+    code: AppErrorCode2.ValidationFailed,
     message: "OpenAI adapter does not support document content blocks in chat messages",
     statusCode: 400
   });
 }
 
 // src/parse-structured-json.ts
-import { AppErrorCode as AppErrorCode2 } from "@assemble-dev/shared-types/errors";
+import { AppErrorCode as AppErrorCode3 } from "@assemble-dev/shared-types/errors";
 import { JsonValueSchema as JsonValueSchema2 } from "@assemble-dev/shared-types/json";
-import { AppError as AppError2 } from "@assemble-dev/shared-utils/errors";
+import { AppError as AppError3 } from "@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)));
@@ -185,8 +402,8 @@ function parseJsonText(text) {
   try {
     return JsonValueSchema2.parse(JSON.parse(text));
   } catch (error) {
-    throw new AppError2({
-      code: AppErrorCode2.ValidationFailed,
+    throw new AppError3({
+      code: AppErrorCode3.ValidationFailed,
       message: "Structured output was not valid JSON",
       statusCode: 422,
       cause: error instanceof Error ? error : void 0
@@ -195,9 +412,9 @@ function parseJsonText(text) {
 }
 
 // src/provider-api-key.ts
-import { z as z2 } from "zod";
-import { AppErrorCode as AppErrorCode3 } from "@assemble-dev/shared-types/errors";
-import { AppError as AppError3 } from "@assemble-dev/shared-utils/errors";
+import { z as z3 } from "zod";
+import { AppErrorCode as AppErrorCode4 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError4 } from "@assemble-dev/shared-utils/errors";
 import {
   buildNamedApiKeyEnvVarName,
   expectedProviderApiKeyNameFormat,
@@ -214,8 +431,8 @@ function resolveProviderApiKey(input) {
 }
 function resolveNamedProviderApiKeyFromEnv(input, apiKeyName) {
   if (!validateProviderApiKeyName(apiKeyName)) {
-    throw new AppError3({
-      code: AppErrorCode3.BadRequest,
+    throw new AppError4({
+      code: AppErrorCode4.BadRequest,
       message: `Invalid ${input.providerLabel} apiKeyName "${apiKeyName}". Expected ${expectedProviderApiKeyNameFormat}.`,
       statusCode: 400
     });
@@ -223,8 +440,8 @@ function resolveNamedProviderApiKeyFromEnv(input, apiKeyName) {
   const envVarName = buildNamedApiKeyEnvVarName(input.baseEnvVarName, apiKeyName);
   const envApiKey = readEnvironmentVariable(envVarName);
   if (envApiKey === void 0 || envApiKey.length === 0) {
-    throw new AppError3({
-      code: AppErrorCode3.Unauthorized,
+    throw new AppError4({
+      code: AppErrorCode4.Unauthorized,
       message: `${input.providerLabel} API key named "${apiKeyName}" is missing. Set the ${envVarName} environment variable or pass apiKey to ${input.adapterFunctionName}.`,
       statusCode: 401
     });
@@ -234,8 +451,8 @@ function resolveNamedProviderApiKeyFromEnv(input, apiKeyName) {
 function resolveBaseProviderApiKeyFromEnv(input) {
   const envApiKey = readEnvironmentVariable(input.baseEnvVarName);
   if (envApiKey === void 0 || envApiKey.length === 0) {
-    throw new AppError3({
-      code: AppErrorCode3.Unauthorized,
+    throw new AppError4({
+      code: AppErrorCode4.Unauthorized,
       message: `${input.providerLabel} API key is missing. Pass apiKey to ${input.adapterFunctionName} or set the ${input.baseEnvVarName} environment variable.`,
       statusCode: 401
     });
@@ -243,19 +460,19 @@ function resolveBaseProviderApiKeyFromEnv(input) {
   return envApiKey;
 }
 function readEnvironmentVariable(envVarName) {
-  const parsedEnv = z2.object({ [envVarName]: z2.string().optional() }).parse(process.env);
+  const parsedEnv = z3.object({ [envVarName]: z3.string().optional() }).parse(process.env);
   return parsedEnv[envVarName];
 }
 
 // src/provider-cancellation.ts
-import { AppErrorCode as AppErrorCode4 } from "@assemble-dev/shared-types/errors";
-import { AppError as AppError4 } from "@assemble-dev/shared-utils/errors";
+import { AppErrorCode as AppErrorCode5 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError5 } from "@assemble-dev/shared-utils/errors";
 function isAbortError(error) {
   return error.name === "AbortError";
 }
 function buildProviderCanceledError(providerLabel) {
-  return new AppError4({
-    code: AppErrorCode4.Canceled,
+  return new AppError5({
+    code: AppErrorCode5.Canceled,
     message: `${providerLabel} request was canceled`,
     statusCode: 499
   });
@@ -281,18 +498,18 @@ function mergeProviderRequestExtraBody(requestBody, adapterExtraBody, requestExt
 }
 
 // src/provider-fallback.ts
-import { AppError as AppError6 } from "@assemble-dev/shared-utils/errors";
+import { AppError as AppError7 } from "@assemble-dev/shared-utils/errors";
 
 // src/provider-retry.ts
-import { AppErrorCode as AppErrorCode5 } from "@assemble-dev/shared-types/errors";
-import { AppError as AppError5 } from "@assemble-dev/shared-utils/errors";
+import { AppErrorCode as AppErrorCode6 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError6 } from "@assemble-dev/shared-utils/errors";
 var defaultProviderRetryMaxAttempts = 3;
 var defaultProviderRetryInitialDelayMs = 500;
 var defaultProviderRetryMaxDelayMs = 8e3;
 var retryableAppErrorCodes = /* @__PURE__ */ new Set([
-  AppErrorCode5.RateLimited,
-  AppErrorCode5.ServiceUnavailable,
-  AppErrorCode5.InternalServerError
+  AppErrorCode6.RateLimited,
+  AppErrorCode6.ServiceUnavailable,
+  AppErrorCode6.InternalServerError
 ]);
 function isRetryableProviderAppError(appError) {
   return retryableAppErrorCodes.has(appError.code);
@@ -307,7 +524,7 @@ async function executeProviderCallWithRetry(retryOptions, executeCall, waitFor)
     try {
       return await executeCall();
     } catch (error) {
-      if (error instanceof AppError5 && !isRetryableProviderAppError(error)) {
+      if (error instanceof AppError6 && !isRetryableProviderAppError(error)) {
         throw error;
       }
       if (error instanceof Error && isAbortError(error)) {
@@ -341,7 +558,7 @@ async function executeProviderCallWithModelFallback(fallbackModel, executePrimar
     if (fallbackModel === void 0) {
       throw error;
     }
-    if (error instanceof AppError6 && !isRetryableProviderAppError(error)) {
+    if (error instanceof AppError7 && !isRetryableProviderAppError(error)) {
       throw error;
     }
     if (error instanceof Error && isAbortError(error)) {
@@ -352,11 +569,11 @@ async function executeProviderCallWithModelFallback(fallbackModel, executePrimar
 }
 
 // src/provider-status-error.ts
-import { AppErrorCode as AppErrorCode6 } from "@assemble-dev/shared-types/errors";
-import { AppError as AppError7 } from "@assemble-dev/shared-utils/errors";
+import { AppErrorCode as AppErrorCode7 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError8 } from "@assemble-dev/shared-utils/errors";
 function buildProviderStatusError(providerLabel, providerStatus) {
   const code = mapProviderStatusToAppErrorCode(providerStatus);
-  return new AppError7({
+  return new AppError8({
     code,
     message: `${providerLabel} request failed with status ${String(providerStatus)}`,
     statusCode: mapAppErrorCodeToStatusCode(code),
@@ -364,44 +581,44 @@ function buildProviderStatusError(providerLabel, providerStatus) {
   });
 }
 function buildProviderInvalidResponseError(providerLabel, expectedShapeDescription) {
-  return new AppError7({
-    code: AppErrorCode6.ValidationFailed,
+  return new AppError8({
+    code: AppErrorCode7.ValidationFailed,
     message: `${providerLabel} response did not match the expected ${expectedShapeDescription} shape`,
     statusCode: 502
   });
 }
 function mapProviderStatusToAppErrorCode(providerStatus) {
   if (providerStatus === 400) {
-    return AppErrorCode6.BadRequest;
+    return AppErrorCode7.BadRequest;
   }
   if (providerStatus === 401) {
-    return AppErrorCode6.Unauthorized;
+    return AppErrorCode7.Unauthorized;
   }
   if (providerStatus === 403) {
-    return AppErrorCode6.Forbidden;
+    return AppErrorCode7.Forbidden;
   }
   if (providerStatus === 404) {
-    return AppErrorCode6.NotFound;
+    return AppErrorCode7.NotFound;
   }
   if (providerStatus === 429) {
-    return AppErrorCode6.RateLimited;
+    return AppErrorCode7.RateLimited;
   }
-  return AppErrorCode6.InternalServerError;
+  return AppErrorCode7.InternalServerError;
 }
 function mapAppErrorCodeToStatusCode(code) {
-  if (code === AppErrorCode6.BadRequest) {
+  if (code === AppErrorCode7.BadRequest) {
     return 400;
   }
-  if (code === AppErrorCode6.Unauthorized) {
+  if (code === AppErrorCode7.Unauthorized) {
     return 401;
   }
-  if (code === AppErrorCode6.Forbidden) {
+  if (code === AppErrorCode7.Forbidden) {
     return 403;
   }
-  if (code === AppErrorCode6.NotFound) {
+  if (code === AppErrorCode7.NotFound) {
     return 404;
   }
-  if (code === AppErrorCode6.RateLimited) {
+  if (code === AppErrorCode7.RateLimited) {
     return 429;
   }
   return 500;
@@ -409,33 +626,29 @@ function mapAppErrorCodeToStatusCode(code) {
 
 // src/openai-adapter.ts
 var defaultOpenAiBaseUrl = "https://api.openai.com/v1";
-var OpenAiResponseToolCallSchema = z3.object({
-  id: z3.string(),
-  function: z3.object({
-    name: z3.string(),
-    arguments: z3.string()
+var OpenAiResponseToolCallSchema = z4.object({
+  id: z4.string(),
+  function: z4.object({
+    name: z4.string(),
+    arguments: z4.string()
   })
 });
-var OpenAiChatCompletionResponseSchema = z3.object({
-  choices: z3.array(
-    z3.object({
-      message: z3.object({
-        content: z3.string().nullable(),
-        tool_calls: z3.array(OpenAiResponseToolCallSchema).optional()
+var OpenAiChatCompletionResponseSchema = z4.object({
+  choices: z4.array(
+    z4.object({
+      message: z4.object({
+        content: z4.string().nullable(),
+        tool_calls: z4.array(OpenAiResponseToolCallSchema).optional()
       }),
-      finish_reason: z3.string().nullable().optional()
+      finish_reason: z4.string().nullable().optional()
     })
   ).min(1),
-  usage: z3.object({
-    prompt_tokens: z3.number().int().nonnegative(),
-    completion_tokens: z3.number().int().nonnegative(),
-    total_tokens: z3.number().int().nonnegative()
+  usage: z4.object({
+    prompt_tokens: z4.number().int().nonnegative(),
+    completion_tokens: z4.number().int().nonnegative(),
+    total_tokens: z4.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}`,
@@ -444,7 +657,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,
@@ -453,10 +665,12 @@ function openai(options) {
     },
     async generateStructuredOutput(request) {
       const completion = await executeOpenAiAdapterCall(options, {
-        messages: [structuredOutputSystemMessage, ...request.messages],
+        messages: request.messages,
         temperature: request.temperature ?? options.temperature,
         maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
-        requireJsonObjectResponse: true,
+        structuredOutputJsonSchema: buildOpenAiStructuredOutputJsonSchema(
+          request.schema
+        ),
         abortSignal: request.abortSignal
       });
       return {
@@ -551,8 +765,8 @@ function parseOpenAiToolArgumentsJson(argumentsJsonText) {
   try {
     return JsonValueSchema3.parse(JSON.parse(argumentsJsonText));
   } catch (error) {
-    throw new AppError8({
-      code: AppErrorCode7.ValidationFailed,
+    throw new AppError9({
+      code: AppErrorCode8.ValidationFailed,
       message: "OpenAI tool call arguments were not valid JSON",
       statusCode: 502,
       cause: error instanceof Error ? error : void 0
@@ -574,8 +788,8 @@ function extractOpenAiMessageContent(response, allowEmptyContent) {
     if (allowEmptyContent) {
       return "";
     }
-    throw new AppError8({
-      code: AppErrorCode7.ValidationFailed,
+    throw new AppError9({
+      code: AppErrorCode8.ValidationFailed,
       message: "OpenAI response contained no message content",
       statusCode: 502
     });
@@ -639,6 +853,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) {
@@ -795,44 +1014,45 @@ function mapMessageContentBlockToAnthropic(contentBlock) {
 }
 
 // src/anthropic-response-parsing.ts
-import { z as z4 } from "zod";
-import { AppErrorCode as AppErrorCode8 } from "@assemble-dev/shared-types/errors";
+import { z as z5 } from "zod";
+import { AppErrorCode as AppErrorCode9 } from "@assemble-dev/shared-types/errors";
 import { JsonValueSchema as JsonValueSchema4 } from "@assemble-dev/shared-types/json";
-import { AppError as AppError9 } from "@assemble-dev/shared-utils/errors";
-var AnthropicUsageSchema = z4.object({
-  input_tokens: z4.number().int().nonnegative(),
-  output_tokens: z4.number().int().nonnegative(),
-  cache_creation_input_tokens: z4.number().int().nonnegative().optional(),
-  cache_read_input_tokens: z4.number().int().nonnegative().optional()
+import { AppError as AppError10 } from "@assemble-dev/shared-utils/errors";
+var AnthropicUsageSchema = z5.object({
+  input_tokens: z5.number().int().nonnegative(),
+  output_tokens: z5.number().int().nonnegative(),
+  cache_creation_input_tokens: z5.number().int().nonnegative().optional(),
+  cache_read_input_tokens: z5.number().int().nonnegative().optional()
 });
-var AnthropicContentBlockSchema = z4.discriminatedUnion("type", [
-  z4.object({
-    type: z4.literal("text"),
-    text: z4.string()
+var AnthropicContentBlockSchema = z5.discriminatedUnion("type", [
+  z5.object({
+    type: z5.literal("text"),
+    text: z5.string()
   }),
-  z4.object({
-    type: z4.literal("tool_use"),
-    id: z4.string(),
-    name: z4.string(),
+  z5.object({
+    type: z5.literal("tool_use"),
+    id: z5.string(),
+    name: z5.string(),
     input: JsonValueSchema4
   }),
-  z4.object({
-    type: z4.literal("thinking"),
-    thinking: z4.string().optional(),
-    signature: z4.string().optional()
+  z5.object({
+    type: z5.literal("thinking"),
+    thinking: z5.string().optional(),
+    signature: z5.string().optional()
   }),
-  z4.object({
-    type: z4.literal("redacted_thinking"),
-    data: z4.string().optional()
+  z5.object({
+    type: z5.literal("redacted_thinking"),
+    data: z5.string().optional()
   })
 ]);
-var AnthropicMessagesResponseSchema = z4.object({
-  content: z4.array(AnthropicContentBlockSchema),
-  stop_reason: z4.string().nullable().optional(),
+var AnthropicMessagesResponseSchema = z5.object({
+  content: z5.array(AnthropicContentBlockSchema),
+  stop_reason: z5.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),
@@ -841,6 +1061,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);
   }
@@ -853,13 +1076,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 AppError9({
-      code: AppErrorCode8.ValidationFailed,
+    throw new AppError10({
+      code: AppErrorCode9.ValidationFailed,
       message: "Anthropic response contained no text content",
       statusCode: 502
     });
@@ -896,58 +1122,68 @@ function mapAnthropicUsageToTokenUsage(usage) {
 }
 
 // src/anthropic-stream.ts
-import { AppErrorCode as AppErrorCode9 } from "@assemble-dev/shared-types/errors";
+import { AppErrorCode as AppErrorCode10 } from "@assemble-dev/shared-types/errors";
 import { JsonValueSchema as JsonValueSchema5 } from "@assemble-dev/shared-types/json";
-import { AppError as AppError10 } from "@assemble-dev/shared-utils/errors";
+import { AppError as AppError11 } from "@assemble-dev/shared-utils/errors";
 
 // src/anthropic-stream-events.ts
-import { z as z5 } from "zod";
-var AnthropicStreamEventSchema = z5.discriminatedUnion("type", [
-  z5.object({
-    type: z5.literal("message_start"),
-    message: z5.object({
-      usage: z5.object({
-        input_tokens: z5.number().int().nonnegative(),
-        output_tokens: z5.number().int().nonnegative().optional(),
-        cache_creation_input_tokens: z5.number().int().nonnegative().optional(),
-        cache_read_input_tokens: z5.number().int().nonnegative().optional()
+import { z as z6 } from "zod";
+var AnthropicStreamEventSchema = z6.discriminatedUnion("type", [
+  z6.object({
+    type: z6.literal("message_start"),
+    message: z6.object({
+      usage: z6.object({
+        input_tokens: z6.number().int().nonnegative(),
+        output_tokens: z6.number().int().nonnegative().optional(),
+        cache_creation_input_tokens: z6.number().int().nonnegative().optional(),
+        cache_read_input_tokens: z6.number().int().nonnegative().optional()
       })
     })
   }),
-  z5.object({
-    type: z5.literal("content_block_start"),
-    index: z5.number().int().nonnegative(),
-    content_block: z5.discriminatedUnion("type", [
-      z5.object({ type: z5.literal("text"), text: z5.string().optional() }),
-      z5.object({
-        type: z5.literal("tool_use"),
-        id: z5.string(),
-        name: z5.string()
+  z6.object({
+    type: z6.literal("content_block_start"),
+    index: z6.number().int().nonnegative(),
+    content_block: z6.discriminatedUnion("type", [
+      z6.object({ type: z6.literal("text"), text: z6.string().optional() }),
+      z6.object({
+        type: z6.literal("thinking"),
+        thinking: z6.string().optional()
+      }),
+      z6.object({
+        type: z6.literal("redacted_thinking"),
+        data: z6.string().optional()
+      }),
+      z6.object({
+        type: z6.literal("tool_use"),
+        id: z6.string(),
+        name: z6.string()
       })
     ])
   }),
-  z5.object({
-    type: z5.literal("content_block_delta"),
-    index: z5.number().int().nonnegative(),
-    delta: z5.discriminatedUnion("type", [
-      z5.object({ type: z5.literal("text_delta"), text: z5.string() }),
-      z5.object({
-        type: z5.literal("input_json_delta"),
-        partial_json: z5.string()
+  z6.object({
+    type: z6.literal("content_block_delta"),
+    index: z6.number().int().nonnegative(),
+    delta: z6.discriminatedUnion("type", [
+      z6.object({ type: z6.literal("text_delta"), text: z6.string() }),
+      z6.object({ type: z6.literal("thinking_delta"), thinking: z6.string() }),
+      z6.object({ type: z6.literal("signature_delta"), signature: z6.string() }),
+      z6.object({
+        type: z6.literal("input_json_delta"),
+        partial_json: z6.string()
       })
     ])
   }),
-  z5.object({ type: z5.literal("content_block_stop") }),
-  z5.object({
-    type: z5.literal("message_delta"),
-    delta: z5.object({ stop_reason: z5.string().nullable().optional() }),
-    usage: z5.object({ output_tokens: z5.number().int().nonnegative() }).optional()
+  z6.object({ type: z6.literal("content_block_stop") }),
+  z6.object({
+    type: z6.literal("message_delta"),
+    delta: z6.object({ stop_reason: z6.string().nullable().optional() }),
+    usage: z6.object({ output_tokens: z6.number().int().nonnegative() }).optional()
   }),
-  z5.object({ type: z5.literal("message_stop") }),
-  z5.object({ type: z5.literal("ping") }),
-  z5.object({
-    type: z5.literal("error"),
-    error: z5.object({ message: z5.string() })
+  z6.object({ type: z6.literal("message_stop") }),
+  z6.object({ type: z6.literal("ping") }),
+  z6.object({
+    type: z6.literal("error"),
+    error: z6.object({ message: z6.string() })
   })
 ]);
 
@@ -1033,6 +1269,7 @@ async function* readServerSentEventDataLines(body, abortSignal) {
 function createAnthropicStreamAccumulator() {
   return {
     contentText: "",
+    thinkingText: "",
     toolCallsByBlockIndex: /* @__PURE__ */ new Map(),
     inputTokens: 0,
     outputTokens: 0
@@ -1040,8 +1277,8 @@ function createAnthropicStreamAccumulator() {
 }
 function* applyAnthropicStreamEvent(event, accumulator) {
   if (event.type === "error") {
-    throw new AppError10({
-      code: AppErrorCode9.InternalServerError,
+    throw new AppError11({
+      code: AppErrorCode10.InternalServerError,
       message: `Anthropic stream reported an error: ${event.error.message}`,
       statusCode: 502
     });
@@ -1077,6 +1314,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,
@@ -1094,6 +1342,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
   );
@@ -1140,6 +1396,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) {
@@ -1156,8 +1415,8 @@ function parseAnthropicToolInputJson(inputJsonText) {
   try {
     return JsonValueSchema5.parse(JSON.parse(inputJsonText));
   } catch (error) {
-    throw new AppError10({
-      code: AppErrorCode9.ValidationFailed,
+    throw new AppError11({
+      code: AppErrorCode10.ValidationFailed,
       message: "Anthropic tool input was not valid JSON",
       statusCode: 502,
       cause: error instanceof Error ? error : void 0
@@ -1169,10 +1428,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}`,
@@ -1184,9 +1439,12 @@ function anthropic(options) {
     },
     async generateStructuredOutput(request) {
       const completion = await executeAnthropicAdapterCall(options, {
-        messages: [structuredOutputSystemMessage2, ...request.messages],
+        messages: request.messages,
         temperature: request.temperature ?? options.temperature,
         maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+        structuredOutputJsonSchema: buildAnthropicStructuredOutputJsonSchema(
+          request.schema
+        ),
         abortSignal: request.abortSignal
       });
       return {
@@ -1302,28 +1560,116 @@ function resolveAnthropicFetch(options) {
 }
 
 // src/gemini-adapter.ts
-import { z as z6 } from "zod";
-import { AppErrorCode as AppErrorCode10 } from "@assemble-dev/shared-types/errors";
-import { AppError as AppError11 } from "@assemble-dev/shared-utils/errors";
+import { z as z7 } from "zod";
+import { AppErrorCode as AppErrorCode11 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError12 } from "@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 = z6.object({
-  candidates: z6.array(
-    z6.object({
-      content: z6.object({
-        parts: z6.array(z6.object({ text: z6.string() }))
+var GeminiGenerateContentResponseSchema = z7.object({
+  candidates: z7.array(
+    z7.object({
+      content: z7.object({
+        parts: z7.array(z7.object({ text: z7.string() }))
       })
     })
   ).optional(),
-  usageMetadata: z6.object({
-    promptTokenCount: z6.number().int().nonnegative().optional(),
-    candidatesTokenCount: z6.number().int().nonnegative().optional(),
-    totalTokenCount: z6.number().int().nonnegative().optional()
+  usageMetadata: z7.object({
+    promptTokenCount: z7.number().int().nonnegative().optional(),
+    candidatesTokenCount: z7.number().int().nonnegative().optional(),
+    totalTokenCount: z7.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}`,
@@ -1333,17 +1679,16 @@ 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],
+        messages: request.messages,
         temperature: request.temperature ?? options.temperature,
         maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
-        requireJsonResponse: true,
+        responseSchema: buildGeminiResponseSchema(request.schema),
         abortSignal: request.abortSignal
       });
       return {
@@ -1430,8 +1775,8 @@ function ensureGeminiRequestHasNoTools(request) {
   if (request.tools === void 0 || request.tools.length === 0) {
     return;
   }
-  throw new AppError11({
-    code: AppErrorCode10.ValidationFailed,
+  throw new AppError12({
+    code: AppErrorCode11.ValidationFailed,
     message: "gemini adapter does not support model-driven tool use; remove tools from the request or use another adapter",
     statusCode: 400
   });
@@ -1468,8 +1813,9 @@ function buildGeminiGenerationConfig(input) {
   if (input.maxOutputTokens !== void 0) {
     generationConfig.maxOutputTokens = input.maxOutputTokens;
   }
-  if (input.requireJsonResponse) {
+  if (input.responseSchema !== void 0) {
     generationConfig.responseMimeType = "application/json";
+    generationConfig.responseSchema = input.responseSchema;
   }
   if (Object.keys(generationConfig).length === 0) {
     return void 0;
@@ -1479,8 +1825,8 @@ function buildGeminiGenerationConfig(input) {
 function extractGeminiCandidateText(response) {
   const firstCandidate = response.candidates?.[0];
   if (firstCandidate === void 0) {
-    throw new AppError11({
-      code: AppErrorCode10.ValidationFailed,
+    throw new AppError12({
+      code: AppErrorCode11.ValidationFailed,
       message: "Gemini response contained no candidates",
       statusCode: 502
     });
@@ -1499,8 +1845,8 @@ function mapGeminiUsageToTokenUsage(response) {
 }
 
 // src/mock-adapter.ts
-import { AppErrorCode as AppErrorCode11 } from "@assemble-dev/shared-types/errors";
-import { AppError as AppError12 } from "@assemble-dev/shared-utils/errors";
+import { AppErrorCode as AppErrorCode12 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError13 } from "@assemble-dev/shared-utils/errors";
 var mockStreamChunkCount = 3;
 function mockModel(options = {}) {
   const remainingScriptedResponses = [...options.scriptedResponses ?? []];
@@ -1580,8 +1926,8 @@ function resolveNextMockResponseText(request, remainingScriptedResponses, respon
   if (respond !== void 0) {
     return respond(request);
   }
-  throw new AppError12({
-    code: AppErrorCode11.BadRequest,
+  throw new AppError13({
+    code: AppErrorCode12.BadRequest,
     message: "Mock model has no scripted responses left and no respond function was provided",
     statusCode: 400
   });
@@ -1669,14 +2015,14 @@ function calculateModelCallCostUsd(pricing, tokenUsage) {
 }
 
 // src/anthropic-batch.ts
-import { AppErrorCode as AppErrorCode13 } from "@assemble-dev/shared-types/errors";
+import { AppErrorCode as AppErrorCode14 } from "@assemble-dev/shared-types/errors";
 import { JsonValueSchema as JsonValueSchema7 } from "@assemble-dev/shared-types/json";
-import { AppError as AppError14 } from "@assemble-dev/shared-utils/errors";
+import { AppError as AppError15 } from "@assemble-dev/shared-utils/errors";
 
 // src/anthropic-batch-structured.ts
-import { AppErrorCode as AppErrorCode12 } from "@assemble-dev/shared-types/errors";
+import { AppErrorCode as AppErrorCode13 } from "@assemble-dev/shared-types/errors";
 import { JsonValueSchema as JsonValueSchema6 } from "@assemble-dev/shared-types/json";
-import { AppError as AppError13 } from "@assemble-dev/shared-utils/errors";
+import { AppError as AppError14 } from "@assemble-dev/shared-utils/errors";
 var anthropicBatchJsonOnlySystemInstruction = "Respond with a single JSON object that satisfies the caller's requested structure. Output only valid JSON with no surrounding text.";
 function parseAnthropicBatchStructuredContent(content, schema) {
   const jsonValue = parseStructuredJsonText(
@@ -1685,8 +2031,8 @@ function parseAnthropicBatchStructuredContent(content, schema) {
   );
   const validationResult = schema.safeParse(jsonValue);
   if (!validationResult.success) {
-    throw new AppError13({
-      code: AppErrorCode12.ValidationFailed,
+    throw new AppError14({
+      code: AppErrorCode13.ValidationFailed,
       message: "Anthropic batch structured output did not match the expected schema",
       statusCode: 422,
       details: { validationErrorMessage: validationResult.error.message }
@@ -1703,11 +2049,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) {
@@ -1723,7 +2083,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) {
@@ -1877,55 +2237,55 @@ function buildBatchResultEvent(eventBase, batchId, result, modelName) {
 }
 
 // src/anthropic-batch-types.ts
-import { z as z7 } from "zod";
-var AnthropicMessageBatchResponseSchema = z7.object({
-  id: z7.string(),
-  processing_status: z7.enum(["in_progress", "canceling", "ended"]),
-  request_counts: z7.object({
-    processing: z7.number().int().nonnegative(),
-    succeeded: z7.number().int().nonnegative(),
-    errored: z7.number().int().nonnegative(),
-    canceled: z7.number().int().nonnegative(),
-    expired: z7.number().int().nonnegative()
+import { z as z8 } from "zod";
+var AnthropicMessageBatchResponseSchema = z8.object({
+  id: z8.string(),
+  processing_status: z8.enum(["in_progress", "canceling", "ended"]),
+  request_counts: z8.object({
+    processing: z8.number().int().nonnegative(),
+    succeeded: z8.number().int().nonnegative(),
+    errored: z8.number().int().nonnegative(),
+    canceled: z8.number().int().nonnegative(),
+    expired: z8.number().int().nonnegative()
   }),
-  results_url: z7.string().nullable(),
-  created_at: z7.string(),
-  ended_at: z7.string().nullable()
+  results_url: z8.string().nullable(),
+  created_at: z8.string(),
+  ended_at: z8.string().nullable()
 });
-var AnthropicBatchContentBlockSchema = z7.discriminatedUnion("type", [
-  z7.object({
-    type: z7.literal("text"),
-    text: z7.string()
+var AnthropicBatchContentBlockSchema = z8.discriminatedUnion("type", [
+  z8.object({
+    type: z8.literal("text"),
+    text: z8.string()
   }),
-  z7.object({
-    type: z7.literal("thinking"),
-    thinking: z7.string().optional(),
-    signature: z7.string().optional()
+  z8.object({
+    type: z8.literal("thinking"),
+    thinking: z8.string().optional(),
+    signature: z8.string().optional()
   }),
-  z7.object({
-    type: z7.literal("redacted_thinking"),
-    data: z7.string().optional()
+  z8.object({
+    type: z8.literal("redacted_thinking"),
+    data: z8.string().optional()
   })
 ]);
-var AnthropicBatchResultLineSchema = z7.object({
-  custom_id: z7.string(),
-  result: z7.discriminatedUnion("type", [
-    z7.object({
-      type: z7.literal("succeeded"),
-      message: z7.object({
-        content: z7.array(AnthropicBatchContentBlockSchema),
+var AnthropicBatchResultLineSchema = z8.object({
+  custom_id: z8.string(),
+  result: z8.discriminatedUnion("type", [
+    z8.object({
+      type: z8.literal("succeeded"),
+      message: z8.object({
+        content: z8.array(AnthropicBatchContentBlockSchema),
         usage: AnthropicUsageSchema
       })
     }),
-    z7.object({
-      type: z7.literal("errored"),
-      error: z7.object({
-        type: z7.string(),
-        message: z7.string()
+    z8.object({
+      type: z8.literal("errored"),
+      error: z8.object({
+        type: z8.string(),
+        message: z8.string()
       })
     }),
-    z7.object({ type: z7.literal("canceled") }),
-    z7.object({ type: z7.literal("expired") })
+    z8.object({ type: z8.literal("canceled") }),
+    z8.object({ type: z8.literal("expired") })
   ])
 });
 function mapAnthropicMessageBatchResponseToMessageBatch(response) {
@@ -2075,8 +2435,8 @@ async function parseAnthropicMessageBatchHttpResponse(response) {
 async function listAnthropicMessageBatchResults(clientContext, batchId) {
   const batch = await fetchAnthropicMessageBatch(clientContext, batchId);
   if (batch.resultsUrl === null) {
-    throw new AppError14({
-      code: AppErrorCode13.Conflict,
+    throw new AppError15({
+      code: AppErrorCode14.Conflict,
       message: `Anthropic message batch ${batchId} has no results because processing has not ended`,
       statusCode: 409,
       details: { batchId, processingStatus: batch.processingStatus }
@@ -2137,16 +2497,760 @@ async function waitForAnthropicMessageBatchCompletion(clientContext, batchId, wa
   return batch;
 }
 function buildAnthropicBatchTimeoutError(batchId, timeoutMs) {
-  return new AppError14({
-    code: AppErrorCode13.ServiceUnavailable,
+  return new AppError15({
+    code: AppErrorCode14.ServiceUnavailable,
     message: `Anthropic message batch ${batchId} did not complete within ${String(timeoutMs)}ms`,
     statusCode: 504,
     details: { batchId, timeoutMs }
   });
 }
+
+// src/azure-openai-adapter.ts
+import { AppErrorCode as AppErrorCode16 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError17 } from "@assemble-dev/shared-utils/errors";
+
+// src/azure-openai-response-parsing.ts
+import { z as z9 } from "zod";
+import { AppErrorCode as AppErrorCode15 } from "@assemble-dev/shared-types/errors";
+import { JsonValueSchema as JsonValueSchema8 } from "@assemble-dev/shared-types/json";
+import { AppError as AppError16 } from "@assemble-dev/shared-utils/errors";
+var AzureOpenAiUsageSchema = z9.object({
+  prompt_tokens: z9.number().int().nonnegative(),
+  completion_tokens: z9.number().int().nonnegative(),
+  total_tokens: z9.number().int().nonnegative()
+});
+var AzureOpenAiResponseToolCallSchema = z9.object({
+  id: z9.string(),
+  function: z9.object({
+    name: z9.string(),
+    arguments: z9.string()
+  })
+});
+var AzureOpenAiChatCompletionResponseSchema = z9.object({
+  choices: z9.array(
+    z9.object({
+      message: z9.object({
+        content: z9.string().nullable(),
+        tool_calls: z9.array(AzureOpenAiResponseToolCallSchema).optional()
+      }),
+      finish_reason: z9.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 JsonValueSchema8.parse(JSON.parse(argumentsJsonText));
+  } catch (error) {
+    throw new AppError16({
+      code: AppErrorCode15.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 AppError16({
+      code: AppErrorCode15.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
+import { z as z10 } from "zod";
+var AzureOpenAiStreamToolCallDeltaSchema = z10.object({
+  index: z10.number().int().nonnegative(),
+  id: z10.string().optional(),
+  function: z10.object({
+    name: z10.string().optional(),
+    arguments: z10.string().optional()
+  }).optional()
+});
+var AzureOpenAiStreamChunkSchema = z10.object({
+  choices: z10.array(
+    z10.object({
+      delta: z10.object({
+        content: z10.string().nullable().optional(),
+        tool_calls: z10.array(AzureOpenAiStreamToolCallDeltaSchema).optional()
+      }).optional(),
+      finish_reason: z10.string().nullable().optional()
+    })
+  ).optional(),
+  usage: AzureOpenAiUsageSchema.nullable().optional()
+});
+async function* streamAzureOpenAiChatCompletion(input) {
+  const startedAt = Date.now();
+  const response = await establishAzureOpenAiStreamResponse(input);
+  if (response.body === null) {
+    throw buildProviderInvalidResponseError("Azure OpenAI", "stream body");
+  }
+  yield* parseAzureOpenAiStreamEvents(
+    response.body,
+    startedAt,
+    input.abortSignal
+  );
+}
+async function establishAzureOpenAiStreamResponse(input) {
+  return await executeProviderCallWithRetry(input.retry, async () => {
+    const response = await executeAbortableProviderFetch(
+      "Azure OpenAI",
+      async () => await input.fetchImplementation(input.url, {
+        method: "POST",
+        headers: input.headers,
+        body: JSON.stringify(input.body),
+        signal: input.abortSignal
+      })
+    );
+    if (!response.ok) {
+      throw buildProviderStatusError("Azure OpenAI", response.status);
+    }
+    return response;
+  });
+}
+async function* parseAzureOpenAiStreamEvents(body, startedAt, abortSignal) {
+  const accumulator = createAzureOpenAiStreamAccumulator();
+  for await (const dataText of readServerSentEventDataLines2(body, abortSignal)) {
+    if (dataText === "[DONE]") {
+      yield {
+        type: "completed",
+        result: buildAzureOpenAiStreamResult(
+          accumulator,
+          Date.now() - startedAt
+        )
+      };
+      return;
+    }
+    const parsedChunk = AzureOpenAiStreamChunkSchema.safeParse(
+      JSON.parse(dataText)
+    );
+    if (!parsedChunk.success) {
+      continue;
+    }
+    yield* applyAzureOpenAiStreamChunk(parsedChunk.data, accumulator);
+  }
+  throw buildProviderInvalidResponseError("Azure OpenAI", "stream termination");
+}
+async function* readServerSentEventDataLines2(body, abortSignal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let bufferedText = "";
+  try {
+    for (; ; ) {
+      if (abortSignal?.aborted === true) {
+        await reader.cancel();
+        throw buildProviderCanceledError("Azure OpenAI");
+      }
+      const readResult = await reader.read();
+      if (readResult.done) {
+        return;
+      }
+      bufferedText += decoder.decode(readResult.value, { stream: true });
+      const lines = bufferedText.split("\n");
+      bufferedText = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line.startsWith("data:")) {
+          const dataText = line.slice("data:".length).trim();
+          if (dataText.length > 0) {
+            yield dataText;
+          }
+        }
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error && isAbortError(error)) {
+      throw buildProviderCanceledError("Azure OpenAI");
+    }
+    throw error;
+  }
+}
+function createAzureOpenAiStreamAccumulator() {
+  return {
+    contentText: "",
+    toolCallsByIndex: /* @__PURE__ */ new Map()
+  };
+}
+function* applyAzureOpenAiStreamChunk(chunk, accumulator) {
+  if (chunk.usage !== null && chunk.usage !== void 0) {
+    accumulator.usage = chunk.usage;
+  }
+  const choice = chunk.choices?.[0];
+  if (choice === void 0) {
+    return;
+  }
+  if (choice.finish_reason !== null && choice.finish_reason !== void 0) {
+    accumulator.finishReason = choice.finish_reason;
+  }
+  if (choice.delta === void 0) {
+    return;
+  }
+  const contentDelta = choice.delta.content;
+  if (contentDelta !== null && contentDelta !== void 0 && contentDelta.length > 0) {
+    accumulator.contentText += contentDelta;
+    yield { type: "text_delta", text: contentDelta };
+  }
+  for (const toolCallDelta of choice.delta.tool_calls ?? []) {
+    yield* applyAzureOpenAiToolCallDelta(toolCallDelta, accumulator);
+  }
+}
+function* applyAzureOpenAiToolCallDelta(toolCallDelta, accumulator) {
+  const existingToolCall = accumulator.toolCallsByIndex.get(toolCallDelta.index);
+  if (existingToolCall === void 0) {
+    yield* startAzureOpenAiToolCallAccumulation(toolCallDelta, accumulator);
+    return;
+  }
+  const argumentsDelta = toolCallDelta.function?.arguments;
+  if (argumentsDelta !== void 0 && argumentsDelta.length > 0) {
+    existingToolCall.argumentsJsonText += argumentsDelta;
+    yield {
+      type: "tool_call_input_delta",
+      id: existingToolCall.id,
+      inputJsonText: argumentsDelta
+    };
+  }
+}
+function* startAzureOpenAiToolCallAccumulation(toolCallDelta, accumulator) {
+  const toolName = toolCallDelta.function?.name;
+  if (toolCallDelta.id === void 0 || toolName === void 0) {
+    throw buildProviderInvalidResponseError(
+      "Azure OpenAI",
+      "stream tool call start"
+    );
+  }
+  const startedToolCall = {
+    id: toolCallDelta.id,
+    toolName,
+    argumentsJsonText: toolCallDelta.function?.arguments ?? ""
+  };
+  accumulator.toolCallsByIndex.set(toolCallDelta.index, startedToolCall);
+  yield {
+    type: "tool_call_started",
+    id: startedToolCall.id,
+    toolName: startedToolCall.toolName
+  };
+  if (startedToolCall.argumentsJsonText.length > 0) {
+    yield {
+      type: "tool_call_input_delta",
+      id: startedToolCall.id,
+      inputJsonText: startedToolCall.argumentsJsonText
+    };
+  }
+}
+function buildAzureOpenAiStreamResult(accumulator, latencyMs) {
+  const result = {
+    content: accumulator.contentText,
+    tokenUsage: mapAzureOpenAiUsageToTokenUsage(
+      accumulator.usage ?? {
+        prompt_tokens: 0,
+        completion_tokens: 0,
+        total_tokens: 0
+      }
+    ),
+    latencyMs
+  };
+  const toolCalls = [...accumulator.toolCallsByIndex.values()].map(
+    mapAccumulatedToolCallToModelToolCall2
+  );
+  if (toolCalls.length > 0) {
+    result.toolCalls = toolCalls;
+  }
+  if (accumulator.finishReason !== void 0) {
+    result.stopReason = normalizeAzureOpenAiFinishReason(
+      accumulator.finishReason
+    );
+  }
+  return result;
+}
+function mapAccumulatedToolCallToModelToolCall2(toolCallAccumulation) {
+  return {
+    id: toolCallAccumulation.id,
+    toolName: toolCallAccumulation.toolName,
+    input: parseAzureOpenAiToolArgumentsJson(
+      toolCallAccumulation.argumentsJsonText
+    )
+  };
+}
+
+// src/azure-openai-adapter.ts
+var defaultAzureOpenAiApiVersion = "2024-10-21";
+var azureDeploymentModelPlaceholder = "azure-deployment";
+function azureOpenai(options) {
+  return {
+    name: `azure-openai:${options.deployment}`,
+    async generateChatCompletion(request) {
+      return await executeAzureOpenAiAdapterCall(options, {
+        messages: request.messages,
+        temperature: request.temperature ?? options.temperature,
+        maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+        tools: request.tools,
+        toolChoice: request.toolChoice,
+        abortSignal: request.abortSignal,
+        extraBody: request.extraBody
+      });
+    },
+    async generateStructuredOutput(request) {
+      const completion = await executeAzureOpenAiAdapterCall(options, {
+        messages: request.messages,
+        temperature: request.temperature ?? options.temperature,
+        maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+        structuredOutputJsonSchema: buildOpenAiStructuredOutputJsonSchema(
+          request.schema
+        ),
+        abortSignal: request.abortSignal
+      });
+      return {
+        value: parseStructuredJsonText(completion.content, request.schema),
+        tokenUsage: completion.tokenUsage,
+        latencyMs: completion.latencyMs
+      };
+    },
+    streamChatCompletion(request) {
+      return streamAzureOpenAiChatCompletion(
+        buildAzureOpenAiStreamInput(options, request)
+      );
+    }
+  };
+}
+function buildAzureOpenAiChatCompletionsUrl(options) {
+  const endpoint = resolveAzureOpenAiEndpoint(options);
+  const apiVersion = options.apiVersion ?? defaultAzureOpenAiApiVersion;
+  return `${endpoint}/openai/deployments/${encodeURIComponent(options.deployment)}/chat/completions?api-version=${encodeURIComponent(apiVersion)}`;
+}
+function resolveAzureOpenAiEndpoint(options) {
+  if (options.baseURL !== void 0 && options.baseURL.length > 0) {
+    return options.baseURL.replace(/\/+$/, "");
+  }
+  if (options.resourceName !== void 0 && options.resourceName.length > 0) {
+    return `https://${options.resourceName}.openai.azure.com`;
+  }
+  throw new AppError17({
+    code: AppErrorCode16.BadRequest,
+    message: "Azure OpenAI endpoint is missing. Pass resourceName or baseURL to azureOpenai().",
+    statusCode: 400
+  });
+}
+function buildAzureOpenAiRequestHeaders(options) {
+  return {
+    "content-type": "application/json",
+    "api-key": resolveProviderApiKey({
+      providerLabel: "Azure OpenAI",
+      adapterFunctionName: "azureOpenai()",
+      baseEnvVarName: "AZURE_OPENAI_API_KEY",
+      apiKey: options.apiKey,
+      apiKeyName: options.apiKeyName
+    })
+  };
+}
+function buildAzureOpenAiChatRequestBody(input) {
+  const requestBody = buildOpenAiRequestBody(
+    azureDeploymentModelPlaceholder,
+    input
+  );
+  const { model: ignoredModel, ...requestBodyWithoutModel } = requestBody;
+  void ignoredModel;
+  return requestBodyWithoutModel;
+}
+async function executeAzureOpenAiAdapterCall(options, input) {
+  return await executeProviderCallWithRetry(
+    options.retry,
+    async () => await requestAzureOpenAiChatCompletion(options, input)
+  );
+}
+async function requestAzureOpenAiChatCompletion(options, input) {
+  const fetchImplementation = options.fetchImplementation ?? fetch;
+  const requestBody = mergeProviderRequestExtraBody(
+    buildAzureOpenAiChatRequestBody(input),
+    options.extraBody,
+    input.extraBody
+  );
+  const startedAt = Date.now();
+  const response = await executeAbortableProviderFetch(
+    "Azure OpenAI",
+    async () => await fetchImplementation(buildAzureOpenAiChatCompletionsUrl(options), {
+      method: "POST",
+      headers: buildAzureOpenAiRequestHeaders(options),
+      body: JSON.stringify(requestBody),
+      signal: input.abortSignal
+    })
+  );
+  const latencyMs = Date.now() - startedAt;
+  if (!response.ok) {
+    throw buildProviderStatusError("Azure OpenAI", response.status);
+  }
+  const parseResult = AzureOpenAiChatCompletionResponseSchema.safeParse(
+    await response.json()
+  );
+  if (!parseResult.success) {
+    throw buildProviderInvalidResponseError("Azure OpenAI", "chat completion");
+  }
+  return mapAzureOpenAiResponseToChatCompletionResult(
+    parseResult.data,
+    latencyMs
+  );
+}
+function buildAzureOpenAiStreamInput(options, request) {
+  const requestBody = mergeProviderRequestExtraBody(
+    buildAzureOpenAiChatRequestBody({
+      messages: request.messages,
+      temperature: request.temperature ?? options.temperature,
+      maxOutputTokens: request.maxOutputTokens ?? options.maxOutputTokens,
+      tools: request.tools,
+      toolChoice: request.toolChoice,
+      abortSignal: request.abortSignal,
+      extraBody: request.extraBody
+    }),
+    options.extraBody,
+    request.extraBody
+  );
+  return {
+    url: buildAzureOpenAiChatCompletionsUrl(options),
+    headers: buildAzureOpenAiRequestHeaders(options),
+    body: {
+      ...requestBody,
+      stream: true,
+      stream_options: { include_usage: true }
+    },
+    fetchImplementation: options.fetchImplementation ?? fetch,
+    retry: options.retry,
+    abortSignal: request.abortSignal
+  };
+}
+
+// src/bedrock-adapter.ts
+import { z as z11 } from "zod";
+import { AppErrorCode as AppErrorCode17 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError18 } from "@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 = z11.object({
+  AWS_ACCESS_KEY_ID: z11.string().optional(),
+  AWS_SECRET_ACCESS_KEY: z11.string().optional(),
+  AWS_SESSION_TOKEN: z11.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 AppError18({
+      code: AppErrorCode17.Unauthorized,
+      message: "AWS credentials are missing. Pass credentials to bedrock() or set the AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables.",
+      statusCode: 401
+    });
+  }
+  const credentials = { accessKeyId, secretAccessKey };
+  const sessionToken = parsedEnv.AWS_SESSION_TOKEN;
+  if (sessionToken !== void 0 && sessionToken.length > 0) {
+    credentials.sessionToken = sessionToken;
+  }
+  return credentials;
+}
+async function executeBedrockAdapterCall(options, input) {
+  return await executeProviderCallWithRetry(
+    options.retry,
+    async () => await requestBedrockInvokeModel(options, input)
+  );
+}
+async function requestBedrockInvokeModel(options, input) {
+  const credentials = resolveBedrockCredentials(options);
+  const fetchImplementation = options.fetchImplementation ?? fetch;
+  const requestBody = mergeProviderRequestExtraBody(
+    buildBedrockInvokeModelRequestBody(input),
+    options.extraBody,
+    input.extraBody
+  );
+  const bodyText = JSON.stringify(requestBody);
+  const url = new URL(buildBedrockInvokeModelUrl(options.region, options.modelId));
+  const signedHeaders = await signAwsRequestWithSigV4({
+    method: "POST",
+    url,
+    headers: { "content-type": "application/json" },
+    bodyText,
+    region: options.region,
+    service: bedrockSigningServiceName,
+    credentials
+  });
+  const startedAt = Date.now();
+  const response = await executeAbortableProviderFetch(
+    "Bedrock",
+    async () => await fetchImplementation(url.toString(), {
+      method: "POST",
+      headers: signedHeaders,
+      body: bodyText,
+      signal: input.abortSignal
+    })
+  );
+  const latencyMs = Date.now() - startedAt;
+  if (!response.ok) {
+    throw buildProviderStatusError("Bedrock", response.status);
+  }
+  const parseResult = AnthropicMessagesResponseSchema.safeParse(
+    await response.json()
+  );
+  if (!parseResult.success) {
+    throw buildProviderInvalidResponseError("Bedrock", "invoke model");
+  }
+  return mapAnthropicResponseToChatCompletionResult(parseResult.data, latencyMs);
+}
+function buildBedrockInvokeModelRequestBody(input) {
+  const anthropicRequestBody = buildAnthropicRequestBody(
+    {
+      model: bedrockModelPlaceholder,
+      defaultMaxOutputTokens: defaultBedrockMaxOutputTokens
+    },
+    input
+  );
+  const {
+    model: ignoredModel,
+    stream: ignoredStream,
+    ...requestBodyWithoutModel
+  } = anthropicRequestBody;
+  void ignoredModel;
+  void ignoredStream;
+  return {
+    ...requestBodyWithoutModel,
+    anthropic_version: bedrockAnthropicVersion
+  };
+}
+function buildBedrockStructuredOutputSystemMessage(schema) {
+  return {
+    role: "system",
+    content: `Respond with a single JSON object that satisfies the following JSON Schema. Output only valid JSON with no surrounding text.
+
+JSON Schema:
+${JSON.stringify(convertZodSchemaToJsonSchema(schema))}`
+  };
+}
 export {
   AnthropicMessagesResponseSchema,
   AnthropicStreamEventSchema,
+  AzureOpenAiChatCompletionResponseSchema,
   ChatMessageCacheControlSchema,
   ChatMessageRoleSchema,
   ChatMessageSchema,
@@ -2157,16 +3261,30 @@ export {
   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,
@@ -2177,6 +3295,7 @@ export {
   executeProviderCallWithModelFallback,
   executeProviderCallWithRetry,
   extractAnthropicTextContent,
+  extractAnthropicThinkingText,
   extractAnthropicToolCalls,
   extractMessageText,
   gemini,
@@ -2185,6 +3304,8 @@ export {
   joinSystemMessageText,
   mapAnthropicResponseToChatCompletionResult,
   mapAnthropicUsageToTokenUsage,
+  mapAzureOpenAiResponseToChatCompletionResult,
+  mapAzureOpenAiUsageToTokenUsage,
   mapChatMessageToAnthropicRequestMessage,
   mapChatMessageToOpenAiRequestMessage,
   mapModelToolChoiceToAnthropicToolChoice,
@@ -2194,11 +3315,21 @@ export {
   mergeProviderRequestExtraBody,
   mockModel,
   normalizeAnthropicStopReason,
+  normalizeAzureOpenAiFinishReason,
+  openAiStructuredOutputSchemaName,
   openai,
   parseAnthropicBatchStructuredContent,
   parseAnthropicStreamEvents,
   parseAnthropicToolInputJson,
+  parseAzureOpenAiStreamEvents,
+  parseAzureOpenAiToolArgumentsJson,
   resolveAnthropicPromptCachingSettings,
+  resolveBedrockCredentials,
   resolveProviderApiKey,
-  streamAnthropicChatCompletion
+  sanitizeJsonSchemaForAnthropicStructuredOutput,
+  sanitizeJsonSchemaForGeminiResponseSchema,
+  sanitizeJsonSchemaForOpenAiStructuredOutput,
+  signAwsRequestWithSigV4,
+  streamAnthropicChatCompletion,
+  streamAzureOpenAiChatCompletion
 };