chainlesschain 0.166.108 → 0.166.112

package/src/gateways/ws/llm-creds.js

@@ -1,27 +1,11 @@
 /**
- * Shared LLM credential resolver for WS handlers.
+ * Shared LLM connection resolver for WS handlers.
  *
- * Used by both `llm.chat` (single-shot streaming) and `chat.intent.*`
- * (intent-understanding flow). Encapsulates the precedence rules so adding
- * a third consumer doesn't fork them again.
- *
- * Resolution order (first non-null wins):
- *   1. Explicit `message.options.{provider,model,baseUrl,apiKey}` from client.
- *   2. WS session creds via `server.sessionManager.getSession(sessionId)`.
- *   3. Process env — first BUILT_IN_PROVIDERS entry whose apiKeyEnv is set.
- *
- * Fall-throughs:
- *   - Provider with `free: true` (ollama) doesn't need apiKey; a session
- *     entry with provider=ollama and no apiKey is valid.
- *   - For non-ollama providers, missing apiKey is a fatal — the caller
- *     should send a clean error frame instead of hanging on a 401.
- *   - When no source has any creds, returns null. Caller decides whether
- *     to fail-fast (llm.chat) or yield "LLM not configured" (chat-intent).
- *
- * @returns {{provider, model, baseUrl, apiKey} | null}
+ * Provider, model, endpoint, and credential are resolved together so a
+ * provider override cannot inherit a model or key from another endpoint.
  */
-
 import { BUILT_IN_PROVIDERS } from "../../lib/llm-providers.js";
