chainlesschain 0.166.112 → 0.166.115

package/src/gateways/ws/llm-chat-protocol.js

@@ -38,12 +38,35 @@ import {
   streamOpenAI,
   streamAnthropic,
   streamGemini,
+  STREAM_STALL_MS,
 } from "../../lib/chat-core.js";
 import { BUILT_IN_PROVIDERS } from "../../lib/llm-providers.js";
 import { resolveLlmCreds } from "./llm-creds.js";
 import { prepareGovernedModelTurn } from "../../lib/evolution/governed-model-turn.js";
 import { normalizeOllamaBaseUrl } from "../../lib/ollama-base-url.js";
 import { normalizeProviderBaseUrl } from "../../lib/provider-protocol.js";
+import { raceWithAbort } from "../../lib/abort-utils.js";
+
+const activeChats = new WeakMap();
+const CHAT_SETUP_TIMEOUT_MS = 60_000;
+
+/** A request id is scoped to its originating socket, never another client. */
+export function cancelLlmChat(ws, id) {
+  activeChats.get(ws)?.get(id)?.abort(new Error("Chat cancelled"));
+}
+
+async function waitForChatPhase(operation, controller, phase) {
+  const timer = setTimeout(
+    () => controller.abort(new Error(`Chat ${phase} timed out after 60s`)),
+    CHAT_SETUP_TIMEOUT_MS,
+  );
+  timer.unref?.();
+  try {
+    return await raceWithAbort(operation, controller.signal);
+  } finally {
+    clearTimeout(timer);
+  }
+}
 
 function validateMessages(messages) {
   if (!Array.isArray(messages) || messages.length === 0)
@@ -77,7 +100,17 @@ export async function handleLlmChat(server, id, ws, message) {
     return;
   }
 
-  const creds = resolveLlmCreds(server, message);
+  let creds;
+  try {
+    creds = resolveLlmCreds(server, message);
+  } catch (error) {
+    send({
+      type: `${topic}.result`,
+      ok: false,
+      error: error?.message || String(error),
+    });
+    return;
+  }
   if (!creds || !creds.provider) {
     send({
       type: `${topic}.result`,
@@ -100,6 +133,7 @@ export async function handleLlmChat(server, id, ws, message) {
 
   let accumulator = "";
   const onToken = (token) => {
+    controller.signal.throwIfAborted();
     if (typeof token !== "string" || token.length === 0) return;
     accumulator += token;
     send({
@@ -114,59 +148,99 @@ export async function handleLlmChat(server, id, ws, message) {
   };
 
   const controller = new AbortController();
+  let requests = null;
+  if (ws && (typeof ws === "object" || typeof ws === "function")) {
+    requests = activeChats.get(ws);
+    if (!requests) activeChats.set(ws, (requests = new Map()));
+    if (requests.has(id)) {
+      send({
+        type: `${topic}.result`,
+        ok: false,
+        error: "Chat request is already active",
+      });
+      return;
+    }
+    requests.set(id, controller);
+  }
   const disconnect = () =>
     controller.abort(new Error("Chat connection closed"));
+  const onStall = (elapsedMs, timeoutMs) => {
+    if (controller.signal.aborted) return;
+    send({
+      type: `${topic}.status`,
+      status: {
+        stage: "waiting",
+        provider: creds.provider,
+        model: creds.model,
+        elapsedMs,
+        timeoutMs,
+      },
+    });
+  };
   ws?.once?.("close", disconnect);
   try {
-    const turn = await prepareGovernedModelTurn(
-      server.evolutionCompositionFactory ?? null,
-      {
+    const turn = await waitForChatPhase(
+      prepareGovernedModelTurn(server.evolutionCompositionFactory ?? null, {
         mode: "ws-llm-chat",
         messages: message.messages,
         signal: controller.signal,
-      },
+      }),
+      controller,
+      "initialization",
     );
     const streamOptions = {
       requireCompletion: turn.governed,
       signal: controller.signal,
     };
+    // Tell the browser the configured deadline even when waiting hints are
+    // disabled, so a slow local model gets its full loading budget.
+    onStall(0, STREAM_STALL_MS);
     const baseUrl =
       creds.provider === "ollama"
         ? normalizeOllamaBaseUrl(creds.baseUrl)
         : normalizeProviderBaseUrl(creds.baseUrl);
     if (creds.provider === "ollama") {
-      await streamOllama(
-        turn.messages,
-        creds.model,
-        baseUrl,
-        onToken,
-        onUsage,
-        undefined,
-        streamOptions,
+      await raceWithAbort(
+        streamOllama(
+          turn.messages,
+          creds.model,
+          baseUrl,
+          onToken,
+          onUsage,
+          onStall,
+          streamOptions,
+        ),
+        controller.signal,
       );
     } else if (creds.provider === "anthropic") {
       const url = baseUrl;
-      await streamAnthropic(
-        turn.messages,
-        creds.model,
-        url,
-        creds.apiKey,
-        onToken,
-        onUsage,
-        undefined,
-        streamOptions,
+      await raceWithAbort(
+        streamAnthropic(
+          turn.messages,
+          creds.model,
+          url,
+          creds.apiKey,
+          onToken,
+          onUsage,
+          onStall,
+          streamOptions,
+        ),
+        controller.signal,
       );
     } else if (creds.provider === "gemini") {
       const url = baseUrl;
-      await streamGemini(
-        turn.messages,
-        creds.model,
-        url,
-        creds.apiKey,
-        onToken,
-        onUsage,
-        undefined,
-        streamOptions,
+      await raceWithAbort(
+        streamGemini(
+          turn.messages,
+          creds.model,
+          url,
+          creds.apiKey,
+          onToken,
+          onUsage,
+          onStall,
+          streamOptions,
+        ),
+        controller.signal,
       );
     } else {
       // OpenAI-compatible — covers openai / volcengine / deepseek / dashscope /
@@ -174,19 +248,26 @@ export async function handleLlmChat(server, id, ws, message) {
       // BUILT_IN_PROVIDERS already applied above.
       const def = BUILT_IN_PROVIDERS[creds.provider];
       const url = baseUrl || def?.baseUrl;
-      await streamOpenAI(
-        turn.messages,
-        creds.model,
-        url,
-        creds.apiKey,
-        onToken,
-        onUsage,
-        undefined,
-        streamOptions,
+      await raceWithAbort(
+        streamOpenAI(
+          turn.messages,
+          creds.model,
+          url,
+          creds.apiKey,
+          onToken,
+          onUsage,
+          onStall,
+          streamOptions,
+        ),
+        controller.signal,
       );
     }
 
-    await turn.complete(accumulator);
+    await waitForChatPhase(
+      turn.complete(accumulator),
+      controller,
+      "completion",
+    );
     send({
       type: `${topic}.result`,
       ok: true,
@@ -205,6 +286,8 @@ export async function handleLlmChat(server, id, ws, message) {
       error: err?.message || String(err),
     });
   } finally {
+    requests?.delete(id);
+    if (requests?.size === 0) activeChats.delete(ws);
     ws?.removeListener?.("close", disconnect);
   }
 }

package/src/gateways/ws/message-dispatcher.js

@@ -30,6 +30,7 @@ import {
   handleRemoteSessionTerminal,
 } from "./remote-session-protocol.js";
 import { RemoteCommandLedger } from "../../harness/remote-command-ledger.js";
+import { cancelLlmChat } from "./llm-chat-protocol.js";
 
 /**
  * Reconnect-safe command execution. When a message carries a stable
@@ -293,6 +294,7 @@ export function createWsMessageDispatcher(server) {
         "chat.intent.classify-followup": () =>
           server._handleChatIntentClassifyFollowup(id, ws, message),
         "llm.chat": () => server._handleLlmChat(id, ws, message),
+        "llm.chat.cancel": () => cancelLlmChat(ws, id),
       };
 
       // Static core routes take precedence and are dispatched directly. The

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

@@ -200,6 +200,16 @@ 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",
@@ -272,12 +282,11 @@ export async function configureEvolutionDeployment(
       revisionFloors,
       activeTrustRootDigest: verified.descriptor.trustRootDigest,
       revokedDescriptorRevisions,
-      deploymentMode:
-        preserveLocalMode
-          ? "local"
-          : preserveTestMode
-            ? "test"
-            : deploymentMode || "managed",
+      deploymentMode: preserveLocalMode
+        ? "local"
+        : preserveTestMode
+          ? "test"
+          : deploymentMode || "managed",
       testPrivateKeyPath:
         deploymentMode === "test"
           ? testPrivateKeyPath || null

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

@@ -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 =
@@ -1027,9 +1029,39 @@ export async function loadEvolutionDeploymentCommandDependencies(
     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 (
@@ -1061,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;
@@ -1111,19 +1152,35 @@ export async function loadEvolutionDeploymentCommandDependencies(
   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",
-      "ui-host.mjs",
+      generation === 2 ? "ui-host-v2.mjs" : "ui-host.mjs",
     );
     const canonicalLocalHostPath = await realpath(localHostPath);
     if (
-      descriptor.commands.length !== 1 ||
-      descriptor.commands[0] !== "ui" ||
+      !(
+        ["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");
+      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(
@@ -1154,6 +1211,7 @@ export async function loadEvolutionDeploymentCommandDependencies(
       createLocalUiEvolutionComposition: (options = {}) =>
         createLocalUiEvolutionComposition({
           ...options,
+          commandName,
           localDirectory: join(dirname(saved.filePath), "local-ui-host"),
           env,
           cwd,

package/src/lib/evolution/evolution-evidence-projector.js

@@ -93,6 +93,8 @@ const TRUSTED_PAYLOAD_COMMITMENT_PURPOSE =
 const LEGACY_LOCAL_UI_TENANT_ID_PATTERN = /^local-ui-[a-f0-9]{32}$/u;
 const FORMATTED_LOCAL_UI_TENANT_ID_PATTERN =
   /^local-ui-(?:[a-f0-9]{8}-){3}[a-f0-9]{8}$/u;
+const ENCODED_LOCAL_UI_TENANT_ID_PATTERN =
+  /^local-ui-(?:[a-p]{8}-){3}[a-p]{8}$/u;
 
 const INPUT_KEYS = new Set(["sourceEnvelope", "payload"]);
 const SOURCE_VERIFICATION_KEYS = new Set([
@@ -877,17 +879,32 @@ function normalizeId(value, label, maximum = 256) {
   return value;
 }
 
-function normalizeTenantId(value, label) {
-  if (
+function isLocalUiTenantId(value) {
+  return (
     typeof value === "string" &&
     (LEGACY_LOCAL_UI_TENANT_ID_PATTERN.test(value) ||
-      FORMATTED_LOCAL_UI_TENANT_ID_PATTERN.test(value))
-  ) {
-    return value;
-  }
+      FORMATTED_LOCAL_UI_TENANT_ID_PATTERN.test(value) ||
+      ENCODED_LOCAL_UI_TENANT_ID_PATTERN.test(value))
+  );
+}
+
+function normalizeTenantId(value, label) {
+  if (isLocalUiTenantId(value)) return value;
   return normalizeId(value, label);
 }
 
+function normalizeLocalAttestationId(value, label, tenantId, suffix) {
+  // A bound local identity is already admitted as tenant metadata. Inspect its
+  // fixed reference structure without treating its random digits as content;
+  // preserve the original signed bytes and scan every other identifier fully.
+  const scanValue =
+    isLocalUiTenantId(tenantId) && value === `local-ui-${tenantId}-${suffix}`
+      ? `local-ui-local-identity-${suffix}`
+      : value;
+  normalizeId(scanValue, label);
+  return value;
+}
+
 function normalizeDigest(
   value,
   label,
@@ -946,7 +963,6 @@ function normalizeOpaqueUri(value, { label, schemes, tenantId }) {
       `${label} is invalid`,
     );
   }
-  assertNoKnownSecrets(value);
   if (
     /[?#@\\%\s]/u.test(value) ||
     hasUriControlOrWhitespace(value) ||
@@ -985,7 +1001,11 @@ function normalizeOpaqueUri(value, { label, schemes, tenantId }) {
     parsed.port ||
     parsed.search ||
     parsed.hash ||
-    parsed.hostname !== formatLocalUiTenantReferenceId(tenantId) ||
+    (parsed.hostname !== formatLocalUiTenantReferenceId(tenantId) &&
+      !(
+        LEGACY_LOCAL_UI_TENANT_ID_PATTERN.test(tenantId) &&
+        parsed.hostname === tenantId
+      )) ||
     !decodedPath.startsWith("/") ||
     decodedPath
       .split("/")
@@ -996,6 +1016,14 @@ function normalizeOpaqueUri(value, { label, schemes, tenantId }) {
       `${label} is outside the tenant-scoped URI policy`,
     );
   }
+  // Only the exact, bound local host is identity metadata. Keep the complete
+  // original path in the scan, and never rewrite persisted URI/digest bytes.
+  const localPrefix = `${scheme}://${parsed.hostname}`;
+  const scanValue =
+    isLocalUiTenantId(tenantId) && value.startsWith(`${localPrefix}/`)
+      ? `${scheme}://local-ui-identity${value.slice(localPrefix.length)}`
+      : value;
+  assertNoKnownSecrets(scanValue);
   return value;
 }
 
@@ -2291,8 +2319,18 @@ function validateAttestation(value, receipt) {
       "projection attestation is invalid or unbound",
     );
   }
-  normalizeId(value.keyId, "attestation keyId");
-  normalizeId(value.issuer, "attestation issuer");
+  normalizeLocalAttestationId(
+    value.keyId,
+    "attestation keyId",
+    receipt.tenantId,
+    "attestation",
+  );
+  normalizeLocalAttestationId(
+    value.issuer,
+    "attestation issuer",
+    receipt.tenantId,
+    "evolution-projector",
+  );
   return deepFreeze(cloneCanonical(value));
 }
 

package/src/lib/evolution/governed-model-turn.js

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { types } from "node:util";
 import { captureAgentEvolutionRuntimeComposition } from "./agent-evolution-runtime-composition-brand.js";
 import { captureAgentEvolutionIngress } from "./agent-evolution-ingress.js";
-import { formatOpaqueHexId } from "./opaque-hex-id.js";
+import { encodeOpaqueHexId } from "./opaque-hex-id.js";
 
 export function readEvolutionCompositionFactory(dependencies = {}) {
   if (
@@ -44,7 +44,7 @@ export async function prepareGovernedModelTurn(
   }
   if (typeof factory !== "function")
     throw new TypeError("Invalid evolution composition factory");
-  const runId = `${mode}-${formatOpaqueHexId(
+  const runId = `${mode}-${encodeOpaqueHexId(
     randomUUID().replaceAll("-", ""),
   )}`;
   const composition = captureAgentEvolutionRuntimeComposition(