chainlesschain 0.166.109 → 0.166.114

package/src/lib/hub-llm-client.js

@@ -44,6 +44,8 @@ import { providerFetch } from "./formal-budget-provider-scope.js";
 ("use strict");
 
 import { BUILT_IN_PROVIDERS } from "./llm-providers.js";
+import { openAICompatibleBaseUrl } from "./provider-protocol.js";
+import { resolveLlmConnection } from "./llm-connection-resolution.js";
 
 const LOCAL_SENTINELS = new Set([
   "",
@@ -87,7 +89,6 @@ export function buildCliHubLLM({ config = {}, env = process.env } = {}) {
   if (!spec) return null;
 
   const cfgLlm = (config && config.llm) || {};
-  const sameAs = (p) => String(cfgLlm.provider || "").toLowerCase() === p;
   let provider, model, baseUrl, apiKey;
 
   if (spec.kind === "object") {
@@ -99,34 +100,41 @@ export function buildCliHubLLM({ config = {}, env = process.env } = {}) {
     apiKey =
       o.apiKey ||
       (o.apiKeyEnv ? env[o.apiKeyEnv] : null) ||
-      (sameAs(provider) ? cfgLlm.apiKey : null);
-    model = o.model || (sameAs(provider) ? cfgLlm.model : null);
-    baseUrl = o.baseUrl || (sameAs(provider) ? cfgLlm.baseUrl : null);
+      null;
+    model = o.model || null;
+    baseUrl = o.baseUrl || null;
   } else {
     const raw = spec.value;
     if (LOCAL_SENTINELS.has(raw)) return null;
     if (CONFIG_SENTINELS.has(raw)) {
       provider = String(cfgLlm.provider || "").toLowerCase();
-      model = cfgLlm.model;
-      baseUrl = cfgLlm.baseUrl;
-      apiKey = cfgLlm.apiKey;
+      model = null;
+      baseUrl = null;
+      apiKey = null;
     } else {
       provider = raw;
       // Reuse the saved credentials only when they belong to the requested
       // provider; otherwise fall back to provider defaults + env key.
-      model = sameAs(provider) ? cfgLlm.model : null;
-      baseUrl = sameAs(provider) ? cfgLlm.baseUrl : null;
-      apiKey = sameAs(provider) ? cfgLlm.apiKey : null;
+      model = null;
+      baseUrl = null;
+      apiKey = null;
     }
   }
 
   if (!provider || provider === "ollama") return null;
 
+  const connection = resolveLlmConnection(
+    { provider, model, baseUrl, apiKey },
+    [cfgLlm],
+    { env },
+  );
   const def = BUILT_IN_PROVIDERS[provider] || null;
-  const resolvedBase = baseUrl || (def && def.baseUrl) || null;
-  const resolvedModel = model || (def && def.models && def.models[0]) || null;
-  const resolvedKey =
-    apiKey || (def && def.apiKeyEnv ? env[def.apiKeyEnv] : null) || null;
+  const resolvedBase = openAICompatibleBaseUrl(
+    provider,
+    connection.baseUrl || (def && def.baseUrl) || null,
+  );
+  const resolvedModel = connection.model || null;
+  const resolvedKey = connection.apiKey || null;
 
   if (!resolvedBase || !resolvedModel) return null;
   if (!resolvedKey) return null; // every supported cloud provider needs a key

package/src/lib/image-input.js

@@ -276,6 +276,17 @@ export function imageUrlBlockToAnthropic(block) {
  * to pin a different snapshot.
  */
 export const DEFAULT_VISION_MODEL = "doubao-seed-2-0-lite-260215";
+const DEFAULT_VISION_MODELS = Object.freeze({
+  ollama: "qwen2.5vl:7b",
+  openai: "gpt-4o-mini",
+  anthropic: "claude-sonnet-4-6",
+  gemini: "gemini-2.5-flash",
+  volcengine: DEFAULT_VISION_MODEL,
+  dashscope: "qwen-vl-plus",
+  kimi: "kimi-k2.5",
+  minimax: "MiniMax-VL-01",
+  mistral: "pixtral-12b-2409",
+});
 
 // Recognize image-input families, including dated snapshots and local tags.
 // Unknown models keep using the configured vision fallback. Do not infer
@@ -327,15 +338,20 @@ export function resolveVisionLlm({ hasImage, flags = {}, llm = {} } = {}) {
       apiKey: undefined,
     };
   }
+  const provider = flags.provider || llm.provider;
+  const sameProvider = !flags.provider || !llm.provider || flags.provider === llm.provider;
   const mainModel =
-    !flags.provider || !llm.provider || flags.provider === llm.provider
+    sameProvider
       ? llm.model
       : undefined;
   const visionModel = supportsVisionModel(mainModel)
     ? mainModel
-    : llm.visionModel || DEFAULT_VISION_MODEL;
+    : (sameProvider ? llm.visionModel : null) ||
+      DEFAULT_VISION_MODELS[provider] ||
+      mainModel ||
+      DEFAULT_VISION_MODEL;
   return {
-    provider: flags.provider || llm.provider,
+    provider,
     model: flags.model || flags.visionModel || visionModel,
     baseUrl: flags.baseUrl || llm.baseUrl,
     apiKey: flags.apiKey || llm.apiKey,

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

@@ -56,26 +56,12 @@ export async function reconcileConfigLlmProvider(cfgLlm = {}) {
   return { llm: corrected, changed: true };
 }
 
-import { resolveApiKeyFromHelper } from "./api-key-helper.js";
 import { modelForeignToProvider } from "./runnable-provider.js";
-
-/**
- * Key backfill order: config llm.apiKey (plaintext, legacy) first, then
- * llm.apiKeyHelper (external command → OS credential store). The helper only
- * runs when no key is otherwise present, so configured setups never pay a
- * subprocess spawn.
- */
-function backfillApiKey(options, cfgLlm) {
-  if (options.apiKey) return;
-  if (cfgLlm.apiKey) {
-    options.apiKey = cfgLlm.apiKey;
-  } else if (cfgLlm.apiKeyHelper) {
-    const key = resolveApiKeyFromHelper(cfgLlm.apiKeyHelper);
-    if (key) options.apiKey = key;
-  }
-}
+import { resolveLlmConnection } from "./llm-connection-resolution.js";
 
 export function applyConfigLlmDefaults(options = {}, cfgLlm = {}, opts = {}) {
+  const connection = resolveLlmConnection(options, [cfgLlm]);
+  const configMatchesTarget = connection.endpointSources.includes(cfgLlm);
   // The IDE chat panel pins --provider/--model (read from config) but DROPS
   // --base-url/--api-key. With an explicit --provider the block below bails, so
   // a cloud provider would lose its endpoint + key → a 401, or a silent
@@ -84,31 +70,34 @@ export function applyConfigLlmDefaults(options = {}, cfgLlm = {}, opts = {}) {
   // baseUrl/apiKey (and model) from config — it's the SAME provider, so its
   // credentials are exactly right. Mixing config into a DIFFERENT explicit
   // provider is still avoided (handled by the early return below).
-  if (
-    options.provider &&
-    cfgLlm.provider &&
-    options.provider === cfgLlm.provider
-  ) {
-    if (!options.baseUrl && cfgLlm.baseUrl) options.baseUrl = cfgLlm.baseUrl;
+  if (options.provider && configMatchesTarget) {
+    if (!options.baseUrl && cfgLlm.baseUrl) options.baseUrl = connection.baseUrl;
     if (options.serviceTier == null && cfgLlm.serviceTier != null)
       options.serviceTier = cfgLlm.serviceTier;
-    backfillApiKey(options, cfgLlm);
+    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 || !cfgLlm.provider) return options;
-  options.provider = cfgLlm.provider;
-  if (options.serviceTier == null && cfgLlm.serviceTier != null)
+  if (options.provider) {
+    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)
     options.serviceTier = cfgLlm.serviceTier;
   if (opts.explicitModel) {
     options.model = opts.explicitModel;
-  } else if (cfgLlm.model) {
+  } else if (configMatchesTarget && cfgLlm.model) {
     options.model = cfgLlm.model;
+  } else if (!configMatchesTarget) {
+    options.model = connection.model;
   }
-  if (!options.baseUrl && cfgLlm.baseUrl) options.baseUrl = cfgLlm.baseUrl;
-  backfillApiKey(options, cfgLlm);
+  if (configMatchesTarget && !options.baseUrl && cfgLlm.baseUrl)
+    options.baseUrl = connection.baseUrl;
+  if (!options.apiKey && connection.apiKey) options.apiKey = connection.apiKey;
   return options;
 }
 

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

@@ -1,4 +1,5 @@
 import { BUILT_IN_PROVIDERS } from "./llm-providers.js";
+import { normalizeOllamaBaseUrl } from "./ollama-base-url.js";
 import {
   setSecretConfigValue,
   updateConfigAtomically,
@@ -65,6 +66,9 @@ export function normalizeLlmConnection(input) {
       "Use the API base path, not a completion/messages endpoint",
     );
   value.baseUrl = url.href.replace(/\/+$/, "");
+  if (value.provider === "ollama") {
+    value.baseUrl = normalizeOllamaBaseUrl(value.baseUrl);
+  }
   return value;
 }
 

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

@@ -2,6 +2,7 @@ import { formatProviderResponseError } from "./provider-http-error.js";
 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";
 
 // Reasoning models spend the same output allowance on thinking before the
 // final answer. A 16-token probe can therefore receive HTTP 200 with only
@@ -139,7 +140,10 @@ export async function probeLlmConnection(
   target,
   { fetchImpl = fetch, timeoutMs = 20_000, includeUsage = false } = {},
 ) {
-  const base = target.baseUrl.replace(/\/+$/, "");
+  const base =
+    target.provider === "ollama"
+      ? normalizeOllamaBaseUrl(target.baseUrl)
+      : target.baseUrl.replace(/\/+$/, "");
   const headers = { "Content-Type": "application/json" };
   let url, body;
   if (target.provider === "ollama") {

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

@@ -0,0 +1,94 @@
+import { BUILT_IN_PROVIDERS } from "./llm-providers.js";
+import { normalizeOllamaBaseUrl } from "./ollama-base-url.js";
+import { normalizeProviderBaseUrl } from "./provider-protocol.js";
+import { resolveApiKeyFromHelper } from "./api-key-helper.js";
+
+const DEFAULT_PROVIDER = "ollama";
+const DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434";
+
+function nonEmpty(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+export function normalizeLlmEndpoint(provider, baseUrl) {
+  if (!nonEmpty(baseUrl)) return "";
+  return provider === "ollama"
+    ? normalizeOllamaBaseUrl(baseUrl)
+    : normalizeProviderBaseUrl(baseUrl);
+}
+
+/**
+ * Resolve provider, model, endpoint, and credential as one configuration.
+ * Saved models and credentials are reusable only for the same provider and
+ * normalized endpoint. An explicit key always belongs to the explicit target.
+ */
+export function resolveLlmConnection(
+  options = {},
+  configuredSources = [],
+  {
+    env = process.env,
+    builtIns = BUILT_IN_PROVIDERS,
+    defaultProvider = DEFAULT_PROVIDER,
+    defaultModel = null,
+    defaultBaseUrl = null,
+  } = {},
+) {
+  const sources = (Array.isArray(configuredSources)
+    ? configuredSources
+    : [configuredSources]
+  ).filter((source) => source && typeof source === "object");
+  const provider =
+    (nonEmpty(options.provider) && options.provider) ||
+    sources.find((source) => nonEmpty(source.provider))?.provider ||
+    defaultProvider;
+  const definition = builtIns[provider];
+  const matchingSources = sources.filter(
+    (source) => source.provider === provider,
+  );
+  const providerBaseUrl =
+    definition?.baseUrl ||
+    defaultBaseUrl ||
+    (provider === "ollama" ? DEFAULT_OLLAMA_BASE_URL : null);
+  const baseUrl =
+    (nonEmpty(options.baseUrl) && options.baseUrl) ||
+    matchingSources.find((source) => nonEmpty(source.baseUrl))?.baseUrl ||
+    providerBaseUrl;
+  const normalizedBaseUrl = normalizeLlmEndpoint(provider, baseUrl);
+  const endpointSources = matchingSources.filter((source) => {
+    const sourceBaseUrl = source.baseUrl || providerBaseUrl;
+    return (
+      normalizedBaseUrl !== "" &&
+      normalizeLlmEndpoint(provider, sourceBaseUrl) === normalizedBaseUrl
+    );
+  });
+  const model =
+    (nonEmpty(options.model) && options.model) ||
+    endpointSources.find((source) => nonEmpty(source.model))?.model ||
+    defaultModel ||
+    definition?.models?.[0] ||
+    null;
+  let apiKey =
+    (nonEmpty(options.apiKey) && options.apiKey) ||
+    (nonEmpty(env?.CC_API_KEY) && env.CC_API_KEY) ||
+    endpointSources.find((source) => nonEmpty(source.apiKey))?.apiKey ||
+    null;
+  if (!apiKey) {
+    const helper = endpointSources.find((source) =>
+      nonEmpty(source.apiKeyHelper),
+    )?.apiKeyHelper;
+    if (helper) apiKey = resolveApiKeyFromHelper(helper);
+  }
+  if (!apiKey && definition?.apiKeyEnv) {
+    apiKey = nonEmpty(env?.[definition.apiKeyEnv])
+      ? env[definition.apiKeyEnv]
+      : null;
+  }
+  return {
+    provider,
+    model,
+    baseUrl: baseUrl || null,
+    apiKey,
+    endpoint: normalizedBaseUrl,
+    endpointSources,
+  };
+}

package/src/lib/llm-providers.js

@@ -7,6 +7,11 @@
  */
 import { providerFetch } from "./formal-budget-provider-scope.js";
 import { isFormalBudgetError } from "./formal-budget-errors.js";
+import { normalizeOllamaBaseUrl } from "./ollama-base-url.js";
+import {
+  geminiGenerateContentUrl,
+  normalizeProviderBaseUrl,
+} from "./provider-protocol.js";
 export const BUILT_IN_PROVIDERS = {
   ollama: {
     name: "ollama",
@@ -345,11 +350,18 @@ export class LLMProviderRegistry {
     const testModel = model || provider.models[0];
 
     if (name === "ollama") {
-      const res = await _fetchWithTimeout(`${provider.baseUrl}/api/generate`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ model: testModel, prompt: "Hi", stream: false }),
-      });
+      const res = await _fetchWithTimeout(
+        `${normalizeOllamaBaseUrl(provider.baseUrl)}/api/generate`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            model: testModel,
+            prompt: "Hi",
+            stream: false,
+          }),
+        },
+      );
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       const data = await res.json();
       return {
@@ -363,23 +375,32 @@ export class LLMProviderRegistry {
       const key = this.getApiKey(name);
       if (!key) throw new Error("GEMINI_API_KEY not set");
       const res = await _fetchWithTimeout(
-        `${provider.baseUrl}/models/${testModel}:generateContent?key=${key}`,
+        geminiGenerateContentUrl(provider.baseUrl, testModel),
         {
           method: "POST",
-          headers: { "Content-Type": "application/json" },
+          headers: {
+            "Content-Type": "application/json",
+            "x-goog-api-key": key,
+          },
           body: JSON.stringify({ contents: [{ parts: [{ text: "Hi" }] }] }),
         },
       );
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       const data = await res.json();
-      const text = data.candidates?.[0]?.content?.parts?.[0]?.text || "";
+      const text =
+        data.candidates?.[0]?.content?.parts
+          ?.filter((part) => part?.thought !== true)
+          ?.map((part) => part?.text || "")
+          ?.join("") || "";
       return { ok: true, elapsed: Date.now() - start, response: text.trim() };
     }
 
     if (name === "anthropic") {
       const key = this.getApiKey(name);
       if (!key) throw new Error("ANTHROPIC_API_KEY not set");
-      const res = await _fetchWithTimeout(`${provider.baseUrl}/messages`, {
+      const res = await _fetchWithTimeout(
+        `${normalizeProviderBaseUrl(provider.baseUrl)}/messages`,
+        {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -391,7 +412,8 @@ export class LLMProviderRegistry {
           max_tokens: 10,
           messages: [{ role: "user", content: "Hi" }],
         }),
-      });
+        },
+      );
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       const data = await res.json();
       const text = data.content?.[0]?.text || "";
@@ -402,7 +424,7 @@ export class LLMProviderRegistry {
     const key = this.getApiKey(name);
     if (!key) throw new Error(`${provider.apiKeyEnv} not set`);
     const res = await _fetchWithTimeout(
-      `${provider.baseUrl}/chat/completions`,
+      `${normalizeProviderBaseUrl(provider.baseUrl)}/chat/completions`,
       {
         method: "POST",
         headers: {

package/src/lib/ollama-base-url.js

@@ -0,0 +1,14 @@
+/**
+ * Normalize an Ollama server URL for native `/api/*` requests.
+ *
+ * Ollama's OpenAI-compatible examples commonly use a `/v1` base path, while
+ * this CLI provider speaks Ollama's native API. Accept both forms in saved
+ * settings and remove trailing OpenAI/native API suffixes before appending a
+ * native `/api/*` path.
+ */
+export function normalizeOllamaBaseUrl(value) {
+  return String(value || "http://localhost:11434")
+    .trim()
+    .replace(/\/+$/, "")
+    .replace(/(?:\/(?:v1|api))+$/i, "");
+}

package/src/lib/provider-protocol.js

@@ -0,0 +1,104 @@
+/** Shared URL and request-shape helpers for provider-specific adapters. */
+
+export function normalizeProviderBaseUrl(baseUrl) {
+  return String(baseUrl || "").replace(/\/+$/u, "");
+}
+
+/**
+ * Google's OpenAI-compatible API lives below `/v1beta/openai`. The provider
+ * registry stores the native API root (`/v1beta`), so adapt only that exact
+ * official root when a caller explicitly uses the OpenAI-compatible protocol.
+ */
+export function openAICompatibleBaseUrl(provider, baseUrl) {
+  const base = normalizeProviderBaseUrl(baseUrl);
+  if (provider !== "gemini") return base;
+  try {
+    const url = new URL(base);
+    if (
+      url.hostname === "generativelanguage.googleapis.com" &&
+      url.pathname.replace(/\/+$/u, "") === "/v1beta"
+    ) {
+      url.pathname = "/v1beta/openai";
+      return normalizeProviderBaseUrl(url.href);
+    }
+  } catch {
+    // Keep custom compatibility endpoints intact; the request layer reports
+    // malformed URLs with the provider's normal transport error.
+  }
+  return base;
+}
+
+export function geminiGenerateContentUrl(baseUrl, model, { stream = false } = {}) {
+  const action = stream ? "streamGenerateContent" : "generateContent";
+  const endpoint = `${normalizeProviderBaseUrl(baseUrl)}/models/${encodeURIComponent(model)}:${action}`;
+  return stream ? `${endpoint}?alt=sse` : endpoint;
+}
+
+function geminiTextParts(content) {
+  if (typeof content === "string") return [{ text: content }];
+  if (!Array.isArray(content)) return [];
+  return content.flatMap((part) => {
+    if (typeof part === "string") return [{ text: part }];
+    if (part && typeof part.text === "string") return [{ text: part.text }];
+    return [];
+  });
+}
+
+export function geminiRequestBody(
+  messages,
+  { maxOutputTokens = 4096, temperature } = {},
+) {
+  const contents = [];
+  const systemParts = [];
+  for (const message of messages || []) {
+    const parts = geminiTextParts(message?.content);
+    if (parts.length === 0) continue;
+    if (message.role === "system") {
+      systemParts.push(...parts);
+      continue;
+    }
+    contents.push({
+      role: message.role === "assistant" || message.role === "model" ? "model" : "user",
+      parts,
+    });
+  }
+  const generationConfig = { maxOutputTokens };
+  if (Number.isFinite(temperature)) generationConfig.temperature = temperature;
+  return {
+    contents,
+    ...(systemParts.length ? { systemInstruction: { parts: systemParts } } : {}),
+    generationConfig,
+  };
+}
+
+export function geminiResponseText(data) {
+  return (data?.candidates?.[0]?.content?.parts || [])
+    .filter((part) => part?.thought !== true)
+    .map((part) => (typeof part?.text === "string" ? part.text : ""))
+    .join("");
+}
+
+export function geminiUsage(data) {
+  const usage = data?.usageMetadata;
+  if (!usage || typeof usage !== "object") return null;
+  const promptTokens = Number(usage.promptTokenCount);
+  const outputTokens =
+    Number(usage.candidatesTokenCount || 0) +
+    Number(usage.thoughtsTokenCount || 0);
+  const cacheReadTokens = Number(usage.cachedContentTokenCount || 0);
+  if (
+    !Number.isSafeInteger(promptTokens) ||
+    promptTokens < 0 ||
+    !Number.isSafeInteger(outputTokens) ||
+    outputTokens < 0 ||
+    !Number.isSafeInteger(cacheReadTokens) ||
+    cacheReadTokens < 0 ||
+    cacheReadTokens > promptTokens
+  )
+    return null;
+  return {
+    inputTokens: promptTokens - cacheReadTokens,
+    outputTokens,
+    cacheReadTokens,
+  };
+}