@zhivex-ai/harness 1.4.0-rc.6 → 1.4.0

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

@@ -87,6 +87,8 @@ function providerDiagnostic(body, status) {
       reason = "permission";
     else if (["rate_limit_exceeded", "rate_limit_error", "RESOURCE_EXHAUSTED"].includes(code))
       reason = "rate_limit";
+    else if (["UNAVAILABLE", "DEADLINE_EXCEEDED", "ABORTED", "INTERNAL"].includes(code))
+      reason = "server_error";
     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)
@@ -97,6 +99,201 @@ function providerDiagnostic(body, status) {
   }
 }
 
+// src/runtime/provider-transient.ts
+var PROVIDER_STATUS_CATEGORIES = [
+  "ABORTED",
+  "RESOURCE_EXHAUSTED",
+  "UNAVAILABLE",
+  "DEADLINE_EXCEEDED",
+  "INTERNAL",
+  "STREAM_RESET"
+];
+var VERTEX_TRANSIENT_ATTEMPTS = 3;
+var TRANSIENT_HTTP = {
+  408: "DEADLINE_EXCEEDED",
+  409: "ABORTED",
+  425: "UNAVAILABLE",
+  429: "RESOURCE_EXHAUSTED",
+  500: "INTERNAL",
+  502: "UNAVAILABLE",
+  503: "UNAVAILABLE",
+  504: "DEADLINE_EXCEEDED"
+};
+var TRANSIENT_GRPC = {
+  4: "DEADLINE_EXCEEDED",
+  8: "RESOURCE_EXHAUSTED",
+  10: "ABORTED",
+  13: "INTERNAL",
+  14: "UNAVAILABLE"
+};
+var CATEGORY_HTTP = {
+  ABORTED: 409,
+  RESOURCE_EXHAUSTED: 429,
+  UNAVAILABLE: 503,
+  DEADLINE_EXCEEDED: 504,
+  INTERNAL: 500,
+  STREAM_RESET: undefined
+};
+var SYMBOLIC = new Set(["ABORTED", "RESOURCE_EXHAUSTED", "UNAVAILABLE", "DEADLINE_EXCEEDED", "INTERNAL"]);
+var STREAM_RESET_CODES = new Set(["ECONNRESET", "ECONNABORTED", "EPIPE", "ETIMEDOUT", "UND_ERR_SOCKET", "ERR_STREAM_PREMATURE_CLOSE"]);
+var HTTP_IN_MESSAGE = /(?:^|[^\d])(408|409|425|429|500|502|503|504)(?=$|[^\d])/;
+var STREAM_RESET_MESSAGE = /stream reset|RST_STREAM|ECONNRESET|socket hang up|ERR_STREAM_PREMATURE_CLOSE|UND_ERR_SOCKET/i;
+var isProviderStatus = (value) => typeof value === "string" && PROVIDER_STATUS_CATEGORIES.includes(value);
+var httpStatusValue = (value) => typeof value === "number" && Number.isInteger(value) && value >= 100 && value <= 599 ? value : undefined;
+var definitiveClientStatus = (status) => status !== undefined && status >= 400 && status < 500 && TRANSIENT_HTTP[status] === undefined;
+function readProviderFailureRecord(record, depth = 0) {
+  let retryable = false;
+  let clientError = false;
+  let httpStatus;
+  let providerStatus;
+  const noteHttp = (status) => {
+    if (status === undefined)
+      return;
+    httpStatus ??= status;
+    const category = TRANSIENT_HTTP[status];
+    if (category) {
+      retryable = true;
+      providerStatus ??= category;
+    } else if (status >= 400 && status < 500)
+      clientError = true;
+  };
+  const noteCategory = (category) => {
+    if (!category || clientError)
+      return;
+    retryable = true;
+    providerStatus ??= category;
+    if (httpStatus === undefined)
+      httpStatus = CATEGORY_HTTP[category];
+  };
+  const absorb = (value) => {
+    if (depth >= 2 || !value || typeof value !== "object" || value === record)
+      return;
+    const signals = readProviderFailureRecord(value, depth + 1);
+    noteHttp(signals.httpStatus);
+    noteCategory(signals.providerStatus);
+  };
+  noteHttp(httpStatusValue(record.status) ?? httpStatusValue(record.statusCode) ?? httpStatusValue(record.httpStatusCode));
+  if (typeof record.status === "string" && /^\d{3}$/.test(record.status))
+    noteHttp(Number(record.status));
+  if (typeof record.code === "number" && record.code >= 100 && record.code <= 599)
+    noteHttp(record.code);
+  if (typeof record.code === "number" && record.code >= 0 && record.code <= 16)
+    noteCategory(TRANSIENT_GRPC[record.code]);
+  if (typeof record.code === "string") {
+    if (STREAM_RESET_CODES.has(record.code))
+      noteCategory("STREAM_RESET");
+    else if (SYMBOLIC.has(record.code))
+      noteCategory(record.code);
+  }
+  if (typeof record.status === "string" && SYMBOLIC.has(record.status))
+    noteCategory(record.status);
+  if (isProviderStatus(record.providerStatus))
+    noteCategory(record.providerStatus);
+  if (record.diagnosticCode === "VERTEX_STREAM_TOOL_TRUNCATED" || record.reason === "stream_truncated")
+    noteCategory("STREAM_RESET");
+  if (record.code === "PROVIDER_UNAVAILABLE" && record.retryable === true)
+    retryable = true;
+  const body = record.responseBody ?? record.body;
+  if (!clientError) {
+    if (typeof body === "string")
+      noteCategory(categoryFromBody(body));
+    else
+      absorb(body);
+    absorb(record.error);
+  }
+  if (!retryable && !clientError && typeof record.message === "string") {
+    const match = record.message.match(HTTP_IN_MESSAGE);
+    if (match?.[1])
+      noteHttp(Number(match[1]));
+    else if (STREAM_RESET_MESSAGE.test(record.message))
+      noteCategory("STREAM_RESET");
+  }
+  if (httpStatus !== undefined && definitiveClientStatus(httpStatus))
+    return { retryable: false, httpStatus };
+  return { retryable, ...httpStatus !== undefined ? { httpStatus } : {}, ...providerStatus ? { providerStatus } : {} };
+}
+function categoryFromBody(body) {
+  if (Buffer.byteLength(body) > 8192)
+    return;
+  try {
+    const parsed = JSON.parse(body);
+    if (!parsed || typeof parsed !== "object")
+      return;
+    const detail = parsed.error;
+    const source = detail && typeof detail === "object" ? detail : parsed;
+    return readProviderFailureRecord(source).providerStatus;
+  } catch {
+    return;
+  }
+}
+function classifyProviderFailure(error) {
+  if (error && typeof error === "object") {
+    const top = readProviderFailureRecord(error);
+    if (top.httpStatus !== undefined && definitiveClientStatus(top.httpStatus))
+      return { retryable: false, httpStatus: top.httpStatus };
+  }
+  const seen = new Set;
+  let retryable = false;
+  let httpStatus;
+  let providerStatus;
+  const visit = (current, depth) => {
+    if (!current || typeof current !== "object" || depth > 5 || seen.has(current))
+      return;
+    seen.add(current);
+    const record = current;
+    const signals = readProviderFailureRecord(record);
+    httpStatus ??= signals.httpStatus;
+    providerStatus ??= signals.providerStatus;
+    if (httpStatus !== undefined && providerStatus === undefined)
+      providerStatus = TRANSIENT_HTTP[httpStatus];
+    if (record.retryable === false)
+      return;
+    if (signals.retryable)
+      retryable = true;
+    visit(record.cause, depth + 1);
+    if (record.error && typeof record.error === "object")
+      visit(record.error, depth + 1);
+    if (record.details && typeof record.details === "object")
+      visit(record.details, depth + 1);
+    if (Array.isArray(record.chain))
+      for (const entry of record.chain)
+        visit(entry, depth + 1);
+  };
+  visit(error, 0);
+  if (retryable && httpStatus === undefined && providerStatus)
+    httpStatus = CATEGORY_HTTP[providerStatus];
+  return { retryable, ...httpStatus !== undefined ? { httpStatus } : {}, ...providerStatus ? { providerStatus } : {} };
+}
+function isRetryableProviderFailure(error) {
+  return classifyProviderFailure(error).retryable;
+}
+function transientBackoffMs(attempt, baseMs = 250) {
+  const exponential = Math.min(baseMs * 2 ** Math.max(0, attempt), 1e4);
+  return exponential + Math.floor(Math.random() * exponential);
+}
+var thoughtOnlyText = (text) => {
+  try {
+    const parsed = JSON.parse(text);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return false;
+    const record = parsed;
+    return record.thought === true && Object.keys(record).every((key) => key === "thought" || key === "thoughtSignature");
+  } catch {
+    return false;
+  }
+};
+function isEmptyModelTurn(result) {
+  if (result.finishReason === "content-filter" || result.finishReason === "error")
+    return false;
+  if ((result.images?.length ?? 0) > 0 || (result.audio?.length ?? 0) > 0)
+    return false;
+  const parts = result.messages?.flatMap((message) => message.parts ?? []) ?? [];
+  if (parts.some((part) => part.type === "tool-call" || part.type === "image" || part.type === "audio"))
+    return false;
+  const texts = [result.text ?? "", ...parts.filter((part) => part.type === "text").map((part) => part.text ?? "")];
+  return texts.every((text) => text.trim().length === 0 || thoughtOnlyText(text.trim()));
+}
+
 // src/providers/vertex-auth.ts
 var CLOUD_PLATFORM_SCOPE = "https://www.googleapis.com/auth/cloud-platform";
 function vertexRoute(env) {
@@ -146,13 +343,31 @@ class VertexAuthenticationError extends Error {
     this.name = "VertexAuthenticationError";
   }
 }
