@zhivex-ai/harness 1.4.0 → 1.4.1

package/dist/{cli-entry-20w6nh0k.js → cli-entry-hdtfef27.js}

@@ -1,6 +1,6 @@
 // src/providers/reasoning.ts
 import { z as z3 } from "zod";
-import { wrapLanguageModel as wrapLanguageModel6 } from "@zhivex-ai/core";
+import { wrapLanguageModel as wrapLanguageModel8 } from "@zhivex-ai/core";
 
 // src/providers/anthropic-continuation.ts
 import { ValidationError, wrapLanguageModel } from "@zhivex-ai/core";
@@ -497,8 +497,293 @@ function providerBody(value) {
   }
 }
 
-// src/providers/qwen-hosted-policy.ts
+// src/providers/azure-openai.ts
+import { createAzureOpenAI } from "@zhivex-ai/azure-openai";
 import { wrapLanguageModel as wrapLanguageModel3 } from "@zhivex-ai/core";
+var API_VERSION = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+var DEPLOYMENT_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+var MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,159}$/;
+function azureOpenAIEndpoint(env) {
+  const value = env.AZURE_OPENAI_ENDPOINT?.trim() ?? "";
+  if (!value)
+    throw new Error("Azure OpenAI requires AZURE_OPENAI_ENDPOINT.");
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("AZURE_OPENAI_ENDPOINT must be an https URL.");
+  }
+  if (url.protocol !== "https:" || url.username || url.password || url.hash || url.search) {
+    throw new Error("AZURE_OPENAI_ENDPOINT must be an https URL without credentials or a query.");
+  }
+  return url.toString().replace(/\/+$/, "");
+}
+function azureOpenAIApiVersion(env) {
+  const value = env.AZURE_OPENAI_API_VERSION?.trim() ?? "";
+  if (!value)
+    return;
+  if (!API_VERSION.test(value))
+    throw new Error("AZURE_OPENAI_API_VERSION is invalid.");
+  return value;
+}
+function azureOpenAIDeployments(env) {
+  const raw = env.AZURE_OPENAI_DEPLOYMENTS?.trim() ?? "";
+  if (!raw)
+    return Object.freeze({});
+  if (raw.length > 8192)
+    throw new Error("AZURE_OPENAI_DEPLOYMENTS is too large.");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error("AZURE_OPENAI_DEPLOYMENTS must be a JSON object.");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("AZURE_OPENAI_DEPLOYMENTS must be a JSON object.");
+  }
+  const entries = Object.entries(parsed);
+  if (entries.length > 32)
+    throw new Error("AZURE_OPENAI_DEPLOYMENTS lists too many deployments.");
+  const deployments = {};
+  for (const [name, value] of entries) {
+    if (!DEPLOYMENT_NAME.test(name))
+      throw new Error("AZURE_OPENAI_DEPLOYMENTS contains an invalid deployment name.");
+    const model = typeof value === "string" ? value : value && typeof value === "object" && !Array.isArray(value) && typeof value.model === "string" ? value.model : "";
+    const normalized = model.trim();
+    if (!MODEL_ID.test(normalized))
+      throw new Error("AZURE_OPENAI_DEPLOYMENTS contains an invalid base model.");
+    deployments[name] = Object.freeze({ model: normalized });
+  }
+  return Object.freeze(deployments);
+}
+function azureOpenAIConfigured(env) {
+  try {
+    azureOpenAIEndpoint(env);
+    azureOpenAIApiVersion(env);
+    azureOpenAIDeployments(env);
+    return Boolean(env.AZURE_OPENAI_API_KEY?.trim());
+  } catch {
+    return false;
+  }
+}
+function createAzureOpenAIModel(model, env) {
+  const endpoint = azureOpenAIEndpoint(env);
+  const apiVersion = azureOpenAIApiVersion(env);
+  const deployments = azureOpenAIDeployments(env);
+  const apiKey = env.AZURE_OPENAI_API_KEY?.trim();
+  if (!apiKey)
+    throw new Error("Missing credentials for azure-openai. Set AZURE_OPENAI_API_KEY in the environment.");
+  const settings = {
+    apiKey,
+    endpoint,
+    ...apiVersion ? { apiVersion } : {},
+    ...Object.keys(deployments).length ? { deployments } : {}
+  };
+  const azure = apiVersion ? createAzureOpenAI(settings) : withoutProcessEnv(["AZURE_OPENAI_API_VERSION"], () => createAzureOpenAI(settings));
+  const deployed = sanitizeAzureModel(azure(model), apiKey);
+  const baseModel = deployments[model]?.model;
+  if (!baseModel || baseModel === model)
+    return deployed;
+  return withBaseModelCapabilities(deployed, azure(baseModel));
+}
+function withoutProcessEnv(names, run) {
+  const saved = new Map;
+  for (const name of names) {
+    saved.set(name, process.env[name]);
+    delete process.env[name];
+  }
+  try {
+    return run();
+  } finally {
+    for (const [name, value] of saved) {
+      if (value === undefined)
+        delete process.env[name];
+      else
+        process.env[name] = value;
+    }
+  }
+}
+function withBaseModelCapabilities(deployed, reference) {
+  return new Proxy(deployed, {
+    get(target, property, receiver) {
+      if (property === "capabilities")
+        return reference.capabilities;
+      const value = Reflect.get(target, property, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+function sanitizeAzureModel(model, secret) {
+  const clean = (error) => {
+    if (error instanceof Error && error.name === "AbortError") {
+      return new DOMException("Azure OpenAI request cancelled.", "AbortError");
+    }
+    const record = error && typeof error === "object" ? error : {};
+    const safe = new Error("Azure OpenAI request failed. Check the endpoint, deployment, and credentials.");
+    if (secret && safe.message.includes(secret))
+      safe.message = safe.message.split(secret).join("[REDACTED]");
+    if (typeof record.status === "number")
+      Object.assign(safe, { status: record.status });
+    if (typeof record.retryable === "boolean")
+      Object.assign(safe, { retryable: record.retryable });
+    return safe;
+  };
+  return wrapLanguageModel3(model, [{
+    name: "harness-azure-openai-sanitized-errors",
+    async wrapGenerate(_context, next) {
+      try {
+        return await next();
+      } catch (error) {
+        throw clean(error);
+      }
+    },
+    async wrapStream(_context, next) {
+      let stream;
+      try {
+        stream = await next();
+      } catch (error) {
+        throw clean(error);
+      }
+      return async function* () {
+        try {
+          for await (const event of stream) {
+            if (event.type === "error")
+              throw clean(event.error);
+            yield event;
+          }
+        } catch (error) {
+          throw clean(error);
+        }
+      }();
+    }
+  }]);
+}
+
+// src/providers/bedrock.ts
+import { createBedrock } from "@zhivex-ai/bedrock";
+import { wrapLanguageModel as wrapLanguageModel4 } from "@zhivex-ai/core";
+var REGION = /^[a-z]{2}(?:-[a-z0-9]+){1,3}$/;
+function bedrockRuntime(env) {
+  const value = env.BEDROCK_RUNTIME?.trim() ?? "";
+  if (!value || value === "converse")
+    return "converse";
+  if (value === "openai")
+    return "openai";
+  throw new Error("BEDROCK_RUNTIME must be converse or openai.");
+}
+function bedrockRegion(env) {
+  const region = env.AWS_REGION?.trim() || env.AWS_DEFAULT_REGION?.trim() || "";
+  if (!REGION.test(region)) {
+    throw new Error("Bedrock requires a valid AWS_REGION or AWS_DEFAULT_REGION.");
+  }
+  return region;
+}
+function bedrockOpenAIBaseURL(env) {
+  const baseURL = env.BEDROCK_OPENAI_BASE_URL?.trim() ?? "";
+  if (!baseURL)
+    throw new Error("Bedrock OpenAI-compatible runtime requires BEDROCK_OPENAI_BASE_URL.");
+  let url;
+  try {
+    url = new URL(baseURL);
+  } catch {
+    throw new Error("BEDROCK_OPENAI_BASE_URL must be an https URL.");
+  }
+  if (url.protocol !== "https:" || url.username || url.password || url.hash) {
+    throw new Error("BEDROCK_OPENAI_BASE_URL must be an https URL without credentials.");
+  }
+  return url.toString().replace(/\/+$/, "");
+}
+function openAIRoute(env) {
+  const apiKey = env.BEDROCK_API_KEY?.trim() || env.AWS_BEARER_TOKEN_BEDROCK?.trim() || "";
+  if (!apiKey) {
+    throw new Error("Bedrock OpenAI-compatible runtime requires BEDROCK_API_KEY or AWS_BEARER_TOKEN_BEDROCK.");
+  }
+  return { apiKey, baseURL: bedrockOpenAIBaseURL(env) };
+}
+function bedrockConfigured(env) {
+  try {
+    if (bedrockRuntime(env) === "openai") {
+      openAIRoute(env);
+      return true;
+    }
+    bedrockRegion(env);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createBedrockModel(model, env) {
+  const runtime = bedrockRuntime(env);
+  if (runtime === "openai") {
+    const route = openAIRoute(env);
+    return sanitizeBedrockModel(createBedrock({
+      runtime: "openai",
+      apiKey: route.apiKey,
+      baseURL: route.baseURL
+    })(model), [route.apiKey]);
+  }
+  const region = bedrockRegion(env);
+  const bearer = env.AWS_BEARER_TOKEN_BEDROCK?.trim();
+  const accessKeyId = env.AWS_ACCESS_KEY_ID?.trim();
+  const secretAccessKey = env.AWS_SECRET_ACCESS_KEY?.trim();
+  const sessionToken = env.AWS_SESSION_TOKEN?.trim();
+  const staticCredentials = !bearer && accessKeyId && secretAccessKey ? { accessKeyId, secretAccessKey, ...sessionToken ? { sessionToken } : {} } : undefined;
+  return sanitizeBedrockModel(createBedrock({
+    region,
+    ...bearer ? { apiKey: bearer } : {},
+    ...staticCredentials ? { credentials: staticCredentials } : {}
+  })(model), [bearer, secretAccessKey, sessionToken].filter((value) => Boolean(value)));
+}
+function sanitizeBedrockModel(model, secrets) {
+  const clean = (error) => {
+    if (error instanceof Error && error.name === "AbortError") {
+      return new DOMException("Bedrock request cancelled.", "AbortError");
+    }
+    const record = error && typeof error === "object" ? error : {};
+    const safe = new Error("Bedrock request failed. Check region, model access, and credentials.");
+    if (typeof record.status === "number")
+      Object.assign(safe, { status: record.status });
+    if (typeof record.retryable === "boolean")
+      Object.assign(safe, { retryable: record.retryable });
+    for (const secret of secrets) {
+      if (secret && safe.message.includes(secret))
+        safe.message = safe.message.split(secret).join("[REDACTED]");
+    }
+    return safe;
+  };
+  return wrapLanguageModel4(model, [{
+    name: "harness-bedrock-sanitized-errors",
+    async wrapGenerate(_context, next) {
+      try {
+        return await next();
+      } catch (error) {
+        throw clean(error);
+      }
+    },
+    async wrapStream(_context, next) {
+      let stream;
+      try {
+        stream = await next();
+      } catch (error) {
+        throw clean(error);
+      }
+      return async function* () {
+        try {
+          for await (const event of stream) {
+            if (event.type === "error")
+              throw clean(event.error);
+            yield event;
+          }
+        } catch (error) {
+          throw clean(error);
+        }
+      }();
+    }
+  }]);
+}
+
+// src/providers/qwen-hosted-policy.ts
+import { wrapLanguageModel as wrapLanguageModel5 } from "@zhivex-ai/core";
 function withQwenHostedPolicy(model) {
   if (model.modelId !== "kimi-k3")
     return model;
@@ -511,7 +796,7 @@ function withQwenHostedPolicy(model) {
     }
     input.providerOptions = { ...options, apiMode: "chat", enable_thinking: true };
   };
-  const wrapped = wrapLanguageModel3(model, [{
+  const wrapped = wrapLanguageModel5(model, [{
     name: "harness-kimi-k3-chat-thinking-v1",
     async wrapGenerate(context, next) {
       prepare(context.input);
@@ -593,7 +878,7 @@ var createMetaContinuationFetch = (fetcher = fetch, backoff = [1000, 2000]) => {
 };
 
 // src/providers/meta-replay.ts
-import { wrapLanguageModel as wrapLanguageModel4 } from "@zhivex-ai/core";
+import { wrapLanguageModel as wrapLanguageModel6 } from "@zhivex-ai/core";
 import { withTimeoutSignal } from "@zhivex-ai/core/provider";
 import { createMeta } from "@zhivex-ai/meta";
 var replayPlan = (messages) => {
@@ -660,7 +945,7 @@ var createMetaReplayModel = (options, modelId) => {
       } }
     };
   };
-  return wrapLanguageModel4(createMeta(options)(modelId), [{
+  return wrapLanguageModel6(createMeta(options)(modelId), [{
     name: "harness-meta-stateless-replay-v1",
     async wrapGenerate({ input }) {
       const prepared = prepare(input);
@@ -752,7 +1037,7 @@ import { z as z2 } from "zod";
 // src/models/catalog.json
 var catalog_default = {
   schemaVersion: 1,
-  revision: "2026-09-29-vertex",
+  revision: "2026-10-15-bedrock-azure",
   providers: [
     {
       id: "openai",
@@ -1517,6 +1802,78 @@ var catalog_default = {
           reason: "Provisional Vertex route; availability depends on project, region and IAM. No live certification."
         }
       ]
+    },
+    {
+      id: "bedrock",
+      defaultModel: "anthropic.claude-haiku-5-5",
+      models: [
+        {
+          id: "anthropic.claude-haiku-5-5",
+          name: "Claude Haiku 5.5 (Bedrock)",
+          group: "primary",
+          order: 0,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: ["chat", "tools"],
+          reason: "Provisional Bedrock Converse route. Account access, region, and live Harness certification are not verified. No prices or context limits are inferred."
+        },
+        {
+          id: "anthropic.claude-sonnet-5-5",
+          name: "Claude Sonnet 5.5 (Bedrock)",
+          group: "other",
+          order: 1,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: ["chat", "tools"],
+          reason: "Provisional Bedrock model id. Availability depends on the account and region. No live certification."
+        },
+        {
+          id: "amazon.nova-2-lite-v1:0",
+          name: "Amazon Nova 2 Lite (Bedrock)",
+          group: "other",
+          order: 2,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: ["chat", "tools"],
+          reason: "Provisional Bedrock model id. Availability depends on the account and region. No live certification."
+        }
+      ]
+    },
+    {
+      id: "azure-openai",
+      defaultModel: "gpt-5.4",
+      models: [
+        {
+          id: "gpt-5.4",
+          name: "GPT-5.4 (Azure OpenAI)",
+          group: "primary",
+          order: 0,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: ["chat", "tools"],
+          reason: "Provisional Azure OpenAI route. Deployment name, API version, and live Harness certification are not verified. No prices are copied from the OpenAI API."
+        },
+        {
+          id: "gpt-5",
+          name: "GPT-5 (Azure OpenAI)",
+          group: "other",
+          order: 1,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: ["chat", "tools"],
+          reason: "Provisional Azure OpenAI model id. Use AZURE_OPENAI_DEPLOYMENTS when the deployment name differs. No live certification."
+        },
+        {
+          id: "gpt-6-astra",
+          name: "GPT-6 Astra (Azure OpenAI)",
+          group: "other",
+          order: 2,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: ["chat", "tools"],
+          reason: "Provisional Azure OpenAI model id. Account rollout and deployment availability are not verified. No live certification."
+        }
+      ]
     }
   ]
 };
@@ -1579,13 +1936,13 @@ var modelCatalogSchema = z2.object({
   schemaVersion: z2.literal(1),
   revision: z2.string().min(1).max(80).regex(/^[a-zA-Z0-9._-]+$/),
   providers: z2.array(z2.object({
-    id: z2.enum(["openai", "qwen", "gemini", "meta", "anthropic", "vertex"]),
+    id: z2.enum(["openai", "qwen", "gemini", "meta", "anthropic", "vertex", "bedrock", "azure-openai"]),
     defaultModel: modelId,
     models: z2.array(catalogModelSchema).min(1).max(500)
-  }).strict()).length(6)
+  }).strict()).length(8)
 }).strict().superRefine((catalog, ctx) => {
   const invalid = (message) => ctx.addIssue({ code: "custom", message });
-  if (new Set(catalog.providers.map((p) => p.id)).size !== 6)
+  if (new Set(catalog.providers.map((p) => p.id)).size !== 8)
     invalid("Duplicate providers");
   for (const provider of catalog.providers) {
     const ids = new Set(provider.models.map((m) => m.id));
@@ -1637,13 +1994,13 @@ function modelDescription(model) {
 // src/providers/providers.ts
 import { createHash } from "node:crypto";
 import {
-  wrapLanguageModel as wrapLanguageModel5
+  wrapLanguageModel as wrapLanguageModel7
 } from "@zhivex-ai/core";
 import { createAnthropic } from "@zhivex-ai/anthropic";
 import { createGemini } from "@zhivex-ai/gemini";
 import { createOpenAI } from "@zhivex-ai/openai";
 import { createQwen } from "@zhivex-ai/qwen";
-var PROVIDERS = ["meta", "qwen", "openai", "gemini", "anthropic", "vertex"];
+var PROVIDERS = ["meta", "qwen", "openai", "gemini", "anthropic", "vertex", "bedrock", "azure-openai"];
 var HARNESS_PROVIDER_CAPABILITIES = [
   "streaming",
   "tool-calling",
@@ -1862,13 +2219,13 @@ var createProviderRegistry = (registrations) => {
       const credentials = Object.freeze(registration.descriptor.credentialNames.map((name) => Object.freeze({ name, present: Boolean(env[name]?.trim()) })));
       return Object.freeze({
         ...registration.descriptor,
-        configured: registration.descriptor.id === "vertex" ? vertexConfigured(env) : credentials.length === 0 || credentials.some((credential) => credential.present),
+        configured: builtinConfigured(registration.descriptor.id, env, credentials),
         credentials,
         configuration: providerConfiguration(registration.diagnostics, env)
       });
     })),
     transportFingerprint: (env = process.env) => {
-      const transport = frozenRegistrations.filter((registration) => (registration.descriptor.id !== "anthropic" || Boolean(env.ANTHROPIC_BASE_URL?.trim())) && (registration.descriptor.id !== "vertex" || VERTEX_ENVIRONMENT.some((name) => Boolean(env[name]?.trim())))).map((registration) => {
+      const transport = frozenRegistrations.filter((registration) => includeTransport(registration.descriptor.id, env)).map((registration) => {
         const names = [
           registration.diagnostics.endpointEnvironmentVariable,
           ...(registration.diagnostics.presence ?? []).map((entry) => entry.environmentVariable),
@@ -1888,6 +2245,27 @@ var createProviderRegistry = (registrations) => {
   });
   return registry;
 };
+var environmentPresent = (env, names) => names.some((name) => Boolean(env[name]?.trim()));
+var builtinConfigured = (id, env, credentials) => {
+  if (id === "vertex")
+    return vertexConfigured(env);
+  if (id === "bedrock")
+    return bedrockConfigured(env);
+  if (id === "azure-openai")
+    return azureOpenAIConfigured(env);
+  return credentials.length === 0 || credentials.some((credential) => credential.present);
+};
+var includeTransport = (id, env) => {
+  if (id === "anthropic")
+    return Boolean(env.ANTHROPIC_BASE_URL?.trim());
+  if (id === "vertex")
+    return environmentPresent(env, VERTEX_ENVIRONMENT);
+  if (id === "bedrock")
+    return bedrockConfigured(env);
+  if (id === "azure-openai")
+    return azureOpenAIConfigured(env);
+  return true;
+};
 var optionalQwenRegion = (value) => {
   if (!value) {
     return;
@@ -1962,12 +2340,12 @@ var normalizeStreamToolCallIds = async function* (model, input, events) {
     };
   }
 };
-var withQwenDurableToolCallIds = (model) => wrapLanguageModel5(model, [{
+var withQwenDurableToolCallIds = (model) => wrapLanguageModel7(model, [{
   name: "harness-qwen-durable-tool-call-ids",
   wrapGenerate: async ({ input }, next) => normalizeGenerateToolCallIds(model, input, await next()),
   wrapStream: async ({ input }, next) => normalizeStreamToolCallIds(model, input, await next())
 }]);
-var withOpenAIToolResultEnvelopes = (model) => wrapLanguageModel5(model, [{
+var withOpenAIToolResultEnvelopes = (model) => wrapLanguageModel7(model, [{
   name: "harness-openai-tool-result-envelopes-v1",
   async wrapGenerate({ input }, next) {
     input.toolResultFormat = "envelope";
@@ -1978,7 +2356,7 @@ var withOpenAIToolResultEnvelopes = (model) => wrapLanguageModel5(model, [{
     return next();
   }
 }]);
-var withMetaResponses = (model) => wrapLanguageModel5(model, [{
+var withMetaResponses = (model) => wrapLanguageModel7(model, [{
   name: "harness-meta-responses-v1",
   async wrapGenerate({ input }, next) {
     input.providerOptions = { ...input.providerOptions, apiMode: "responses" };
@@ -2117,6 +2495,48 @@ var BUILTIN_PROVIDER_REGISTRATIONS = Object.freeze([
         ...baseURL ? { baseURL } : {}
       })(model);
     }
+  },
+  {
+    descriptor: {
+      id: "bedrock",
+      name: "Amazon Bedrock",
+      defaultModel: bundledDefaultModel("bedrock"),
+      credentialNames: ["BEDROCK_API_KEY", "AWS_BEARER_TOKEN_BEDROCK"],
+      capabilities: HARNESS_PROVIDER_CAPABILITIES,
+      support: "provisional"
+    },
+    diagnostics: {
+      endpointEnvironmentVariable: "BEDROCK_OPENAI_BASE_URL",
+      presence: [
+        { key: "region", environmentVariable: "AWS_REGION" },
+        { key: "defaultRegion", environmentVariable: "AWS_DEFAULT_REGION" },
+        { key: "profile", environmentVariable: "AWS_PROFILE" }
+      ],
+      enums: [{
+        key: "runtime",
+        environmentVariable: "BEDROCK_RUNTIME",
+        allowedValues: ["converse", "openai"]
+      }]
+    },
+    factory: ({ model, env }) => createBedrockModel(model, env)
+  },
+  {
+    descriptor: {
+      id: "azure-openai",
+      name: "Azure OpenAI",
+      defaultModel: bundledDefaultModel("azure-openai"),
+      credentialNames: ["AZURE_OPENAI_API_KEY"],
+      capabilities: HARNESS_PROVIDER_CAPABILITIES,
+      support: "provisional"
+    },
+    diagnostics: {
+      endpointEnvironmentVariable: "AZURE_OPENAI_ENDPOINT",
+      presence: [
+        { key: "apiVersion", environmentVariable: "AZURE_OPENAI_API_VERSION" },
+        { key: "deployments", environmentVariable: "AZURE_OPENAI_DEPLOYMENTS" }
+      ]
+    },
+    factory: ({ model, env }) => createAzureOpenAIModel(model, env)
   }
 ]);
 var DEFAULT_PROVIDER_REGISTRY = createProviderRegistry(BUILTIN_PROVIDER_REGISTRATIONS);
@@ -2137,7 +2557,7 @@ function withReasoningEffort(model, value) {
     return model;
   if (!supportedReasoningEfforts(model.capabilities).includes(value))
     throw new Error(`Reasoning effort ${value} is not declared for ${model.provider}/${model.modelId}. Use default or a supported level.`);
-  return wrapLanguageModel6(model, [{
+  return wrapLanguageModel8(model, [{
     name: `harness-reasoning-${value}`,
     async wrapGenerate(context, next) {
       context.input.reasoning = { ...context.input.reasoning, effort: value };
@@ -2676,7 +3096,7 @@ var resolveHarnessConfig = (input = {}, registry = DEFAULT_PROVIDER_REGISTRY) =>
 var createProviderModel = (config, env = process.env, registry = DEFAULT_PROVIDER_REGISTRY) => {
   try {
     const model = registry.createModel(config, env);
-    return registry === DEFAULT_PROVIDER_REGISTRY && ["anthropic", "openai", "gemini", "vertex", "qwen"].includes(config.provider) ? markTaskTransportModel(model) : model;
+    return registry === DEFAULT_PROVIDER_REGISTRY && ["anthropic", "openai", "gemini", "vertex", "qwen", "bedrock", "azure-openai"].includes(config.provider) ? markTaskTransportModel(model) : model;
   } catch (error) {
     throw new HarnessProviderError(`Provider ${config.provider} could not be initialized.`, {
       cause: error,
@@ -2685,4 +3105,4 @@ var createProviderModel = (config, env = process.env, registry = DEFAULT_PROVIDE
   }
 };
 var providerAvailability = (env = process.env, registry = DEFAULT_PROVIDER_REGISTRY) => registry.availability(env);
-export { HARNESS_ERROR_CODES, HARNESS_ERROR_SCHEMA_VERSION, providerStreamDiagnostic, HarnessError, HarnessConfigError, HarnessWorkspaceError, HarnessStateConflictError, HarnessProviderError, HarnessExecutionError, harnessErrorDocument, normalizeHarnessError, vertexRoute, vertexConfigured, modelCatalogSchema, bundledModelCatalog, catalogModels, modelDescription, PROVIDERS, createProviderRegistry, BUILTIN_PROVIDER_REGISTRATIONS, DEFAULT_PROVIDER_REGISTRY, PROVIDER_DESCRIPTORS, reasoningEffortSchema, modelReasoningEfforts, withReasoningEffort, isTaskTransportModel, DEFAULT_ALLOWED_CHECKS, HARNESS_CONFIG_SCHEMA_VERSION, HARNESS_CONFIG_MIGRATABLE_SCHEMA_VERSIONS, HARNESS_STORE_BACKENDS, HARNESS_EXECUTION_BACKENDS, HARNESS_OCI_RUNTIMES, HARNESS_OCI_SHELL_MODES, HARNESS_EXECUTION_POLICY_VERSION, DEFAULT_OCI_EXECUTION, HARNESS_REQUIRED_CAPABILITIES, HARNESS_SUBAGENT_PROFILES, DEFAULT_HARNESS_MAX_STEPS, DEFAULT_HARNESS_BUDGET, DEFAULT_HARNESS_COMPACTION, DEFAULT_SUBAGENT_BUDGET, migrateHarnessConfigInput, defaultHarnessNamespace, parseProvider, providerDescriptor, resolveHarnessConfig, createProviderModel, providerAvailability };
+export { HARNESS_ERROR_CODES, HARNESS_ERROR_SCHEMA_VERSION, providerStreamDiagnostic, HarnessError, HarnessConfigError, HarnessWorkspaceError, HarnessStateConflictError, HarnessProviderError, HarnessExecutionError, harnessErrorDocument, normalizeHarnessError, vertexRoute, vertexConfigured, azureOpenAIEndpoint, azureOpenAIApiVersion, azureOpenAIDeployments, bedrockRuntime, bedrockRegion, bedrockOpenAIBaseURL, bedrockConfigured, modelCatalogSchema, bundledModelCatalog, catalogModels, modelDescription, PROVIDERS, createProviderRegistry, BUILTIN_PROVIDER_REGISTRATIONS, DEFAULT_PROVIDER_REGISTRY, PROVIDER_DESCRIPTORS, reasoningEffortSchema, modelReasoningEfforts, withReasoningEffort, isTaskTransportModel, DEFAULT_ALLOWED_CHECKS, HARNESS_CONFIG_SCHEMA_VERSION, HARNESS_CONFIG_MIGRATABLE_SCHEMA_VERSIONS, HARNESS_STORE_BACKENDS, HARNESS_EXECUTION_BACKENDS, HARNESS_OCI_RUNTIMES, HARNESS_OCI_SHELL_MODES, HARNESS_EXECUTION_POLICY_VERSION, DEFAULT_OCI_EXECUTION, HARNESS_REQUIRED_CAPABILITIES, HARNESS_SUBAGENT_PROFILES, DEFAULT_HARNESS_MAX_STEPS, DEFAULT_HARNESS_BUDGET, DEFAULT_HARNESS_COMPACTION, DEFAULT_SUBAGENT_BUDGET, migrateHarnessConfigInput, defaultHarnessNamespace, parseProvider, providerDescriptor, resolveHarnessConfig, createProviderModel, providerAvailability };