chainlesschain 0.166.36 → 0.166.37

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-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");

package/src/lib/evolution/governed-hub-llm.js

@@ -0,0 +1,56 @@
+import { prepareGovernedModelTurn } from "./governed-model-turn.js";
+
+// A scoped wrapper preserves the Hub's independent local/cloud consent check.
+// Never replace llm on the process-wide cached Hub or its analysis engine.
+export function createGovernedHubLlm(llm, factory) {
+  if (
+    !llm ||
+    typeof llm.chat !== "function" ||
+    typeof llm.isLocal !== "boolean"
+  ) {
+    throw new TypeError(
+      "A Hub model client with declared locality is required",
+    );
+  }
+  if (typeof factory !== "function")
+    throw new TypeError("A Hub evolution factory is required");
+  const identity = { name: llm.name, isLocal: llm.isLocal, chat: llm.chat };
+  const assertIdentity = () => {
+    if (
+      llm.name !== identity.name ||
+      llm.isLocal !== identity.isLocal ||
+      llm.chat !== identity.chat
+    ) {
+      throw new Error(
+        "Hub model identity changed; reopen the analysis invocation",
+      );
+    }
+  };
+  const chat = identity.chat.bind(llm);
+  return Object.freeze({
+    get name() {
+      assertIdentity();
+      return identity.name;
+    },
+    get isLocal() {
+      assertIdentity();
+      return identity.isLocal;
+    },
+    async chat(messages, options = {}) {
+      assertIdentity();
+      const turn = await prepareGovernedModelTurn(factory, {
+        mode: "hub-analysis",
+        messages,
+        signal: options.signal,
+      });
+      assertIdentity();
+      const response = await chat(turn.messages, options);
+      assertIdentity();
+      if (!response || typeof response.text !== "string") {
+        throw new Error("Hub model response must contain text");
+      }
+      await turn.complete(response.text);
+      return response;
+    },
+  });
+}

package/src/lib/evolution/governed-hub-resolver.js

@@ -0,0 +1,65 @@
+import { prepareGovernedModelTurn } from "./governed-model-turn.js";
+import { createGovernedHubLlm } from "./governed-hub-llm.js";
+
+export function createGovernedHubResolver(ports, factory) {
+  if (typeof factory !== "function")
+    throw new TypeError("A resolver evolution factory is required");
+  const {
+    resolver,
+    llm,
+    embeddingStage,
+    EntityResolver,
+    EmbeddingStage,
+    LLMStage,
+  } = ports;
+  // Rebuild stages for each drain. Neither the shared resolver nor its embedding
+  // cache may acquire the authority of an individual WebSocket request.
+  const embedding =
+    embeddingStage &&
+    new EmbeddingStage({
+      vault: resolver.vault,
+      embedFn: async (profile) => {
+        const turn = await prepareGovernedModelTurn(factory, {
+          mode: "hub-embedding",
+          messages: [{ role: "user", content: profile }],
+        });
+        // Chat projection prepends host provenance. Embed only the projected
+        // profile: per-Run evidence IDs must not change semantic similarity.
+        const profileMessage = turn.messages[1];
+        if (
+          turn.messages.length !== 2 ||
+          turn.messages[0].role !== "system" ||
+          profileMessage?.role !== "user" ||
+          typeof profileMessage.content !== "string"
+        )
+          throw new Error(
+            "Projected embedding input must contain one text message",
+          );
+        const vector = await embeddingStage._embed(profileMessage.content);
+        if (
+          (!Array.isArray(vector) && !(vector instanceof Float32Array)) ||
+          vector.length === 0 ||
+          !Array.from(vector).every(Number.isFinite)
+        )
+          throw new Error(
+            "Embedding response must contain a nonempty finite vector",
+          );
+        await turn.complete(JSON.stringify(Array.from(vector)));
+        return vector;
+      },
+    });
+  const model =
+    resolver._llmStage &&
+    new LLMStage({
+      llm: createGovernedHubLlm(llm, factory),
+      acceptNonLocal: false,
+    });
+  return new EntityResolver({
+    vault: resolver.vault,
+    candidateLimit: resolver._candidateLimit,
+    embeddingHighThreshold: resolver._embeddingHighThreshold,
+    embeddingLowThreshold: resolver._embeddingLowThreshold,
+    embeddingStage: embedding ? embedding.asStageFn() : null,
+    llmStage: model ? model.asStageFn() : null,
+  });
+}

package/src/lib/evolution/governed-hub-skill.js

@@ -0,0 +1,36 @@
+import { createGovernedHubLlm } from "./governed-hub-llm.js";
+
+// Analysis skills treat commentary failures as optional. A governed invocation
+// must still surface a failed model turn after the SDK returns its report.
+export async function runGovernedHubSkill(
+  hub,
+  factory,
+  runSkill,
+  name,
+  options,
+) {
+  const model = createGovernedHubLlm(hub.llm, factory);
+  let failure;
+  let failed = false;
+  const llm = Object.freeze({
+    get name() {
+      return model.name;
+    },
+    get isLocal() {
+      return model.isLocal;
+    },
+    async chat(messages, chatOptions) {
+      if (failed) throw failure;
+      try {
+        return await model.chat(messages, chatOptions);
+      } catch (error) {
+        failure = error;
+        failed = true;
+        throw error;
+      }
+    },
+  });
+  const result = await runSkill({ vault: hub.vault, llm }, name, options);
+  if (failed) throw failure;
+  return result;
+}