@evident-ai/cli 3.6.1-dev.69de1a0 → 3.6.1-dev.6d23da1

package/README.md

@@ -125,6 +125,10 @@ Options:
 - `--opencode-config-overlay <path>` — Apply a runner-provided OpenCode config
   before starting OpenCode. Relative paths are resolved from the working directory;
   an existing `opencode.jsonc` is replaced before `opencode.json`.
+- `--auto-configure-credentials-proxy` — Install Evident's generated `evident-*`
+  OpenCode provider entries for the runner's credential pool. This is off by default;
+  without it, the CLI only delivers `EVIDENT_PROXY_TOKEN` and leaves provider
+  configuration to you.
 - `--credential-sync-marker <path>` — Own the interval credential sync and write
   this marker once the shutdown flush has finished, so the runner image's lifecycle
   hooks can wait on it.

package/dist/index.js

@@ -1442,7 +1442,7 @@ import ora4 from "ora";
 import { select as select4 } from "@inquirer/prompts";
 
 // src/lib/telemetry.ts
-var CLI_VERSION = (true ? "3.6.1-dev.69de1a0" : void 0) ?? process.env.npm_package_version ?? "unknown";
+var CLI_VERSION = (true ? "3.6.1-dev.6d23da1" : void 0) ?? process.env.npm_package_version ?? "unknown";
 function getCliVersion() {
   return CLI_VERSION;
 }
@@ -3209,6 +3209,52 @@ async function getModelAttachmentCapability(port, model, client) {
     return null;
   }
 }
