@zhivex-ai/harness 0.6.1 → 0.7.0

package/dist/hostile-repository-demo.js

@@ -7,13 +7,359 @@ import path8 from "path";
 import { createMockLanguageModel } from "@zhivex-ai/agents/testing";
 
 // src/config.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import { realpathSync } from "fs";
 import path from "path";
+
+// src/providers.ts
+import { createHash } from "crypto";
+import { createGemini } from "@zhivex-ai/gemini";
 import { createMeta } from "@zhivex-ai/meta";
 import { createOpenAI } from "@zhivex-ai/openai";
 import { createQwen } from "@zhivex-ai/qwen";
-var PROVIDERS = ["meta", "qwen", "openai"];
+var HARNESS_PROVIDER_CAPABILITIES = [
+  "streaming",
+  "tool-calling",
+  "approval-resume"
+];
+var QWEN_REGIONS = [
+  "singapore",
+  "beijing",
+  "hong-kong",
+  "tokyo",
+  "frankfurt",
+  "virginia"
+];
+var PROVIDER_ID = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+var ENVIRONMENT_VARIABLE = /^[A-Z_][A-Z0-9_]{0,127}$/;
+var DIAGNOSTIC_KEY = /^[a-z][A-Za-z0-9]{0,63}$/;
+var requiredText = (name, value) => {
+  const normalized = value.trim();
+  if (!normalized || /[\u0000-\u001f\u007f]/.test(normalized)) {
+    throw new Error(`${name} must be a non-empty printable string.`);
+  }
+  return normalized;
+};
+var environmentVariable = (name, value) => {
+  if (!ENVIRONMENT_VARIABLE.test(value)) {
+    throw new Error(`${name} must be a valid environment variable name.`);
+  }
+  return value;
+};
+var diagnosticKey = (value) => {
+  if (!DIAGNOSTIC_KEY.test(value)) {
+    throw new Error(`Invalid provider diagnostic key: ${value}.`);
+  }
+  return value;
+};
+var normalizedDescriptor = (descriptor) => {
+  const id = descriptor.id.trim().toLowerCase();
+  if (descriptor.id !== id || !PROVIDER_ID.test(id)) {
+    throw new Error(`Invalid provider id: ${descriptor.id}. Use 1-64 lowercase letters, digits, dot, underscore, or hyphen.`);
+  }
+  if (!(descriptor.support === "certified" || descriptor.support === "provisional")) {
+    throw new Error(`Invalid support level for provider ${id}.`);
+  }
+  const credentialNames = [...new Set(descriptor.credentialNames.map((name) => environmentVariable(`Credential for provider ${id}`, name)))];
+  const capabilities = [...new Set(descriptor.capabilities)];
+  const invalidCapability = capabilities.find((capability) => !HARNESS_PROVIDER_CAPABILITIES.includes(capability));
+  if (invalidCapability) {
+    throw new Error(`Invalid capability for provider ${id}: ${invalidCapability}.`);
+  }
+  return Object.freeze({
+    id,
+    name: requiredText(`Name for provider ${id}`, descriptor.name),
+    defaultModel: requiredText(`Default model for provider ${id}`, descriptor.defaultModel),
+    credentialNames: Object.freeze(credentialNames),
+    capabilities: Object.freeze(capabilities),
+    support: descriptor.support
+  });
+};
+var normalizedDiagnostics = (provider, diagnostics) => {
+  const endpointEnvironmentVariable = diagnostics?.endpointEnvironmentVariable === undefined ? undefined : environmentVariable(`Endpoint diagnostic for provider ${provider}`, diagnostics.endpointEnvironmentVariable);
+  const seenKeys = new Set;
+  const presence = (diagnostics?.presence ?? []).map((entry) => {
+    const key = diagnosticKey(entry.key);
+    if (seenKeys.has(key)) {
+      throw new Error(`Duplicate diagnostic key for provider ${provider}: ${key}.`);
+    }
+    seenKeys.add(key);
+    return Object.freeze({
+      key,
+      environmentVariable: environmentVariable(`Presence diagnostic for provider ${provider}`, entry.environmentVariable)
+    });
+  });
+  const enums = (diagnostics?.enums ?? []).map((entry) => {
+    const key = diagnosticKey(entry.key);
+    if (seenKeys.has(key)) {
+      throw new Error(`Duplicate diagnostic key for provider ${provider}: ${key}.`);
+    }
+    seenKeys.add(key);
+    const allowedValues = [...new Set(entry.allowedValues.map((value) => requiredText(`Allowed diagnostic value for provider ${provider}`, value)))];
+    if (allowedValues.length === 0) {
+      throw new Error(`Enum diagnostic ${key} for provider ${provider} needs allowed values.`);
+    }
+    return Object.freeze({
+      key,
+      environmentVariable: environmentVariable(`Enum diagnostic for provider ${provider}`, entry.environmentVariable),
+      allowedValues: Object.freeze(allowedValues)
+    });
+  });
+  return Object.freeze({
+    ...endpointEnvironmentVariable ? { endpointEnvironmentVariable } : {},
+    ...presence.length > 0 ? { presence: Object.freeze(presence) } : {},
+    ...enums.length > 0 ? { enums: Object.freeze(enums) } : {}
+  });
+};
+var endpointConfiguration = (value) => {
+  const configured = Boolean(value?.trim());
+  if (!configured) {
+    return {
+      customEndpoint: false,
+      endpointValid: true,
+      endpointSecure: true
+    };
+  }
+  try {
+    const endpoint = new URL(value.trim());
+    const supportedProtocol = endpoint.protocol === "https:" || endpoint.protocol === "http:";
+    return {
+      customEndpoint: true,
+      endpointValid: supportedProtocol && !endpoint.username && !endpoint.password && !endpoint.hash && !endpoint.search,
+      endpointSecure: endpoint.protocol === "https:"
+    };
+  } catch {
+    return {
+      customEndpoint: true,
+      endpointValid: false,
+      endpointSecure: false
+    };
+  }
+};
+var createCredentials = (env, provider, names) => Object.freeze({
+  names,
+  get: (name) => {
+    if (!names.includes(name)) {
+      throw new Error(`Credential ${name} is not declared for provider ${provider}.`);
+    }
+    return env[name]?.trim() || undefined;
+  },
+  first: () => {
+    for (const name of names) {
+      const value = env[name]?.trim();
+      if (value) {
+        return value;
+      }
+    }
+    return;
+  },
+  require: () => {
+    for (const name of names) {
+      const value = env[name]?.trim();
+      if (value) {
+        return value;
+      }
+    }
+    throw new Error(names.length === 0 ? `Provider ${provider} does not declare a credential.` : `Missing credentials for ${provider}. Set ${names.join(" or ")} in the environment.`);
+  }
+});
+var normalizeRegistration = (registration) => {
+  if (typeof registration.factory !== "function") {
+    throw new Error("Provider registration factory must be a function.");
+  }
+  const descriptor = normalizedDescriptor(registration.descriptor);
+  return Object.freeze({
+    descriptor,
+    factory: registration.factory,
+    diagnostics: normalizedDiagnostics(descriptor.id, registration.diagnostics)
+  });
+};
+var providerConfiguration = (diagnostics, env) => {
+  const configuration = endpointConfiguration(diagnostics.endpointEnvironmentVariable ? env[diagnostics.endpointEnvironmentVariable] : undefined);
+  for (const entry of diagnostics.presence ?? []) {
+    configuration[`${entry.key}Configured`] = Boolean(env[entry.environmentVariable]?.trim());
+  }
+  for (const entry of diagnostics.enums ?? []) {
+    const value = env[entry.environmentVariable]?.trim();
+    configuration[`${entry.key}Configured`] = Boolean(value);
+    configuration[`${entry.key}Valid`] = !value || entry.allowedValues.includes(value);
+  }
+  return Object.freeze(configuration);
+};
+var parseWithRegistrations = (value, registrations) => {
+  const defaultProvider = registrations.has("openai") ? "openai" : registrations.keys().next().value;
+  const normalized = (value ?? defaultProvider ?? "").trim().toLowerCase();
+  if (registrations.has(normalized)) {
+    return normalized;
+  }
+  throw new Error(`Unknown provider: ${value}. Use ${[...registrations.keys()].join(", ")}.`);
+};
+var createProviderRegistry = (registrations) => {
+  if (registrations.length === 0) {
+    throw new Error("Provider registry must contain at least one provider.");
+  }
+  const entries = new Map;
+  for (const registration of registrations) {
+    const normalized = normalizeRegistration(registration);
+    if (entries.has(normalized.descriptor.id)) {
+      throw new Error(`Duplicate provider registration: ${normalized.descriptor.id}.`);
+    }
+    entries.set(normalized.descriptor.id, normalized);
+  }
+  const frozenRegistrations = Object.freeze([...entries.values()]);
+  const descriptors = Object.freeze(frozenRegistrations.map((entry) => entry.descriptor));
+  const registry = Object.freeze({
+    descriptors,
+    has: (provider) => entries.has(provider.trim().toLowerCase()),
+    parse: (value) => parseWithRegistrations(value, entries),
+    descriptor: (provider) => {
+      const registration = entries.get(provider);
+      if (!registration) {
+        throw new Error(`No descriptor is available for provider ${provider}.`);
+      }
+      return registration.descriptor;
+    },
+    createModel: (config, env = process.env) => {
+      const registration = entries.get(config.provider);
+      if (!registration) {
+        throw new Error(`No factory is available for provider ${config.provider}.`);
+      }
+      return registration.factory(Object.freeze({
+        provider: config.provider,
+        model: config.model,
+        env,
+        credentials: createCredentials(env, config.provider, registration.descriptor.credentialNames)
+      }));
+    },
+    availability: (env = process.env) => Object.freeze(frozenRegistrations.map((registration) => {
+      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),
+        credentials,
+        configuration: providerConfiguration(registration.diagnostics, env)
+      });
+    })),
+    transportFingerprint: (env = process.env) => {
+      const transport = frozenRegistrations.map((registration) => {
+        const names = [
+          registration.diagnostics.endpointEnvironmentVariable,
+          ...(registration.diagnostics.presence ?? []).map((entry) => entry.environmentVariable),
+          ...(registration.diagnostics.enums ?? []).map((entry) => entry.environmentVariable)
+        ].filter((name) => Boolean(name));
+        return {
+          provider: registration.descriptor.id,
+          values: names.map((name) => [name, env[name]?.trim() ?? ""])
+        };
+      });
+      return `sha256:${createHash("sha256").update(JSON.stringify(transport)).digest("hex")}`;
+    },
+    extend: (additional) => createProviderRegistry([
+      ...frozenRegistrations,
+      ...additional
+    ])
+  });
+  return registry;
+};
+var optionalQwenRegion = (value) => {
+  if (!value) {
+    return;
+  }
+  if (QWEN_REGIONS.includes(value)) {
+    return value;
+  }
+  throw new Error(`Invalid QWEN_REGION: ${value}.`);
+};
+var BUILTIN_PROVIDER_REGISTRATIONS = Object.freeze([
+  {
+    descriptor: {
+      id: "meta",
+      name: "Meta Model API",
+      defaultModel: "muse-spark-1.2",
+      credentialNames: ["MODEL_API_KEY"],
+      capabilities: HARNESS_PROVIDER_CAPABILITIES,
+      support: "certified"
+    },
+    diagnostics: { endpointEnvironmentVariable: "META_BASE_URL" },
+    factory: ({ model, env, credentials }) => {
+      const baseURL = env.META_BASE_URL?.trim();
+      return createMeta({
+        apiKey: credentials.require(),
+        ...baseURL ? { baseURL } : {}
+      })(model);
+    }
+  },
+  {
+    descriptor: {
+      id: "qwen",
+      name: "Qwen / Alibaba Cloud Model Studio",
+      defaultModel: "qwen3.8-max",
+      credentialNames: ["DASHSCOPE_API_KEY", "QWEN_API_KEY"],
+      capabilities: HARNESS_PROVIDER_CAPABILITIES,
+      support: "certified"
+    },
+    diagnostics: {
+      endpointEnvironmentVariable: "QWEN_BASE_URL",
+      presence: [{ key: "workspaceId", environmentVariable: "QWEN_WORKSPACE_ID" }],
+      enums: [{
+        key: "region",
+        environmentVariable: "QWEN_REGION",
+        allowedValues: QWEN_REGIONS
+      }]
+    },
+    factory: ({ model, env, credentials }) => {
+      const baseURL = env.QWEN_BASE_URL?.trim();
+      const workspaceId = env.QWEN_WORKSPACE_ID?.trim();
+      const region = optionalQwenRegion(env.QWEN_REGION?.trim());
+      return createQwen({
+        apiKey: credentials.require(),
+        ...baseURL ? { baseURL } : {},
+        ...workspaceId ? { workspaceId } : {},
+        ...region ? { region } : {}
+      })(model);
+    }
+  },
+  {
+    descriptor: {
+      id: "openai",
+      name: "OpenAI",
+      defaultModel: "gpt-5.4",
+      credentialNames: ["OPENAI_API_KEY"],
+      capabilities: HARNESS_PROVIDER_CAPABILITIES,
+      support: "certified"
+    },
+    diagnostics: { endpointEnvironmentVariable: "OPENAI_BASE_URL" },
+    factory: ({ model, env, credentials }) => {
+      const baseURL = env.OPENAI_BASE_URL?.trim();
+      return createOpenAI({
+        apiKey: credentials.require(),
+        ...baseURL ? { baseURL } : {}
+      })(model);
+    }
+  },
+  {
+    descriptor: {
+      id: "gemini",
+      name: "Google Gemini",
+      defaultModel: "gemini-3.6-flash",
+      credentialNames: ["GEMINI_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY"],
+      capabilities: HARNESS_PROVIDER_CAPABILITIES,
+      support: "provisional"
+    },
+    diagnostics: { endpointEnvironmentVariable: "GEMINI_BASE_URL" },
+    factory: ({ model, env, credentials }) => {
+      const baseURL = env.GEMINI_BASE_URL?.trim();
+      return createGemini({
+        apiKey: credentials.require(),
+        ...baseURL ? { baseURL } : {}
+      })(model);
+    }
+  }
+]);
+var DEFAULT_PROVIDER_REGISTRY = createProviderRegistry(BUILTIN_PROVIDER_REGISTRATIONS);
+var PROVIDER_DESCRIPTORS = DEFAULT_PROVIDER_REGISTRY.descriptors;
+
+// src/config.ts
 var DEFAULT_ALLOWED_CHECKS = ["test", "typecheck", "lint", "build"];
 var HARNESS_CONFIG_SCHEMA_VERSION = 4;
 var HARNESS_STORE_BACKENDS = ["sqlite", "file"];
