jeo-code 0.6.21 → 0.6.23

package/src/ai/model-manager.ts

@@ -1,12 +1,14 @@
 import { providerRegistry } from "./provider-registry";
 import { OAUTH_FLOW_REGISTRY } from "../auth/flows";
 import { readGlobalConfig } from "../agent/state";
-import { resolveCredential, type AuthProvider, type Credential } from "../auth";
+import { resolveCredential, isOAuthProvider, type AuthProvider, type Credential } from "../auth";
 import "./register-providers"; // side-effect: registers built-in adapters into providerRegistry
 import type { CallOptions, Message, ProviderAdapter, ProviderName } from "./types";
 import { expandAlias, resolveModelId, effectiveAliasesFor } from "./model-registry";
 import { findCatalogEntry, type ModelCatalogEntry } from "./model-catalog-compat";
 import { toProviderModel, CODEX_MODELS } from "./model-catalog";
+import { xaiCredential } from "./providers/xai";
+import { OPENAI_COMPAT_NAMES, isOpenAICompatProvider } from "./providers/openai-compatible-catalog";
 import { withRetry, defaultRetryable, type RetryOptions } from "../util/retry";
 import { jeoEnv } from "../util/env";
 import type { Config } from "../agent/state";
@@ -20,20 +22,39 @@ export function resolveProvider(model: string): ProviderName {
   const entry = findCatalogEntry(model);
   if (entry) return entry.provider;
   const m = (model ?? "").toLowerCase();
+  // Explicit `<provider>/` prefixes ALWAYS win over substring heuristics — a model id
+  // can legitimately contain another provider's name (e.g. `synthetic/hf:moonshotai/Kimi-K2.5`
+  // or `openrouter/openai/gpt-4o-mini`), so prefix routing is resolved first.
   if (m.startsWith("ollama/")) return "ollama";
+  if (m.startsWith("lmstudio/")) return "lmstudio";
   if (m.startsWith("antigravity/")) return "antigravity";
-  // OpenAI: explicit prefix, any GPT, or a reasoning model (o1/o3/o4-mini, o1-preview…).
-  if (m.startsWith("openai/") || m.includes("gpt") || /(^|\/)o\d/.test(m)) return "openai";
-  if (m.startsWith("google/") || m.includes("gemini")) return "gemini";
+  if (m.startsWith("xai/")) return "xai";
+  if (m.startsWith("kimi/")) return "kimi";
+  for (const p of OPENAI_COMPAT_NAMES) if (m.startsWith(`${p}/`)) return p;
+  if (m.startsWith("openai/")) return "openai";
+  if (m.startsWith("google/")) return "gemini";
+  // Loose substring heuristics for BARE (unprefixed) ids only.
+  if (m.includes("grok")) return "xai";
+  if (m.includes("kimi") || m.includes("moonshot")) return "kimi";
+  if (m.includes("gpt") || /(^|\/)o\d/.test(m)) return "openai";
+  if (m.includes("gemini")) return "gemini";
   return "anthropic";
 }
