chainlesschain 0.166.34 → 0.166.37

package/src/gateways/ws/session-core-protocol.js

@@ -321,13 +321,29 @@ async function streamRun(message, sender, signal, context) {
   const { buildProviderSource } = await import("../../lib/provider-stream.js");
   const { createStreamRouter } = await loadSingletons();
   const router = createStreamRouter();
-  const source = buildProviderSource(provider, {
-    model: message.model,
-    baseUrl: message.baseUrl,
-    apiKey: message.apiKey,
-    prompt: message.prompt,
+  const { prepareGovernedModelTurn, governModelTokenSource } =
+    await import("../../lib/evolution/governed-model-turn.js");
+  const turn = await prepareGovernedModelTurn(
+    context?.server?.evolutionCompositionFactory ?? null,
+    {
+      mode: "ws-stream",
+      messages: [{ role: "user", content: message.prompt }],
+      signal,
+    },
+  );
+  const source = governModelTokenSource(
+    buildProviderSource(provider, {
+      model: message.model,
+      baseUrl: message.baseUrl,
+      apiKey: message.apiKey,
+      prompt: message.prompt,
+      messages: turn.governed ? turn.messages : undefined,
+      requireCompletion: turn.governed,
+      signal,
+    }),
+    turn,
     signal,
-  });
+  );
 
   let envelopeHelper = null;
   if (context?.server?.envelopeBus && message.sessionId) {
@@ -368,6 +384,7 @@ async function streamRun(message, sender, signal, context) {
     }
   }
   if (errored) return fail("STREAM_ERROR", errorMsg);
+  signal?.throwIfAborted();
   return ok({ text });
 }
 

package/src/gateways/ws/session-protocol.js

@@ -592,6 +592,7 @@ async function ensureSessionHandler(
     handler = new WSChatHandler({
       session,
       interaction: session.interaction,
+      evolutionCompositionFactory: server.evolutionCompositionFactory ?? null,
     });
   } else {
     const { WSAgentHandler } = await import("./ws-agent-handler.js");

package/src/lib/__tests__/provider-stream.test.js

@@ -34,14 +34,12 @@ function mockFetch(
       ok,
       status,
       statusText,
-      body: {
-        getReader: () => ({
-          read: async () =>
-            i < chunks.length
-              ? { value: enc.encode(chunks[i++]), done: false }
-              : { value: undefined, done: true },
-        }),
-      },
+      body: new ReadableStream({
+        pull(controller) {
+          if (i < chunks.length) controller.enqueue(enc.encode(chunks[i++]));
+          else controller.close();
+        },
+      }),
     };
   });
 }

package/src/lib/chat-core.js