@@ -69,45 +415,6 @@ var DEFAULT_SUBAGENT_BUDGET = {
   maxTotalTokens: 36000,
   includeChildRuns: false
 };
-var HARNESS_PROVIDER_CAPABILITIES = [
-  "streaming",
-  "tool-calling",
-  "approval-resume"
-];
-var PROVIDER_DESCRIPTORS = [
-  {
-    id: "meta",
-    name: "Meta Model API",
-    defaultModel: "muse-spark-1.2",
-    credentialNames: ["MODEL_API_KEY"],
-    capabilities: HARNESS_PROVIDER_CAPABILITIES,
-    support: "certified"
-  },
-  {
-    id: "qwen",
-    name: "Qwen / Alibaba Cloud Model Studio",
-    defaultModel: "qwen3.8-max",
-    credentialNames: ["DASHSCOPE_API_KEY", "QWEN_API_KEY"],
-    capabilities: HARNESS_PROVIDER_CAPABILITIES,
-    support: "certified"
-  },
-  {
-    id: "openai",
-    name: "OpenAI",
-    defaultModel: "gpt-5.4",
-    credentialNames: ["OPENAI_API_KEY"],
-    capabilities: HARNESS_PROVIDER_CAPABILITIES,
-    support: "certified"
-  }
-];
-var QWEN_REGIONS = [
-  "singapore",
-  "beijing",
-  "hong-kong",
-  "tokyo",
-  "frankfurt",
-  "virginia"
-];
 var integerOption = (name, input, envValue, fallback, minimum, maximum) => {
   const value = input ?? (envValue === undefined ? fallback : Number(envValue));
   if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
@@ -136,7 +443,7 @@ var nonNegativeNumberOption = (name, input, envValue) => {
   }
   return value;
 };
