jeo-code 0.6.22 → 0.6.24

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

@@ -0,0 +1,34 @@
+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; thinkingFormat?: CallOptions["reasoningFormat"] }): 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,
+    // Carry the backend's native-reasoning enablement so openaiRequest can turn thinking
+    // on with the right param (gjc parity) — without it OpenRouter/Qwen models stay silent.
+    reasoningFormat: o.reasoningFormat ?? opts.thinkingFormat,
+  });
+  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));
+    },
+  };
+}

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

@@ -76,6 +76,17 @@ export function codexResponsesRequest(
     // frame can show the model's thinking instead of a frozen "calling model (Ns)…".
     payload.reasoning = { effort: options.reasoningEffort, summary: "auto" };
   }
+  // OAuth → the undocumented ChatGPT/Codex backend (codex headers + account-id).
+  // API key → the public OpenAI Responses API (`/v1/responses`) with a plain Bearer.
+  // Both speak the same Responses schema (the body above), so only url+headers differ.
+  if (credential.kind === "api_key") {
+    const base = (options.baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "");
+    return {
+      url: `${base}/responses`,
+      headers: { "content-type": "application/json", authorization: `Bearer ${token}`, accept: "text/event-stream" },
+      body: JSON.stringify(payload),
+    };
+  }
   const accountId = extractChatgptAccountId(token);
   const headers: Record<string, string> = {
     "content-type": "application/json",

package/src/ai/providers/openai.ts

@@ -4,6 +4,37 @@ import { readSse } from "../sse";
 import { providerHttpError } from "./errors";
 import { codexResponsesCall, codexResponsesStream } from "./openai-responses";
 import { serializeToolCalls, serializeAccumulatedToolCalls } from "../../agent/tool-schemas";
+import { createThinkSplitter } from "../think-tags";
+
+/** True for OpenAI reasoning models (o-series + gpt-5+ family). Digit-count agnostic
+ *  (gpt-6/o10 stay reasoning). Strips the `openai/` routing prefix first. */
+export function isOpenAIReasoningModel(model: string): boolean {
+  const m = model.startsWith("openai/") ? model.slice(7) : model;
+  const gptMajor = m.match(/^gpt-(\d+)/);
+  return /^o\d/.test(m) || (gptMajor ? Number(gptMajor[1]) >= 5 : false);
+}
+
+/** gjc-parity: write the backend-specific param that turns NATIVE reasoning ON, so the
+ *  model streams thinking we can surface. Mutates `payload`. "openai" needs no param here
+ *  (handled by `reasoning_effort` for true o-series/gpt-5 models). */
+export function applyCompatThinking(
+  payload: Record<string, unknown>,
+  format: CallOptions["reasoningFormat"],
+  effort: NonNullable<CallOptions["reasoningEffort"]>,
+): void {
+  switch (format) {
+    case "openrouter":
+      payload.reasoning = { effort };
+      break;
+    case "qwen":
+      payload.enable_thinking = true;
+      break;
+    case "zai":
+      payload.thinking = { type: "enabled" };
+      break;
+    // "openai" / undefined: no extra param (reasoning_effort path covers real OpenAI models).
+  }
+}
 
 export function openaiRequest(messages: Message[], options: CallOptions, credential: Credential, stream: boolean): { url: string; headers: Record<string, string>; body: string } {
   const model = options.model.startsWith("openai/") ? options.model.slice(7) : options.model;
@@ -22,9 +53,10 @@ export function openaiRequest(messages: Message[], options: CallOptions, credent
       : msg.content;
     openaiMessages.push({ role: msg.role, content });
   }
-  // Reasoning models (o-series, gpt-5 family) take max_completion_tokens + reasoning_effort
+  // Reasoning models (o-series, gpt-5+ family) take max_completion_tokens + reasoning_effort
   // and reject temperature; classic chat models (gpt-4o, …) take max_tokens + temperature.
-  const isReasoning = /^o\d/.test(model) || /^gpt-5/.test(model);
+  // Digit-count agnostic (gpt-6/o10 stay reasoning) — mirrors inferCatalogMetadata.
+  const isReasoning = isOpenAIReasoningModel(model);
   const payload: Record<string, unknown> = {
     model,
     messages: openaiMessages,
@@ -36,6 +68,13 @@ export function openaiRequest(messages: Message[], options: CallOptions, credent
     payload.temperature = options.temperature ?? 0.2;
     payload.max_tokens = options.maxTokens ?? 4000;
   }
+  // gjc parity — enable NATIVE reasoning per the backend's thinking format so the model
+  // actually emits reasoning (otherwise OpenRouter/Qwen/z.ai stay silent and the TUI has
+  // nothing to show). `reasoning_effort` (OpenAI-style) only suits o-series/gpt-5; other
+  // backends need their own param. Gated on a requested effort (off → no thinking).
+  if (options.reasoningEffort && !isReasoning) {
+    applyCompatThinking(payload, options.reasoningFormat, options.reasoningEffort);
+  }
   if (stream) {
     payload.stream = true;
     payload.stream_options = { include_usage: true };
@@ -62,12 +101,56 @@ function emptyCompletionError(finishReason: string | undefined): Error {
   return new Error(`OpenAI returned no content${finishReason ? ` (finish_reason=${finishReason})` : ""}${hint}.`);
 }
 
+/** A streamed `choices[].delta`. `reasoning` is `unknown` because OpenAI-compatible
+ *  servers disagree on its shape: a plain string (OpenRouter/xAI), an object
+ *  `{ text|content }`, or absent (the `reasoning_details[]` array carries it instead). */
+export interface OpenAIDelta {
+  content?: string;
+  reasoning_content?: string;
+  reasoning_text?: string;
+  reasoning?: unknown;
+  reasoning_details?: { text?: string; content?: string }[];
+  tool_calls?: { index?: number; function?: { name?: string; arguments?: string } }[];
+}
+
+/** Pull a reasoning-text delta out of the many OpenAI-compatible shapes. Returns the
+ *  first non-empty of: `reasoning_content`, `reasoning_text`, a string/`{text|content}`
+ *  `reasoning`, or the concatenated `reasoning_details[].text|content`. */
+export function reasoningDeltaOf(delta: OpenAIDelta | undefined): string | undefined {
+  if (!delta) return undefined;
+  if (typeof delta.reasoning_content === "string" && delta.reasoning_content) return delta.reasoning_content;
+  if (typeof delta.reasoning_text === "string" && delta.reasoning_text) return delta.reasoning_text;
+  const r = delta.reasoning;
+  if (typeof r === "string" && r) return r;
+  if (r && typeof r === "object") {
+    const o = r as { text?: unknown; content?: unknown };
+    if (typeof o.text === "string" && o.text) return o.text;
+    if (typeof o.content === "string" && o.content) return o.content;
+  }
+  if (Array.isArray(delta.reasoning_details)) {
+    const t = delta.reasoning_details
+      .map(x => (typeof x?.text === "string" ? x.text : typeof x?.content === "string" ? x.content : ""))
+      .join("");
+    if (t) return t;
+  }
+  return undefined;
+}
+
 export const openaiAdapter: ProviderAdapter = {
   name: "openai",
   supportsNativeTools: true,
   async call(messages, options, credential) {
     // ChatGPT/Codex OAuth can't use /chat/completions — route to the Codex Responses backend.
     if (credential.kind === "oauth") return codexResponsesCall(messages, options, credential);
+    // OpenAI reasoning models (o-series/gpt-5) expose reasoning ONLY via the Responses
+    // API — /chat/completions hides it. Use Responses for a real-OpenAI API key (no
+    // custom baseUrl); OpenAI-compatible servers (groq/xai/lmstudio/… set baseUrl) keep
+    // the chat path + reasoning_content. Fall back to chat if /responses is unavailable.
+    if (credential.kind === "api_key" && !options.baseUrl && isOpenAIReasoningModel(options.model)) {
+      try {
+        return await codexResponsesCall(messages, options, credential);
+      } catch { /* /responses unsupported for this model/account — fall through to chat */ }
+    }
     const { url, headers, body } = openaiRequest(messages, options, credential, false);
     const response = await fetch(url, { method: "POST", headers, body, signal: options.signal });
     if (!response.ok) throw await providerHttpError("OpenAI", response);
@@ -85,6 +168,18 @@ export const openaiAdapter: ProviderAdapter = {
       yield* codexResponsesStream(messages, options, credential);
       return;
     }
+    // OpenAI reasoning models surface reasoning only via Responses (see call()). Pre-stream
+    // fallback: if it fails before any chunk, retry on chat completions (no regression).
+    if (credential.kind === "api_key" && !options.baseUrl && isOpenAIReasoningModel(options.model)) {
+      let started = false;
+      try {
+        for await (const chunk of codexResponsesStream(messages, options, credential)) { started = true; yield chunk; }
+        return;
+      } catch (e) {
+        if (started) throw e; // mid-stream failure — cannot safely restart on another endpoint
+        // else fall through to chat completions below
+      }
+    }
     const { url, headers, body } = openaiRequest(messages, options, credential, true);
     let response = await fetch(url, { method: "POST", headers, body, signal: options.signal });
     if (response.status === 400) {
@@ -102,19 +197,30 @@ export const openaiAdapter: ProviderAdapter = {
     if (!response.body) return;
     let yieldedAny = false;
     let finishReason: string | undefined;
+    // Split inline <think>…</think> (DeepSeek-R1/Qwen-style local models) out of the
+    // visible answer and onto the reasoning channel. No-op for models that never emit it.
+    const think = createThinkSplitter(options.onReasoning);
     const toolAcc = new Map<number, { name: string; args: string }>();
     for await (const data of readSse(response.body)) {
-      let chunk: { choices?: { delta?: { content?: string; tool_calls?: { index?: number; function?: { name?: string; arguments?: string } }[] }; finish_reason?: string }[]; usage?: { prompt_tokens?: number; completion_tokens?: number } };
+      let chunk: { choices?: { delta?: OpenAIDelta; finish_reason?: string }[]; usage?: { prompt_tokens?: number; completion_tokens?: number } };
       try {
         chunk = JSON.parse(data);
       } catch {
         continue;
       }
-      const delta = chunk.choices?.[0]?.delta?.content;
-      if (delta) {
-        yieldedAny = true;
-        yield delta;
+      const raw = chunk.choices?.[0]?.delta?.content;
+      if (raw) {
+        const visible = think.push(raw);
+        if (visible) {
+          yieldedAny = true;
+          yield visible;
+        }
       }
+      // Structured reasoning channel (separate from `content`, so it bypasses the
+      // <think> splitter): handles string fields, an object `reasoning`, and the
+      // `reasoning_details[]` array form (OpenRouter/xAI/DeepSeek variants).
+      const reason = reasoningDeltaOf(chunk.choices?.[0]?.delta);
+      if (reason) options.onReasoning?.(reason);
       const tcs = chunk.choices?.[0]?.delta?.tool_calls;
       if (tcs) {
         for (const tc of tcs) {
@@ -128,6 +234,8 @@ export const openaiAdapter: ProviderAdapter = {
       if (chunk.choices?.[0]?.finish_reason) finishReason = chunk.choices[0].finish_reason;
       if (chunk.usage) options.onUsage?.({ inputTokens: chunk.usage.prompt_tokens, outputTokens: chunk.usage.completion_tokens });
     }
+    const trailing = think.flush();
+    if (trailing) { yieldedAny = true; yield trailing; }
     // Native tool calls stream as tool_calls argument fragments — re-serialize once at end.
     const envelope = serializeAccumulatedToolCalls(toolAcc);
     if (envelope) { yieldedAny = true; yield envelope; }

package/src/ai/providers/xai.ts

@@ -0,0 +1,18 @@
+import type { Credential } from "../../auth";
+import { makeOpenAICompatibleAdapter } from "./openai-compatible";
+
+/**
+ * xAI (Grok) — OpenAI-compatible cloud API at https://api.x.ai/v1, keyed by
+ * XAI_API_KEY (or `providers.xai`). The credential (an api_key bearer) is passed
+ * through; grok reasoning models (grok-4.3, grok-4-fast-*, grok-code-fast-1) stream
+ * reasoning via `reasoning_content`, which the openai adapter routes to onReasoning.
+ */
+export const XAI_BASE_URL = "https://api.x.ai/v1";
+
+export const xaiAdapter = makeOpenAICompatibleAdapter({ name: "xai", baseUrl: XAI_BASE_URL });
+
+/** Credential carrier for xAI calls — an api_key bearer (the adapter only reads the
+ *  token); a keyless `none` when no key is set. */
+export function xaiCredential(key: string | undefined): Credential {
+  return key ? { kind: "api_key", provider: "openai", token: key } : { kind: "none", provider: "openai" };
+}

package/src/ai/register-providers.ts

@@ -12,10 +12,28 @@ import { anthropicAdapter } from "./providers/anthropic";
 import { openaiAdapter } from "./providers/openai";
 import { geminiAdapter } from "./providers/gemini";
 import { ollamaAdapter } from "./providers/ollama";
+import { lmstudioAdapter } from "./providers/lmstudio";
+import { xaiAdapter } from "./providers/xai";
 import { antigravityAdapter } from "./providers/antigravity";
+import { kimiAdapter } from "./providers/kimi";
+import { makeOpenAICompatibleAdapter } from "./providers/openai-compatible";
+import { makeAnthropicCompatibleAdapter } from "./providers/anthropic-compatible";
+import { OPENAI_COMPAT_PROVIDERS } from "./providers/openai-compatible-catalog";
 
 providerRegistry.register("anthropic", anthropicAdapter);
 providerRegistry.register("openai", openaiAdapter);
 providerRegistry.register("gemini", geminiAdapter);
 providerRegistry.register("antigravity", antigravityAdapter);
 providerRegistry.register("ollama", ollamaAdapter);
+providerRegistry.register("lmstudio", lmstudioAdapter);
+providerRegistry.register("xai", xaiAdapter);
+providerRegistry.register("kimi", kimiAdapter);
+
+// gjc-style data-driven providers: every catalog entry gets a thin factory adapter,
+// selected by wire protocol. Add a provider by adding ONE catalog row.
+for (const def of OPENAI_COMPAT_PROVIDERS) {
+  const adapter = def.protocol === "anthropic"
+    ? makeAnthropicCompatibleAdapter({ name: def.name, baseUrl: def.baseUrl })
+    : makeOpenAICompatibleAdapter({ name: def.name, baseUrl: def.baseUrl, thinkingFormat: def.thinkingFormat });
+  providerRegistry.register(def.name, adapter);
+}

package/src/ai/think-tags.ts

@@ -0,0 +1,84 @@
+/**
+ * Streaming `<think>…</think>` splitter for OpenAI-compatible / Ollama models.
+ *
+ * Many open/local reasoning models (DeepSeek-R1, Qwen "thinking", QwQ, …) do NOT
+ * expose a separate reasoning channel; they inline their chain-of-thought as
+ * `<think>…</think>` inside the normal content stream. Without splitting, that
+ * reasoning is dumped into the answer as literal text. This stateful splitter
+ * routes think-tag content to `onReasoning` (the dimmed live trace) and returns
+ * only the user-visible answer text — handling tags that straddle chunk
+ * boundaries, so it is safe to feed raw streamed deltas one at a time.
+ *
+ * Passthrough is near-free: text with no `<think>` tag flows through unchanged
+ * (only a trailing partial-tag fragment is briefly buffered).
+ */
+const OPEN = "<think>";
+const CLOSE = "</think>";
+
+/** Longest suffix of `s` that is a non-empty proper prefix of `tag` (0 if none). */
+function partialTail(s: string, tag: string): number {
+  const max = Math.min(s.length, tag.length - 1);
+  for (let k = max; k > 0; k--) {
+    if (s.endsWith(tag.slice(0, k))) return k;
+  }
+  return 0;
+}
+
+export interface ThinkSplitter {
+  /** Feed one streamed delta; returns the visible (answer) text to yield. */
+  push(delta: string): string;
+  /** Flush any buffered partial tag at stream end; returns trailing visible text. */
+  flush(): string;
+}
+
+export function createThinkSplitter(onReasoning?: (delta: string) => void): ThinkSplitter {
+  let inThink = false;
+  let pending = ""; // a tail that might be the start of an OPEN/CLOSE tag
+
+  const push = (delta: string): string => {
+    let s = pending + delta;
+    pending = "";
+    let visible = "";
+    for (;;) {
+      if (!inThink) {
+        const idx = s.indexOf(OPEN);
+        if (idx === -1) {
+          const tail = partialTail(s, OPEN);
+          visible += s.slice(0, s.length - tail);
+          pending = s.slice(s.length - tail);
+          break;
+        }
+        visible += s.slice(0, idx);
+        s = s.slice(idx + OPEN.length);
+        inThink = true;
+      } else {
+        const idx = s.indexOf(CLOSE);
+        if (idx === -1) {
+          const tail = partialTail(s, CLOSE);
+          const think = s.slice(0, s.length - tail);
+          if (think) onReasoning?.(think);
+          pending = s.slice(s.length - tail);
+          break;
+        }
+        const think = s.slice(0, idx);
+        if (think) onReasoning?.(think);
+        s = s.slice(idx + CLOSE.length);
+        inThink = false;
+      }
+    }
+    return visible;
+  };
+
+  const flush = (): string => {
+    const out = pending;
+    pending = "";
+    // An unterminated tail is literal content: emit it on whichever channel was open.
+    if (inThink) {
+      if (out) onReasoning?.(out);
+      return "";
+    }
+    return out;
+  };
+
+  return { push, flush };
+}

package/src/ai/types.ts

@@ -1,6 +1,6 @@
 import type { Credential } from "../auth";
 
-export type ProviderName = "anthropic" | "openai" | "gemini" | "antigravity" | "ollama";
+export type ProviderName = "anthropic" | "openai" | "gemini" | "antigravity" | "ollama" | "lmstudio" | "xai" | "kimi" | "groq" | "deepseek" | "mistral" | "openrouter" | "together" | "cerebras" | "fireworks" | "nvidia" | "alibaba-coding-plan" | "huggingface" | "nanogpt" | "qwen-portal" | "synthetic" | "venice" | "zenmux" | "qianfan" | "xiaomi" | "xiaomi-token-plan-ams" | "xiaomi-token-plan-cn" | "xiaomi-token-plan-sgp" | "minimax-code" | "minimax-code-cn" | "zai" | "minimax";
 
 /** An image attached to a (user) message — base64 payload + IANA media type. */
 export interface ImageAttachment {
@@ -17,6 +17,11 @@ export interface Message {
    *  these alongside `content`; history bookkeeping (compaction, transcripts)
    *  keeps treating `content` as the message body. */
   images?: ImageAttachment[];
+  /** Persisted reasoning/thinking text for an assistant turn (the thought before the
+   *  answer). Survives /resume + export so the durable record shows "think → answer".
+   *  Display-only: NOT replayed to providers (anthropic/gemini thinking replay needs
+   *  the original signed block, which the streaming path does not capture). */
+  reasoning?: string;
 }
 
 export interface Usage {
@@ -50,6 +55,11 @@ export interface CallOptions {
   signal?: AbortSignal;
   /** Reasoning effort for reasoning models (o-series / gpt-5), mapped from thinkingLevel. */
   reasoningEffort?: "minimal" | "low" | "medium" | "high";
+  /** How an OpenAI-compatible backend enables/streams native reasoning (gjc parity):
+   *  "openai" → `reasoning_effort`; "openrouter" → `reasoning: {effort}`; "qwen" →
+   *  `enable_thinking: true`; "zai" → `thinking: {type:"enabled"}`. Set per provider by
+   *  the openai-compatible factory; without it a model never emits reasoning to surface. */
+  reasoningFormat?: "openai" | "openrouter" | "qwen" | "zai";
   /** Notified before each auto-retry backoff wait (rate limits / transient errors).
    *  NOT forwarded to provider adapters — consumed by the manager's retry layer. */
   onRetry?: (attempt: number, err: unknown, delayMs: number) => void;

package/src/auth/flows/index.ts

@@ -1,5 +1,5 @@
 /** Per-provider OAuth login + refresh dispatch. */
-import type { AuthProvider } from "../storage";
+import type { AuthProvider, OAuthProvider } from "../storage";
 import type { OAuthController, OAuthCredentials } from "../types";
 import { loginAnthropic, refreshAnthropicToken } from "./anthropic";
 import { loginOpenAI, refreshOpenAIToken } from "./openai";
@@ -7,7 +7,7 @@ import { loginGoogle, refreshGoogleToken } from "./google";
 import { loginAntigravity, refreshAntigravityToken } from "./antigravity";
 
 export interface OAuthFlow {
-  readonly provider: AuthProvider;
+  readonly provider: OAuthProvider;
   readonly label: string;
   /** Run the interactive browser/PKCE login. */
   login(ctrl: OAuthController): Promise<OAuthCredentials>;
@@ -19,7 +19,7 @@ export interface OAuthFlow {
   readonly note?: string;
 }
 
-export const OAUTH_FLOW_REGISTRY: Record<AuthProvider, OAuthFlow> = {
+export const OAUTH_FLOW_REGISTRY: Record<OAuthProvider, OAuthFlow> = {
   anthropic: {
     provider: "anthropic",
     label: "Anthropic (Claude Pro/Max)",

package/src/auth/index.ts

@@ -6,8 +6,11 @@ export {
   setOauthCredential,
   clearOauthToken,
   setApiKey,
+  isOAuthProvider,
+  OAUTH_PROVIDERS,
+  API_KEY_ONLY_PROVIDERS,
 } from "./storage";
-export type { AuthProvider, Credential, AuthSnapshot } from "./storage";
+export type { AuthProvider, OAuthProvider, Credential, AuthSnapshot } from "./storage";
 export {
   OAUTH_FLOWS,
   openInBrowser,

package/src/auth/oauth.ts

@@ -1,4 +1,4 @@
-import type { AuthProvider } from "./storage";
+import type { AuthProvider, OAuthProvider } from "./storage";
 import { setOauthToken, clearOauthToken, setOauthCredential } from "./storage";
 import { OAUTH_FLOW_REGISTRY } from "./flows";
 import type { OAuthController } from "./types";
@@ -10,7 +10,7 @@ export interface OauthFlowDef {
 }
 
 /** Metadata kept for help text / manual-paste fallback. */
-export const OAUTH_FLOWS: Record<AuthProvider, OauthFlowDef> = {
+export const OAUTH_FLOWS: Record<OAuthProvider, OauthFlowDef> = {
   anthropic: {
     label: "Anthropic Console (Claude)",
     authorizeUrl: "https://claude.ai/oauth/authorize",
@@ -64,7 +64,7 @@ export async function openInBrowser(url: string): Promise<void> {
  * the local callback server, wait for the code (or manual paste), exchange it,
  * and persist the full credential set (access + refresh + expiry).
  */
-export async function interactiveLogin(provider: AuthProvider, ctrl: OAuthController): Promise<{ email?: string }> {
+export async function interactiveLogin(provider: OAuthProvider, ctrl: OAuthController): Promise<{ email?: string }> {
   const flow = OAUTH_FLOW_REGISTRY[provider];
   const creds = await flow.login(ctrl);
   await setOauthCredential(provider, {

package/src/auth/refresh.ts

@@ -7,6 +7,7 @@ import {
   acquireLock,
   releaseLock,
   type AuthProvider,
+  isOAuthProvider,
   type Credential,
 } from "./storage";
 import { OAUTH_FLOW_REGISTRY } from "./flows";
@@ -24,6 +25,10 @@ export interface RefreshResult {
  * Mirrors gjc's auth-broker refresher semantics (single source of truth).
  */
 export async function refreshOAuthToken(provider: AuthProvider): Promise<RefreshResult> {
+  // API-key-only providers (xai/kimi) have no OAuth flow — nothing to refresh.
+  if (!isOAuthProvider(provider)) {
+    return { refreshed: false, reason: "no_oauth_token", credential: await resolveCredential(provider) };
+  }
   await acquireLock(provider);
   try {
     const stored = await getStoredOAuth(provider);

package/src/auth/storage.ts

@@ -5,7 +5,18 @@ import { readGlobalConfig, readRawGlobalConfig, saveConfigPatch, type StoredOAut
 import { jeoEnv } from "../util/env";
 
 
-export type AuthProvider = "anthropic" | "openai" | "gemini" | "antigravity";
+/** Providers with an interactive OAuth login + refresh flow. */
+export type OAuthProvider = "anthropic" | "openai" | "gemini" | "antigravity";
+/** Every provider jeo resolves a credential for: OAuth-capable ∪ API-key-only. */
+export type AuthProvider = OAuthProvider | "xai" | "kimi" | "groq" | "deepseek" | "mistral" | "openrouter" | "together" | "cerebras" | "fireworks" | "nvidia" | "alibaba-coding-plan" | "huggingface" | "nanogpt" | "qwen-portal" | "synthetic" | "venice" | "zenmux" | "qianfan" | "xiaomi" | "xiaomi-token-plan-ams" | "xiaomi-token-plan-cn" | "xiaomi-token-plan-sgp" | "minimax-code" | "minimax-code-cn" | "zai" | "minimax";
+
+export const OAUTH_PROVIDERS: readonly OAuthProvider[] = ["anthropic", "openai", "gemini", "antigravity"];
+/** API-key-only providers (no OAuth flow) — resolved from config.providers / `<NAME>_API_KEY`. */
+export const API_KEY_ONLY_PROVIDERS: readonly AuthProvider[] = ["xai", "kimi", "groq", "deepseek", "mistral", "openrouter", "together", "cerebras", "fireworks", "nvidia", "alibaba-coding-plan", "huggingface", "nanogpt", "qwen-portal", "synthetic", "venice", "zenmux", "qianfan", "xiaomi", "xiaomi-token-plan-ams", "xiaomi-token-plan-cn", "xiaomi-token-plan-sgp", "minimax-code", "minimax-code-cn", "zai", "minimax"];
+/** Narrow an AuthProvider to the OAuth-capable subset (xai/kimi have no OAuth flow). */
+export function isOAuthProvider(p: AuthProvider): p is OAuthProvider {
+  return (OAUTH_PROVIDERS as readonly string[]).includes(p);
+}
 
 export type Credential =
   | { kind: "oauth"; provider: AuthProvider; token: string; projectId?: string }

package/src/commands/auth.ts

@@ -14,6 +14,10 @@ import {
   logoutOAuth,
   refreshOAuthToken,
   snapshotProvider,
+  setApiKey,
+  isOAuthProvider,
+  OAUTH_PROVIDERS,
+  API_KEY_ONLY_PROVIDERS,
   type AuthProvider,
   type OAuthController,
 } from "../auth";
@@ -29,7 +33,8 @@ export async function runAuthCommand(args: string[]): Promise<void> {
   process.exitCode = 1;
 }
 
-const CLOUD_PROVIDERS: readonly AuthProvider[] = ["anthropic", "openai", "gemini", "antigravity"]
+// Every loginable provider: OAuth-capable ∪ API-key-only (keyless ollama/lmstudio excluded).
+const CLOUD_PROVIDERS: readonly AuthProvider[] = [...OAUTH_PROVIDERS, ...API_KEY_ONLY_PROVIDERS];
 /** True (and prints an error + sets exit code) when `p` is given but not a known provider. */
 function rejectInvalidProvider(p: string | undefined): boolean {
   if (p !== undefined && !(CLOUD_PROVIDERS as readonly string[]).includes(p)) {
@@ -53,7 +58,7 @@ async function runAuthStatus(): Promise<void> {
   const cfg = await readGlobalConfig();
   console.log("\n=== jeo auth status ===");
   console.log("Provider     API key   OAuth");
-  for (const p of ["anthropic", "openai", "gemini", "antigravity"] as AuthProvider[]) {
+  for (const p of CLOUD_PROVIDERS) {
     const snap = await snapshotProvider(p);
     const key = p === "antigravity" ? "—" : (snap.apiKey ? "set" : "—");
     let oauth = "—";
@@ -99,6 +104,17 @@ async function runAuthLogin(rest: string[]): Promise<void> {
     rl.close();
     return;
   }
+  // API-key-only providers (xai/kimi): no OAuth flow — store/guide an API key.
+  if ((API_KEY_ONLY_PROVIDERS as readonly string[]).includes(chosen)) {
+    rl.close();
+    if (manualToken) {
+      await setApiKey(chosen, manualToken.trim());
+      console.log(`[SUCCESS] Stored ${chosen.toUpperCase()}_API_KEY in ~/.jeo/config.json.`);
+    } else {
+      console.log(`Provider '${chosen}' is API-key only (no OAuth flow). Set ${chosen.toUpperCase()}_API_KEY, or run 'jeo auth login ${chosen} --token <key>'.`);
+    }
+    return;
+  }
 
   // Non-interactive paste path (`--token`): store as a manual bearer.
   if (manualToken) {
@@ -213,6 +229,9 @@ export async function interactiveOAuthLogin(
   prompt: OAuthPrompt,
   log: (s: string) => void = console.log,
 ): Promise<{ email?: string }> {
+  if (!isOAuthProvider(provider)) {
+    throw new Error(`Provider '${provider}' is API-key only (no OAuth flow) — set ${provider.toUpperCase()}_API_KEY or run 'jeo auth login ${provider} --token <key>'.`);
+  }
   const flow = OAUTH_FLOW_REGISTRY[provider];
   log(`\n=== OAuth login — ${flow.label} ===`);
   if (!flow.verifiedEndToEnd && flow.note) log(`Note: ${flow.note}`);

package/src/commands/launch/flags.ts

@@ -51,7 +51,11 @@ export function fastThinkingLevelForModel(modelId: string): ThinkLevel | undefin
   const supported = catalogMetadata(modelId)?.thinking ?? [];
   if (supported.includes("minimal")) return "minimal";
   if (supported.includes("low")) return "low";
-  if (/gemini-(2\.5|[3-9])/.test(modelId.toLowerCase())) return "minimal";
+  // Digit-count agnostic (gemini-10+ / 2.6+ stay reasoning) — mirrors the gates in
+  // gemini.ts and inferCatalogMetadata. Last resort for prefixed ids (models/gemini-…)
+  // the catalog lookup above misses; catalogued ids already returned via thinking caps.
+  const g = modelId.toLowerCase().match(/gemini-(\d+)(?:\.(\d+))?/);
+  if (g && (Number(g[1]) >= 3 || (Number(g[1]) === 2 && Number(g[2] ?? 0) >= 5))) return "minimal";
   return undefined;
 }
 

package/src/commands/launch/input.ts

@@ -395,3 +395,16 @@ export function createInFlightAbortHarness(opts: AbortHarnessOptions = {}): InFl
     },
   };
 }
+
+/** Classify a mid-turn Enter draft. `/` (slash command) and `$` (skill) are jeo's
+ *  command sigils: such a line must run as a COMMAND, never be steered as literal text
+ *  into the running model. Anything else is a STEER query fed to the live turn; blank
+ *  is EMPTY (ignored). Pure + exported so the live-turn handler and tests can't drift. */
+export function classifyMidTurnLine(line: string): "command" | "steer" | "empty" {
+  const t = line.trim();
+  if (!t) return "empty";
+  // A lone sigil ("/" or "$") has no command name — ignore it instead of aborting the
+  // running turn to dispatch an empty command (a stray slash should not interrupt work).
+  if (t === "/" || t === "$") return "empty";
+  return /^[/$]/.test(t) ? "command" : "steer";
+}