-function createVertexModel(model, env, createAuth) {
+function createVertexModel(model, env, createAuth, retry) {
   const route = vertexRoute(env);
   const adapter = createVertex({
     ...route,
     getAccessToken: vertexTokenSource(env, route, createAuth)
   })(model);
-  return wrapLanguageModel2(adapter, [{
+  const attempts = retry?.attempts ?? VERTEX_TRANSIENT_ATTEMPTS;
+  const delayFor = (input) => retry?.delayMs ?? ((attempt) => input.retryBackoffMs === 0 ? 0 : transientBackoffMs(attempt, input.retryBackoffMs ?? 250));
+  const generate = async (input) => withVertexAttempts(input.abortSignal, vertexAttemptBudget(input, attempts), delayFor(input), async () => {
+    try {
+      return await adapter.generate({ ...input, maxRetries: 0 });
+    } catch (error) {
+      throw safeVertexError(error);
+    }
+  }, (result) => !isEmptyModelTurn(result));
+  const innerStream = adapter.stream?.bind(adapter);
+  const retrying = innerStream ? {
+    ...adapter,
+    generate,
+    async stream(input) {
+      const events = await withVertexAttempts(input.abortSignal, vertexAttemptBudget(input, attempts), delayFor(input), () => collectVertexStream(() => innerStream({ ...input, maxRetries: 0 })), (events2) => !isEmptyVertexStream(events2));
+      return replayVertexStream(events);
+    }
+  } : { ...adapter, generate };
+  return wrapLanguageModel2(retrying, [{
     name: "harness-vertex-sanitized-errors",
     async wrapGenerate(_context, next) {
       try {
@@ -178,19 +393,109 @@ function createVertexModel(model, env, createAuth) {
     }
   }]);
 }
+async function collectVertexStream(next) {
+  let stream;
+  try {
+    stream = await next();
+  } catch (error) {
+    throw safeVertexError(error);
+  }
+  const events = [];
+  try {
+    for await (const event of stream) {
+      if (event.type === "error")
+        throw safeVertexError(event.error);
+      events.push(event);
+    }
+  } catch (error) {
+    throw error instanceof Error && error.message.startsWith("Vertex request failed.") ? error : safeVertexError(error);
+  }
+  return events;
+}
+function isEmptyVertexStream(events) {
+  let text = "";
+  let finishReason;
+  let tools = false;
+  let media = false;
+  for (const event of events) {
+    if (event.type === "text-delta")
+      text += event.textDelta;
+    else if (event.type === "tool-call" || event.type === "tool-approval-request")
+      tools = true;
+    else if (event.type === "image-generation")
+      media = true;
+    else if (event.type === "finish")
+      finishReason = event.finishReason;
+  }
+  return isEmptyModelTurn({
+    text,
+    finishReason,
+    ...tools ? { messages: [{ parts: [{ type: "tool-call" }] }] } : {},
+    ...media ? { images: [{}] } : {}
+  });
+}
+function replayVertexStream(events) {
+  return async function* () {
+    yield* events;
+  }();
+}
+async function withVertexAttempts(abortSignal, attempts, delayMs, run, accept) {
+  let last;
+  for (let attempt = 0;attempt < attempts; attempt += 1) {
+    if (abortSignal?.aborted)
+      throw new DOMException("Vertex request cancelled.", "AbortError");
+    try {
+      const value = await run();
+      if (accept(value) || attempt === attempts - 1)
+        return value;
+      last = value;
+    } catch (error) {
+      const safe = error instanceof Error && (error.name === "AbortError" || error.message.startsWith("Vertex request failed.")) ? error : safeVertexError(error);
+      if (safe.name === "AbortError" || abortSignal?.aborted || attempt === attempts - 1 || !isRetryableProviderFailure(safe))
+        throw safe;
+    }
+    await sleep(delayMs(attempt));
+  }
+  return last;
+}
+var sleep = (ms) => ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
+function vertexAttemptBudget(input, fallback) {
+  const requested = [
+    typeof input.maxProviderRequests === "number" ? input.maxProviderRequests : undefined,
+    typeof input.maxRetries === "number" ? input.maxRetries + 1 : undefined
+  ].filter((value) => value !== undefined);
+  if (requested.length === 0)
+    return Math.max(1, fallback);
+  return Math.max(1, Math.min(...requested));
+}
 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;
+  const failure = classifyProviderFailure(error);
+  const body = providerBody(record.responseBody) ?? providerBody(record.body);
+  const preserved = providerDiagnosticSchema.safeParse(record.provider);
+  const provider = body !== undefined ? providerDiagnostic(body, failure.httpStatus) : preserved.success ? preserved.data : providerDiagnostic(undefined, failure.httpStatus);
   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
+    ...failure.httpStatus !== undefined ? { status: failure.httpStatus } : {},
+    ...failure.providerStatus ? { providerStatus: failure.providerStatus } : {},
+    provider,
+    retryable: failure.retryable
   });
 }
+function providerBody(value) {
+  if (typeof value === "string")
+    return value;
+  if (!value || typeof value !== "object")
+    return;
+  try {
+    return JSON.stringify(value).slice(0, 8192);
+  } catch {
+    return;
+  }
+}
 
 // src/providers/qwen-hosted-policy.ts
 import { wrapLanguageModel as wrapLanguageModel3 } from "@zhivex-ai/core";
@@ -1845,6 +2150,17 @@ function withReasoningEffort(model, value) {
   }]);
 }
 