+async function isPinnedProviderLoaded(port, model, client) {
+  if (client?.version === "v2") return null;
+  const { model: baseModel } = splitModelVariant(model);
+  if (!baseModel) return null;
+  const slash = baseModel.indexOf("/");
+  if (slash <= 0) return null;
+  const providerId = baseModel.slice(0, slash);
+  try {
+    const res = await requestWithClient(port, client, "/config/providers");
+    if (!res.ok) {
+      console.error(
+        `[isPinnedProviderLoaded] GET /config/providers returned HTTP ${res.status} (port ${port})`
+      );
+      return null;
+    }
+    const body = await res.json();
+    if (body === null || typeof body !== "object" || Array.isArray(body)) {
+      console.error(
+        `[isPinnedProviderLoaded] GET /config/providers body was not a plain object (port ${port})`
+      );
+      return null;
+    }
+    const providers = body.providers;
+    if (!Array.isArray(providers)) {
+      console.error(
+        `[isPinnedProviderLoaded] GET /config/providers body had no providers array (port ${port})`
+      );
+      return null;
+    }
+    const providerIds = providers.filter(
+      (provider) => provider !== null && typeof provider === "object" && typeof provider.id === "string"
+    ).map((provider) => provider.id);
+    if (providerIds.length === 0) {
+      console.error(
+        `[isPinnedProviderLoaded] GET /config/providers had no provider entries with string ids (port ${port})`
+      );
+      return null;
+    }
+    return providerIds.includes(providerId);
+  } catch (err) {
+    console.error(
+      `[isPinnedProviderLoaded] GET /config/providers failed (port ${port}): ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
+}
 async function buildFileParts(attachments, capable) {
   const outcomes = [];
   const parts = [];
@@ -8722,6 +8768,47 @@ var ChannelDriver = class _ChannelDriver {
         agent: message.opencode_agent ?? void 0,
         model: message.opencode_model ?? void 0
       };
+      const pinnedProviderLoaded = await isPinnedProviderLoaded(
+        this.port,
+        options.model,
+        this.openCodeClient
+      );
+      if (pinnedProviderLoaded === false) {
+        const dispatchedModel = message.opencode_model;
+        const separator = dispatchedModel?.indexOf("/") ?? -1;
+        const hasProviderAndModel = dispatchedModel !== null && separator > 0 && separator < dispatchedModel.length - 1;
+        const providerId = hasProviderAndModel ? dispatchedModel.slice(0, separator) : null;
+        const modelId = hasProviderAndModel ? dispatchedModel.slice(separator + 1) : null;
+        const errorMessage3 = `Provider namespace not loaded on this runner: ${message.opencode_model}. Refused before dispatch; no turn was started.`;
+        this.log({
+          level: "error",
+          message: `Refusing message ${message.id.slice(0, 8)} in conversation ${conv.id.slice(0, 8)}: provider namespace ${providerId ?? "(unknown)"} is not loaded; no turn was started`,
+          conversation_id: conv.id,
+          message_id: message.id
+        });
+        try {
+          await this.markFailed(conv.id, message.id, sessionId, errorMessage3, void 0, {
+            classification: {
+              kind: "model_auth",
+              providerId,
+              modelId,
+              reason: "missing"
+            },
+            errorShape: { name: null, statusCode: null }
+          });
+          this.signalDispatchNotStarted(conv, message, "model_provider_absent");
+        } catch (markErr) {
+          this.log({
+            level: "warn",
+            message: `markFailed PATCH for refused message ${message.id.slice(0, 8)} (conversation ${conv.id.slice(0, 8)}) failed: ${markErr instanceof Error ? markErr.message : String(markErr)}`,
+            conversation_id: conv.id,
+            message_id: message.id
+          });
+          this.signalDispatchNotStarted(conv, message, "failure_unreported");
+        }
+        await this.repairProviderRegistry(conv.id, message.id);
+        break;
+      }
       let opencodeMessageId;
       let preDispatchUserIds = null;
       try {
@@ -13920,22 +14007,6 @@ function mergeManagedOpenCodeConfigContent(content, managedProviders) {
   }
   return JSON.stringify({ ...config, provider: { ...provider, ...managedProviders } });
 }
-function removeManagedOpenCodeConfigContent(content) {
-  if (!content?.trim()) return content;
-  const config = parseConfigContent(content);
-  if (typeof config.provider !== "object" || config.provider === null || Array.isArray(config.provider)) {
-    return content;
-  }
-  const provider = { ...config.provider };
-  let changed = false;
-  for (const namespace of CREDENTIAL_PROXY_NATIVE_NAMESPACES) {
-    if (namespace in provider) {
-      delete provider[namespace];
-      changed = true;
-    }
-  }
-  return changed ? JSON.stringify({ ...config, provider }) : content;
-}
 function isFile(filePath) {
   return existsSync2(filePath) && statSync6(filePath).isFile();
 }
@@ -14397,7 +14468,7 @@ async function responseJson(response) {
 function readSetup(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
   const setup = value;
-  if (typeof setup.runner_id !== "string" || typeof setup.generation !== "string" || typeof setup.status !== "string" || setup.token_id !== null && typeof setup.token_id !== "string") {
+  if (typeof setup.runner_id !== "string" || typeof setup.generation !== "string" || typeof setup.status !== "string" || setup.token_id !== null && typeof setup.token_id !== "string" || typeof setup.acknowledged_at !== "string" && setup.acknowledged_at !== null) {
     return null;
   }
   return setup;
@@ -14406,16 +14477,6 @@ function clearLocalSetup(options) {
   const env = options.env ?? process.env;
   (options.store ?? defaultStore).clear(options.agentId);
   delete env.EVIDENT_PROXY_TOKEN;
-  try {
-    const content = removeManagedOpenCodeConfigContent(env.OPENCODE_CONFIG_CONTENT);
-    if (content === void 0) delete env.OPENCODE_CONFIG_CONTENT;
-    else env.OPENCODE_CONFIG_CONTENT = content;
-  } catch (error2) {
-    options.log(
-      "MANAGED-INFERENCE-CLEANUP-PARTIAL: stored credentials were removed, but malformed OPENCODE_CONFIG_CONTENT could not be inspected",
-      "warn"
-    );
-  }
 }
 async function discoverManagedInferenceSetup(options) {
   const headers = requestHeaders(options);
@@ -14439,6 +14500,25 @@ async function discoverManagedInferenceSetup(options) {
   const setup = readSetup(body?.setup);
   return setup ? { kind: "setup", setup } : { kind: "failed", reason: "Managed setup discovery returned an invalid response" };
 }
+async function enrollManagedInferenceSetup(options) {
+  const response = await post(options, "enroll", {});
+  if (!response) {
+    return { kind: "failed", reason: safeFailure("Managed credential enrollment") };
+  }
+  if (response.status === 404) {
+    return { kind: "none" };
+  }
+  const body = await responseJson(response);
+  if (!response.ok) {
+    const serverError = body?.error;
+    return {
+      kind: "failed",
+      reason: typeof serverError === "string" && serverError.trim() ? redactDiagnosticText(serverError).slice(0, 500) : safeFailure("Managed credential enrollment", response.status)
+    };
+  }
+  const setup = readSetup(body?.setup);
+  return setup ? { kind: "setup", setup } : { kind: "failed", reason: "Managed credential enrollment returned an invalid response" };
+}
 async function post(options, operation, body) {
   const headers = requestHeaders(options);
   try {
@@ -14453,31 +14533,37 @@ async function post(options, operation, body) {
   }
 }
 function applyCredential(options, credential) {
-  const { config, unsupportedProviders } = buildCredentialProxyNativeConfig({
-    inferenceBaseUrl: credential.inferenceBaseUrl,
-    modelDescriptors: credential.modelDescriptors
-  });
-  if (unsupportedProviders.length > 0 || Object.keys(config.provider).length === 0) {
-    return "Managed setup contains unsupported provider descriptors";
-  }
   const env = options.env ?? process.env;
   let merged;
-  try {
-    merged = mergeManagedOpenCodeConfigContent(env.OPENCODE_CONFIG_CONTENT, config.provider);
-  } catch (error2) {
-    return "OPENCODE_CONFIG_CONTENT is malformed; managed providers were not installed";
+  if (options.autoConfigureCredentialsProxy) {
+    const { config, unsupportedProviders } = buildCredentialProxyNativeConfig({
+      inferenceBaseUrl: credential.inferenceBaseUrl,
+      modelDescriptors: credential.modelDescriptors
+    });
+    if (unsupportedProviders.length > 0 || Object.keys(config.provider).length === 0) {
+      return "Managed setup contains unsupported provider descriptors";
+    }
+    try {
+      merged = mergeManagedOpenCodeConfigContent(env.OPENCODE_CONFIG_CONTENT, config.provider);
+    } catch (error2) {
+      return "OPENCODE_CONFIG_CONTENT is malformed; managed providers were not installed";
+    }
   }
   try {
     (options.store ?? defaultStore).set(options.agentId, credential);
   } catch (error2) {
+    const detail = (error2 instanceof Error ? error2.message : String(error2)).replaceAll(
+      credential.token,
+      "[redacted]"
+    );
     options.log(
-      `MANAGED-INFERENCE-STORE-FAILED: runner=${options.agentId} generation=${credential.generation}`,
+      `MANAGED-INFERENCE-STORE-FAILED: runner=${options.agentId} generation=${credential.generation} detail=${redactDiagnosticText(detail)}`,
       "warn"
     );
     return "Managed credentials could not be written to the protected store";
   }
   env.EVIDENT_PROXY_TOKEN = credential.token;
-  env.OPENCODE_CONFIG_CONTENT = merged;
+  if (merged !== void 0) env.OPENCODE_CONFIG_CONTENT = merged;
   return null;
 }
 async function reportManagedInferenceApplyFailure(options, failure) {
@@ -14528,7 +14614,7 @@ async function prepareManagedInferenceSetup(options, discovery, health) {
     }
     return reaffirmStored(options, stored);
   }
-  if (discovery.setup.status === "acknowledged" && stored?.generation === discovery.setup.generation && stored.tokenId === discovery.setup.token_id) {
+  if (discovery.setup.acknowledged_at !== null && stored?.generation === discovery.setup.generation && stored.tokenId === discovery.setup.token_id) {
     return reaffirmStored(options, stored);
   }
   const response = await post(options, "bootstrap", { generation: discovery.setup.generation });
@@ -14566,7 +14652,7 @@ async function acknowledgeManagedInferenceSetup(options, preparation) {
   const response = await post(options, "acknowledge", {
     generation: preparation.generation,
     token_id: preparation.tokenId,
-    config_validated: true
+    config_validated: options.autoConfigureCredentialsProxy === true
   });
   if (!response?.ok) {
     throw new Error(
@@ -16369,13 +16455,17 @@ async function run(options) {
       agentId: state.agentId,
       apiUrl: getApiUrlConfig(),
       getAuthHeader: () => state.authHeader,
+      autoConfigureCredentialsProxy: options.autoConfigureCredentialsProxy,
       log: (message, level = "info") => logActivity(state, {
         type: level === "error" ? "error" : "info",
         level,
         ...level === "error" ? { error: message } : { message }
       })
     };
-    const managedDiscovery = await discoverManagedInferenceSetup(managedSetupOptions);
+    let managedDiscovery = await discoverManagedInferenceSetup(managedSetupOptions);
+    if (managedDiscovery.kind === "none") {
+      managedDiscovery = await enrollManagedInferenceSetup(managedSetupOptions);
+    }
     let managedPreparation = { kind: "none" };
     if (managedDiscovery.kind === "failed") {
       managedPreparation = managedDiscovery;
@@ -16996,6 +17086,9 @@ program.command("run").description("Connect to Evident and process messages").op
 ).option(
   "--opencode-config-overlay <path>",
   "Apply this runner-provided OpenCode config before starting OpenCode."
+).option(
+  "--auto-configure-credentials-proxy",
+  "Install Evident's generated OpenCode providers for the runner's credential pool (off by default)."
 ).option(
   "--credential-sync-marker <path>",
   "Own the interval credential sync and write this marker once the shutdown flush has finished, so the runner image's lifecycle hooks can wait on it."
@@ -17039,6 +17132,7 @@ program.command("run").description("Connect to Evident and process messages").op
       restoreSessionDb: options.restoreSessionDb,
       restoreRunnerCredentials: options.restoreRunnerCredentials,
       opencodeConfigOverlay: options.opencodeConfigOverlay,
+      autoConfigureCredentialsProxy: options.autoConfigureCredentialsProxy,
       credentialSyncMarker: options.credentialSyncMarker
     });
   }