chainlesschain 0.166.109 → 0.166.112

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,
+  };
+}

package/src/lib/provider-stream.js

@@ -9,6 +9,13 @@ import {
  */
 
 import { BUILT_IN_PROVIDERS } from "./llm-providers.js";
+import { normalizeOllamaBaseUrl } from "./ollama-base-url.js";
+import {
+  geminiGenerateContentUrl,
+  geminiRequestBody,
+  normalizeProviderBaseUrl,
+  openAICompatibleBaseUrl,
+} from "./provider-protocol.js";
 
 async function* responseLines(body) {
   const reader = body.getReader();
@@ -51,8 +58,9 @@ export async function* ollamaTokenStream({
   signal,
   requireCompletion = false,
 }) {
+  const normalizedBaseUrl = normalizeOllamaBaseUrl(baseUrl);
   const res = await providerFetch(
-    `${baseUrl}/api/${messages ? "chat" : "generate"}`,
+    `${normalizedBaseUrl}/api/${messages ? "chat" : "generate"}`,
     {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -96,7 +104,9 @@ export async function* openAIStream({
   requireCompletion = false,
 }) {
   const governed = hasFormalBudgetProviderScope();
-  const res = await providerFetch(`${baseUrl}/chat/completions`, {
+  const res = await providerFetch(
+    `${normalizeProviderBaseUrl(baseUrl)}/chat/completions`,
+    {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -109,7 +119,8 @@ export async function* openAIStream({
       ...(governed ? { stream_options: { include_usage: true } } : {}),
     }),
     signal,
-  });
+    },
+  );
   if (!res.ok || !res.body) {
     throw new Error(`${res.status} ${res.statusText}`);
   }
@@ -139,6 +150,126 @@ export async function* openAIStream({
     throw new Error("OpenAI stream ended before its completion marker");
 }
 
+export async function* geminiTokenStream({
+  baseUrl,
+  apiKey,
+  model,
+  prompt,
+  messages,
+  signal,
+  requireCompletion = false,
+}) {
+  const requestMessages = messages ?? [{ role: "user", content: prompt }];
+  const res = await providerFetch(
+    geminiGenerateContentUrl(baseUrl, model, { stream: true }),
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-goog-api-key": apiKey,
+      },
+      body: JSON.stringify(geminiRequestBody(requestMessages)),
+      signal,
+    },
+  );
+  if (!res.ok || !res.body) {
+    throw new Error(`Gemini ${res.status} ${res.statusText}`);
+  }
+
+  let completed = false;
+  for await (const raw of responseLines(res.body)) {
+    const line = raw.trim();
+    if (!line.startsWith("data:")) continue;
+    const payload = line.slice(5).trim();
+    if (!payload || payload === "[DONE]") continue;
+    try {
+      const data = JSON.parse(payload);
+      if (requireCompletion && data.error)
+        throw new Error("Gemini stream returned an error");
+      const candidate = data.candidates?.[0];
+      if (candidate?.finishReason || data.promptFeedback?.blockReason)
+        completed = true;
+      for (const part of candidate?.content?.parts || []) {
+        if (part?.thought !== true && typeof part?.text === "string")
+          yield part.text;
+      }
+    } catch (error) {
+      if (requireCompletion) throw error;
+      /* skip malformed chunks when completion isn't enforced */
+    }
+  }
+  if (requireCompletion && !completed)
+    throw new Error("Gemini stream ended before its completion marker");
+}
+
+export async function* anthropicTokenStream({
+  baseUrl,
+  apiKey,
+  model,
+  prompt,
+  messages,
+  signal,
+  requireCompletion = false,
+}) {
+  const requestMessages = messages ?? [{ role: "user", content: prompt }];
+  const system = requestMessages
+    .filter((message) => message.role === "system")
+    .map((message) => message.content)
+    .join("\n\n");
+  const turns = requestMessages
+    .filter((message) => message.role !== "system")
+    .map((message) => ({
+      role: message.role === "assistant" ? "assistant" : "user",
+      content: message.content,
+    }));
+  const res = 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: turns,
+      }),
+      signal,
+    },
+  );
+  if (!res.ok || !res.body) {
+    throw new Error(`Anthropic ${res.status} ${res.statusText}`);
+  }
+
+  let completed = false;
+  for await (const raw of responseLines(res.body)) {
+    const line = raw.trim();
+    if (!line.startsWith("data:")) continue;
+    const payload = line.slice(5).trim();
+    if (!payload) continue;
+    try {
+      const data = JSON.parse(payload);
+      if (requireCompletion && (data.error || data.type === "error"))
+        throw new Error("Anthropic stream returned an error");
+      if (data.type === "message_stop") completed = true;
+      if (
+        data.type === "content_block_delta" &&
+        typeof data.delta?.text === "string"
+      )
+        yield data.delta.text;
+    } catch (error) {
+      if (requireCompletion) throw error;
+      /* skip malformed chunks when completion isn't enforced */
+    }
+  }
+  if (requireCompletion && !completed)
+    throw new Error("Anthropic stream ended before its completion marker");
+}
+
 /**
  * Build an AsyncIterable<string> token stream for the given provider.
  * Throws on unsupported provider / missing API key.
@@ -172,8 +303,36 @@ export function buildProviderSource(provider, opts = {}) {
       `API key required for ${provider} (--api-key or ${def.apiKeyEnv})`,
     );
   }
+  if (provider === "anthropic") {
+    return anthropicTokenStream({
+      baseUrl: baseUrl || def.baseUrl,
+      apiKey: finalKey,
+      model: model || def.models[0],
+      prompt,
+      messages,
+      signal,
+      requireCompletion,
+    });
+  }
+  if (provider === "gemini") {
+    return geminiTokenStream({
+      baseUrl:
+        baseUrl ||
+        def.baseUrl ||
+        "https://generativelanguage.googleapis.com/v1beta",
+      apiKey: finalKey,
+      model: model || def.models[0],
+      prompt,
+      messages,
+      signal,
+      requireCompletion,
+    });
+  }
   return openAIStream({
-    baseUrl: baseUrl || def.baseUrl,
+    baseUrl: openAICompatibleBaseUrl(
+      provider,
+      normalizeProviderBaseUrl(baseUrl || def.baseUrl),
+    ),
     apiKey: finalKey,
     model: model || def.models[0],
     prompt,

package/src/lib/runnable-provider.js

@@ -198,6 +198,7 @@ export function makeRunnableProviderFallback(
     // swap ONLY the model to the provider's own default so the call succeeds.
     if (
       nonEmpty(options.provider) &&
+      inferProviderFromBaseUrl(options.baseUrl) === options.provider &&
       modelForeignToProvider(options.provider, options.model)
     ) {
       const def = defaultModelFor(options.provider);