@zhivex-ai/harness 1.2.0 → 1.3.0-rc.7

package/dist/{cli-entry-427869g9.js → cli-entry-d5788aay.js}

@@ -1,9 +1,199 @@
 // src/providers/reasoning.ts
-import { z as z2 } from "zod";
-import { wrapLanguageModel as wrapLanguageModel4 } from "@zhivex-ai/core";
+import { z as z3 } from "zod";
+import { wrapLanguageModel as wrapLanguageModel6 } from "@zhivex-ai/core";
+
+// src/providers/anthropic-continuation.ts
+import { ValidationError, wrapLanguageModel } from "@zhivex-ai/core";
+async function* assembleAnthropicContinuation(events) {
+  let pending;
+  let bytes = 0;
+  const invalid = () => new ValidationError("Invalid or oversized Anthropic signed continuation block.");
+  const flush = function* () {
+    if (!pending)
+      return;
+    if (!pending.signature)
+      throw invalid();
+    yield { type: "provider-data", provider: "anthropic", data: pending };
+    pending = undefined;
+    bytes = 0;
+  };
+  for await (const event of events) {
+    if (event.type === "provider-data" && event.provider === "anthropic" && event.data && typeof event.data === "object" && !Array.isArray(event.data)) {
+      const data = event.data;
+      if (data.type === "thinking_delta" || data.type === "signature_delta") {
+        const field = data.type === "thinking_delta" ? "thinking" : "signature";
+        if (!pending || typeof data[field] !== "string")
+          throw invalid();
+        bytes += Buffer.byteLength(data[field]);
+        if (bytes > 1024 * 1024)
+          throw invalid();
+        pending[field] += data[field];
+        continue;
+      }
+      if (data.type === "thinking") {
+        yield* flush();
+        if (typeof data.thinking !== "string" || typeof data.signature !== "string")
+          throw invalid();
+        pending = { type: "thinking", thinking: data.thinking, signature: data.signature };
+        bytes = Buffer.byteLength(data.thinking) + Buffer.byteLength(data.signature);
+        if (bytes > 1024 * 1024)
+          throw invalid();
+        continue;
+      }
+    }
+    yield* flush();
+    yield event;
+  }
+  yield* flush();
+}
+var withAnthropicContinuation = (model) => wrapLanguageModel(model, [{
+  name: "harness-anthropic-signed-continuation-v1",
+  wrapStream: async (_context, next) => assembleAnthropicContinuation(await next())
+}]);
+
+// src/providers/vertex-auth.ts
+import { GoogleAuth } from "google-auth-library";
+import { createVertex } from "@zhivex-ai/vertex";
+import { wrapLanguageModel as wrapLanguageModel2 } from "@zhivex-ai/core";
+
+// src/runtime/provider-diagnostics.ts
+import { z } from "zod";
+var providerDiagnosticSchema = z.strictObject({
+  reason: z.enum(["previous_response_unavailable", "context_length_exceeded", "authentication", "payment_required", "permission", "rate_limit", "model_unavailable", "invalid_request", "server_error", "unknown"]),
+  parameter: z.enum(["previous_response_id", "input", "messages", "tools", "model", "max_output_tokens", "max_tokens", "temperature", "other", "none"]),
+  bodyState: z.enum(["parsed", "malformed", "too_large", "unavailable", "read_timeout"])
+});
+function providerDiagnostic(body, status) {
+  let reason = status === 401 ? "authentication" : status === 402 ? "payment_required" : status === 403 ? "permission" : status === 429 ? "rate_limit" : status && status >= 500 ? "server_error" : "unknown";
+  let parameter = "none";
+  if (typeof body !== "string")
+    return { reason, parameter, bodyState: "unavailable" };
+  if (Buffer.byteLength(body) > 8192)
+    return { reason, parameter, bodyState: "too_large" };
+  try {
+    const parsed = JSON.parse(body);
+    const detail = parsed?.error ?? parsed;
+    const code = [detail?.code, detail?.status, detail?.type].find((value) => typeof value === "string") ?? "";
+    const message = typeof detail?.message === "string" ? detail.message : "";
+    const param = providerDiagnosticSchema.shape.parameter.safeParse(detail?.param);
+    parameter = param.success ? param.data : detail?.param == null ? "none" : "other";
+    if (/response/i.test(message) && /not found|expired/i.test(message) && (parameter === "previous_response_id" || parameter === "none"))
+      reason = "previous_response_unavailable";
+    else if (["context_length_exceeded", "context_window_exceeded"].includes(code))
+      reason = "context_length_exceeded";
+    else if (["invalid_api_key", "authentication_error", "UNAUTHENTICATED"].includes(code))
+      reason = "authentication";
+    else if (["permission_denied", "permission_error", "PERMISSION_DENIED"].includes(code))
+      reason = "permission";
+    else if (["rate_limit_exceeded", "rate_limit_error", "RESOURCE_EXHAUSTED"].includes(code))
+      reason = "rate_limit";
+    else if (["model_not_found", "model_not_available", "NOT_FOUND"].includes(code))
+      reason = "model_unavailable";
+    else if (["invalid_request_error", "INVALID_ARGUMENT"].includes(code) || status === 400 || status === 422)
+      reason = "invalid_request";
+    return { reason, parameter, bodyState: "parsed" };
+  } catch {
+    return { reason, parameter, bodyState: "malformed" };
+  }
+}
+
+// src/providers/vertex-auth.ts
+var CLOUD_PLATFORM_SCOPE = "https://www.googleapis.com/auth/cloud-platform";
+function vertexRoute(env) {
+  const projectId = (env.GOOGLE_CLOUD_PROJECT ?? "").trim();
+  const location = (env.VERTEX_LOCATION ?? "").trim();
+  if (!/^(?:[a-z][a-z0-9-]{4,61}[a-z0-9]|[0-9]{6,20})$/.test(projectId)) {
+    throw new Error("Vertex requires a valid GOOGLE_CLOUD_PROJECT.");
+  }
+  if (!/^(?:global|us|eu|[a-z]+-[a-z]+[0-9]+)$/.test(location)) {
+    throw new Error("Vertex requires an explicit valid VERTEX_LOCATION.");
+  }
+  return Object.freeze({ projectId, location });
+}
+function vertexConfigured(env) {
+  try {
+    vertexRoute(env);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var VERTEX_ENVIRONMENT = ["GOOGLE_CLOUD_PROJECT", "VERTEX_LOCATION", "GOOGLE_APPLICATION_CREDENTIALS"];
+function vertexTokenSource(env, route, createAuth = (options) => new GoogleAuth(options)) {
+  const keyFilename = env.GOOGLE_APPLICATION_CREDENTIALS?.trim();
+  const auth = createAuth({
+    projectId: route.projectId,
+    scopes: [CLOUD_PLATFORM_SCOPE],
+    ...keyFilename ? { keyFilename } : {}
+  });
+  return async () => {
+    try {
+      const token = await auth.getAccessToken();
+      if (!token)
+        throw new Error("Empty ADC token");
+      return token;
+    } catch {
+      throw new VertexAuthenticationError;
+    }
+  };
+}
+
+class VertexAuthenticationError extends Error {
+  status = 401;
+  retryable = false;
+  constructor() {
+    super("Vertex ADC credentials are unavailable or could not be refreshed. Configure Application Default Credentials and retry.");
+    this.name = "VertexAuthenticationError";
+  }
+}
+function createVertexModel(model, env, createAuth) {
+  const route = vertexRoute(env);
+  const adapter = createVertex({
+    ...route,
+    getAccessToken: vertexTokenSource(env, route, createAuth)
+  })(model);
+  return wrapLanguageModel2(adapter, [{
+    name: "harness-vertex-sanitized-errors",
+    async wrapGenerate(_context, next) {
+      try {
+        return await next();
+      } catch (error) {
+        throw safeVertexError(error);
+      }
+    },
+    async wrapStream(_context, next) {
+      let stream;
+      try {
+        stream = await next();
+      } catch (error) {
+        throw safeVertexError(error);
+      }
+      return async function* () {
+        try {
+          yield* stream;
+        } catch (error) {
+          throw safeVertexError(error);
+        }
+      }();
+    }
+  }]);
+}
+function safeVertexError(error) {
+  if (error instanceof VertexAuthenticationError)
+    return error;
+  const record = error && typeof error === "object" ? error : {};
+  if (record.name === "AbortError")
+    return new DOMException("Vertex request cancelled.", "AbortError");
+  const status = typeof record.status === "number" && Number.isInteger(record.status) && record.status >= 100 && record.status <= 599 ? record.status : undefined;
+  return Object.assign(new Error("Vertex request failed. Check the sanitized provider diagnosis."), {
+    ...status ? { status } : {},
+    provider: providerDiagnostic(record.responseBody ?? record.body, status),
+    retryable: record.retryable === true
+  });
+}
 
 // src/providers/qwen-hosted-policy.ts
-import { wrapLanguageModel } from "@zhivex-ai/core";
+import { wrapLanguageModel as wrapLanguageModel3 } from "@zhivex-ai/core";
 function withQwenHostedPolicy(model) {
   if (model.modelId !== "kimi-k3")
     return model;
@@ -16,7 +206,7 @@ function withQwenHostedPolicy(model) {
     }
     input.providerOptions = { ...options, apiMode: "chat", enable_thinking: true };
   };
-  const wrapped = wrapLanguageModel(model, [{
+  const wrapped = wrapLanguageModel3(model, [{
     name: "harness-kimi-k3-chat-thinking-v1",
     async wrapGenerate(context, next) {
       prepare(context.input);
@@ -98,7 +288,8 @@ var createMetaContinuationFetch = (fetcher = fetch, backoff = [1000, 2000]) => {
 };
 
 // src/providers/meta-replay.ts
-import { wrapLanguageModel as wrapLanguageModel2 } from "@zhivex-ai/core";
+import { wrapLanguageModel as wrapLanguageModel4 } from "@zhivex-ai/core";
+import { withTimeoutSignal } from "@zhivex-ai/core/provider";
 import { createMeta } from "@zhivex-ai/meta";
 var replayPlan = (messages) => {
   let offset = 0;
@@ -164,7 +355,7 @@ var createMetaReplayModel = (options, modelId) => {
       } }
     };
   };
-  return wrapLanguageModel2(createMeta(options)(modelId), [{
+  return wrapLanguageModel4(createMeta(options)(modelId), [{
     name: "harness-meta-stateless-replay-v1",
     async wrapGenerate({ input }) {
       const prepared = prepare(input);
@@ -172,7 +363,54 @@ var createMetaReplayModel = (options, modelId) => {
     },
     async wrapStream({ input }) {
       const prepared = prepare(input);
-      return prepared.model.stream(prepared.input);
+      const lifetime = withTimeoutSignal(prepared.input);
+      const { timeoutMs: _timeout, ...request } = prepared.input;
+      try {
+        const stream = await prepared.model.stream({ ...request, abortSignal: lifetime.signal });
+        const iterator = stream[Symbol.asyncIterator]();
+        const owned = {
+          [Symbol.asyncIterator]() {
+            return owned;
+          },
+          async next() {
+            try {
+              const result = await iterator.next();
+              if (result.done)
+                lifetime.cleanup();
+              return result;
+            } catch (error) {
+              lifetime.cleanup();
+              throw error;
+            }
+          },
+          async return() {
+            try {
+              return await iterator.return?.() ?? { done: true, value: undefined };
+            } finally {
+              lifetime.cleanup();
+            }
+          },
+          async throw(error) {
+            try {
+              if (iterator.throw) {
+                const result = await iterator.throw(error);
+                if (result.done)
+                  lifetime.cleanup();
+                return result;
+              }
+              await iterator.return?.();
+              throw error;
+            } catch (failure) {
+              lifetime.cleanup();
+              throw failure;
+            }
+          }
+        };
+        return owned;
+      } catch (error) {
+        lifetime.cleanup();
+        throw error;
+      }
     }
   }]);
 };
@@ -205,11 +443,11 @@ function annotateMetaRequestError(error) {
 }
 
 // src/models/catalog.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 // src/models/catalog.json
 var catalog_default = {
   schemaVersion: 1,
-  revision: "2026-09-26-frontier",
+  revision: "2026-09-29-vertex",
   providers: [
     {
       id: "openai",
@@ -907,42 +1145,109 @@ var catalog_default = {
           ]
         }
       ]
+    },
+    {
+      id: "anthropic",
+      defaultModel: "claude-sonnet-5",
+      models: [
+        {
+          id: "claude-sonnet-5",
+          name: "claude-sonnet-5",
+          group: "primary",
+          order: 0,
+          lifecycle: "active",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools",
+            "vision"
+          ],
+          reason: "Provisional Anthropic API route. Account access and live Harness certification are not verified."
+        },
+        {
+          id: "claude-haiku-4-5",
+          name: "claude-haiku-4-5",
+          group: "other",
+          order: 1,
+          lifecycle: "active",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools",
+            "vision"
+          ],
+          reason: "Provisional Anthropic API route. Account access and live Harness certification are not verified."
+        },
+        {
+          id: "claude-opus-5-5",
+          name: "claude-opus-5-5",
+          group: "other",
+          order: 2,
+          lifecycle: "active",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools",
+            "vision"
+          ],
+          reason: "Provisional Anthropic API route. Account access and live Harness certification are not verified."
+        }
+      ]
+    },
+    {
+      id: "vertex",
+      defaultModel: "gemini-3.7-flash",
+      models: [
+        {
+          id: "gemini-3.7-flash",
+          name: "Gemini 3.7 Flash (Vertex)",
+          group: "primary",
+          order: 0,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ],
+          reason: "Provisional Vertex route; availability depends on project, region and IAM. No live certification."
+        }
+      ]
     }
   ]
 };
 
 // src/models/catalog.ts
-var modelId = z.string().min(1).max(160).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/-]*$/);
-var text = z.string().min(1).max(300).regex(/^[^\x00-\x1f\x7f-\x9f]*$/);
-var evidence = z.object({
-  sourceUrl: z.url().max(1000).refine((value) => {
+var modelId = z2.string().min(1).max(160).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/-]*$/);
+var text = z2.string().min(1).max(300).regex(/^[^\x00-\x1f\x7f-\x9f]*$/);
+var evidence = z2.object({
+  sourceUrl: z2.url().max(1000).refine((value) => {
     const url = new URL(value);
     return url.protocol === "https:" && !url.username && !url.password;
   }, "Evidence requires an HTTPS URL without credentials"),
-  checkedAt: z.iso.date()
+  checkedAt: z2.iso.date()
 }).strict();
-var tokenLimit = z.number().int().positive().max(1e9);
-var price = z.number().finite().nonnegative().max(1e6);
-var catalogModelSchema = z.object({
+var tokenLimit = z2.number().int().positive().max(1e9);
+var price = z2.number().finite().nonnegative().max(1e6);
+var catalogModelSchema = z2.object({
   id: modelId,
   name: text,
-  group: z.enum(["primary", "other"]),
-  order: z.number().int().min(0),
-  lifecycle: z.enum(["active", "deprecated", "retired", "unknown"]),
-  validation: z.enum(["verified", "unverified"]),
-  capabilities: z.array(z.enum(["chat", "tools", "vision"])).max(3),
+  group: z2.enum(["primary", "other"]),
+  order: z2.number().int().min(0),
+  lifecycle: z2.enum(["active", "deprecated", "retired", "unknown"]),
+  validation: z2.enum(["verified", "unverified"]),
+  capabilities: z2.array(z2.enum(["chat", "tools", "vision"])).max(3),
   reason: text.optional(),
   replacement: modelId.optional(),
-  retirementDate: z.iso.date().optional(),
-  limits: z.object({
+  retirementDate: z2.iso.date().optional(),
+  limits: z2.object({
     contextWindowTokens: tokenLimit,
-    contextWindowType: z.enum(["combined", "input"]),
+    contextWindowType: z2.enum(["combined", "input"]),
     maxOutputTokens: tokenLimit,
     maxInputTokens: tokenLimit.optional(),
     evidence
   }).strict().optional(),
-  pricing: z.object({
-    currency: z.literal("USD"),
+  pricing: z2.object({
+    currency: z2.literal("USD"),
     inputPerMillionTokens: price,
     outputPerMillionTokens: price,
     cachedInputPerMillionTokens: price.optional(),
@@ -950,8 +1255,8 @@ var catalogModelSchema = z.object({
     scope: text,
     evidence
   }).strict().optional(),
-  compaction: z.object({
-    suitability: z.enum(["candidate", "evaluated", "unsuitable", "unknown"]),
+  compaction: z2.object({
+    suitability: z2.enum(["candidate", "evaluated", "unsuitable", "unknown"]),
     reason: text,
     evidence
   }).strict().optional()
@@ -965,17 +1270,17 @@ var catalogModelSchema = z.object({
     ctx.addIssue({ code: "custom", message: "maxOutputTokens exceeds combined context window" });
   }
 });
-var modelCatalogSchema = z.object({
-  schemaVersion: z.literal(1),
-  revision: z.string().min(1).max(80).regex(/^[a-zA-Z0-9._-]+$/),
-  providers: z.array(z.object({
-    id: z.enum(["openai", "qwen", "gemini", "meta"]),
+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"]),
     defaultModel: modelId,
-    models: z.array(catalogModelSchema).min(1).max(500)
-  }).strict()).length(4)
+    models: z2.array(catalogModelSchema).min(1).max(500)
+  }).strict()).length(6)
 }).strict().superRefine((catalog, ctx) => {
   const invalid = (message) => ctx.addIssue({ code: "custom", message });
-  if (new Set(catalog.providers.map((p) => p.id)).size !== 4)
+  if (new Set(catalog.providers.map((p) => p.id)).size !== 6)
     invalid("Duplicate providers");
   for (const provider of catalog.providers) {
     const ids = new Set(provider.models.map((m) => m.id));
@@ -1027,12 +1332,13 @@ function modelDescription(model) {
 // src/providers/providers.ts
 import { createHash } from "node:crypto";
 import {
-  wrapLanguageModel as wrapLanguageModel3
+  wrapLanguageModel as wrapLanguageModel5
 } 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"];
+var PROVIDERS = ["meta", "qwen", "openai", "gemini", "anthropic", "vertex"];
 var HARNESS_PROVIDER_CAPABILITIES = [
   "streaming",
   "tool-calling",
@@ -1251,13 +1557,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: credentials.length === 0 || credentials.some((credential) => credential.present),
+        configured: registration.descriptor.id === "vertex" ? vertexConfigured(env) : credentials.length === 0 || credentials.some((credential) => credential.present),
         credentials,
         configuration: providerConfiguration(registration.diagnostics, env)
       });
     })),
     transportFingerprint: (env = process.env) => {
-      const transport = frozenRegistrations.map((registration) => {
+      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 names = [
           registration.diagnostics.endpointEnvironmentVariable,
           ...(registration.diagnostics.presence ?? []).map((entry) => entry.environmentVariable),
@@ -1351,12 +1657,12 @@ var normalizeStreamToolCallIds = async function* (model, input, events) {
     };
   }
 };
-var withQwenDurableToolCallIds = (model) => wrapLanguageModel3(model, [{
+var withQwenDurableToolCallIds = (model) => wrapLanguageModel5(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) => wrapLanguageModel3(model, [{
+var withOpenAIToolResultEnvelopes = (model) => wrapLanguageModel5(model, [{
   name: "harness-openai-tool-result-envelopes-v1",
   async wrapGenerate({ input }, next) {
     input.toolResultFormat = "envelope";
@@ -1367,7 +1673,7 @@ var withOpenAIToolResultEnvelopes = (model) => wrapLanguageModel3(model, [{
     return next();
   }
 }]);
-var withMetaResponses = (model) => wrapLanguageModel3(model, [{
+var withMetaResponses = (model) => wrapLanguageModel5(model, [{
   name: "harness-meta-responses-v1",
   async wrapGenerate({ input }, next) {
     input.providerOptions = { ...input.providerOptions, apiMode: "responses" };
@@ -1387,6 +1693,41 @@ var withMetaResponses = (model) => wrapLanguageModel3(model, [{
   }
 }]);
 var BUILTIN_PROVIDER_REGISTRATIONS = Object.freeze([
+  {
+    descriptor: {
+      id: "vertex",
+      name: "Google Cloud Vertex AI",
+      defaultModel: bundledDefaultModel("vertex"),
+      credentialNames: [],
+      capabilities: HARNESS_PROVIDER_CAPABILITIES,
+      support: "provisional"
+    },
+    diagnostics: { presence: [
+      { key: "project", environmentVariable: "GOOGLE_CLOUD_PROJECT" },
+      { key: "location", environmentVariable: "VERTEX_LOCATION" },
+      { key: "adcFile", environmentVariable: "GOOGLE_APPLICATION_CREDENTIALS" }
+    ] },
+    factory: ({ model, env }) => createVertexModel(model, env)
+  },
+  {
+    descriptor: {
+      id: "anthropic",
+      name: "Anthropic",
+      defaultModel: bundledDefaultModel("anthropic"),
+      credentialNames: ["ANTHROPIC_API_KEY"],
+      capabilities: HARNESS_PROVIDER_CAPABILITIES,
+      support: "provisional"
+    },
+    diagnostics: { endpointEnvironmentVariable: "ANTHROPIC_BASE_URL" },
+    factory: ({ model, env, credentials }) => {
+      const baseURL = env.ANTHROPIC_BASE_URL?.trim();
+      return withAnthropicContinuation(createAnthropic({
+        apiKey: credentials.require(),
+        baseURL: baseURL || "https://api.anthropic.com/v1",
+        workspaceId: null
+      })(model));
+    }
+  },
   {
     descriptor: {
       id: "meta",
@@ -1477,7 +1818,7 @@ var DEFAULT_PROVIDER_REGISTRY = createProviderRegistry(BUILTIN_PROVIDER_REGISTRA
 var PROVIDER_DESCRIPTORS = DEFAULT_PROVIDER_REGISTRY.descriptors;
 
 // src/providers/reasoning.ts
-var reasoningEffortSchema = z2.enum(["default", "none", "minimal", "low", "medium", "high", "xhigh", "max"]);
+var reasoningEffortSchema = z3.enum(["default", "none", "minimal", "low", "medium", "high", "xhigh", "max"]);
 var supportedReasoningEfforts = (capabilities) => ["default", ...capabilities.reasoning ? capabilities.reasoningEfforts ?? [] : []];
 function modelReasoningEfforts(provider, model) {
   if (!DEFAULT_PROVIDER_REGISTRY.has(provider))
@@ -1491,7 +1832,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 wrapLanguageModel4(model, [{
+  return wrapLanguageModel6(model, [{
     name: `harness-reasoning-${value}`,
     async wrapGenerate(context, next) {
       context.input.reasoning = { ...context.input.reasoning, effort: value };
@@ -2006,4 +2347,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, HarnessError, HarnessConfigError, HarnessWorkspaceError, HarnessStateConflictError, HarnessProviderError, HarnessExecutionError, harnessErrorDocument, normalizeHarnessError, modelCatalogSchema, bundledModelCatalog, catalogModels, modelDescription, PROVIDERS, createProviderRegistry, BUILTIN_PROVIDER_REGISTRATIONS, DEFAULT_PROVIDER_REGISTRY, PROVIDER_DESCRIPTORS, reasoningEffortSchema, modelReasoningEfforts, withReasoningEffort, 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, 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, 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 };