@@ -98,7 +98,11 @@ async function _deliverToken(onToken, token, guard) {
   try {
     await onToken(token);
   } catch (error) {
-    if (error?.isOutputBackpressureFailure === true) throw error;
+    if (
+      options.requireCompletion ||
+      error?.isOutputBackpressureFailure === true
+    )
+      throw error;
     // Generic UI callbacks retain their historical best-effort semantics.
   } finally {
     guard.bump();
@@ -117,6 +121,7 @@ export async function streamOllama(
   onToken,
   onUsage,
   onStall,
+  options = {},
 ) {
   const guard = makeStallGuard(STREAM_STALL_MS, { onHint: onStall });
   guard.bump();
@@ -130,7 +135,9 @@ export async function streamOllama(
         messages,
         stream: true,
       }),
-      signal: guard.signal,
+      signal: options.signal
+        ? AbortSignal.any([guard.signal, options.signal])
+        : guard.signal,
     });
   } catch (e) {
     guard.stop();
@@ -149,6 +156,7 @@ export async function streamOllama(
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
   let fullResponse = "";
+  let completed = false;
   // Buffer incomplete lines across reads: an NDJSON line can be split across two
   // stream chunks (TCP doesn't align to '\n'), so parsing each chunk in
   // isolation would drop the split line entirely (both halves fail JSON.parse).
@@ -169,6 +177,9 @@ export async function streamOllama(
         if (!line) continue;
         try {
           const json = JSON.parse(line);
+          if (options.requireCompletion && json.error)
+            throw new Error("Ollama stream returned an error");
+          if (json.done === true) completed = true;
           if (json.message?.content) {
             fullResponse += json.message.content;
             await _deliverToken(onToken, json.message.content, guard);
@@ -181,7 +192,11 @@ export async function streamOllama(
             }
           }
         } catch (error) {
-          if (error?.isOutputBackpressureFailure === true) throw error;
+          if (
+            options.requireCompletion ||
+            error?.isOutputBackpressureFailure === true
+          )
+            throw error;
           // Partial JSON, skip
         }
       }
@@ -196,6 +211,9 @@ export async function streamOllama(
     guard.stop();
   }
 
+  options.signal?.throwIfAborted();
+  if (options.requireCompletion && !completed)
+    throw new Error("Model stream ended before its completion marker");
   return fullResponse;
 }
 
@@ -210,6 +228,7 @@ export async function streamOpenAI(
   onToken,
   onUsage,
   onStall,
+  options = {},
 ) {
   const guard = makeStallGuard(STREAM_STALL_MS, { onHint: onStall });
   guard.bump();
@@ -229,7 +248,9 @@ export async function streamOpenAI(
         // Servers that don't understand it simply ignore it.
         stream_options: { include_usage: true },
       }),
-      signal: guard.signal,
+      signal: options.signal
+        ? AbortSignal.any([guard.signal, options.signal])
+        : guard.signal,
     });
   } catch (e) {
     guard.stop();
@@ -248,6 +269,7 @@ export async function streamOpenAI(
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
   let fullResponse = "";
+  let completed = false;
   // Buffer incomplete lines across reads: an SSE `data:` line can be split
   // across two stream chunks, so parsing each chunk in isolation would drop the
   // split line (both halves fail JSON.parse) — losing content and usage. Keep
@@ -267,9 +289,14 @@ export async function streamOpenAI(
       for (const line of lines) {
         if (line.startsWith("data: ")) {
           const data = line.slice(6);
-          if (data === "[DONE]") continue;
+          if (data === "[DONE]") {
+            completed = true;
+            continue;
+          }
           try {
             const json = JSON.parse(data);
+            if (options.requireCompletion && json.error)
+              throw new Error("OpenAI stream returned an error");
             const content = json.choices?.[0]?.delta?.content;
             if (content) {
               fullResponse += content;
@@ -287,7 +314,11 @@ export async function streamOpenAI(
               }
             }
           } catch (error) {
-            if (error?.isOutputBackpressureFailure === true) throw error;
+            if (
+              options.requireCompletion ||
+              error?.isOutputBackpressureFailure === true
+            )
+              throw error;
             // Partial data
           }
         }
@@ -301,6 +332,9 @@ export async function streamOpenAI(
     guard.stop();
   }
 
+  options.signal?.throwIfAborted();
+  if (options.requireCompletion && !completed)
+    throw new Error("Model stream ended before its completion marker");
   return fullResponse;
 }
 
@@ -317,6 +351,7 @@ export async function streamAnthropic(
   onToken,
   onUsage,
   onStall,
+  options = {},
 ) {
   // Split out a leading system prompt (Anthropic requires it as top-level
   // `system`, not an OpenAI-style role=system message).
@@ -348,7 +383,9 @@ export async function streamAnthropic(
         ...(system ? { system } : {}),
         messages: convo,
       }),
-      signal: guard.signal,
+      signal: options.signal
+        ? AbortSignal.any([guard.signal, options.signal])
+        : guard.signal,
     });
   } catch (e) {
     guard.stop();
@@ -369,6 +406,7 @@ export async function streamAnthropic(
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
   let fullResponse = "";
+  let completed = false;
   let buf = "";
   let inputTokens = 0;
   let outputTokens = 0;
@@ -390,6 +428,9 @@ export async function streamAnthropic(
         if (!payload) continue;
         try {
           const obj = JSON.parse(payload);
+          if (options.requireCompletion && (obj.error || obj.type === "error"))
+            throw new Error("Anthropic stream returned an error");
+          if (obj.type === "message_stop") completed = true;
           if (obj.type === "content_block_delta") {
             const delta = obj.delta?.text;
             if (delta) {
@@ -408,7 +449,11 @@ export async function streamAnthropic(
             outputTokens = Number(obj.usage?.output_tokens) || outputTokens;
           }
         } catch (error) {
-          if (error?.isOutputBackpressureFailure === true) throw error;
+          if (
+            options.requireCompletion ||
+            error?.isOutputBackpressureFailure === true
+          )
+            throw error;
           /* skip malformed */
         }
       }
@@ -435,6 +480,9 @@ export async function streamAnthropic(
     });
   }
 
+  options.signal?.throwIfAborted();
+  if (options.requireCompletion && !completed)
+    throw new Error("Model stream ended before its completion marker");
   return fullResponse;
 }
 
@@ -488,7 +536,15 @@ export async function* chatStream(messages, options) {
   let providerCall;
   if (provider === "ollama") {
     providerCall = () =>
-      streamOllama(messages, model, baseUrl, onToken, onUsage, options.onStall);
+      streamOllama(
+        messages,
+        model,
+        baseUrl,
+        onToken,
+        onUsage,
+        options.onStall,
+        options,
+      );
   } else if (provider === "anthropic") {
     const providerDef = BUILT_IN_PROVIDERS.anthropic;
     const url =
@@ -512,6 +568,7 @@ export async function* chatStream(messages, options) {
         onToken,
         onUsage,
         options.onStall,
+        options,
       );
   } else {
     const providerDef = BUILT_IN_PROVIDERS[provider];
@@ -536,6 +593,7 @@ export async function* chatStream(messages, options) {
         onToken,
         onUsage,
         options.onStall,
+        options,
       );
   }
 

package/src/lib/chat-intent-service.js

@@ -19,9 +19,97 @@
 
 import { chatWithStreaming, chatStream } from "./chat-core.js";
 import { firstBalancedJson } from "./json-schema-output.js";
+import { prepareGovernedModelTurn } from "./evolution/governed-model-turn.js";
 
 const DEFAULT_INTENT_TIMEOUT_MS = 15000;
 
+async function waitForIntentOperation(operation, signal) {
+  if (signal.aborted) {
+    void Promise.resolve(operation).catch(() => {});
+    throw signal.reason;
+  }
+  let abort;
+  const cancelled = new Promise((_resolve, reject) => {
+    abort = () => reject(signal.reason);
+    signal.addEventListener("abort", abort, { once: true });
+  });
+  try {
+    return await Promise.race([operation, cancelled]);
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}
+
+async function* intentModelStream(messages, options, factory, mode) {
+  if (factory === null) {
+    yield* chatStream(messages, options);
+    return;
+  }
+  const controller = new AbortController();
+  const timeoutMs = resolveIntentTimeout(options);
+  const timer =
+    timeoutMs > 0
+      ? setTimeout(
+          () =>
+            controller.abort(
+              new Error(`intent LLM call timed out after ${timeoutMs}ms`),
+            ),
+          timeoutMs,
+        )
+      : null;
+  timer?.unref?.();
+  let completed = false;
+  try {
+    const turn = await waitForIntentOperation(
+      prepareGovernedModelTurn(factory, {
+        mode,
+        messages,
+        signal: controller.signal,
+      }),
+      controller.signal,
+    );
+    let content = "";
+    for await (const event of chatStream(turn.messages, {
+      ...options,
+      signal: controller.signal,
+      requireCompletion: true,
+    })) {
+      controller.signal.throwIfAborted();
+      if (event.type === "response-token") {
+        content += event.token;
+        yield event;
+      } else if (event.type === "response-complete") {
+        content = event.content;
+      }
+    }
+    await waitForIntentOperation(turn.complete(content), controller.signal);
+    completed = true;
+    yield { type: "response-complete", content };
+  } finally {
+    clearTimeout(timer);
+    if (!completed) controller.abort(new Error("Intent stream cancelled"));
+  }
+}
+
+async function intentModelText(messages, options, factory, mode) {
+  if (factory === null) {
+    return withIntentTimeout(
+      chatWithStreaming(messages, options),
+      resolveIntentTimeout(options),
+    );
+  }
+  let content = "";
+  for await (const event of intentModelStream(
+    messages,
+    options,
+    factory,
+    mode,
+  )) {
+    if (event.type === "response-complete") content = event.content;
+  }
+  return content;
+}
+
 /**
  * Resolve the per-call intent-classification budget. `llmOptions.intentTimeoutMs`
  * overrides the default; an explicit 0 disables the cap; NaN/negative/absent →
@@ -40,8 +128,8 @@ function resolveIntentTimeout(llmOptions) {
  * trips it, so without this the declared 15s intent budget was never enforced
  * and classification could block for minutes. Racing the deadline makes it fail
  * fast into the caller's graceful rule/verbatim fallback. `ms <= 0` disables.
- * The losing background request is harmless (chat-core releases its own socket);
- * the timer is unref'd so it never holds the process open.
+ * This helper is used only for the unconfigured legacy path; governed requests
+ * use the abortable intentModelStream deadline. The timer is unref'd.
  */
 function withIntentTimeout(promise, ms) {
   if (!(Number(ms) > 0)) return promise;
@@ -134,6 +222,7 @@ export async function understandIntent({
   contextMode = "global",
   history,
   llmOptions,
+  evolutionCompositionFactory = null,
 }) {
   if (!userInput || !userInput.trim()) {
     throw new Error("userInput required");
@@ -157,20 +246,19 @@ export async function understandIntent({
   );
 
   try {
-    const fullContent = await withIntentTimeout(
-      chatWithStreaming(
-        [
-          { role: "system", content: systemPrompt },
-          { role: "user", content: userPrompt },
-        ],
-        {
-          ...llmOptions,
-          // Lower temperature → more deterministic JSON output.
-          temperature: 0.3,
-          maxTokens: 500,
-        },
-      ),
-      resolveIntentTimeout(llmOptions),
+    const fullContent = await intentModelText(
+      [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userPrompt },
+      ],
+      {
+        ...llmOptions,
+        // Lower temperature → more deterministic JSON output.
+        temperature: 0.3,
+        maxTokens: 500,
+      },
+      evolutionCompositionFactory,
+      "intent-understand",
     );
 
     const jsonText = extractJson(fullContent);
@@ -218,6 +306,7 @@ export async function* understandIntentStream({
   contextMode = "global",
   history,
   llmOptions,
+  evolutionCompositionFactory = null,
 }) {
   if (!userInput || !userInput.trim()) {
     throw new Error("userInput required");
@@ -241,17 +330,16 @@ export async function* understandIntentStream({
   );
   let buffer = "";
   try {
-    // Incremental token yielding makes a per-call deadline awkward to apply
-    // here; this streaming variant is instead bounded by chat-core's own
-    // silence-based stall guard (CC_CHAT_STALL_MS, default 180s). The awaited
-    // understandIntent / classifyFollowupIntent paths enforce the tighter
-    // intent budget (resolveIntentTimeout) directly.
-    for await (const event of chatStream(
+    // Governed streams use an abortable per-call intent deadline. The legacy
+    // unconfigured stream retains chat-core's silence-based stall guard.
+    for await (const event of intentModelStream(
       [
         { role: "system", content: systemPrompt },
         { role: "user", content: userPrompt },
       ],
       { ...llmOptions, temperature: 0.3, maxTokens: 500 },
+      evolutionCompositionFactory,
+      "intent-understand-stream",
     )) {
       if (event.type === "response-token") {
         buffer += event.token;
@@ -461,10 +549,10 @@ function buildFollowupPrompts(userInput, context = {}) {
    - 示例: "算了"、"不用了"、"停止"、"先不做了"
 
 # 输出格式
-严格返回 JSON 格式：
+严格返回 JSON 格式，confidence 为 0 到 1 之间的数值：
 {
   "intent": "CONTINUE_EXECUTION | MODIFY_REQUIREMENT | CLARIFICATION | CANCEL_TASK",
-  "confidence": 0.0-1.0,
+  "confidence": 0.8,
   "reason": "判断理由（1-2句话）",
   "extractedInfo": "如果是 MODIFY_REQUIREMENT 或 CLARIFICATION，提取关键信息"
 }`;
@@ -492,21 +580,25 @@ ${
   return { systemPrompt, userPrompt };
 }
 
-async function llmBasedClassify(userInput, context, llmOptions) {
+async function llmBasedClassify(
+  userInput,
+  context,
+  llmOptions,
+  evolutionCompositionFactory,
+) {
   const { systemPrompt, userPrompt } = buildFollowupPrompts(userInput, context);
-  const fullContent = await withIntentTimeout(
-    chatWithStreaming(
-      [
-        { role: "system", content: systemPrompt },
-        { role: "user", content: userPrompt },
-      ],
-      {
-        ...llmOptions,
-        temperature: 0.1,
-        maxTokens: 300,
-      },
-    ),
-    resolveIntentTimeout(llmOptions),
+  const fullContent = await intentModelText(
+    [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userPrompt },
+    ],
+    {
+      ...llmOptions,
+      temperature: 0.1,
+      maxTokens: 300,
+    },
+    evolutionCompositionFactory,
+    "intent-classify",
   );
   const jsonText = extractJson(fullContent);
   if (!jsonText) throw new Error("LLM response missing JSON");
@@ -535,6 +627,7 @@ export async function classifyFollowupIntent({
   input,
   context = {},
   llmOptions,
+  evolutionCompositionFactory = null,
 }) {
   const startTime = Date.now();
   const ruleResult = ruleBasedClassify(input);
@@ -556,13 +649,19 @@ export async function classifyFollowupIntent({
   }
 
   try {
-    const llmResult = await llmBasedClassify(input, context, llmOptions);
+    const llmResult = await llmBasedClassify(
+      input,
+      context,
+      llmOptions,
+      evolutionCompositionFactory,
+    );
     return {
       ...llmResult,
       method: "llm",
       latency: Date.now() - startTime,
     };
   } catch (_err) {
+    if (evolutionCompositionFactory !== null) throw _err;
     return ruleResult.confidence > 0
       ? {
           ...ruleResult,

package/src/lib/evolution/evolution-artifact-ports.js

@@ -13,6 +13,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { types as utilTypes } from "node:util";
 import { ArtifactStore } from "../artifact-store.js";
+import { withEvolutionFileIdentity } from "./evolution-file-identity.js";
 import {
   EVOLUTION_ARTIFACT_REF_SCHEMA,
   EVOLUTION_ARTIFACT_RESOLUTION_SCHEMA,
@@ -1106,6 +1107,16 @@ function inspectPhysicalDirectory(directory, label) {
 }
 
 function inspectPhysicalIndex(indexPath, rootRealPath) {
+  return withEvolutionFileIdentity(fs, indexPath, (samePathHandle) =>
+    inspectPhysicalIndexWithIdentity(indexPath, rootRealPath, samePathHandle),
+  );
+}
+
+function inspectPhysicalIndexWithIdentity(
+  indexPath,
+  rootRealPath,
+  samePathHandle,
+) {
   let pathStat;
   let realPath;
   let descriptor = null;
@@ -1128,7 +1139,7 @@ function inspectPhysicalIndex(indexPath, rootRealPath) {
     );
     const descriptorStat = fs.fstatSync(descriptor);
     assertRegularSingleLink(descriptorStat, "ArtifactStore index descriptor");
-    if (!sameFileIdentity(pathStat, descriptorStat)) {
+    if (!samePathHandle(pathStat, descriptorStat)) {
       throw artifactError(
         EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
         "ArtifactStore index pathname and descriptor identities differ",
@@ -1375,6 +1386,12 @@ function parseTrustedIndexBytes(bytes) {
 }
 
 function readTrustedIndexSnapshot(layout) {
+  return withEvolutionFileIdentity(fs, layout.indexPath, (samePathHandle) =>
+    readTrustedIndexSnapshotWithIdentity(layout, samePathHandle),
+  );
+}
+
+function readTrustedIndexSnapshotWithIdentity(layout, samePathHandle) {
   attestStoreDirectories(layout);
   let beforePathStat;
   let beforeDescriptorStat;
@@ -1412,7 +1429,7 @@ function readTrustedIndexSnapshot(layout) {
       "ArtifactStore index descriptor",
     );
     if (
-      !sameFileIdentity(beforePathStat, beforeDescriptorStat) ||
+      !samePathHandle(beforePathStat, beforeDescriptorStat) ||
       beforeDescriptorStat.size > EVOLUTION_ARTIFACT_MAX_INDEX_BYTES
     ) {
       throw artifactError(
@@ -2311,6 +2328,26 @@ export class EvolutionArtifactPorts {
   }
 
   #readStoredBytes(entry, normalizedEntry, expectedDigest) {
+    const expectedPath = path.resolve(
+      this.#store.layout.filesDir,
+      normalizedEntry.file,
+    );
+    return withEvolutionFileIdentity(fs, expectedPath, (samePathHandle) =>
+      this.#readStoredBytesWithIdentity(
+        entry,
+        normalizedEntry,
+        expectedDigest,
+        samePathHandle,
+      ),
+    );
+  }
+
+  #readStoredBytesWithIdentity(
+    entry,
+    normalizedEntry,
+    expectedDigest,
+    samePathHandle,
+  ) {
     attestStoreDirectories(this.#store.layout);
     const expectedHex = expectedDigest.slice("sha256:".length);
     let storedPath;
@@ -2387,7 +2424,7 @@ export class EvolutionArtifactPorts {
         beforeDescriptorStat,
         "stored artifact descriptor",
       );
-      if (!sameFileIdentity(beforePathStat, beforeDescriptorStat)) {
+      if (!samePathHandle(beforePathStat, beforeDescriptorStat)) {
         throw artifactError(
           EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
           "stored artifact pathname and descriptor identities differ",

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

@@ -16,9 +16,12 @@ const SUPPORTED_COMMANDS = new Set([
   "cowork",
   "desktop",
   "evolution",
+  "hub",
   "marketplace",
   "orchestrate",
   "serve",
+  "stream",
+  "ui",
 ]);
 
 function canonical(value) {
@@ -285,10 +288,13 @@ async function loadBuiltInFactories(commandName) {
     commandName === "chat" ||
     commandName === "compact" ||
     commandName === "complete" ||
+    commandName === "hub" ||
     commandName === "desktop" ||
     commandName === "cowork" ||
     commandName === "orchestrate" ||
-    commandName === "serve"
+    commandName === "serve" ||
+    commandName === "stream" ||
+    commandName === "ui"
   ) {
     const { createAgentEvolutionRuntimeComposition } =
       await import("./agent-evolution-runtime-composition.js");