+import { resolveLlmConnection } from "../../lib/llm-connection-resolution.js";
 
 const ENV_PREFERRED_ORDER = [
   "volcengine",
@@ -37,57 +21,51 @@ const ENV_PREFERRED_ORDER = [
 
 export function resolveLlmCreds(server, message) {
   const opts = message?.options || {};
-  const optProvider = opts.provider;
-  const optModel = opts.model;
-  const optBaseUrl = opts.baseUrl;
-  const optApiKey = opts.apiKey;
-
-  if (optProvider) {
-    const def = BUILT_IN_PROVIDERS[optProvider];
-    return {
-      provider: optProvider,
-      model: optModel || def?.models?.[0] || null,
-      baseUrl: optBaseUrl || def?.baseUrl || null,
-      apiKey: optApiKey || (def?.apiKeyEnv ? process.env[def.apiKeyEnv] : null),
-    };
+  let cfgLlm = {};
+  if (typeof server?._loadLlmConfig === "function") {
+    try {
+      const configured = server._loadLlmConfig();
+      cfgLlm = configured?.llm || configured || {};
+    } catch {
+      // A stale config snapshot can still be bypassed with session or env data.
+    }
+  } else {
+    cfgLlm = server?.sessionManager?.config?.llm || {};
   }
 
+  let session = null;
   const sessionId = message?.sessionId;
   if (sessionId && server?.sessionManager?.getSession) {
-    let session;
     try {
       session = server.sessionManager.getSession(sessionId);
     } catch {
       session = null;
     }
-    if (session?.provider) {
-      const def = BUILT_IN_PROVIDERS[session.provider];
-      // Don't default baseUrl to ollama — that breaks every cloud provider
-      // when the session was created without an explicit baseUrl. Fall back
-      // to the provider's own default endpoint instead.
-      const fallbackBase =
-        def?.baseUrl ||
-        (session.provider === "ollama" ? "http://localhost:11434" : null);
-      return {
-        provider: session.provider,
-        model: optModel || session.model,
-        baseUrl: session.baseUrl || fallbackBase,
-        apiKey: session.apiKey,
-      };
-    }
   }
 
-  for (const name of ENV_PREFERRED_ORDER) {
-    const def = BUILT_IN_PROVIDERS[name];
-    if (def?.apiKeyEnv && process.env[def.apiKeyEnv]) {
-      return {
-        provider: name,
-        model: optModel || def.models?.[0] || null,
-        baseUrl: def.baseUrl,
-        apiKey: process.env[def.apiKeyEnv],
-      };
-    }
+  const envProvider = ENV_PREFERRED_ORDER.find((name) => {
+    const envName = BUILT_IN_PROVIDERS[name]?.apiKeyEnv;
+    return envName && process.env[envName];
+  });
+  const defaultProvider =
+    opts.provider || session?.provider || cfgLlm.provider || envProvider || "ollama";
+  if (!opts.provider && !session?.provider && !cfgLlm.provider && !envProvider) {
+    return null;
   }
 
-  return null;
+  return resolveLlmConnection(
+    opts,
+    [
+      session
+        ? {
+            provider: session.provider,
+            model: session.model,
+            baseUrl: session.baseUrl,
+            apiKey: session.apiKey,
+          }
+        : null,
+      cfgLlm,
+    ],
+    { defaultProvider },
+  );
 }

package/src/gateways/ws/ws-agent-handler.js

@@ -1530,7 +1530,7 @@ export class WSAgentHandler {
             }),
         provider: session.provider,
         model: activeModel,
-        baseUrl: session.baseUrl || "http://localhost:11434",
+        baseUrl: session.baseUrl,
         apiKey: session.apiKey,
         contextEngine: session.contextEngine,
         hookDb: this.db,

package/src/gateways/ws/ws-server.js

@@ -124,6 +124,10 @@ import {
 } from "./artifact-protocol.js";
 import { executionBroker } from "../../lib/process-execution-broker/index.js";
 import { collectWorkspacePluginBinSandboxPolicy } from "../../lib/plugin-runtime/bin.js";
+import {
+  loadConfig,
+  loadUserConfig,
+} from "../../lib/config-manager.js";
 
 export const _deps = {
   spawn: (...args) => executionBroker.spawn(...args),
@@ -195,6 +199,47 @@ function boundedInteger(value, fallback, maximum = Number.MAX_SAFE_INTEGER) {
   return Math.min(parsed, maximum);
 }
 
+function loadCurrentLlmConfig() {
+  const savedLlm =
+    loadUserConfig({ failIfUnavailable: true }).llm || {};
+  const resolvedLlm = loadConfig({ failIfUnavailable: true }).llm || {};
+  const confirmedLlm =
+    loadUserConfig({ failIfUnavailable: true }).llm || {};
+  const provider =
+    typeof savedLlm.provider === "string" && savedLlm.provider.trim()
+      ? savedLlm.provider.trim()
+      : null;
+  const routingIdentity = (llm) =>
+    JSON.stringify([
+      llm.provider ?? null,
+      llm.baseUrl ?? null,
+      llm.apiKey ?? null,
+      llm.model ?? null,
+    ]);
+
+  // Config writes are atomic, but a save can land between reads. Never pair
+  // a key or route from different saved versions in that case.
+  if (
+    routingIdentity(savedLlm) !== routingIdentity(confirmedLlm) ||
+    (provider && provider !== resolvedLlm.provider)
+  ) {
+    throw new Error("LLM configuration changed while being read");
+  }
+
+  return {
+    provider,
+    model:
+      typeof savedLlm.model === "string" && savedLlm.model.trim()
+        ? savedLlm.model.trim()
+        : null,
+    baseUrl:
+      typeof savedLlm.baseUrl === "string" && savedLlm.baseUrl.trim()
+        ? savedLlm.baseUrl.trim()
+        : null,
+    apiKey: provider ? resolvedLlm.apiKey || null : null,
+  };
+}
+
 function frameByteLength(data) {
   if (typeof data === "string") return Buffer.byteLength(data, "utf8");
   if (Buffer.isBuffer(data)) return data.byteLength;
@@ -368,6 +413,8 @@ export class ChainlessChainWSServer extends EventEmitter {
 
     /** Session manager for stateful agent/chat sessions */
     this.sessionManager = options.sessionManager || null;
+    /** Read current saved LLM settings for stateless chat requests. */
+    this._loadLlmConfig = options.loadLlmConfig || loadCurrentLlmConfig;
     this.projectRoot = options.projectRoot || process.cwd();
 
     /** Session handlers: sessionId → WSAgentHandler | WSChatHandler */

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

@@ -36,6 +36,7 @@ import {
   deleteSession as dbDeleteSession,
 } from "../../lib/session-manager.js";
 import { buildSystemPrompt } from "../../runtime/agent-core.js";
+import { resolveLlmConnection } from "../../lib/llm-connection-resolution.js";
 import { createHostToolPolicyAuthority } from "../../lib/host-tool-policy-authority.js";
 import { SubAgentRegistry } from "../../lib/sub-agent-registry.js";
 import {
@@ -518,14 +519,13 @@ export class WSSessionManager {
         ? this._hooksV2HostWorkspaceRoot
         : null;
     const cfgLlm = this.config?.llm || {};
-    const provider = options.provider || cfgLlm.provider || "ollama";
-    const model =
-      options.model ||
-      cfgLlm.model ||
-      (provider === "ollama" ? "qwen2.5:7b" : null);
-    const baseUrl =
-      options.baseUrl || cfgLlm.baseUrl || "http://localhost:11434";
-    const apiKey = options.apiKey || cfgLlm.apiKey || null;
+    const connection = resolveLlmConnection(options, [cfgLlm], {
+      defaultModel:
+        (options.provider || cfgLlm.provider || "ollama") === "ollama"
+          ? "qwen2.5:7b"
+          : null,
+    });
+    const { provider, model, baseUrl, apiKey } = connection;
     const worktreeIsolationRequested = options.worktreeIsolation === true;
     const enabledToolNames = this._normalizeEnabledToolNames(
       options.enabledToolNames,
@@ -839,15 +839,29 @@ export class WSSessionManager {
         // Non-critical
       }
 
+      const connection = resolveLlmConnection(
+        {
+          provider: dbSession.provider || "ollama",
+          model: dbSession.model || null,
+          baseUrl: metadata.baseUrl || null,
+        },
+        [this.config?.llm || {}],
+        {
+          defaultModel:
+            (dbSession.provider || "ollama") === "ollama"
+              ? "qwen2.5:7b"
+              : null,
+        },
+      );
       const session = {
         id: dbSession.id,
         type: metadata.sessionType || "agent",
         status: "active",
         messages,
-        provider: dbSession.provider || "ollama",
-        model: dbSession.model || null,
-        apiKey: null,
-        baseUrl: metadata.baseUrl || "http://localhost:11434",
+        provider: connection.provider,
+        model: connection.model,
+        apiKey: connection.apiKey,
+        baseUrl: connection.baseUrl,
         mcpClient: this.mcpClient,
         enabledToolNames: this._normalizeEnabledToolNames(
           metadata.enabledToolNames,

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

@@ -4,10 +4,9 @@
  * provider-stream tests (previously untested) — the token-stream parsers behind
  * `cc stream` and the Hosted Session stream.run route. Pins the bug-prone
  * streaming parse logic: Ollama NDJSON (yield response, stop on done, line
- * buffering across chunk boundaries, skip malformed) and OpenAI-style SSE
- * (yield delta.content, stop on [DONE], skip non-data/empty), error on non-ok,
- * plus buildProviderSource routing (ollama defaults / known-provider endpoint +
- * Authorization / unsupported / missing-key). fetch is stubbed; no network.
+ * buffering across chunk boundaries, skip malformed), OpenAI-style SSE, and
+ * native Anthropic/Gemini SSE. Also pins protocol routing, completion markers,
+ * authentication headers, and URL normalization. fetch is stubbed; no network.
  */
 
 import { describe, it, expect, afterEach, vi } from "vitest";
@@ -173,6 +172,73 @@ describe("buildProviderSource", () => {
     );
   });
 
+  it("normalizes a trailing slash on OpenAI-compatible provider bases", async () => {
+    const fetchMock = mockFetch(["data: [DONE]\n"]);
+    vi.stubGlobal("fetch", fetchMock);
+    await collect(
+      buildProviderSource("deepseek", {
+        baseUrl: "https://api.deepseek.com/v1/",
+        apiKey: "sk-x",
+        prompt: "hi",
+      }),
+    );
+    expect(fetchMock.mock.calls[0][0]).toBe(
+      "https://api.deepseek.com/v1/chat/completions",
+    );
+  });
+
+  it("routes Gemini through its native SSE API without putting the key in the URL", async () => {
+    const fetchMock = mockFetch([
+      'data: {"candidates":[{"content":{"parts":[{"thought":true,"text":"private"},{"text":"hello"}]}}]}\n',
+      'data: {"candidates":[{"finishReason":"STOP"}]}\n',
+    ]);
+    vi.stubGlobal("fetch", fetchMock);
+    const out = await collect(
+      buildProviderSource("gemini", {
+        apiKey: "secret",
+        model: "gemini-2.0-flash",
+        baseUrl: "https://generativelanguage.googleapis.com/v1beta/",
+        prompt: "hello",
+        requireCompletion: true,
+      }),
+    );
+    const [url, options] = fetchMock.mock.calls[0];
+    expect(url).toBe(
+      "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:streamGenerateContent?alt=sse",
+    );
+    expect(url).not.toContain("secret");
+    expect(options.headers["x-goog-api-key"]).toBe("secret");
+    expect(out).toEqual(["hello"]);
+  });
+
+  it("routes Anthropic through native Messages SSE with a trimmed base URL", async () => {
+    const fetchMock = mockFetch([
+      'data: {"type":"content_block_delta","delta":{"text":"hello"}}\n',
+      'data: {"type":"message_stop"}\n',
+    ]);
+    vi.stubGlobal("fetch", fetchMock);
+    const out = await collect(
+      buildProviderSource("anthropic", {
+        apiKey: "secret",
+        model: "claude-haiku-4-5-20251001",
+        baseUrl: "https://api.anthropic.com/v1/",
+        messages: [
+          { role: "system", content: "be concise" },
+          { role: "user", content: "hello" },
+        ],
+        requireCompletion: true,
+      }),
+    );
+    const [url, options] = fetchMock.mock.calls[0];
+    expect(url).toBe("https://api.anthropic.com/v1/messages");
+    expect(options.headers["x-api-key"]).toBe("secret");
+    expect(JSON.parse(options.body)).toMatchObject({
+      system: "be concise",
+      messages: [{ role: "user", content: "hello" }],
+    });
+    expect(out).toEqual(["hello"]);
+  });
+
   it("throws for an unsupported provider", () => {
     expect(() => buildProviderSource("nope", { prompt: "x" })).toThrow(
       /Unsupported provider/,

package/src/lib/chat-core.js

@@ -11,6 +11,13 @@ import { providerFetch } from "./formal-budget-provider-scope.js";
  */
 
 import { BUILT_IN_PROVIDERS } from "./llm-providers.js";
+import { normalizeOllamaBaseUrl } from "./ollama-base-url.js";
+import {
+  geminiGenerateContentUrl,
+  geminiRequestBody,
+  geminiUsage,
+  normalizeProviderBaseUrl,
+} from "./provider-protocol.js";
 import { appendTokenUsage } from "../harness/jsonl-session-store.js";
 import {
   isRetryableStreamError,
@@ -134,18 +141,21 @@ export async function streamOllama(
   guard.bump();
   let response;
   try {
-    response = await providerFetch(`${baseUrl}/api/chat`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model,
-        messages,
-        stream: true,
-      }),
-      signal: options.signal
-        ? AbortSignal.any([guard.signal, options.signal])
-        : guard.signal,
-    });
+    response = await providerFetch(
+      `${normalizeOllamaBaseUrl(baseUrl)}/api/chat`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model,
+          messages,
+          stream: true,
+        }),
+        signal: options.signal
+          ? AbortSignal.any([guard.signal, options.signal])
+          : guard.signal,
+      },
+    );
   } catch (e) {
     guard.stop();
     throw guard.stalled() && !isFormalBudgetError(e)
@@ -249,7 +259,9 @@ export async function streamOpenAI(
   guard.bump();
   let response;
   try {
-    response = await providerFetch(`${baseUrl}/chat/completions`, {
+    response = await providerFetch(
+      `${normalizeProviderBaseUrl(baseUrl)}/chat/completions`,
+      {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -266,7 +278,8 @@ export async function streamOpenAI(
       signal: options.signal
         ? AbortSignal.any([guard.signal, options.signal])
         : guard.signal,
-    });
+      },
+    );
   } catch (e) {
     guard.stop();
     throw guard.stalled() && !isFormalBudgetError(e)
@@ -394,7 +407,9 @@ export async function streamAnthropic(
   guard.bump();
   let response;
   try {
-    response = await providerFetch(`${baseUrl}/messages`, {
+    response = await providerFetch(
+      `${normalizeProviderBaseUrl(baseUrl)}/messages`,
+      {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -411,7 +426,8 @@ export async function streamAnthropic(
       signal: options.signal
         ? AbortSignal.any([guard.signal, options.signal])
         : guard.signal,
-    });
+      },
+    );
   } catch (e) {
     guard.stop();
     throw guard.stalled() && !isFormalBudgetError(e)
@@ -517,6 +533,128 @@ export async function streamAnthropic(
   return fullResponse;
 }
 
+/** Stream Google's native Gemini generateContent SSE API. */
+export async function streamGemini(
+  messages,
+  model,
+  baseUrl,
+  apiKey,
+  onToken,
+  onUsage,
+  onStall,
+  options = {},
+) {
+  const guard = makeStallGuard(STREAM_STALL_MS, { onHint: onStall });
+  guard.bump();
+  let response;
+  try {
+    response = await providerFetch(
+      geminiGenerateContentUrl(baseUrl, model, { stream: true }),
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-goog-api-key": apiKey,
+        },
+        body: JSON.stringify(geminiRequestBody(messages)),
+        signal: options.signal
+          ? AbortSignal.any([guard.signal, options.signal])
+          : guard.signal,
+      },
+    );
+  } catch (error) {
+    guard.stop();
+    throw guard.stalled() && !isFormalBudgetError(error)
+      ? new Error(
+          `Gemini request stalled (no response in ${STREAM_STALL_MS / 1000}s)`,
+        )
+      : error;
+  }
+
+  if (!response.ok || !response.body) {
+    guard.stop();
+    throw attachStreamRetryMetadata(
+      new Error(`Gemini error: ${response.status} ${response.statusText}`),
+      captureStreamRetryMetadata(response),
+    );
+  }
+
+  const retryMetadata = captureStreamRetryMetadata(response);
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let fullResponse = "";
+  let completed = false;
+  let latestUsage = null;
+
+  const consumeLine = async (raw) => {
+    const line = raw.trim();
+    if (!line.startsWith("data:")) return;
+    const payload = line.slice(5).trim();
+    if (!payload || payload === "[DONE]") return;
+    const data = JSON.parse(payload);
+    if (data.error) {
+      throw new Error(
+        typeof data.error.message === "string"
+          ? data.error.message
+          : "Gemini stream returned an error",
+      );
+    }
+    const candidate = data.candidates?.[0];
+    if (candidate?.finishReason || data.promptFeedback?.blockReason)
+      completed = true;
+    const usage = geminiUsage(data);
+    if (usage) latestUsage = usage;
+    for (const part of candidate?.content?.parts || []) {
+      if (part?.thought === true || typeof part?.text !== "string") continue;
+      fullResponse += part.text;
+      await _deliverToken(onToken, part.text, guard, options);
+    }
+  };
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      guard.bump();
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        try {
+          await consumeLine(line);
+        } catch (error) {
+          if (
+            options.requireCompletion ||
+            error?.isOutputBackpressureFailure === true
+          )
+            throw error;
+          // Non-governed streaming keeps its historical best-effort parsing.
+        }
+      }
+    }
+    buffer += decoder.decode();
+    if (buffer.trim()) await consumeLine(buffer);
+  } catch (error) {
+    throw attachStreamRetryMetadata(
+      guard.stalled() && !isFormalBudgetError(error)
+        ? new Error(
+            `Gemini stream stalled (no data in ${STREAM_STALL_MS / 1000}s)`,
+          )
+        : error,
+      retryMetadata,
+    );
+  } finally {
+    guard.stop();
+  }
+
+  if (latestUsage && onUsage) onUsage(latestUsage);
+  options.signal?.throwIfAborted();
+  if (options.requireCompletion && !completed)
+    throw new Error("Model stream ended before its completion marker");
+  return fullResponse;
+}
+
 /**
  * Async generator that streams a chat response.
  *
@@ -578,10 +716,9 @@ export async function* chatStream(messages, options) {
       );
   } else if (provider === "anthropic") {
     const providerDef = BUILT_IN_PROVIDERS.anthropic;
-    const url =
-      baseUrl && baseUrl !== "http://localhost:11434"
-        ? baseUrl
-        : providerDef?.baseUrl || "https://api.anthropic.com/v1";
+    const url = normalizeProviderBaseUrl(
+      baseUrl || providerDef?.baseUrl || "https://api.anthropic.com/v1",
+    );
     const key =
       apiKey ||
       (providerDef?.apiKeyEnv ? process.env[providerDef.apiKeyEnv] : null);
@@ -601,12 +738,37 @@ export async function* chatStream(messages, options) {
         options.onStall,
         options,
       );
+  } else if (provider === "gemini") {
+    const providerDef = BUILT_IN_PROVIDERS.gemini;
+    const url = normalizeProviderBaseUrl(
+      baseUrl ||
+        providerDef?.baseUrl ||
+        "https://generativelanguage.googleapis.com/v1beta",
+    );
+    const key =
+      apiKey ||
+      (providerDef?.apiKeyEnv ? process.env[providerDef.apiKeyEnv] : null);
+    if (!key) {
+      throw new Error(
+        `API key required for gemini (set ${providerDef?.apiKeyEnv || "GEMINI_API_KEY"})`,
+      );
+    }
+    providerCall = () =>
+      streamGemini(
+        messages,
+        model,
+        url,
+        key,
+        onToken,
+        onUsage,
+        options.onStall,
+        options,
+      );
   } else {
     const providerDef = BUILT_IN_PROVIDERS[provider];
-    const url =
-      baseUrl !== "http://localhost:11434"
-        ? baseUrl
-        : providerDef?.baseUrl || "https://api.openai.com/v1";
+    const url = normalizeProviderBaseUrl(
+      baseUrl || providerDef?.baseUrl || "https://api.openai.com/v1",
+    );
     const key =
       apiKey ||
       (providerDef?.apiKeyEnv ? process.env[providerDef.apiKeyEnv] : null);