chainlesschain 0.166.109 → 0.166.114

package/src/gateways/ws/llm-chat-protocol.js

@@ -37,15 +37,35 @@ import {
   streamOllama,
   streamOpenAI,
   streamAnthropic,
+  streamGemini,
+  STREAM_STALL_MS,
 } from "../../lib/chat-core.js";
 import { BUILT_IN_PROVIDERS } from "../../lib/llm-providers.js";
 import { resolveLlmCreds } from "./llm-creds.js";
 import { prepareGovernedModelTurn } from "../../lib/evolution/governed-model-turn.js";
+import { normalizeOllamaBaseUrl } from "../../lib/ollama-base-url.js";
+import { normalizeProviderBaseUrl } from "../../lib/provider-protocol.js";
+import { raceWithAbort } from "../../lib/abort-utils.js";
 
-function normalizeOllamaBaseUrl(value) {
-  return String(value || "http://localhost:11434")
-    .replace(/\/v1\/?$/i, "")
-    .replace(/\/+$/, "");
+const activeChats = new WeakMap();
+const CHAT_SETUP_TIMEOUT_MS = 60_000;
+
+/** A request id is scoped to its originating socket, never another client. */
+export function cancelLlmChat(ws, id) {
+  activeChats.get(ws)?.get(id)?.abort(new Error("Chat cancelled"));
+}
+
+async function waitForChatPhase(operation, controller, phase) {
+  const timer = setTimeout(
+    () => controller.abort(new Error(`Chat ${phase} timed out after 60s`)),
+    CHAT_SETUP_TIMEOUT_MS,
+  );
+  timer.unref?.();
+  try {
+    return await raceWithAbort(operation, controller.signal);
+  } finally {
+    clearTimeout(timer);
+  }
 }
 
 function validateMessages(messages) {
@@ -80,7 +100,17 @@ export async function handleLlmChat(server, id, ws, message) {
     return;
   }
 
-  const creds = resolveLlmCreds(server, message);
+  let creds;
+  try {
+    creds = resolveLlmCreds(server, message);
+  } catch (error) {
+    send({
+      type: `${topic}.result`,
+      ok: false,
+      error: error?.message || String(error),
+    });
+    return;
+  }
   if (!creds || !creds.provider) {
     send({
       type: `${topic}.result`,
@@ -103,6 +133,7 @@ export async function handleLlmChat(server, id, ws, message) {
 
   let accumulator = "";
   const onToken = (token) => {
+    controller.signal.throwIfAborted();
     if (typeof token !== "string" || token.length === 0) return;
     accumulator += token;
     send({
@@ -117,68 +148,126 @@ export async function handleLlmChat(server, id, ws, message) {
   };
 
   const controller = new AbortController();
+  let requests = null;
+  if (ws && (typeof ws === "object" || typeof ws === "function")) {
+    requests = activeChats.get(ws);
+    if (!requests) activeChats.set(ws, (requests = new Map()));
+    if (requests.has(id)) {
+      send({
+        type: `${topic}.result`,
+        ok: false,
+        error: "Chat request is already active",
+      });
+      return;
+    }
+    requests.set(id, controller);
+  }
   const disconnect = () =>
     controller.abort(new Error("Chat connection closed"));
+  const onStall = (elapsedMs, timeoutMs) => {
+    if (controller.signal.aborted) return;
+    send({
+      type: `${topic}.status`,
+      status: {
+        stage: "waiting",
+        provider: creds.provider,
+        model: creds.model,
+        elapsedMs,
+        timeoutMs,
+      },
+    });
+  };
   ws?.once?.("close", disconnect);
   try {
-    const turn = await prepareGovernedModelTurn(
-      server.evolutionCompositionFactory ?? null,
-      {
+    const turn = await waitForChatPhase(
+      prepareGovernedModelTurn(server.evolutionCompositionFactory ?? null, {
         mode: "ws-llm-chat",
         messages: message.messages,
         signal: controller.signal,
-      },
+      }),
+      controller,
+      "initialization",
     );
     const streamOptions = {
       requireCompletion: turn.governed,
       signal: controller.signal,
     };
+    // Tell the browser the configured deadline even when waiting hints are
+    // disabled, so a slow local model gets its full loading budget.
+    onStall(0, STREAM_STALL_MS);
     const baseUrl =
       creds.provider === "ollama"
         ? normalizeOllamaBaseUrl(creds.baseUrl)
-        : creds.baseUrl || "http://localhost:11434";
+        : normalizeProviderBaseUrl(creds.baseUrl);
     if (creds.provider === "ollama") {
-      await streamOllama(
-        turn.messages,
-        creds.model,
-        baseUrl,
-        onToken,
-        onUsage,
-        undefined,
-        streamOptions,
+      await raceWithAbort(
+        streamOllama(
+          turn.messages,
+          creds.model,
+          baseUrl,
+          onToken,
+          onUsage,
+          onStall,
+          streamOptions,
+        ),
+        controller.signal,
       );
     } else if (creds.provider === "anthropic") {
-      const def = BUILT_IN_PROVIDERS.anthropic;
-      const url = baseUrl !== "http://localhost:11434" ? baseUrl : def.baseUrl;
-      await streamAnthropic(
-        turn.messages,
-        creds.model,
-        url,
-        creds.apiKey,
-        onToken,
-        onUsage,
-        undefined,
-        streamOptions,
+      const url = baseUrl;
+      await raceWithAbort(
+        streamAnthropic(
+          turn.messages,
+          creds.model,
+          url,
+          creds.apiKey,
+          onToken,
+          onUsage,
+          onStall,
+          streamOptions,
+        ),
+        controller.signal,
+      );
+    } else if (creds.provider === "gemini") {
+      const url = baseUrl;
+      await raceWithAbort(
+        streamGemini(
+          turn.messages,
+          creds.model,
+          url,
+          creds.apiKey,
+          onToken,
+          onUsage,
+          onStall,
+          streamOptions,
+        ),
+        controller.signal,
       );
     } else {
       // OpenAI-compatible — covers openai / volcengine / deepseek / dashscope /
       // kimi / minimax / mistral / custom. baseUrl from creds; default-from
       // BUILT_IN_PROVIDERS already applied above.
       const def = BUILT_IN_PROVIDERS[creds.provider];
-      const url = baseUrl !== "http://localhost:11434" ? baseUrl : def?.baseUrl;
-      await streamOpenAI(
-        turn.messages,
-        creds.model,
-        url,
-        creds.apiKey,
-        onToken,
-        onUsage,
-        undefined,
-        streamOptions,
+      const url = baseUrl || def?.baseUrl;
+      await raceWithAbort(
+        streamOpenAI(
+          turn.messages,
+          creds.model,
+          url,
+          creds.apiKey,
+          onToken,
+          onUsage,
+          onStall,
+          streamOptions,
+        ),
+        controller.signal,
       );
     }
 
-    await turn.complete(accumulator);
+    await waitForChatPhase(
+      turn.complete(accumulator),
+      controller,
+      "completion",
+    );
     send({
       type: `${topic}.result`,
       ok: true,
@@ -197,6 +286,8 @@ export async function handleLlmChat(server, id, ws, message) {
       error: err?.message || String(err),
     });
   } finally {
+    requests?.delete(id);
+    if (requests?.size === 0) activeChats.delete(ws);
     ws?.removeListener?.("close", disconnect);
   }
 }

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/message-dispatcher.js

@@ -30,6 +30,7 @@ import {
   handleRemoteSessionTerminal,
 } from "./remote-session-protocol.js";
 import { RemoteCommandLedger } from "../../harness/remote-command-ledger.js";
+import { cancelLlmChat } from "./llm-chat-protocol.js";
 
 /**
  * Reconnect-safe command execution. When a message carries a stable
@@ -293,6 +294,7 @@ export function createWsMessageDispatcher(server) {
         "chat.intent.classify-followup": () =>
           server._handleChatIntentClassifyFollowup(id, ws, message),
         "llm.chat": () => server._handleLlmChat(id, ws, message),
+        "llm.chat.cancel": () => cancelLlmChat(ws, id),
       };
 
       // Static core routes take precedence and are dispatched directly. The

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/,