chainlesschain 0.166.109 → 0.166.114

package/src/lib/chat-core.js

@@ -11,6 +11,13 @@ import { providerFetch } from "./formal-budget-provider-scope.js";
  */
 
 import { BUILT_IN_PROVIDERS } from "./llm-providers.js";
+import { normalizeOllamaBaseUrl } from "./ollama-base-url.js";
+import {
+  geminiGenerateContentUrl,
+  geminiRequestBody,
+  geminiUsage,
+  normalizeProviderBaseUrl,
+} from "./provider-protocol.js";
 import { appendTokenUsage } from "../harness/jsonl-session-store.js";
 import {
   isRetryableStreamError,
@@ -134,18 +141,21 @@ export async function streamOllama(
   guard.bump();
   let response;
   try {
-    response = await providerFetch(`${baseUrl}/api/chat`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model,
-        messages,
-        stream: true,
-      }),
-      signal: options.signal
-        ? AbortSignal.any([guard.signal, options.signal])
-        : guard.signal,
-    });
+    response = await providerFetch(
+      `${normalizeOllamaBaseUrl(baseUrl)}/api/chat`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model,
+          messages,
+          stream: true,
+        }),
+        signal: options.signal
+          ? AbortSignal.any([guard.signal, options.signal])
+          : guard.signal,
+      },
+    );
   } catch (e) {
     guard.stop();
     throw guard.stalled() && !isFormalBudgetError(e)
@@ -249,7 +259,9 @@ export async function streamOpenAI(
   guard.bump();
   let response;
   try {
-    response = await providerFetch(`${baseUrl}/chat/completions`, {
+    response = await providerFetch(
+      `${normalizeProviderBaseUrl(baseUrl)}/chat/completions`,
+      {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -266,7 +278,8 @@ export async function streamOpenAI(
       signal: options.signal
         ? AbortSignal.any([guard.signal, options.signal])
         : guard.signal,
-    });
+      },
+    );
   } catch (e) {
     guard.stop();
     throw guard.stalled() && !isFormalBudgetError(e)
@@ -394,7 +407,9 @@ export async function streamAnthropic(
   guard.bump();
   let response;
   try {
-    response = await providerFetch(`${baseUrl}/messages`, {
+    response = await providerFetch(
+      `${normalizeProviderBaseUrl(baseUrl)}/messages`,
+      {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -411,7 +426,8 @@ export async function streamAnthropic(
       signal: options.signal
         ? AbortSignal.any([guard.signal, options.signal])
         : guard.signal,
-    });
+      },
+    );
   } catch (e) {
     guard.stop();
     throw guard.stalled() && !isFormalBudgetError(e)
@@ -517,6 +533,128 @@ export async function streamAnthropic(
   return fullResponse;
 }
 
+/** Stream Google's native Gemini generateContent SSE API. */
+export async function streamGemini(
+  messages,
+  model,
+  baseUrl,
+  apiKey,
+  onToken,
+  onUsage,
+  onStall,
+  options = {},
+) {
+  const guard = makeStallGuard(STREAM_STALL_MS, { onHint: onStall });
+  guard.bump();
+  let response;
+  try {
+    response = await providerFetch(
+      geminiGenerateContentUrl(baseUrl, model, { stream: true }),
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-goog-api-key": apiKey,
+        },
+        body: JSON.stringify(geminiRequestBody(messages)),
+        signal: options.signal
+          ? AbortSignal.any([guard.signal, options.signal])
+          : guard.signal,
+      },
+    );
+  } catch (error) {
+    guard.stop();
+    throw guard.stalled() && !isFormalBudgetError(error)
+      ? new Error(
+          `Gemini request stalled (no response in ${STREAM_STALL_MS / 1000}s)`,
+        )
+      : error;
+  }
+
+  if (!response.ok || !response.body) {
+    guard.stop();
+    throw attachStreamRetryMetadata(
+      new Error(`Gemini error: ${response.status} ${response.statusText}`),
+      captureStreamRetryMetadata(response),
+    );
+  }
+
+  const retryMetadata = captureStreamRetryMetadata(response);
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let fullResponse = "";
+  let completed = false;
+  let latestUsage = null;
+
+  const consumeLine = async (raw) => {
+    const line = raw.trim();
+    if (!line.startsWith("data:")) return;
+    const payload = line.slice(5).trim();
+    if (!payload || payload === "[DONE]") return;
+    const data = JSON.parse(payload);
+    if (data.error) {
+      throw new Error(
+        typeof data.error.message === "string"
+          ? data.error.message
+          : "Gemini stream returned an error",
+      );
+    }
+    const candidate = data.candidates?.[0];
+    if (candidate?.finishReason || data.promptFeedback?.blockReason)
+      completed = true;
+    const usage = geminiUsage(data);
+    if (usage) latestUsage = usage;
+    for (const part of candidate?.content?.parts || []) {
+      if (part?.thought === true || typeof part?.text !== "string") continue;
+      fullResponse += part.text;
+      await _deliverToken(onToken, part.text, guard, options);
+    }
+  };
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      guard.bump();
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        try {
+          await consumeLine(line);
+        } catch (error) {
+          if (
+            options.requireCompletion ||
+            error?.isOutputBackpressureFailure === true
+          )
+            throw error;
+          // Non-governed streaming keeps its historical best-effort parsing.
+        }
+      }
+    }
+    buffer += decoder.decode();
+    if (buffer.trim()) await consumeLine(buffer);
+  } catch (error) {
+    throw attachStreamRetryMetadata(
+      guard.stalled() && !isFormalBudgetError(error)
+        ? new Error(
+            `Gemini stream stalled (no data in ${STREAM_STALL_MS / 1000}s)`,
+          )
+        : error,
+      retryMetadata,
+    );
+  } finally {
+    guard.stop();
+  }
+
+  if (latestUsage && onUsage) onUsage(latestUsage);
+  options.signal?.throwIfAborted();
+  if (options.requireCompletion && !completed)
+    throw new Error("Model stream ended before its completion marker");
+  return fullResponse;
+}
+
 /**
  * Async generator that streams a chat response.
  *
@@ -578,10 +716,9 @@ export async function* chatStream(messages, options) {
       );
   } else if (provider === "anthropic") {
     const providerDef = BUILT_IN_PROVIDERS.anthropic;
-    const url =
-      baseUrl && baseUrl !== "http://localhost:11434"
-        ? baseUrl
-        : providerDef?.baseUrl || "https://api.anthropic.com/v1";
+    const url = normalizeProviderBaseUrl(
+      baseUrl || providerDef?.baseUrl || "https://api.anthropic.com/v1",
+    );
     const key =
       apiKey ||
       (providerDef?.apiKeyEnv ? process.env[providerDef.apiKeyEnv] : null);
@@ -601,12 +738,37 @@ export async function* chatStream(messages, options) {
         options.onStall,
         options,
       );
+  } else if (provider === "gemini") {
+    const providerDef = BUILT_IN_PROVIDERS.gemini;
+    const url = normalizeProviderBaseUrl(
+      baseUrl ||
+        providerDef?.baseUrl ||
+        "https://generativelanguage.googleapis.com/v1beta",
+    );
+    const key =
+      apiKey ||
+      (providerDef?.apiKeyEnv ? process.env[providerDef.apiKeyEnv] : null);
+    if (!key) {
+      throw new Error(
+        `API key required for gemini (set ${providerDef?.apiKeyEnv || "GEMINI_API_KEY"})`,
+      );
+    }
+    providerCall = () =>
+      streamGemini(
+        messages,
+        model,
+        url,
+        key,
+        onToken,
+        onUsage,
+        options.onStall,
+        options,
+      );
   } else {
     const providerDef = BUILT_IN_PROVIDERS[provider];
-    const url =
-      baseUrl !== "http://localhost:11434"
-        ? baseUrl
-        : providerDef?.baseUrl || "https://api.openai.com/v1";
+    const url = normalizeProviderBaseUrl(
+      baseUrl || providerDef?.baseUrl || "https://api.openai.com/v1",
+    );
     const key =
       apiKey ||
       (providerDef?.apiKeyEnv ? process.env[providerDef.apiKeyEnv] : null);

package/src/lib/cowork-adapter.js

@@ -12,6 +12,11 @@ import { LLMProviderRegistry, BUILT_IN_PROVIDERS } from "./llm-providers.js";
 import { loadConfig } from "./config-manager.js";
 import { applyConfigLlmDefaults } from "./llm-config-defaults.js";
 import { captureAgentEvolutionIngress } from "./evolution/agent-evolution-ingress.js";
+import { normalizeOllamaBaseUrl } from "./ollama-base-url.js";
+import {
+  normalizeProviderBaseUrl,
+  openAICompatibleBaseUrl,
+} from "./provider-protocol.js";
 
 function plainUsage(value) {
   return value && typeof value === "object" && !Array.isArray(value)
@@ -175,17 +180,20 @@ export function createChatFn(options = {}) {
         currentModel,
         async ({ signal = opts.signal || resolved.signal } = {}) => {
           const modelMessages = await prepareMessages();
-          const res = await providerFetch(`${baseUrl}/api/chat`, {
-            method: "POST",
-            signal: requestSignal(signal),
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-              model: currentModel,
-              messages: modelMessages,
-              stream: false,
-              options: { num_predict: maxTokens },
-            }),
-          });
+          const res = await providerFetch(
+            `${normalizeOllamaBaseUrl(baseUrl)}/api/chat`,
+            {
+              method: "POST",
+              signal: requestSignal(signal),
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({
+                model: currentModel,
+                messages: modelMessages,
+                stream: false,
+                options: { num_predict: maxTokens },
+              }),
+            },
+          );
           if (!res.ok) throw new Error(`Ollama error: ${res.status}`);
           const data = await res.json();
           return chatEnvelope(
@@ -215,7 +223,9 @@ export function createChatFn(options = {}) {
               ? { system: systemMsgs.map((m) => m.content).join("\n") }
               : {}),
           };
-          const res = await providerFetch(`${baseUrl}/messages`, {
+          const res = await providerFetch(
+            `${normalizeProviderBaseUrl(baseUrl)}/messages`,
+            {
             method: "POST",
             signal: requestSignal(signal),
             headers: {
@@ -224,7 +234,8 @@ export function createChatFn(options = {}) {
               "anthropic-version": "2023-06-01",
             },
             body: JSON.stringify(body),
-          });
+            },
+          );
           if (!res.ok) throw new Error(`Anthropic error: ${res.status}`);
           const data = await res.json();
           return chatEnvelope(
@@ -246,7 +257,9 @@ export function createChatFn(options = {}) {
       currentModel,
       async ({ signal = opts.signal || resolved.signal } = {}) => {
         const modelMessages = await prepareMessages();
-        const res = await providerFetch(`${baseUrl}/chat/completions`, {
+        const res = await providerFetch(
+          `${openAICompatibleBaseUrl(provider, baseUrl)}/chat/completions`,
+          {
           method: "POST",
           signal: requestSignal(signal),
           headers: {
@@ -258,7 +271,8 @@ export function createChatFn(options = {}) {
             messages: modelMessages,
             max_tokens: maxTokens,
           }),
-        });
+          },
+        );
         if (!res.ok) throw new Error(`API error: ${res.status}`);
         const data = await res.json();
         return chatEnvelope(

package/src/lib/evolution/agent-evolution-runtime-composition.js

@@ -22,6 +22,7 @@ import { EvolutionRunLedgerAdapter } from "./evolution-run-ledger-adapter.js";
 import { createEvolutionRunWikiEvidenceResolver } from "./evolution-run-wiki-evidence-resolver.js";
 import { WikiMaintainerLedgerAdapter } from "./wiki-maintainer-ledger-adapter.js";
 import { EvidenceBackedWikiMaintainer } from "./evidence-backed-wiki-maintainer.js";
+import { ensureDirectoryTreeDurable } from "./evolution-windows-directory-durability.js";
 import { createWikiEvidenceCommitGuard } from "./wiki-evidence-commit-guard.js";
 import { EvolutionWorkbenchMetricsLedgerAdapter } from "./evolution-workbench-metrics-ledger-adapter.js";
 import { EvolutionReleaseTrainLedgerAdapter } from "./evolution-release-train-ledger-adapter.js";
@@ -158,7 +159,7 @@ function normalizeClock(clock) {
   });
 }
 
-function layout(stateRootDir, tenantId, runId, initialize = true) {
+function layout(stateRootDir, tenantId, runId, initialize = true, fsImpl = fs) {
   if (typeof stateRootDir !== "string" || stateRootDir.trim() === "") {
     throw new TypeError("stateRootDir is required");
   }
@@ -176,11 +177,12 @@ function layout(stateRootDir, tenantId, runId, initialize = true) {
     ledgerAuthorityRootDir: path.join(scope, "ledger-authority"),
     witnessFilePath: path.join(scope, "witness", "checkpoint.json"),
   });
-  if (initialize)
-    fs.mkdirSync(path.dirname(result.witnessFilePath), {
-      recursive: true,
-      mode: 0o700,
-    });
+  if (initialize) {
+    ensureDirectoryTreeDurable(
+      fsImpl,
+      path.dirname(result.witnessFilePath),
+    );
+  }
   return result;
 }
 
@@ -408,7 +410,7 @@ export function createAgentEvolutionRuntimeComposition({
   capture(authorities.witness?.signer, "sign", "witness signer");
   capture(authorities.witness?.verifier, "verify", "witness verifier");
   assertIndependentSigningAuthorities(authorities.ledger, authorities.witness);
-  const storage = layout(stateRootDir, tenantId, runId);
+  const storage = layout(stateRootDir, tenantId, runId, true, fsImpl ?? fs);
   const artifactPorts = new EvolutionArtifactPorts({
     tenantId,
     audience,
@@ -712,6 +714,7 @@ export function createAgentEvolutionRuntimeComposition({
         tenantId,
         sourceRunId,
         false,
+        fsImpl ?? fs,
       );
       if (!fs.existsSync(sourceStorage.witnessFilePath))
         throw new Error("Cache source Run witness does not exist");

package/src/lib/evolution/evolution-deployment-config.js

@@ -103,6 +103,9 @@ function withDeploymentReadiness(status) {
   return Object.freeze({
     ...status,
     readiness: Object.freeze({
+      ui: assessEvolutionDeploymentReadiness(status, {
+        requiredCommands: ["ui"],
+      }),
       ask: assessEvolutionDeploymentReadiness(status, {
         requiredCommands: ["ask"],
       }),
@@ -197,6 +200,23 @@ export async function configureEvolutionDeployment(
     options,
   );
   updateEvolutionDeploymentProfile((current) => {
+    if (
+      options.expectedProfile &&
+      JSON.stringify(current) !== JSON.stringify(options.expectedProfile)
+    ) {
+      const error = new Error(
+        "Evolution deployment profile changed during local migration",
+      );
+      error.code = "EVOLUTION_DEPLOYMENT_PROFILE_CHANGED";
+      throw error;
+    }
+    if (options.expectedProfileAbsent === true && current) {
+      const error = new Error(
+        "Evolution deployment profile was configured during local initialization",
+      );
+      error.code = "EVOLUTION_DEPLOYMENT_PROFILE_ALREADY_CONFIGURED";
+      throw error;
+    }
     if (
       current?.activeTrustRootDigest &&
       current.activeTrustRootDigest !== verified.descriptor.trustRootDigest
@@ -245,6 +265,11 @@ export async function configureEvolutionDeployment(
         verified.descriptor.revision,
       ),
     };
+    const preserveLocalMode =
+      deploymentMode === undefined &&
+      current?.deploymentMode === "local" &&
+      current.descriptorPath === verified.descriptorPath &&
+      current.trustRootPath === verified.trustRootPath;
     const preserveTestMode =
       deploymentMode === undefined &&
       current?.deploymentMode === "test" &&
@@ -257,10 +282,17 @@ export async function configureEvolutionDeployment(
       revisionFloors,
       activeTrustRootDigest: verified.descriptor.trustRootDigest,
       revokedDescriptorRevisions,
-      deploymentMode: preserveTestMode ? "test" : deploymentMode || "managed",
-      testPrivateKeyPath: preserveTestMode
-        ? current.testPrivateKeyPath
-        : testPrivateKeyPath || null,
+      deploymentMode: preserveLocalMode
+        ? "local"
+        : preserveTestMode
+          ? "test"
+          : deploymentMode || "managed",
+      testPrivateKeyPath:
+        deploymentMode === "test"
+          ? testPrivateKeyPath || null
+          : preserveTestMode
+            ? current.testPrivateKeyPath
+            : null,
     };
   }, options);
   return getEvolutionDeploymentStatus(options);

package/src/lib/evolution/evolution-deployment-loader.js

@@ -1,6 +1,6 @@
 import { createHash, createPublicKey, verify } from "node:crypto";
 import { readFile, realpath } from "node:fs/promises";
-import { isAbsolute } from "node:path";
+import { dirname, isAbsolute, join } from "node:path";
 import { types as utilTypes } from "node:util";
 import {
   assertEvolutionDeploymentActiveTrustRoot,
@@ -622,7 +622,9 @@ async function loadBuiltInFactories(commandName) {
       import("./evolution-eval-process-supervisor.js"),
       import("./governed-skill-synthesis-attestor-trust-approval-client.js"),
       import("./governed-skill-synthesis-attestor-trust-operations-client.js"),
-      import("./governed-skill-synthesis-attestor-trust-operations-cli-host.js"),
+      import(
+        "./governed-skill-synthesis-attestor-trust-operations-cli-host.js"
+      ),
     ]);
     factories.createEvolutionWorkbenchCliHost = createEvolutionWorkbenchCliHost;
     factories.createEvolutionWorkbenchReviewRuntime =
@@ -840,6 +842,15 @@ function bindFactoriesToModule(factories, moduleDigest) {
       return factories[name](options);
     };
   }
+  if (typeof factories.createLocalUiEvolutionComposition === "function") {
+    result.createLocalUiEvolutionComposition = (options = {}) => {
+      if (options?.handlerArtifactDigest !== moduleDigest)
+        throw new Error(
+          "Local UI Evolution host digest must equal the authenticated deployment module digest",
+        );
+      return factories.createLocalUiEvolutionComposition(options);
+    };
+  }
   for (const name of [
     "createSkillEvaluatedPromotionProvider",
     "createSkillPromotionReviewProvider",
@@ -1012,19 +1023,62 @@ export async function loadEvolutionDeploymentCommandDependencies(
   commandName,
   {
     env = process.env,
+    cwd = process.cwd(),
     read = readFile,
     resolveRealPath = realpath,
     importModule = (url) => import(url),
     additionalFactories = {},
+    initializeDefaultLocalUi = false,
+    initializeDefaultLocalModels = true,
   } = {},
 ) {
   if (!SUPPORTED_COMMANDS.has(commandName)) return null;
+  const localModelDependencies = () =>
+    dependencies(
+      {
+        evolutionCompositionFactory: async (context) => {
+          const { initializeDefaultLocalUiEvolutionDeployment } = await import(
+            "./local-ui-evolution-deployment.js"
+          );
+          await initializeDefaultLocalUiEvolutionDeployment({ env, cwd });
+          const admitted = await loadEvolutionDeploymentCommandDependencies(
+            commandName,
+            {
+              env,
+              cwd,
+              read,
+              resolveRealPath,
+              importModule,
+              additionalFactories,
+              initializeDefaultLocalModels: false,
+            },
+          );
+          if (typeof admitted?.evolutionCompositionFactory !== "function")
+            throw new Error(
+              "Local model command requires an authenticated Evolution deployment",
+            );
+          return admitted.evolutionCompositionFactory(context);
+        },
+      },
+      commandName,
+    );
   let descriptorPath = env.CHAINLESSCHAIN_EVOLUTION_DEPLOYMENT_DESCRIPTOR;
   let trustRootPath = env.CHAINLESSCHAIN_EVOLUTION_DEPLOYMENT_TRUST_ROOT;
+  if (
+    initializeDefaultLocalUi === true &&
+    commandName === "ui" &&
+    !descriptorPath &&
+    !trustRootPath
+  ) {
+    const { initializeDefaultLocalUiEvolutionDeployment } = await import(
+      "./local-ui-evolution-deployment.js"
+    );
+    await initializeDefaultLocalUiEvolutionDeployment({ env, cwd });
+  }
   let fromSavedProfile = false;
   let saved = null;
   if (!descriptorPath && !trustRootPath) {
-    saved = await readEvolutionDeploymentProfile({ env });
+    saved = await readEvolutionDeploymentProfile({ env, cwd });
     if (saved.error) {
       return deniedAgentDependencies(
         commandName,
@@ -1039,6 +1093,15 @@ export async function loadEvolutionDeploymentCommandDependencies(
         "Saved evolution deployment profile is disabled",
       );
     }
+    if (
+      initializeDefaultLocalModels &&
+      ["agent", "ask", "chat"].includes(commandName) &&
+      !saved.profile
+    ) {
+      // Registration/help is read-only. Bootstrap only when a real command
+      // requests its authenticated composition, then re-read current policy.
+      return localModelDependencies();
+    }
     if (!saved.error && saved.profile?.enabled) {
       descriptorPath = saved.profile.descriptorPath;
       trustRootPath = saved.profile.trustRootPath;
@@ -1086,6 +1149,39 @@ export async function loadEvolutionDeploymentCommandDependencies(
     throw error;
   }
   const { descriptor, moduleBytes } = verified;
+  const localProfile =
+    fromSavedProfile && saved.profile.deploymentMode === "local";
+  if (localProfile) {
+    const generation = saved.profile.descriptorPath.endsWith(
+      "deployment-v2.json",
+    )
+      ? 2
+      : 1;
+    const localHostPath = join(
+      dirname(saved.filePath),
+      "local-ui-host",
+      generation === 2 ? "ui-host-v2.mjs" : "ui-host.mjs",
+    );
+    const canonicalLocalHostPath = await realpath(localHostPath);
+    if (
+      !(
+        ["ui"].join(",") === descriptor.commands.join(",") ||
+        "agent,ask,chat,ui" === descriptor.commands.join(",")
+      ) ||
+      verified.modulePath !== canonicalLocalHostPath
+    ) {
+      throw new Error(
+        "Local Evolution deployment is not the protected UI host",
+      );
+    }
+    if (
+      initializeDefaultLocalModels &&
+      ["agent", "ask", "chat", "ui"].includes(commandName) &&
+      descriptor.commands.length === 1 &&
+      descriptor.commands[0] === "ui"
+    )
+      return localModelDependencies();
+  }
   if (!descriptor.commands.includes(commandName)) {
     return deniedAgentDependencies(
       commandName,
@@ -1105,8 +1201,25 @@ export async function loadEvolutionDeploymentCommandDependencies(
     throw new Error(
       "evolution deployment module must export createChainlessChainCommandDependencies",
     );
+  const builtIn = await loadBuiltInFactories(commandName);
+  let localFactories = null;
+  if (localProfile) {
+    const { createLocalUiEvolutionComposition } = await import(
+      "./local-ui-evolution-runtime.js"
+    );
+    localFactories = {
+      createLocalUiEvolutionComposition: (options = {}) =>
+        createLocalUiEvolutionComposition({
+          ...options,
+          commandName,
+          localDirectory: join(dirname(saved.filePath), "local-ui-host"),
+          env,
+          cwd,
+        }),
+    };
+  }
   const builtInFactories = bindFactoriesToModule(
-    await loadBuiltInFactories(commandName),
+    { ...builtIn, ...(localFactories || {}) },
     descriptor.moduleDigest,
   );
   if (

package/src/lib/evolution/evolution-deployment-profile.js

@@ -124,7 +124,7 @@ function normalizeProfile(value) {
   const deploymentMode = beforeDeploymentMode
     ? "managed"
     : value.deploymentMode;
-  if (!["managed", "test"].includes(deploymentMode))
+  if (!["managed", "test", "local"].includes(deploymentMode))
     throw new TypeError("evolution deployment profile mode is invalid");
   const testPrivateKeyPath = beforeDeploymentMode
     ? null
@@ -133,7 +133,7 @@ function normalizeProfile(value) {
     (deploymentMode === "test" &&
       (typeof testPrivateKeyPath !== "string" ||
         !isAbsolute(testPrivateKeyPath))) ||
-    (deploymentMode === "managed" && testPrivateKeyPath !== null)
+    (deploymentMode !== "test" && testPrivateKeyPath !== null)
   ) {
     throw new TypeError(
       "evolution deployment profile test private key path is invalid",