chainlesschain 0.166.109 → 0.166.112

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

@@ -1,28 +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. Current saved `config.llm` (refreshed per request by the WS server).
- *   4. 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",
@@ -38,84 +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;
   let cfgLlm = {};
   if (typeof server?._loadLlmConfig === "function") {
     try {
       const configured = server._loadLlmConfig();
       cfgLlm = configured?.llm || configured || {};
     } catch {
-      // If the saved config cannot be refreshed, continue with explicit
-      // options, session credentials, or environment credentials. The
-      // session manager snapshot may contain merged defaults rather than
-      // values the user actually saved.
+      // A stale config snapshot can still be bypassed with session or env data.
     }
   } else {
     cfgLlm = server?.sessionManager?.config?.llm || {};
   }
 
-  const buildCreds = (provider, inherited = {}) => {
-    const def = BUILT_IN_PROVIDERS[provider];
-    const sameConfiguredProvider = provider === cfgLlm.provider;
-    return {
-      provider,
-      model:
-        optModel ||
-        inherited.model ||
-        (sameConfiguredProvider ? cfgLlm.model : null) ||
-        def?.models?.[0] ||
-        null,
-      baseUrl:
-        optBaseUrl ||
-        inherited.baseUrl ||
-        (sameConfiguredProvider ? cfgLlm.baseUrl : null) ||
-        def?.baseUrl ||
-        (provider === "ollama" ? "http://localhost:11434" : null),
-      apiKey:
-        optApiKey ||
-        inherited.apiKey ||
-        (sameConfiguredProvider ? cfgLlm.apiKey : null) ||
-        (def?.apiKeyEnv ? process.env[def.apiKeyEnv] : null),
-    };
-  };
-
-  if (optProvider) {
-    return buildCreds(optProvider);
-  }
-
+  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) {
-      // 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.
-      return buildCreds(session.provider, {
-        model: session.model,
-        baseUrl: session.baseUrl,
-        apiKey: session.apiKey,
-      });
-    }
   }
 
-  if (cfgLlm.provider) {
-    return buildCreds(cfgLlm.provider);
-  }
-
-  for (const name of ENV_PREFERRED_ORDER) {
-    const def = BUILT_IN_PROVIDERS[name];
-    if (def?.apiKeyEnv && process.env[def.apiKeyEnv]) {
-      return buildCreds(name);
-    }
+  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-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);

package/src/lib/cowork-adapter.js

@@ -12,6 +12,11 @@ import { LLMProviderRegistry, BUILT_IN_PROVIDERS } from "./llm-providers.js";
 import { loadConfig } from "./config-manager.js";
 import { applyConfigLlmDefaults } from "./llm-config-defaults.js";
 import { captureAgentEvolutionIngress } from "./evolution/agent-evolution-ingress.js";
+import { normalizeOllamaBaseUrl } from "./ollama-base-url.js";
+import {
+  normalizeProviderBaseUrl,
+  openAICompatibleBaseUrl,
+} from "./provider-protocol.js";
 
 function plainUsage(value) {
   return value && typeof value === "object" && !Array.isArray(value)
@@ -175,17 +180,20 @@ export function createChatFn(options = {}) {
         currentModel,
         async ({ signal = opts.signal || resolved.signal } = {}) => {
           const modelMessages = await prepareMessages();
-          const res = await providerFetch(`${baseUrl}/api/chat`, {
-            method: "POST",
-            signal: requestSignal(signal),
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-              model: currentModel,
-              messages: modelMessages,
-              stream: false,
-              options: { num_predict: maxTokens },
-            }),
-          });
+          const res = await providerFetch(
+            `${normalizeOllamaBaseUrl(baseUrl)}/api/chat`,
+            {
+              method: "POST",
+              signal: requestSignal(signal),
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({
+                model: currentModel,
+                messages: modelMessages,
+                stream: false,
+                options: { num_predict: maxTokens },
+              }),
+            },
+          );
           if (!res.ok) throw new Error(`Ollama error: ${res.status}`);
           const data = await res.json();
           return chatEnvelope(
@@ -215,7 +223,9 @@ export function createChatFn(options = {}) {
               ? { system: systemMsgs.map((m) => m.content).join("\n") }
               : {}),
           };
-          const res = await providerFetch(`${baseUrl}/messages`, {
+          const res = await providerFetch(
+            `${normalizeProviderBaseUrl(baseUrl)}/messages`,
+            {
             method: "POST",
             signal: requestSignal(signal),
             headers: {
@@ -224,7 +234,8 @@ export function createChatFn(options = {}) {
               "anthropic-version": "2023-06-01",
             },
             body: JSON.stringify(body),
-          });
+            },
+          );
           if (!res.ok) throw new Error(`Anthropic error: ${res.status}`);
           const data = await res.json();
           return chatEnvelope(
@@ -246,7 +257,9 @@ export function createChatFn(options = {}) {
       currentModel,
       async ({ signal = opts.signal || resolved.signal } = {}) => {
         const modelMessages = await prepareMessages();
-        const res = await providerFetch(`${baseUrl}/chat/completions`, {
+        const res = await providerFetch(
+          `${openAICompatibleBaseUrl(provider, baseUrl)}/chat/completions`,
+          {
           method: "POST",
           signal: requestSignal(signal),
           headers: {
@@ -258,7 +271,8 @@ export function createChatFn(options = {}) {
             messages: modelMessages,
             max_tokens: maxTokens,
           }),
-        });
+          },
+        );
         if (!res.ok) throw new Error(`API error: ${res.status}`);
         const data = await res.json();
         return chatEnvelope(