+// src/runtime/task-transport.ts
+var provenance = Symbol("harness-vetted-task-transport");
+var capability = Object.freeze({ version: 1 });
+function markTaskTransportModel(model) {
+  Object.defineProperty(model, provenance, { value: capability, enumerable: true });
+  return model;
+}
+function isTaskTransportModel(model) {
+  return Reflect.get(model, provenance) === capability;
+}
+
 // src/runtime/config.ts
 import { createHash as createHash2 } from "node:crypto";
 import { realpathSync } from "node:fs";
@@ -1861,6 +2177,18 @@ var HARNESS_ERROR_CODES = [
   "EXECUTION_FAILED"
 ];
 var HARNESS_ERROR_SCHEMA_VERSION = 1;
+var providerStreamDiagnostic = (error) => {
+  const seen = new Set;
+  for (let depth = 0;depth < 5 && error && typeof error === "object" && !seen.has(error); depth++) {
+    seen.add(error);
+    const value = error;
+    if (value.provider === "qwen" && value.diagnosticCode === "QWEN_SSE_EVENT_INVALID" && (value.name === "QwenStreamEventError" || value.category === "provider-stream") && (value.transport === "chat" || value.transport === "responses") && (value.reason === "invalid_json" || value.reason === "invalid_event") && value.retryable === false) {
+      return { provider: "qwen", transport: value.transport, diagnosticCode: "QWEN_SSE_EVENT_INVALID", reason: value.reason, retryable: false };
+    }
+    error = value.cause;
+  }
+  return;
+};
 
 class HarnessError extends Error {
   code;
@@ -1933,30 +2261,35 @@ class HarnessExecutionError extends HarnessError {
 }
 var harnessErrorDocument = (error) => {
   const normalized = normalizeHarnessError(error);
+  const diagnostic = providerStreamDiagnostic(error);
   return {
     schemaVersion: HARNESS_ERROR_SCHEMA_VERSION,
     kind: "error",
     error: {
       code: normalized.code,
       category: normalized.category,
-      retryable: normalized.retryable
+      retryable: normalized.retryable,
+      ...diagnostic ? { providerDiagnostic: diagnostic } : {}
     }
   };
 };
-var numericStatuses = (error) => {
-  if (!error || typeof error !== "object")
-    return;
-  const record = error;
-  const values = [record.status, record.statusCode].filter((value) => typeof value === "number" && Number.isSafeInteger(value));
-  return values.length > 0 ? values : undefined;
-};
 var normalizeHarnessError = (error) => {
+  const diagnostic = providerStreamDiagnostic(error);
+  if (diagnostic)
+    return new HarnessProviderError("Provider stream failed.", { cause: error, retryable: false });
   if (error instanceof HarnessError)
     return error;
   const message = error instanceof Error ? error.message : "Harness execution failed.";
-  const statuses = numericStatuses(error) ?? [];
-  if (statuses.some((status) => status === 429 || status >= 500 && status <= 599)) {
-    return new HarnessProviderError(message, { cause: error, retryable: true });
+  const failure = classifyProviderFailure(error);
+  if (failure.retryable) {
+    const record = error && typeof error === "object" ? error : {};
+    const body = typeof record.responseBody === "string" ? record.responseBody : typeof record.body === "string" ? record.body : undefined;
+    const providerError = new HarnessProviderError("Provider request failed.", { cause: error, retryable: true });
+    return Object.assign(providerError, {
+      ...failure.httpStatus !== undefined ? { status: failure.httpStatus } : {},
+      ...failure.providerStatus ? { providerStatus: failure.providerStatus } : {},
+      provider: providerDiagnostic(body, failure.httpStatus)
+    });
   }
   const name = error && typeof error === "object" && typeof error.name === "string" ? error.name : "";
   const code = error && typeof error === "object" && typeof error.code === "string" ? error.code : "";
@@ -2236,12 +2569,15 @@ var resolveHarnessConfig = (input = {}, registry = DEFAULT_PROVIDER_REGISTRY) =>
   const userId = scopeValue("userId", input.userId ?? process.env.ZHIVEX_HARNESS_USER_ID);
   const namespace = scopeValue("namespace", input.namespace ?? process.env.ZHIVEX_HARNESS_NAMESPACE, defaultHarnessNamespace(workspace));
   const timeoutMs = integerOption("timeoutMs", input.timeoutMs, process.env.ZHIVEX_HARNESS_TIMEOUT_MS, 15 * 60000, 1000, 24 * 60 * 60000);
-  if (input.unlimitedTokens !== undefined && typeof input.unlimitedTokens !== "boolean") {
-    throw new HarnessConfigError("unlimitedTokens must be a boolean.");
+  for (const key of ["unlimitedTokens", "unlimitedSteps", "unlimitedToolCalls", "unlimitedDuration"]) {
+    if (input[key] !== undefined && typeof input[key] !== "boolean")
+      throw new HarnessConfigError(`${key} must be a boolean.`);
   }
   const tokenMode = input.unlimitedTokens === undefined ? {} : { unlimitedTokens: input.unlimitedTokens };
   const budget = {
     ...tokenMode,
+    ...input.unlimitedSteps === undefined ? {} : { unlimitedSteps: input.unlimitedSteps },
+    ...input.unlimitedToolCalls === undefined ? {} : { unlimitedToolCalls: input.unlimitedToolCalls },
     maxSteps,
     maxToolCalls: integerOption("maxToolCalls", input.maxToolCalls, process.env.ZHIVEX_HARNESS_MAX_TOOL_CALLS, DEFAULT_HARNESS_BUDGET.maxToolCalls, 0, Number.MAX_SAFE_INTEGER),
     maxToolErrors: integerOption("maxToolErrors", input.maxToolErrors, process.env.ZHIVEX_HARNESS_MAX_TOOL_ERRORS, DEFAULT_HARNESS_BUDGET.maxToolErrors, 0, 100),
@@ -2315,6 +2651,7 @@ var resolveHarnessConfig = (input = {}, registry = DEFAULT_PROVIDER_REGISTRY) =>
     },
     maxSteps,
     timeoutMs,
+    ...input.unlimitedDuration === undefined ? {} : { unlimitedDuration: input.unlimitedDuration },
     requireVerifiedDelivery: input.requireVerifiedDelivery ?? false,
     budget,
     ...maxCostUsd === undefined ? {} : {
@@ -2338,7 +2675,8 @@ var resolveHarnessConfig = (input = {}, registry = DEFAULT_PROVIDER_REGISTRY) =>
 };
 var createProviderModel = (config, env = process.env, registry = DEFAULT_PROVIDER_REGISTRY) => {
   try {
-    return registry.createModel(config, env);
+    const model = registry.createModel(config, env);
+    return registry === DEFAULT_PROVIDER_REGISTRY && ["anthropic", "openai", "gemini", "vertex", "qwen"].includes(config.provider) ? markTaskTransportModel(model) : model;
   } catch (error) {
     throw new HarnessProviderError(`Provider ${config.provider} could not be initialized.`, {
       cause: error,
@@ -2347,4 +2685,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, 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 };
+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 };