-const PROVIDER_ID_PREFIX: Record<ProviderName, string> = {
+// Static routing prefixes for the built-in (non-catalog) providers. Catalog
+// OpenAI-compatible providers use `<name>/` directly (see providerIdPrefix).
+const STATIC_ID_PREFIX: Partial<Record<ProviderName, string>> = {
   anthropic: "anthropic/",
   openai: "openai/",
   gemini: "google/",
   antigravity: "antigravity/",
   ollama: "ollama/",
+  lmstudio: "lmstudio/",
+  xai: "xai/",
+  kimi: "kimi/",
 };
+function providerIdPrefix(provider: ProviderName): string {
+  return isOpenAICompatProvider(provider) ? `${provider}/` : (STATIC_ID_PREFIX[provider] ?? `${provider}/`);
+}
 
 /**
  * Pin-time provider qualification: when a picked live model id would route to a
@@ -45,7 +66,7 @@ const PROVIDER_ID_PREFIX: Record<ProviderName, string> = {
 export function qualifyModelId(model: string, provider: ProviderName): string {
   const id = (model ?? "").trim();
   if (!id) return id;
-  return resolveProvider(id) === provider ? id : `${PROVIDER_ID_PREFIX[provider]}${id}`;
+  return resolveProvider(id) === provider ? id : `${providerIdPrefix(provider)}${id}`;
 }
 
 /**
@@ -59,7 +80,11 @@ export function providerModelFor(model: string): string {
     model.startsWith("openai/") ||
     model.startsWith("anthropic/") ||
     model.startsWith("google/") ||
-    model.startsWith("antigravity/")
+    model.startsWith("antigravity/") ||
+    model.startsWith("lmstudio/") ||
+    model.startsWith("xai/") ||
+    model.startsWith("kimi/") ||
+    isOpenAICompatProvider(model.split("/")[0])
   ) {
     return model;
   }
@@ -135,7 +160,7 @@ export interface ModelManager {
   resolveProvider: typeof resolveProvider;
 }
 
-const ALIAS_DEFAULTS = { fast: "ollama/qwen2.5:0.5b", local: "ollama/qwen2.5:0.5b", sonnet: "claude-sonnet-4-5", opus: "claude-opus-4-5", haiku: "claude-haiku-4-5", gpt: "gpt-5.5", flash: "gemini-2.5-flash" };
+const ALIAS_DEFAULTS = { fast: "ollama/qwen2.5:0.5b", local: "ollama/qwen2.5:0.5b", sonnet: "claude-sonnet-4-5", opus: "claude-opus-4-5", haiku: "claude-haiku-4-5", gpt: "gpt-5.5", flash: "gemini-2.5-flash", grok: "grok-4.3" };
 
 /**
  * Build retry options from a config `retry` budget (gjc parity). `requestMaxRetries`
@@ -243,7 +268,7 @@ export function effectiveCredentialForProvider(
   if (credential.kind === "oauth") {
     const apiKey = config.providers[provider];
     if (apiKey) return { kind: "api_key", provider, token: apiKey };
-    if (OAUTH_FLOW_REGISTRY[provider]?.verifiedEndToEnd === false) {
+    if (isOAuthProvider(provider) && OAUTH_FLOW_REGISTRY[provider].verifiedEndToEnd === false) {
       throw new Error(
         `Provider '${provider}' has only an OAuth token, but its OAuth backend is not compatible with the bundled adapter. Set ${provider.toUpperCase()}_API_KEY (or run 'jeo setup') to use ${model}.`,
       );
@@ -291,7 +316,8 @@ async function resolveCall(options: Partial<CallOptions>, kind: "request" | "str
   const baseUrl =
     options.baseUrl ??
     (provider === "openai" ? config.openaiBaseUrl : undefined) ??
-    (provider === "ollama" ? config.ollamaBaseUrl : undefined);
+    (provider === "ollama" ? config.ollamaBaseUrl : undefined) ??
+    (provider === "lmstudio" ? config.lmstudioBaseUrl : undefined);
 
   const callOptions: CallOptions = {
     // Map a catalog canonical (e.g. claude-3-5-sonnet) to the exact wire id the
@@ -317,10 +343,16 @@ async function resolveCall(options: Partial<CallOptions>, kind: "request" | "str
   // generous gjc default of 100 only applies when the user configures it.
   const retry: RetryOptions = { ...resolveRetryOptions(config.retry, kind), ...(options.onRetry ? { onRetry: options.onRetry } : {}) };
 
-  if (provider === "ollama") {
+  if (provider === "ollama" || provider === "lmstudio") {
     return { adapter, callOptions, credential: { kind: "none", provider: "openai" }, retry };
   }
 
+  if (provider === "xai") {
+    const key = config.providers?.xai;
+    if (!key) throw new Error("No credential for provider 'xai'. Set XAI_API_KEY (or providers.xai in config).");
+    return { adapter, callOptions, credential: xaiCredential(key), retry };
+  }
+
   if (provider === "antigravity") {
     // Prefer the dedicated Antigravity login (its client is what the agent
     // backend authorizes); fall back to a gemini-cli OAuth token for users with

package/src/ai/model-registry.ts

@@ -14,6 +14,8 @@ export const BUILTIN_ALIASES: ModelAliases = {
   haiku: "claude-haiku-4-5",
   gpt: "gpt-5.5",
   flash: "gemini-2.5-flash",
+  grok: "grok-4.3",
+  kimi: "kimi-k2-0711-preview",
 };
 
 // Expand an alias to a concrete model id. Unknown input passes through unchanged.

package/src/ai/provider-status.ts

@@ -5,11 +5,13 @@
  * its effective base URL, and whether it is ready to serve a request.
  */
 import { readGlobalConfig, type Config, type StoredOAuth } from "../agent/state";
-import type { AuthProvider, Credential } from "../auth";
+import { isOAuthProvider, API_KEY_ONLY_PROVIDERS, type AuthProvider, type Credential } from "../auth";
 import { OAUTH_FLOW_REGISTRY } from "../auth/flows";
 import type { ProviderName } from "./types";
 
-export const PROVIDER_NAMES: readonly ProviderName[] = ["anthropic", "openai", "gemini", "antigravity", "ollama"];
+import { OPENAI_COMPAT_NAMES, openaiCompatDef } from "./providers/openai-compatible-catalog";
+
+export const PROVIDER_NAMES: readonly ProviderName[] = ["anthropic", "openai", "gemini", "antigravity", "ollama", "lmstudio", "xai", "kimi", ...OPENAI_COMPAT_NAMES];
 
 /** Cloud providers that authenticate via API key / OAuth. Ollama is keyless. */
 export const CLOUD_PROVIDERS: readonly AuthProvider[] = ["anthropic", "openai", "gemini", "antigravity"];
@@ -29,9 +31,12 @@ export interface ProviderStatus {
   ready: boolean;
 }
 
-/** The uppercase `<PROVIDER>_API_KEY` env var name for a cloud provider. */
+/** The env var that supplies a provider's API key. Catalog providers carry their
+ *  own (e.g. HF_TOKEN, NANO_GPT_API_KEY); built-ins use `<PROVIDER>_API_KEY`. */
 export function providerEnvVar(name: ProviderName): string | undefined {
-  if (name === "ollama" || name === "antigravity") return undefined;
+  if (name === "ollama" || name === "lmstudio" || name === "antigravity") return undefined;
+  const def = openaiCompatDef(name);
+  if (def) return def.apiKeyEnv;
   return `${name.toUpperCase()}_API_KEY`;
 }
 
@@ -74,10 +79,24 @@ function effectiveCredential(provider: AuthProvider, cred: Credential, cfg: Conf
 /** Resolve the status of a single provider. */
 export async function describeProvider(name: ProviderName, config?: Config): Promise<ProviderStatus> {
   const cfg = config ?? (await readGlobalConfig());
-  if (name === "ollama") {
-    const baseUrl = cfg.ollamaBaseUrl ?? "http://localhost:11434";
+  if (name === "ollama" || name === "lmstudio") {
+    const baseUrl = name === "ollama"
+      ? (cfg.ollamaBaseUrl ?? "http://localhost:11434")
+      : (cfg.lmstudioBaseUrl ?? "http://localhost:1234/v1");
     return { name, kind: "keyless", label: credentialLabel("keyless"), baseUrl, ready: true };
   }
+  if ((API_KEY_ONLY_PROVIDERS as readonly string[]).includes(name)) {
+    // API-key-only providers (xai/kimi): no OAuth flow — ready when their key is set.
+    const key = cfg.providers?.[name as AuthProvider];
+    const envVar = providerEnvVar(name);
+    return {
+      name,
+      kind: key ? "api_key" : "none",
+      label: key ? credentialLabel("api_key") : `none (set ${envVar})`,
+      envVar,
+      ready: !!key,
+    };
+  }
   const ownProvider = name as AuthProvider;
   const ownCred = configuredCredential(ownProvider, cfg);
   // Antigravity prefers its own login but accepts a gemini-cli OAuth fallback.
@@ -97,7 +116,7 @@ export async function describeProvider(name: ProviderName, config?: Config): Pro
       : hasGeminiFallback
         ? "OAuth catalog via Gemini CLI; calls need 'jeo auth login antigravity'"
         : "none (run 'jeo auth login antigravity')";
-  } else if (kind === "oauth" && OAUTH_FLOW_REGISTRY[credentialProvider]?.verifiedEndToEnd === false) {
+  } else if (kind === "oauth" && isOAuthProvider(credentialProvider) && OAUTH_FLOW_REGISTRY[credentialProvider].verifiedEndToEnd === false) {
     ready = false;
     label = "OAuth (API key needed)";
   } else if (name === "gemini" && kind === "oauth") {

package/src/ai/providers/anthropic-compatible.ts

@@ -0,0 +1,27 @@
+import type { ProviderAdapter, CallOptions, ProviderName } from "../types";
+import { anthropicAdapter } from "./anthropic";
+
+/**
+ * Factory for Anthropic-Messages-compatible providers (z.ai, MiniMax, …). They speak
+ * the same `/v1/messages` wire protocol as Anthropic with an `x-api-key` bearer, so each
+ * is a thin shim over `anthropicAdapter`: strip the `<name>/` routing prefix and pin the
+ * base URL (resolved upstream into `options.baseUrl`). The credential is an api_key —
+ * `anthropicAdapter` emits the plain `x-api-key` Messages headers for api_key creds
+ * (no Claude-Code OAuth cloaking / billing / betas), so it works as a generic client.
+ */
+export function makeAnthropicCompatibleAdapter(opts: { name: ProviderName; baseUrl: string }): ProviderAdapter {
+  const prefix = `${opts.name}/`;
+  const prep = (o: CallOptions): CallOptions => ({
+    ...o,
+    model: o.model.startsWith(prefix) ? o.model.slice(prefix.length) : o.model,
+    baseUrl: o.baseUrl ?? opts.baseUrl,
+  });
+  return {
+    name: opts.name,
+    supportsNativeTools: anthropicAdapter.supportsNativeTools,
+    call: (messages, options, credential) => anthropicAdapter.call(messages, prep(options), credential),
+    async *stream(messages, options, credential) {
+      yield* anthropicAdapter.stream!(messages, prep(options), credential);
+    },
+  };
+}

package/src/ai/providers/anthropic.ts

@@ -72,11 +72,13 @@ function anthropicSystemBlocks(
   return blocks;
 }
 
-/** Anthropic extended-thinking budget by reasoning effort (kept under max_tokens). Off for
- *  low/minimal/unset effort so /fast and minimal thinking stay non-thinking (cheaper/faster). */
+/** Anthropic extended-thinking budget by reasoning effort (kept under max_tokens). Cross-provider
+ *  parity (matches Gemini's tiers): low/medium/high all enable thinking with scaling depth; only
+ *  minimal/unset stay non-thinking so /fast and minimal thinking remain cheaper/faster. */
 function anthropicThinkingBudget(effort: CallOptions["reasoningEffort"], maxTokens: number): number | undefined {
   let budget: number;
   switch (effort) {
+    case "low": budget = 4000; break;
     case "medium": budget = 10000; break;
     case "high": budget = 24000; break;
     default: return undefined;
@@ -160,7 +162,9 @@ export function anthropicRequest(
   includeTemperature: boolean,
 ): { url: string; headers: Record<string, string>; body: string } {
   return {
-    url: ANTHROPIC_URL,
+    // Anthropic-compatible providers (z.ai, MiniMax, …) accept the Messages wire
+    // format at their own host; an explicit baseUrl pins `${base}/v1/messages`.
+    url: options.baseUrl ? `${options.baseUrl.replace(/\/$/, "")}/v1/messages` : ANTHROPIC_URL,
     headers: headersFor(credential, stream),
     body: anthropicPayload(messages, options, stream, includeTemperature, credential),
   };

package/src/ai/providers/antigravity.ts

@@ -8,6 +8,18 @@ import { geminiThinkingBudget } from "./gemini";
 
 const ANTIGRAVITY_DAILY_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
 const ANTIGRAVITY_SANDBOX_ENDPOINT = "https://daily-cloudcode-pa.sandbox.googleapis.com";
+
+/** Anthropic-style thinking budget for Claude served via CCA. gemini's budget fn
+ *  returns undefined for claude ids, which left antigravity Claude with NO thinking
+ *  requested (the opus "no reasoning" gap). Mirrors anthropic's effort→budget tiers. */
+function antigravityClaudeThinkingBudget(effort: CallOptions["reasoningEffort"]): number | undefined {
+  switch (effort) {
+    case "low": return 4000;
+    case "medium": return 10000;
+    case "high": return 24000;
+    default: return undefined;
+  }
+}
 const ENDPOINTS = [ANTIGRAVITY_DAILY_ENDPOINT, ANTIGRAVITY_SANDBOX_ENDPOINT] as const;
 
 export function getAntigravityUserAgent(): string {
@@ -129,13 +141,24 @@ export function antigravityRequest(messages: Message[], options: CallOptions, cr
   const systemPrompt = options.systemPrompt ?? messages.find(m => m.role === "system")?.content;
   const generationConfig: Record<string, unknown> = {};
   if (options.temperature !== undefined) generationConfig.temperature = options.temperature;
+  const isClaude = model.toLowerCase().includes("claude");
   // Upstream Antigravity strips maxOutputTokens for non-Claude models; do the same.
-  if (model.toLowerCase().includes("claude")) generationConfig.maxOutputTokens = options.maxTokens ?? 4000;
-  // Apply the thinking level: antigravity serves Gemini models through CCA, so reuse the
-  // Gemini thinkingConfig budget (off at minimal, scaling with reasoning effort). Without
-  // this the thinking level only changed token budget, never actual reasoning depth.
-  const agThinkingBudget = geminiThinkingBudget(model, options.reasoningEffort);
-  if (agThinkingBudget !== undefined) generationConfig.thinkingConfig = { thinkingBudget: agThinkingBudget };
+  if (isClaude) generationConfig.maxOutputTokens = options.maxTokens ?? 4000;
+  // Apply the thinking level. CCA emits `thought` parts ONLY when thinkingConfig has
+  // includeThoughts set. Gemini scales via geminiThinkingBudget; Claude-via-CCA needs an
+  // Anthropic-style budget (gemini's fn returns undefined for claude) PLUS the
+  // interleaved-thinking beta header below — without both, antigravity Claude (e.g. opus)
+  // never streamed reasoning while native sonnet did.
+  const agThinkingBudget = isClaude
+    ? antigravityClaudeThinkingBudget(options.reasoningEffort)
+    : geminiThinkingBudget(model, options.reasoningEffort);
+  const claudeThinkingOn = isClaude && agThinkingBudget !== undefined;
+  if (agThinkingBudget !== undefined) {
+    generationConfig.thinkingConfig = { includeThoughts: true, thinkingBudget: agThinkingBudget };
+    // Claude (via CCA) enforces max_tokens > thinking.budget_tokens — bump the output cap
+    // above the budget (mirrors the native Anthropic provider) or CCA returns HTTP 400.
+    if (claudeThinkingOn) generationConfig.maxOutputTokens = Math.max((options.maxTokens ?? 4000), agThinkingBudget + 1024);
+  }
 
   const request: Record<string, unknown> = {
     contents: antigravityContents(messages),
@@ -165,6 +188,8 @@ export function antigravityRequest(messages: Message[], options: CallOptions, cr
       "content-type": "application/json",
       accept: "text/event-stream",
       "User-Agent": getAntigravityUserAgent(),
+      // Claude reasoning over CCA requires the Anthropic interleaved-thinking beta (gjc parity).
+      ...(claudeThinkingOn ? { "anthropic-beta": "interleaved-thinking-2025-05-14" } : {}),
     },
     body,
   };

package/src/ai/providers/gemini.ts

@@ -3,6 +3,7 @@ import type { CallOptions, Message, ProviderAdapter } from "../types";
 import { readSse } from "../sse";
 import { providerHttpError } from "./errors";
 import { jeoEnv } from "../../util/env";
+import { serializeToolCalls } from "../../agent/tool-schemas";
 
 /** Gemini 2.5+/latest models think by default and BILL thought tokens against
  *  `maxOutputTokens` — a small-budget call can burn its entire budget on thoughts
@@ -12,7 +13,13 @@ import { jeoEnv } from "../../util/env";
  *  Older models (1.5/2.0) reject `thinkingConfig` entirely → undefined (omit). */
 export function geminiThinkingBudget(model: string, effort?: CallOptions["reasoningEffort"], maxTokens?: number): number | undefined {
   const m = model.toLowerCase();
-  const thinkingCapable = /gemini-(2\.5|[3-9])|flash-latest|pro-latest/.test(m);
+  // Reasoning-capable when Gemini >= 2.5 (any 2.5+ minor) or major >= 3 (digit-count
+  // agnostic so gemini-10+ never silently loses thinking the way opus-4-8 did), plus
+  // the rolling *-latest aliases. Mirrors `inferCatalogMetadata` in model-catalog.ts.
+  const ver = m.match(/gemini-(\d+)(?:\.(\d+))?/);
+  const major = ver ? Number(ver[1]) : 0;
+  const minor = ver ? Number(ver[2] ?? 0) : 0;
+  const thinkingCapable = (major >= 3 || (major === 2 && minor >= 5)) || /flash-latest|pro-latest/.test(m);
   if (!thinkingCapable) return undefined;
   const floor = m.includes("pro") ? 128 : 0; // pro-class cannot fully disable thinking
   let budget: number;
@@ -63,12 +70,23 @@ export function buildGeminiPayload(messages: Message[], options: CallOptions): {
     temperature: options.temperature ?? 0.2,
     maxOutputTokens: options.maxTokens ?? 4000,
   };
-  if (options.jsonMode) generationConfig.responseMimeType = "application/json";
+  // Function-calling and responseMimeType:json are mutually exclusive in the Gemini
+  // API — when native tools are declared, the functionCall parts replace JSON-in-prose.
+  if (options.jsonMode && !options.tools?.length) generationConfig.responseMimeType = "application/json";
   const thinkingBudget = geminiThinkingBudget(geminiModel, options.reasoningEffort, options.maxTokens);
-  if (thinkingBudget !== undefined) generationConfig.thinkingConfig = { thinkingBudget };
+  // includeThoughts: required for Gemini to STREAM thought summaries (the `thought:true`
+  // parts thoughtOf() routes to onReasoning) — without it the model thinks silently.
+  if (thinkingBudget !== undefined) generationConfig.thinkingConfig = { includeThoughts: true, thinkingBudget };
 
   const payload: Record<string, unknown> = { contents, generationConfig };
   if (systemPrompt) payload.systemInstruction = { parts: [{ text: systemPrompt }] };
+  if (options.tools?.length) {
+    // NATIVE function-calling (gjc/antigravity parity): declare the toolset so the
+    // model emits functionCall parts instead of hand-formatting the JSON tool protocol
+    // (which weaker models mangle — wasted steps + apology prose leaking into replies).
+    payload.tools = [{ functionDeclarations: options.tools.map(t => ({ name: t.name, description: t.description, parameters: t.parameters })) }];
+    payload.toolConfig = { functionCallingConfig: { mode: "AUTO" } };
+  }
   return { geminiModel, payload };
 }
 
@@ -119,7 +137,7 @@ export function geminiCliRequest(messages: Message[], options: CallOptions, acce
 }
 
 interface GeminiChunk {
-  candidates?: { content?: { parts?: { text?: string; thought?: boolean }[] }; finishReason?: string }[];
+  candidates?: { content?: { parts?: { text?: string; thought?: boolean; functionCall?: { name?: string; args?: Record<string, unknown> } }[] }; finishReason?: string }[];
   promptFeedback?: { blockReason?: string };
   usageMetadata?: { promptTokenCount?: number; candidatesTokenCount?: number; thoughtsTokenCount?: number };
 }
@@ -138,6 +156,18 @@ function textOf(chunk: GeminiChunk): string {
 function thoughtOf(chunk: GeminiChunk): string {
   return chunk.candidates?.[0]?.content?.parts?.filter(p => p.thought).map(p => p.text ?? "").join("") ?? "";
 }
+/** Native Gemini functionCall parts → {tool, arguments} (gjc/antigravity parity). Kept
+ *  separate from textOf so the re-serialized canonical JSON envelope drives the loop. */
+function geminiFunctionCallsOf(chunk: GeminiChunk): { tool: string; arguments: Record<string, unknown> }[] {
+  const parts = chunk.candidates?.[0]?.content?.parts ?? [];
+  const out: { tool: string; arguments: Record<string, unknown> }[] = [];
+  for (const p of parts) {
+    if (p.functionCall && typeof p.functionCall.name === "string") {
+      out.push({ tool: p.functionCall.name, arguments: (p.functionCall.args ?? {}) as Record<string, unknown> });
+    }
+  }
+  return out;
+}
 
 /** When Gemini returns HTTP 200 with no text, surface the real cause (safety block /
  *  RECITATION / MAX_TOKENS) instead of a silent empty string that downstream JSON
@@ -173,6 +203,7 @@ async function* ccaTurn(messages: Message[], options: CallOptions, credential: C
   let lastUsage: GeminiChunk["usageMetadata"];
   let yieldedAny = false;
   let lastEmptyReason: string | undefined;
+  const fnCalls: { tool: string; arguments: Record<string, unknown> }[] = [];
   for await (const data of readSse(response.body)) {
     let chunk: CcaChunk;
     try {
@@ -192,7 +223,10 @@ async function* ccaTurn(messages: Message[], options: CallOptions, credential: C
       lastEmptyReason = blockedReason(inner) ?? lastEmptyReason;
     }
     if (inner.usageMetadata) lastUsage = inner.usageMetadata;
+    fnCalls.push(...geminiFunctionCallsOf(inner));
   }
+  const envelope = serializeToolCalls(fnCalls);
+  if (envelope) { yieldedAny = true; yield envelope; }
   if (!yieldedAny) {
     throw new Error(`Gemini (Cloud Code Assist) returned no content${lastEmptyReason ? ` (${lastEmptyReason})` : ""}.`);
   }
@@ -206,6 +240,7 @@ async function* ccaTurn(messages: Message[], options: CallOptions, credential: C
 
 export const geminiAdapter: ProviderAdapter = {
   name: "gemini",
+  supportsNativeTools: true,
   async call(messages, options, credential) {
     // OAuth (gemini-cli login) → Cloud Code Assist; no GEMINI_API_KEY required.
     if (credential.kind === "oauth") {
@@ -220,6 +255,8 @@ export const geminiAdapter: ProviderAdapter = {
     if (result.usageMetadata) {
       options.onUsage?.({ inputTokens: result.usageMetadata.promptTokenCount, outputTokens: result.usageMetadata.candidatesTokenCount });
     }
+    const envelope = serializeToolCalls(geminiFunctionCallsOf(result));
+    if (envelope) return envelope;
     const text = textOf(result);
     if (!text) {
       const reason = blockedReason(result);
@@ -240,6 +277,7 @@ export const geminiAdapter: ProviderAdapter = {
     let lastUsage: GeminiChunk["usageMetadata"];
     let yieldedAny = false;
     let lastEmptyReason: string | undefined;
+    const fnCalls: { tool: string; arguments: Record<string, unknown> }[] = [];
     for await (const data of readSse(response.body)) {
       let chunk: GeminiChunk;
       try {
@@ -259,7 +297,10 @@ export const geminiAdapter: ProviderAdapter = {
       // Gemini emits cumulative usageMetadata on most chunks; capture the last and
       // report ONCE after the stream so an accumulating sink can't over-count.
       if (chunk.usageMetadata) lastUsage = chunk.usageMetadata;
+      fnCalls.push(...geminiFunctionCallsOf(chunk));
     }
+    const envelope = serializeToolCalls(fnCalls);
+    if (envelope) { yieldedAny = true; yield envelope; }
     if (!yieldedAny && lastEmptyReason) {
       throw new Error(`Gemini returned no content (${lastEmptyReason}).`);
     }

package/src/ai/providers/kimi.ts

@@ -0,0 +1,18 @@
+import type { Credential } from "../../auth";
+import { makeOpenAICompatibleAdapter } from "./openai-compatible";
+
+/**
+ * Kimi (Moonshot) — OpenAI-compatible cloud API at https://api.moonshot.ai/v1, keyed
+ * by KIMI_API_KEY (or `providers.kimi`). The credential (an api_key bearer) is passed
+ * through; thinking models (kimi-thinking-preview) stream reasoning via
+ * `reasoning_content`/`<think>`, which the openai adapter routes to onReasoning.
+ */
+export const KIMI_BASE_URL = "https://api.moonshot.ai/v1";
+
+export const kimiAdapter = makeOpenAICompatibleAdapter({ name: "kimi", baseUrl: KIMI_BASE_URL });
+
+/** Credential carrier for Kimi calls — an api_key bearer (the adapter only reads the
+ *  token); a keyless `none` when no key is set. */
+export function kimiCredential(key: string | undefined): Credential {
+  return key ? { kind: "api_key", provider: "openai", token: key } : { kind: "none", provider: "openai" };
+}

package/src/ai/providers/lmstudio.ts

@@ -0,0 +1,8 @@
+import { makeOpenAICompatibleAdapter } from "./openai-compatible";
+
+/** LM Studio — local, keyless, OpenAI-compatible server (default http://localhost:1234/v1). */
+export const lmstudioAdapter = makeOpenAICompatibleAdapter({
+  name: "lmstudio",
+  baseUrl: "http://localhost:1234/v1",
+  keyless: true,
+});

package/src/ai/providers/ollama.ts

@@ -1,6 +1,7 @@
 import type { CallOptions, Message, ProviderAdapter } from "../types";
 import { readLines } from "../sse";
 import { providerHttpError } from "./errors";
+import { createThinkSplitter } from "../think-tags";
 
 /**
  * Resolve the Ollama base URL. `OLLAMA_HOST` is documented as a bare host:port
@@ -61,24 +62,35 @@ export const ollamaAdapter: ProviderAdapter = {
     if (!response.body) return;
     let yieldedAny = false;
     let doneReason: string | undefined;
+    // Route inline <think>…</think> (local reasoning models) to the reasoning channel.
+    const think = createThinkSplitter(options.onReasoning);
     for await (const line of readLines(response.body)) {
-      let chunk: { message?: { content?: string }; done?: boolean; done_reason?: string; prompt_eval_count?: number; eval_count?: number; total_duration?: number };
+      let chunk: { message?: { content?: string; thinking?: string }; done?: boolean; done_reason?: string; prompt_eval_count?: number; eval_count?: number; total_duration?: number };
       try {
         chunk = JSON.parse(line);
       } catch {
         continue;
       }
-      const delta = chunk.message?.content;
-      if (delta) {
-        yieldedAny = true;
-        yield delta;
+      const raw = chunk.message?.content;
+      if (raw) {
+        const visible = think.push(raw);
+        if (visible) {
+          yieldedAny = true;
+          yield visible;
+        }
       }
+      // Native separated thinking (Ollama `message.thinking`, present when the model
+      // runs in think mode) → reasoning channel. Inline <think> is handled above.
+      const reason = chunk.message?.thinking;
+      if (reason) options.onReasoning?.(reason);
       if (chunk.done) {
         if (chunk.done_reason) doneReason = chunk.done_reason;
         options.onUsage?.({ inputTokens: chunk.prompt_eval_count, outputTokens: chunk.eval_count, durationMs: chunk.total_duration ? Math.round(chunk.total_duration / 1e6) : undefined });
         break;
       }
     }
+    const trailing = think.flush();
+    if (trailing) { yieldedAny = true; yield trailing; }
     if (!yieldedAny) throw emptyCompletionError(doneReason);
   },
 };

package/src/ai/providers/openai-compatible-catalog.ts

@@ -0,0 +1,72 @@
+import type { ProviderName } from "../types";
+
+/**
+ * gjc-style data-driven provider catalog. Every entry here is an OpenAI-compatible
+ * cloud API (same `/chat/completions` + `/models` wire protocol), so adding a new
+ * provider is ONE table row — `register-providers` builds its adapter via
+ * `makeOpenAICompatibleAdapter`, and routing / discovery / status / auth all derive
+ * their per-provider behavior from this table instead of hardcoded string branches.
+ *
+ * Constraints kept deliberately uniform so the generic paths stay simple:
+ *  - `name` is the routing prefix (`<name>/…`) AND the config/auth key.
+ *  - `apiKeyEnv` is `<NAME>_API_KEY` (matches `providerEnvVar`'s convention).
+ *  - api-key-only (no OAuth flow); reasoning rides `reasoning_content`/`<think>`.
+ */
+export interface OpenAICompatProviderDef {
+  /** Routing prefix + config/auth key (must be a ProviderName literal). */
+  readonly name: ProviderName;
+  /** Display name (companyLabel). */
+  readonly label: string;
+  /** Default API base URL (…/v1) — `${base}/chat/completions` + `${base}/models`. */
+  readonly baseUrl: string;
+  /** `<NAME>_API_KEY` env var that seeds `config.providers[name]`. */
+  readonly apiKeyEnv: string;
+  /** Default model id (provider-prefixed) used by `--provider <name>`. */
+  readonly defaultModel: string;
+  /** Wire protocol: "openai" (/chat/completions, default) or "anthropic" (/v1/messages). */
+  readonly protocol?: "openai" | "anthropic";
+}
+
+export const OPENAI_COMPAT_PROVIDERS: readonly OpenAICompatProviderDef[] = [
+  { name: "groq", label: "Groq", baseUrl: "https://api.groq.com/openai/v1", apiKeyEnv: "GROQ_API_KEY", defaultModel: "groq/llama-3.3-70b-versatile" },
+  { name: "deepseek", label: "DeepSeek", baseUrl: "https://api.deepseek.com/v1", apiKeyEnv: "DEEPSEEK_API_KEY", defaultModel: "deepseek/deepseek-chat" },
+  { name: "mistral", label: "Mistral", baseUrl: "https://api.mistral.ai/v1", apiKeyEnv: "MISTRAL_API_KEY", defaultModel: "mistral/mistral-large-latest" },
+  { name: "openrouter", label: "OpenRouter", baseUrl: "https://openrouter.ai/api/v1", apiKeyEnv: "OPENROUTER_API_KEY", defaultModel: "openrouter/openai/gpt-4o-mini" },
+  { name: "together", label: "Together", baseUrl: "https://api.together.xyz/v1", apiKeyEnv: "TOGETHER_API_KEY", defaultModel: "together/meta-llama/Llama-3.3-70B-Instruct-Turbo" },
+  { name: "cerebras", label: "Cerebras", baseUrl: "https://api.cerebras.ai/v1", apiKeyEnv: "CEREBRAS_API_KEY", defaultModel: "cerebras/llama-3.3-70b" },
+  { name: "fireworks", label: "Fireworks", baseUrl: "https://api.fireworks.ai/inference/v1", apiKeyEnv: "FIREWORKS_API_KEY", defaultModel: "fireworks/accounts/fireworks/models/llama-v3p3-70b-instruct" },
+  { name: "nvidia", label: "NVIDIA", baseUrl: "https://integrate.api.nvidia.com/v1", apiKeyEnv: "NVIDIA_API_KEY", defaultModel: "nvidia/meta/llama-3.3-70b-instruct" },
+  // Additional gjc-parity OpenAI-compatible clouds (authoritative base URLs + env vars).
+  { name: "alibaba-coding-plan", label: "Alibaba Coding Plan", baseUrl: "https://coding-intl.dashscope.aliyuncs.com/v1", apiKeyEnv: "ALIBABA_CODING_PLAN_API_KEY", defaultModel: "alibaba-coding-plan/qwen3.5-plus" },
+  { name: "huggingface", label: "Hugging Face", baseUrl: "https://router.huggingface.co/v1", apiKeyEnv: "HF_TOKEN", defaultModel: "huggingface/deepseek-ai/DeepSeek-R1" },
+  { name: "nanogpt", label: "NanoGPT", baseUrl: "https://nano-gpt.com/api/v1", apiKeyEnv: "NANO_GPT_API_KEY", defaultModel: "nanogpt/openai/gpt-5.4" },
+  { name: "qwen-portal", label: "Qwen Portal", baseUrl: "https://portal.qwen.ai/v1", apiKeyEnv: "QWEN_PORTAL_API_KEY", defaultModel: "qwen-portal/coder-model" },
+  { name: "synthetic", label: "Synthetic", baseUrl: "https://api.synthetic.new/openai/v1", apiKeyEnv: "SYNTHETIC_API_KEY", defaultModel: "synthetic/hf:moonshotai/Kimi-K2.5" },
+  { name: "venice", label: "Venice", baseUrl: "https://api.venice.ai/api/v1", apiKeyEnv: "VENICE_API_KEY", defaultModel: "venice/llama-3.3-70b" },
+  { name: "zenmux", label: "ZenMux", baseUrl: "https://zenmux.ai/api/v1", apiKeyEnv: "ZENMUX_API_KEY", defaultModel: "zenmux/anthropic/claude-opus-4.6" },
+  { name: "qianfan", label: "Qianfan", baseUrl: "https://qianfan.baidubce.com/v2", apiKeyEnv: "QIANFAN_API_KEY", defaultModel: "qianfan/deepseek-v3.2" },
+  { name: "xiaomi", label: "Xiaomi", baseUrl: "https://api.xiaomimimo.com/v1", apiKeyEnv: "XIAOMI_API_KEY", defaultModel: "xiaomi/mimo-v2-flash" },
+  { name: "xiaomi-token-plan-ams", label: "Xiaomi Token Plan (Europe)", baseUrl: "https://token-plan-ams.xiaomimimo.com/v1", apiKeyEnv: "XIAOMI_TOKEN_PLAN_AMS_API_KEY", defaultModel: "xiaomi-token-plan-ams/mimo-v2.5" },
+  { name: "xiaomi-token-plan-cn", label: "Xiaomi Token Plan (China)", baseUrl: "https://token-plan-cn.xiaomimimo.com/v1", apiKeyEnv: "XIAOMI_TOKEN_PLAN_CN_API_KEY", defaultModel: "xiaomi-token-plan-cn/mimo-v2.5" },
+  { name: "xiaomi-token-plan-sgp", label: "Xiaomi Token Plan (Singapore)", baseUrl: "https://token-plan-sgp.xiaomimimo.com/v1", apiKeyEnv: "XIAOMI_TOKEN_PLAN_SGP_API_KEY", defaultModel: "xiaomi-token-plan-sgp/mimo-v2.5" },
+  { name: "minimax-code", label: "MiniMax Code", baseUrl: "https://api.minimax.io/v1", apiKeyEnv: "MINIMAX_CODE_API_KEY", defaultModel: "minimax-code/minimax-m3" },
+  { name: "minimax-code-cn", label: "MiniMax Code (China)", baseUrl: "https://api.minimaxi.com/v1", apiKeyEnv: "MINIMAX_CODE_CN_API_KEY", defaultModel: "minimax-code-cn/minimax-m3" },
+  // Anthropic-Messages-protocol providers (served via makeAnthropicCompatibleAdapter).
+  { name: "zai", label: "z.ai", baseUrl: "https://api.z.ai/api/anthropic", apiKeyEnv: "ZAI_API_KEY", defaultModel: "zai/glm-5.2", protocol: "anthropic" },
+  { name: "minimax", label: "MiniMax", baseUrl: "https://api.minimax.io/anthropic", apiKeyEnv: "MINIMAX_API_KEY", defaultModel: "minimax/minimax-m3", protocol: "anthropic" },
+];
+
+const BY_NAME = new Map<string, OpenAICompatProviderDef>(OPENAI_COMPAT_PROVIDERS.map(p => [p.name, p]));
+
+/** All catalog provider names (for PROVIDER_NAMES / AuthProvider unions). */
+export const OPENAI_COMPAT_NAMES: readonly ProviderName[] = OPENAI_COMPAT_PROVIDERS.map(p => p.name);
+
+/** Catalog entry for a provider name, or undefined when it is not catalog-driven. */
+export function openaiCompatDef(name: string): OpenAICompatProviderDef | undefined {
+  return BY_NAME.get(name);
+}
+
+/** True when `name` is a catalog-driven OpenAI-compatible provider. */
+export function isOpenAICompatProvider(name: string): boolean {
+  return BY_NAME.has(name);
+}

package/src/ai/providers/openai-compatible.ts

@@ -0,0 +1,31 @@
+import type { ProviderAdapter, CallOptions, ProviderName } from "../types";
+import type { Credential } from "../../auth";
+import { openaiAdapter } from "./openai";
+
+/**
+ * Factory for OpenAI-compatible providers (LM Studio, xAI/Grok, …). They all speak
+ * the same `/chat/completions` wire protocol, so each is a thin shim over
+ * `openaiAdapter`: strip the `<name>/` routing prefix, pin the base URL, and pass the
+ * credential (or force keyless for local servers that ignore auth). `keyless` keeps
+ * the openai adapter on plain /chat/completions (an oauth credential would divert to
+ * the Codex Responses backend).
+ */
+const KEYLESS: Credential = { kind: "none", provider: "openai" };
+
+export function makeOpenAICompatibleAdapter(opts: { name: ProviderName; baseUrl: string; keyless?: boolean }): ProviderAdapter {
+  const prefix = `${opts.name}/`;
+  const prep = (o: CallOptions): CallOptions => ({
+    ...o,
+    model: o.model.startsWith(prefix) ? o.model.slice(prefix.length) : o.model,
+    baseUrl: o.baseUrl ?? opts.baseUrl,
+  });
+  const credFor = (c: Credential): Credential => (opts.keyless ? KEYLESS : c);
+  return {
+    name: opts.name,
+    supportsNativeTools: openaiAdapter.supportsNativeTools,
+    call: (messages, options, credential) => openaiAdapter.call(messages, prep(options), credFor(credential)),
+    async *stream(messages, options, credential) {
+      yield* openaiAdapter.stream!(messages, prep(options), credFor(credential));
+    },
+  };
+}