-var defaultHarnessNamespace = (workspace) => `workspace-${createHash("sha256").update(workspace).digest("hex").slice(0, 16)}`;
+var defaultHarnessNamespace = (workspace) => `workspace-${createHash2("sha256").update(workspace).digest("hex").slice(0, 16)}`;
 var canonicalStateDirectory = (requestedWorkspace, canonicalWorkspace, configured) => {
   if (!configured) {
     return path.join(canonicalWorkspace, ".zhivex-harness", "runs");
@@ -238,26 +545,14 @@ var canonicalWorkspaceFile = (requestedWorkspace, canonicalWorkspace, configured
   const insideRequestedWorkspace = relative === "" || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
   return insideRequestedWorkspace ? path.resolve(canonicalWorkspace, relative) : requestedPath;
 };
-var parseProvider = (value) => {
-  const normalized = (value ?? "openai").trim().toLowerCase();
-  if (PROVIDERS.includes(normalized)) {
-    return normalized;
-  }
-  throw new Error(`Unknown provider: ${value}. Use meta, qwen, or openai.`);
-};
-var providerDescriptor = (provider) => {
-  const descriptor = PROVIDER_DESCRIPTORS.find((entry) => entry.id === provider);
-  if (!descriptor) {
-    throw new Error(`No descriptor is available for provider ${provider}.`);
-  }
-  return descriptor;
-};
-var resolveHarnessConfig = (input = {}) => {
+var parseProvider = (value, registry = DEFAULT_PROVIDER_REGISTRY) => registry.parse(value);
+var providerDescriptor = (provider, registry = DEFAULT_PROVIDER_REGISTRY) => registry.descriptor(provider);
+var resolveHarnessConfig = (input = {}, registry = DEFAULT_PROVIDER_REGISTRY) => {
   if (input.schemaVersion !== undefined && input.schemaVersion !== HARNESS_CONFIG_SCHEMA_VERSION) {
     throw new Error(`Unsupported config schema version: ${input.schemaVersion}. Expected ${HARNESS_CONFIG_SCHEMA_VERSION}.`);
   }
-  const provider = parseProvider(input.provider ?? process.env.ZHIVEX_HARNESS_PROVIDER);
-  const descriptor = providerDescriptor(provider);
+  const provider = parseProvider(input.provider ?? process.env.ZHIVEX_HARNESS_PROVIDER, registry);
+  const descriptor = providerDescriptor(provider, registry);
   const requestedWorkspace = path.resolve(input.workspace ?? process.cwd());
   let workspace = requestedWorkspace;
   try {
@@ -351,59 +646,10 @@ var resolveHarnessConfig = (input = {}) => {
     ...mcpConfigPath ? { mcpConfigPath } : {}
   };
 };
-var requiredCredential = (env, provider, names) => {
-  for (const name of names) {
-    const value = env[name]?.trim();
-    if (value) {
-      return value;
-    }
-  }
-  throw new Error(`Missing credentials for ${provider}. Set ${names.join(" or ")} in the environment.`);
-};
-var optionalQwenRegion = (value) => {
-  if (!value) {
-    return;
-  }
-  if (QWEN_REGIONS.includes(value)) {
-    return value;
-  }
-  throw new Error(`Invalid QWEN_REGION: ${value}.`);
-};
-var createProviderModel = (config, env = process.env) => {
-  switch (config.provider) {
-    case "meta": {
-      const baseURL = env.META_BASE_URL?.trim();
-      const provider = createMeta({
-        apiKey: requiredCredential(env, "meta", ["MODEL_API_KEY"]),
-        ...baseURL ? { baseURL } : {}
-      });
-      return provider(config.model);
-    }
-    case "qwen": {
-      const baseURL = env.QWEN_BASE_URL?.trim();
-      const workspaceId = env.QWEN_WORKSPACE_ID?.trim();
-      const region = optionalQwenRegion(env.QWEN_REGION?.trim());
-      const provider = createQwen({
-        apiKey: requiredCredential(env, "qwen", ["DASHSCOPE_API_KEY", "QWEN_API_KEY"]),
-        ...baseURL ? { baseURL } : {},
-        ...workspaceId ? { workspaceId } : {},
-        ...region ? { region } : {}
-      });
-      return provider(config.model);
-    }
-    case "openai": {
-      const baseURL = env.OPENAI_BASE_URL?.trim();
-      const provider = createOpenAI({
-        apiKey: requiredCredential(env, "openai", ["OPENAI_API_KEY"]),
-        ...baseURL ? { baseURL } : {}
-      });
-      return provider(config.model);
-    }
-  }
-};
+var createProviderModel = (config, env = process.env, registry = DEFAULT_PROVIDER_REGISTRY) => registry.createModel(config, env);
 
 // src/execution-environment.ts
-import { createHash as createHash4, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash5, randomUUID as randomUUID2 } from "crypto";
 import {
   chmod,
   lstat as lstat2,
@@ -419,7 +665,7 @@ import path4 from "path";
 import { createAgentExecutionEnvironmentBinding } from "@zhivex-ai/agents/beta";
 
 // src/edit-contracts.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import path2 from "path";
 import { z } from "zod";
 var EDIT_CONTRACT_SCHEMA_VERSION = 1;
@@ -519,7 +765,7 @@ var mutationAuditEntrySchema = z.strictObject({
   timestamp: z.iso.datetime(),
   quarantineId: z.string().min(1).max(200).optional()
 });
-var digest = (value) => `sha256:${createHash2("sha256").update(value).digest("hex")}`;
+var digest = (value) => `sha256:${createHash3("sha256").update(value).digest("hex")}`;
 var canonicalProposalPayload = (changes) => ({
   schemaVersion: EDIT_CONTRACT_SCHEMA_VERSION,
   kind: "edit-proposal",
@@ -554,7 +800,7 @@ var editContractDocument = (kind, result) => ({
 });
 
 // src/workspace.ts
-import { createHash as createHash3, randomUUID } from "crypto";
+import { createHash as createHash4, randomUUID } from "crypto";
 import { link, lstat, mkdir, open, readFile, readdir, realpath, rename, stat, unlink } from "fs/promises";
 import path3 from "path";
 var HARD_IGNORES = new Set([".git", ".next", ".turbo", ".zhivex-harness", "coverage", "dist", "node_modules"]);
@@ -572,7 +818,7 @@ var isInside = (root, candidate) => {
   return relative === "" || !relative.startsWith(`..${path3.sep}`) && relative !== ".." && !path3.isAbsolute(relative);
 };
 var wirePath = (value) => value.split(path3.sep).join("/");
-var digestBytes = (value) => `sha256:${createHash3("sha256").update(value).digest("hex")}`;
+var digestBytes = (value) => `sha256:${createHash4("sha256").update(value).digest("hex")}`;
 var truncate = (value, maxLength = MAX_TOOL_OUTPUT) => value.length <= maxLength ? value : `${value.slice(0, maxLength)}
 \u2026 output truncated (${value.length - maxLength} characters omitted)`;
 var cursorEncode = (value) => Buffer.from(JSON.stringify(value)).toString("base64url");
@@ -1339,8 +1585,8 @@ var BUILT_IN_TOOL_NAMES = new Set([
   "apply_environment_patch",
   "environment_status"
 ]);
-var digest2 = (value) => `sha256:${createHash4("sha256").update(value).digest("hex")}`;
-var runHash = (runId) => createHash4("sha256").update(runId).digest("hex").slice(0, 24);
+var digest2 = (value) => `sha256:${createHash5("sha256").update(value).digest("hex")}`;
+var runHash = (runId) => createHash5("sha256").update(runId).digest("hex").slice(0, 24);
 var isInside2 = (root, candidate) => {
   const relative = path4.relative(root, candidate);
   return relative === "" || relative !== ".." && !relative.startsWith(`..${path4.sep}`) && !path4.isAbsolute(relative);
@@ -2308,7 +2554,7 @@ var executionFingerprintInput = (execution, environment) => execution.backend ==
 };
 
 // src/harness.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import {
   Agent,
   applySafetyPolicyToAgent as applySafetyPolicyToAgent2,
@@ -3052,7 +3298,7 @@ var createHarnessMcpTools = async (configuration, options = {}) => {
 var mcpConfigurationFingerprintInput = (configuration) => serializeJsonValue(configuration);
 
 // src/orchestration.ts
-import { createHash as createHash5, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash6, randomUUID as randomUUID3 } from "crypto";
 import {
   applySafetyPolicyToAgent,
   createBudgetGuard,
@@ -3099,7 +3345,7 @@ var childHarnessBinding = (parent, profile, model, toolNames, config) => ({
   schemaVersion: 1,
   id: `${parent.id}-${profile}`,
   version: parent.version,
-  fingerprint: `sha256:${createHash5("sha256").update(JSON.stringify({
+  fingerprint: `sha256:${createHash6("sha256").update(JSON.stringify({
     parent: parent.fingerprint,
     profile,
     model: {
@@ -3184,11 +3430,11 @@ var createHarnessSubagents = (options) => {
 // src/harness.ts
 var APPROVAL_VERSION = "2026-08-17-v5";
 var TOOL_CONTRACT_VERSION = "enforced-execution-v1";
-var createHarnessBinding = (config, mcpConfiguration, model, subagentModels, executionEnvironment) => ({
+var createHarnessBinding = (config, mcpConfiguration, model, subagentModels, providerTransportFingerprint, executionEnvironment) => ({
   schemaVersion: 1,
   id: "zhivex-harness",
   version: HARNESS_VERSION,
-  fingerprint: `sha256:${createHash6("sha256").update(JSON.stringify({
+  fingerprint: `sha256:${createHash7("sha256").update(JSON.stringify({
     configSchemaVersion: HARNESS_CONFIG_SCHEMA_VERSION,
     approvalVersion: APPROVAL_VERSION,
     toolContractVersion: TOOL_CONTRACT_VERSION,
@@ -3196,6 +3442,7 @@ var createHarnessBinding = (config, mcpConfiguration, model, subagentModels, exe
     provider: config.provider,
     model: config.model,
     runtimeModel: inspectHarnessModelCapabilities(model),
+    providerTransportFingerprint,
     subagentModels: Object.fromEntries(config.orchestration.profiles.map((profile) => [
       profile,
       inspectHarnessModelCapabilities(subagentModels?.[profile] ?? model)
@@ -3418,32 +3665,35 @@ var createExecutionEnvironmentTools = (workspace) => ({
   })
 });
 var estimateMessageTokens = (messages) => Math.max(1, Math.ceil(JSON.stringify(messages).length / 4));
-var createHarnessCompactor = () => {
+var summarizeHarnessMessages = (messages) => {
   const redaction = createRedactionPolicy2({ includeEmails: true });
-  return async ({ messages }) => {
-    const summaries = messages.map((message, index) => {
-      const record = message;
-      const parts = (record.parts ?? []).map((part) => {
-        if (part.type === "text" && typeof part.text === "string") {
-          const text = redaction.redactText(part.text).replace(/\s+/g, " ").trim();
-          return text.length > 160 ? `${text.slice(0, 160)}\u2026` : text;
-        }
-        if (part.type === "tool-call") {
-          const call = part.toolCall;
-          return `tool-call:${typeof call?.name === "string" ? call.name : "unknown"}`;
-        }
-        if (part.type === "tool-result") {
-          const result = part.toolResult;
-          return `tool-result:${typeof result?.toolName === "string" ? result.toolName : "unknown"}`;
-        }
-        return typeof part.type === "string" ? part.type : "part";
-      });
-      return `${index + 1}. ${record.role ?? "message"}: ${parts.join(" | ")}`;
+  const summaries = messages.map((message, index) => {
+    const record = message;
+    const parts = (record.parts ?? []).map((part) => {
+      if (part.type === "text" && typeof part.text === "string") {
+        const text = redaction.redactText(part.text).replace(/\bBearer\s+\S+/gi, "Bearer [REDACTED]").replace(/\b([A-Z][A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD)|api[_-]?key|access[_-]?token|password)\s*([=:])\s*(?:"[^"]*"|'[^']*'|\S+)/gi, "$1$2[REDACTED]").replace(/\b(?:sk|ghp|gho|github_pat)-[A-Za-z0-9_-]{8,}\b/g, "[REDACTED]").replace(/\s+/g, " ").trim();
+        return text.length > 160 ? `${text.slice(0, 160)}\u2026` : text;
+      }
+      if (part.type === "tool-call") {
+        const call = part.toolCall;
+        return `tool-call:${typeof call?.name === "string" ? call.name : "unknown"}`;
+      }
+      if (part.type === "tool-result") {
+        const result = part.toolResult;
+        return `tool-result:${typeof result?.toolName === "string" ? result.toolName : "unknown"}`;
+      }
+      return typeof part.type === "string" ? part.type : "part";
     });
-    const summary = summaries.join(`
+    return `${index + 1}. ${record.role ?? "message"}: ${parts.join(" | ")}`;
+  });
+  const summary = summaries.join(`
 `);
+  return summary.length > 4000 ? `${summary.slice(0, 4000)}\u2026` : summary;
+};
+var createHarnessCompactor = () => {
+  return async ({ messages }) => {
     return {
-      summary: summary.length > 4000 ? `${summary.slice(0, 4000)}\u2026` : summary,
+      summary: summarizeHarnessMessages(messages),
       metadata: {
         strategy: "deterministic-redacted-transcript",
         sourceMessages: messages.length
@@ -3506,7 +3756,7 @@ var createProviderCompatibleBudget = (config) => {
   };
 };
 var createHarness = async (options = {}) => {
-  const config = resolveHarnessConfig(options);
+  const config = resolveHarnessConfig(options, options.providerRegistry);
   const workspace = await Workspace.open(config.workspace);
   await validateStateDirectory(config.workspace, config.stateDirectory);
   const executionEnvironment = config.execution.backend === "oci" ? await createHarnessOciExecutionEnvironment({
@@ -3515,7 +3765,7 @@ var createHarness = async (options = {}) => {
     stateDirectory: config.stateDirectory,
     ...options.ociRuntimeAdapter ? { runtime: options.ociRuntimeAdapter } : {}
   }) : undefined;
-  const model = options.modelInstance ?? createProviderModel(config, options.env ?? process.env);
+  const model = options.modelInstance ?? createProviderModel(config, options.env ?? process.env, options.providerRegistry);
   const capabilityRequirements = [...new Set([
     ...config.requiredCapabilities,
     ...config.orchestration.profiles.length > 0 || config.mcpConfigPath || options.mcpConfiguration ? ["tools", "streaming"] : []
@@ -3557,7 +3807,7 @@ var createHarness = async (options = {}) => {
     await options.onTelemetryEvent?.(event);
   };
   const costGuardrails = createCostGuardrails(config);
-  const binding = createHarnessBinding(config, mcpConfiguration, model, options.subagentModels, executionEnvironment);
+  const binding = createHarnessBinding(config, mcpConfiguration, model, options.subagentModels, (options.providerRegistry ?? DEFAULT_PROVIDER_REGISTRY).transportFingerprint(options.env ?? process.env), executionEnvironment);
   const subagentRuntime = createHarnessSubagents({
     config,
     parentBinding: binding,