chainlesschain 0.166.132 → 0.166.135

package/src/lib/chat-core.js

@@ -10,9 +10,13 @@ import { providerFetch } from "./formal-budget-provider-scope.js";
  *  - streamOllama / streamOpenAI — low-level streaming helpers
  */
 
-import { BUILT_IN_PROVIDERS } from "./llm-providers.js";
+import {
+  BUILT_IN_PROVIDERS,
+  resolveProviderDefinition,
+} from "./llm-providers.js";
 import { normalizeOllamaBaseUrl } from "./ollama-base-url.js";
 import {
+  assertCustomProviderConnection,
   geminiGenerateContentUrl,
   geminiRequestBody,
   geminiUsage,
@@ -262,22 +266,22 @@ export async function streamOpenAI(
     response = await providerFetch(
       `${normalizeProviderBaseUrl(baseUrl)}/chat/completions`,
       {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`,
-      },
-      body: JSON.stringify({
-        model,
-        messages,
-        stream: true,
-        // Opt-in token usage in the terminal chunk (OpenAI-compatible).
-        // Servers that don't understand it simply ignore it.
-        stream_options: { include_usage: true },
-      }),
-      signal: options.signal
-        ? AbortSignal.any([guard.signal, options.signal])
-        : guard.signal,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+        },
+        body: JSON.stringify({
+          model,
+          messages,
+          stream: true,
+          // Opt-in token usage in the terminal chunk (OpenAI-compatible).
+          // Servers that don't understand it simply ignore it.
+          stream_options: { include_usage: true },
+        }),
+        signal: options.signal
+          ? AbortSignal.any([guard.signal, options.signal])
+          : guard.signal,
       },
     );
   } catch (e) {
@@ -410,22 +414,22 @@ export async function streamAnthropic(
     response = await providerFetch(
       `${normalizeProviderBaseUrl(baseUrl)}/messages`,
       {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": apiKey,
-        "anthropic-version": "2023-06-01",
-      },
-      body: JSON.stringify({
-        model,
-        max_tokens: 4096,
-        stream: true,
-        ...(system ? { system } : {}),
-        messages: convo,
-      }),
-      signal: options.signal
-        ? AbortSignal.any([guard.signal, options.signal])
-        : guard.signal,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01",
+        },
+        body: JSON.stringify({
+          model,
+          max_tokens: 4096,
+          stream: true,
+          ...(system ? { system } : {}),
+          messages: convo,
+        }),
+        signal: options.signal
+          ? AbortSignal.any([guard.signal, options.signal])
+          : guard.signal,
       },
     );
   } catch (e) {
@@ -666,6 +670,7 @@ export async function streamGemini(
  * @param {object} options - provider, model, baseUrl, apiKey
  */
 export async function* chatStream(messages, options) {
+  assertCustomProviderConnection(options.provider, options);
   const { provider, model, baseUrl, apiKey, sessionId } = options;
 
   // Token queue + waiter promise. onToken (called synchronously by each
@@ -765,14 +770,14 @@ export async function* chatStream(messages, options) {
         options,
       );
   } else {
-    const providerDef = BUILT_IN_PROVIDERS[provider];
+    const providerDef = resolveProviderDefinition(provider);
     const url = normalizeProviderBaseUrl(
       baseUrl || providerDef?.baseUrl || "https://api.openai.com/v1",
     );
     const key =
       apiKey ||
       (providerDef?.apiKeyEnv ? process.env[providerDef.apiKeyEnv] : null);
-    if (!key) {
+    if (!key && provider !== "custom") {
       throw new Error(
         `API key required for ${provider} (set ${providerDef?.apiKeyEnv || "API key"})`,
       );

package/src/lib/coding-task-guidance.js

@@ -1,14 +1,15 @@
 /** Shared correctness guidance for normal and file-only coding sessions. */
 export const CODING_TASK_QUALITY_GUIDANCE = `Coding task quality:
-- Read the actual implementation and its exported API before writing a caller or test. Check parameter order, return shapes, asynchronous lifecycle and fixture requirements against the source; an example in another directory can have different relative imports.
-- Keep progress explanations to one or two sentences. Once the relevant API and behavior are clear, make the next tool call; resolve a remaining uncertainty with a targeted read. Put implementation code directly in write/edit tool arguments instead of rehearsing the code or repeatedly analyzing the same source in ordinary assistant text.
-- Resolve each relative import from the destination file's directory. Read back the completed file and fix newDiagnostics from write/edit results before finishing. A successful write confirms persistence, not syntax, test execution or acceptance.
-- Before finishing a regression task, map each explicit acceptance requirement to a concrete fixture, production call path and observable assertion in the deliverable. Positive and negative controls must exercise the same requested behavior and differ in the intended condition. Resolve uncovered requirements with permitted tools, or report the specific gap. Avoid mocks or alternate calls that bypass the behavior under test. Complete the current worker/request when testing cancellation and replacement.
-- Allocate limited test cases from the user's explicit requirements, not from the tests already written. A test-count cap is a prioritization budget, not permission to omit a requirement. Merge or replace equivalent cases that reach the same decision so uncovered requirements take priority. Repair known coverage gaps within the authorized scope and remaining budgets; if a gap cannot be resolved, report the task as incomplete.
-- For boundary regressions, derive expected defaults, computed values and rejection rules from the implementation or the explicit requested contract. Inject mismatched, tampered or stale input through the real entry point while keeping other prerequisites valid; verify that the fixture reaches the intended check rather than failing during setup. Compare observable results with independent expected values or authoritative state, not a helper that merely recomputes the same result.
-- Trace rejection before asserting its aftermath: a request can be rejected before registration or persistence. Check whether state stays unchanged, a failed record is saved, or an event is emitted; do not assume every rejection creates a failed task. When testing attribution, verify independently recorded identities and provenance as well as message contents; identical text can still be attributed to the wrong source.
-- Use available execution tools for a focused check when permitted. When execution tools are unavailable, inspect imports, API contracts and fixtures using the available file tools, and clearly say that tests were not run. Never describe a read-back or static check as a passing test or end-to-end verification.
-- Finish requested file changes before the final response. Reserve output and remaining requests for writing, read-back and focused validation. For large files, aim for a few thousand characters of new content per call: write a small complete section, then extend it with edit_file using a unique existing anchor and a replacement containing that anchor plus the next complete section. A list of available tool names is not a limit on the number of tool calls; use further calls within the actual request budget to finish and inspect the file. Keep each tool call complete and wait for its result before extending the file again; do not repeatedly rewrite the growing file. State what was delivered, what was checked and what remains unverified, without repeating that account in multiple drafts.`;
+- Read the actual implementation and its exported API before writing a caller or test. Verify parameter order, return shapes, fixture requirements and the delegated owner of each lifecycle transition.
+- Keep progress explanations to one or two sentences. Resolve uncertainty with targeted reads, reuse unchanged source already inspected, and put code directly in write/edit arguments.
+- Resolve each relative import from the destination file's directory. Read back completed files and fix newDiagnostics. A successful write proves persistence, not test execution or acceptance.
+- Map every acceptance requirement to a fixture, real production call path and observable assertion. Positive and negative controls must reach the same boundary with unrelated prerequisites valid. Avoid mocks that bypass it; identify which assertion would fail without that boundary.
+- Derive case allocation from the user's requirements. A test-count cap does not waive coverage: merge redundant cases to cover gaps within the cap, authorized scope and remaining budget. Report unresolved gaps as incomplete.
+- For races, control the intended transition and complete the current worker/request when testing cancellation or replacement. An earlier unrelated rejection does not prove the target guard. Derive expectations independently from the contract or authoritative state, not by calling the function under test.
+- Trace rejection before asserting its aftermath: it may precede registration or persistence. Inspect whether state stays unchanged, a failed record exists or an event is emitted. Compare independently recorded identities and provenance; equal text does not prove ownership.
+- Inspect persistence projections before comparing histories. Host notices, lineage and imports may accompany user/assistant messages; verify their provenance separately. Report defects that cannot be repaired within the permitted scope instead of inventing passing behavior.
+- Run focused checks with permitted execution tools. With file tools only, inspect imports, contracts and fixtures and say tests were not run. Read-back or static inspection is not a passing test.
+- Finish requested edits and read-back before the final reply; reserve the last available model request for a concise terminal account. For large files, write a small complete section, await its result, then extend it with a unique edit anchor rather than rewriting the growing file. Report delivery, actual checks and limitations once.`;
 
 export const HERMETIC_CODING_SYSTEM_PROMPT = `You are a hermetic coding assistant. The exposed file tools are the complete tool surface. Inspect and mutate only the exact paths authorized by the user request. Do not invoke hidden tools, commands, language servers or other execution paths.
 

package/src/lib/context-memory-kernel/message-adapter.js

@@ -549,7 +549,11 @@ export function createSummaryContextItem({
       Math.ceil((Buffer.byteLength(content, "utf8") - image.bytes) / 4) +
         image.tokens,
     ),
-    priority: Math.max(...parents.map((item) => item.priority)),
+    // Keep the new handoff ahead of ordinary conversation in the final plan.
+    // Otherwise newer messages can fill the partition and evict the summary
+    // of the already-dropped history. This is selection priority only: the
+    // summary stays unpinned, data-only and subject to the same token ceilings.
+    priority: Math.max(600_000, ...parents.map((item) => item.priority)),
     pinned: false,
     createdAt: new Date(now).toISOString(),
     ...contentFields,

package/src/lib/evolution/agent-model-projection.js

@@ -221,7 +221,6 @@ function openAIReasoningItem(value) {
   if (Object.hasOwn(value, "summary")) {
     if (
       !Array.isArray(value.summary) ||
-      value.summary.length < 1 ||
       value.summary.length > 16 ||
       value.summary.some(
         (part) =>

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

@@ -264,7 +264,10 @@ export function createGovernedHubLlm(llm, factory, options = {}, sdkPorts) {
       "A Hub model client with declared locality is required",
     );
   }
-  if (typeof factory !== "function")
+  if (
+    typeof factory !== "function" &&
+    !(factory === null && options.evolutionDisabled === true)
+  )
     throw new TypeError("A Hub evolution factory is required");
   if (options.onFailure != null && typeof options.onFailure !== "function")
     throw new TypeError("onFailure must be a function");
@@ -298,6 +301,7 @@ export function createGovernedHubLlm(llm, factory, options = {}, sdkPorts) {
         mode: "hub-analysis",
         messages,
         signal: chatOptions.signal,
+        evolutionDisabled: options.evolutionDisabled === true,
       });
     },
     async transport(messages, chatOptions = {}) {

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

@@ -77,8 +77,16 @@ function captureEmbeddingTransport(stage, sdk) {
   };
 }
 
-export function createGovernedHubResolver(ports, factory, sdkPorts) {
-  if (typeof factory !== "function")
+export function createGovernedHubResolver(
+  ports,
+  factory,
+  sdkPorts,
+  options = {},
+) {
+  if (
+    typeof factory !== "function" &&
+    !(factory === null && options.evolutionDisabled === true)
+  )
     throw new TypeError("A resolver evolution factory is required");
   const {
     resolver,
@@ -102,13 +110,14 @@ export function createGovernedHubResolver(ports, factory, sdkPorts) {
         const turn = await prepareGovernedModelTurn(factory, {
           mode: "hub-embedding",
           messages: [{ role: "user", content: profile }],
+          evolutionDisabled: options.evolutionDisabled === true,
         });
         // Chat projection prepends host provenance. Embed only the projected
         // profile: per-Run evidence IDs must not change semantic similarity.
-        const profileMessage = turn.messages[1];
+        const profileMessage = turn.messages[turn.governed ? 1 : 0];
         if (
-          turn.messages.length !== 2 ||
-          turn.messages[0].role !== "system" ||
+          turn.messages.length !== (turn.governed ? 2 : 1) ||
+          (turn.governed && turn.messages[0].role !== "system") ||
           profileMessage?.role !== "user" ||
           typeof profileMessage.content !== "string"
         )
@@ -133,7 +142,7 @@ export function createGovernedHubResolver(ports, factory, sdkPorts) {
   const model =
     resolver._llmStage &&
     new LLMStage({
-      llm: createGovernedHubLlm(llm, factory, {}, sdk),
+      llm: createGovernedHubLlm(llm, factory, options, sdk),
       acceptNonLocal: false,
     });
   return new EntityResolver({

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

@@ -9,6 +9,7 @@ export async function runGovernedHubSkill(
   name,
   options,
   sdkPorts,
+  modelTurnOptions = {},
 ) {
   let failure;
   let failed = false;
@@ -16,6 +17,7 @@ export async function runGovernedHubSkill(
     hub.llm,
     factory,
     {
+      evolutionDisabled: modelTurnOptions.evolutionDisabled === true,
       onFailure(error) {
         failure = error;
         failed = true;

package/src/lib/evolution/optional-ui-model-turn.js

@@ -12,9 +12,20 @@ export async function loadConfiguredUiEvolutionFactory(options = {}) {
 }
 
 export async function resolveServerEvolutionFactory(server) {
-  return typeof server.resolveEvolutionCompositionFactory === "function"
+  return typeof server?.resolveEvolutionCompositionFactory === "function"
     ? server.resolveEvolutionCompositionFactory()
-    : (server.evolutionCompositionFactory ?? null);
+    : (server?.evolutionCompositionFactory ?? null);
+}
+
+/** Apply the host's current UI policy for every turn, including old sessions. */
+export async function prepareServerUiModelTurn(server, context) {
+  if (typeof server?.prepareUiModelTurn === "function") {
+    return server.prepareUiModelTurn(context);
+  }
+  return prepareGovernedModelTurn(
+    await resolveServerEvolutionFactory(server),
+    context,
+  );
 }
 
 export async function prepareConfiguredUiModelTurn(context, options = {}) {

package/src/lib/llm-config-defaults.js

@@ -35,7 +35,12 @@
  * so an intentionally-custom endpoint is left untouched.
  */
 export async function reconcileConfigLlmProvider(cfgLlm = {}) {
-  if (!cfgLlm || !cfgLlm.provider || !cfgLlm.baseUrl) {
+  if (
+    !cfgLlm ||
+    !cfgLlm.provider ||
+    !cfgLlm.baseUrl ||
+    cfgLlm.provider === "custom"
+  ) {
     return { llm: cfgLlm, changed: false };
   }
   const { inferProviderFromBaseUrl, modelForeignToProvider } = await import(
@@ -71,22 +76,29 @@ export function applyConfigLlmDefaults(options = {}, cfgLlm = {}, opts = {}) {
   // credentials are exactly right. Mixing config into a DIFFERENT explicit
   // provider is still avoided (handled by the early return below).
   if (options.provider && configMatchesTarget) {
-    if (!options.baseUrl && cfgLlm.baseUrl) options.baseUrl = connection.baseUrl;
+    if (!options.baseUrl && cfgLlm.baseUrl)
+      options.baseUrl = connection.baseUrl;
     if (options.serviceTier == null && cfgLlm.serviceTier != null)
       options.serviceTier = cfgLlm.serviceTier;
-    if (!options.apiKey && connection.apiKey) options.apiKey = connection.apiKey;
+    if (!options.apiKey && connection.apiKey)
+      options.apiKey = connection.apiKey;
     if (!options.model && !opts.explicitModel && cfgLlm.model) {
       options.model = cfgLlm.model;
     }
     return options;
   }
   if (options.provider) {
-    if (!options.apiKey && connection.apiKey) options.apiKey = connection.apiKey;
+    if (!options.apiKey && connection.apiKey)
+      options.apiKey = connection.apiKey;
     return options;
   }
   if (!cfgLlm.provider) return options;
   options.provider = connection.provider;
-  if (configMatchesTarget && options.serviceTier == null && cfgLlm.serviceTier != null)
+  if (
+    configMatchesTarget &&
+    options.serviceTier == null &&
+    cfgLlm.serviceTier != null
+  )
     options.serviceTier = cfgLlm.serviceTier;
   if (opts.explicitModel) {
     options.model = opts.explicitModel;

package/src/lib/llm-connection-config.js

@@ -31,7 +31,10 @@ export function normalizeLlmConnection(input) {
     if (value[key].length > (key === "apiKey" ? 8192 : 2048))
       throw new Error(`${key} is too long`);
   }
-  if (!Object.hasOwn(BUILT_IN_PROVIDERS, value.provider))
+  if (
+    value.provider !== "custom" &&
+    !Object.hasOwn(BUILT_IN_PROVIDERS, value.provider)
+  )
     throw new Error("Choose a supported provider/protocol");
   if (!value.model || /[\r\n\0]/.test(value.model + value.visionModel))
     throw new Error("A valid model name is required");
@@ -84,7 +87,7 @@ export function saveLlmConnection(input, { storage = "auto" } = {}) {
         current.baseUrl || BUILT_IN_PROVIDERS[current.provider]?.baseUrl || "",
       ).replace(/\/+$/, "") === value.baseUrl;
     if (
-      value.provider !== "ollama" &&
+      !["ollama", "custom"].includes(value.provider) &&
       !value.apiKey &&
       (!sameEndpoint || !current.apiKey)
     )
@@ -98,6 +101,11 @@ export function saveLlmConnection(input, { storage = "auto" } = {}) {
       baseUrl: value.baseUrl,
       visionModel: value.visionModel || null,
     };
+    // A keyless custom endpoint must never receive the previous target's key.
+    if (!sameEndpoint && !value.apiKey && value.provider === "custom") {
+      delete config.llm.apiKey;
+      delete config.llm.apiKeyHelper;
+    }
   };
   // A single lock and atomic rename bind endpoint and credential together.
   // An interrupted save cannot route the old credential to the new endpoint.

package/src/lib/llm-connection-probe.js

@@ -3,6 +3,7 @@ import { estimateCost } from "./llm-pricing.js";
 import { providerFetch } from "./formal-budget-provider-scope.js";
 import { isFormalBudgetError } from "./formal-budget-errors.js";
 import { normalizeOllamaBaseUrl } from "./ollama-base-url.js";
+import { assertCustomProviderConnection } from "./provider-protocol.js";
 import { resolveModelCapabilityProfile } from "./model-capabilities.js";
 import {
   projectEnvelopePricingContext,
@@ -159,6 +160,7 @@ export async function probeLlmConnection(
   target,
   { fetchImpl = fetch, timeoutMs = 20_000, includeUsage = false } = {},
 ) {
+  assertCustomProviderConnection(target.provider, target);
   const base =
     target.provider === "ollama"
       ? normalizeOllamaBaseUrl(target.baseUrl)
@@ -183,7 +185,8 @@ export async function probeLlmConnection(
       options: { num_predict: PROBE_OUTPUT_TOKENS },
     };
   } else {
-    if (!target.apiKey) throw new Error("API key required");
+    if (!target.apiKey && target.provider !== "custom")
+      throw new Error("API key required");
     if (target.provider === "anthropic") {
       url = `${base}/messages`;
       headers["x-api-key"] = target.apiKey;
@@ -211,7 +214,7 @@ export async function probeLlmConnection(
       });
     } else {
       url = `${base}/chat/completions`;
-      headers.Authorization = `Bearer ${target.apiKey}`;
+      if (target.apiKey) headers.Authorization = `Bearer ${target.apiKey}`;
       body = {
         model: target.model,
         messages: [{ role: "user", content: "Say hi in one word." }],

package/src/lib/llm-connection-resolution.js

@@ -1,6 +1,9 @@
 import { BUILT_IN_PROVIDERS } from "./llm-providers.js";
 import { normalizeOllamaBaseUrl } from "./ollama-base-url.js";
-import { normalizeProviderBaseUrl } from "./provider-protocol.js";
+import {
+  assertCustomProviderConnection,
+  normalizeProviderBaseUrl,
+} from "./provider-protocol.js";
 import { resolveApiKeyFromHelper } from "./api-key-helper.js";
 
 const DEFAULT_PROVIDER = "ollama";
@@ -33,9 +36,8 @@ export function resolveLlmConnection(
     defaultBaseUrl = null,
   } = {},
 ) {
-  const sources = (Array.isArray(configuredSources)
-    ? configuredSources
-    : [configuredSources]
+  const sources = (
+    Array.isArray(configuredSources) ? configuredSources : [configuredSources]
   ).filter((source) => source && typeof source === "object");
   const provider =
     (nonEmpty(options.provider) && options.provider) ||
@@ -67,6 +69,7 @@ export function resolveLlmConnection(
     defaultModel ||
     definition?.models?.[0] ||
     null;
+  assertCustomProviderConnection(provider, { baseUrl, model });
   let apiKey =
     (nonEmpty(options.apiKey) && options.apiKey) ||
     (nonEmpty(env?.CC_API_KEY) && env.CC_API_KEY) ||

package/src/lib/llm-providers.js

@@ -127,6 +127,19 @@ export const BUILT_IN_PROVIDERS = {
   },
 };
 
+/** Custom platforms use Chat Completions with an explicit endpoint and model. */
+export function resolveProviderDefinition(provider) {
+  return provider === "custom"
+    ? {
+        name: "custom",
+        baseUrl: null,
+        models: [],
+        apiKeyEnv: "CC_API_KEY",
+        custom: true,
+      }
+    : BUILT_IN_PROVIDERS[provider];
+}
+
 // A connectivity probe (`testProvider`) sends a tiny "Hi" and expects a quick
 // reply, so it must fail fast — a probe that hangs forever defeats its purpose
 // (it backs `cc llm test`, provider selection, doctor). Bound it with a total
@@ -402,17 +415,17 @@ export class LLMProviderRegistry {
       const res = await _fetchWithTimeout(
         `${normalizeProviderBaseUrl(provider.baseUrl)}/messages`,
         {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-api-key": key,
-          "anthropic-version": "2023-06-01",
-        },
-        body: JSON.stringify({
-          model: testModel,
-          max_tokens: 10,
-          messages: [{ role: "user", content: "Hi" }],
-        }),
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-api-key": key,
+            "anthropic-version": "2023-06-01",
+          },
+          body: JSON.stringify({
+            model: testModel,
+            max_tokens: 10,
+            messages: [{ role: "user", content: "Hi" }],
+          }),
         },
       );
       if (!res.ok) throw new Error(`HTTP ${res.status}`);

package/src/lib/openai-responses.js

@@ -103,7 +103,8 @@ function sanitizeReasoningItems(items) {
       type: "reasoning",
       ...(id ? { id } : {}),
       ...(encryptedContent ? { encrypted_content: encryptedContent } : {}),
-      ...(summary.length ? { summary } : {}),
+      // Responses requires this field even when no summary was requested.
+      summary,
       ...(status ? { status } : {}),
     });
   }