jeo-code 0.7.27 → 0.7.29

package/src/ai/providers/anthropic.ts

@@ -12,9 +12,14 @@ const CLAUDE_CODE_VERSION = "2.1.63";
 const CLAUDE_CODE_SYSTEM_INSTRUCTION = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
 const CLAUDE_BILLING_HEADER_PREFIX = "x-anthropic-billing-header:";
 /** Betas needed for API-key requests: interleaved-thinking enables thinking+tools,
- *  prompt-caching-scope gives scoped cache breakpoints. */
+ *  context-management matches gjc's default beta set (sent on ALL requests),
+ *  prompt-caching-scope gives scoped cache breakpoints.
+ *  ponytail: fine-grained-tool-streaming-2025-05-14 — gjc sends it and repairs truncated
+ *  tool-argument JSON; jeo parses accumulated tool JSON without that repair pass, so the
+ *  beta stays off until a repair step exists. */
 const ANTHROPIC_API_KEY_BETA = [
   "interleaved-thinking-2025-05-14",
+  "context-management-2025-06-27",
   "prompt-caching-scope-2026-01-05",
 ];
 const ANTHROPIC_OAUTH_BETA = [
@@ -46,8 +51,10 @@ function stripAnthropicPrefix(model: string): string {
   return model.startsWith("anthropic/") ? model.slice(10) : model;
 }
 
-function shouldUseClaudeCodeOAuthShape(model: string, credential: Credential): boolean {
-  return credential.kind === "oauth" && !model.startsWith("claude-3-5-haiku");
+function shouldUseClaudeCodeOAuthShape(model: string, credential: Credential, baseUrl?: string): boolean {
+  // Claude-Code OAuth cloaking is for api.anthropic.com only. An OAuth credential
+  // against a custom base (e.g. Kimi Code at api.kimi.com/coding) is a plain bearer.
+  return credential.kind === "oauth" && !baseUrl && !model.startsWith("claude-3-5-haiku");
 }
 
 function createClaudeCloakingUserId(): string {
@@ -68,9 +75,10 @@ function anthropicSystemBlocks(
   model: string,
   credential: Credential,
   billingPayload: Record<string, unknown>,
+  baseUrl?: string,
 ): AnthropicSystemBlock[] | undefined {
   const blocks: AnthropicSystemBlock[] = [];
-  if (shouldUseClaudeCodeOAuthShape(model, credential)) {
+  if (shouldUseClaudeCodeOAuthShape(model, credential, baseUrl)) {
     const billingSeed = systemPrompt ? { ...billingPayload, system: [systemPrompt] } : billingPayload;
     blocks.push(
       { type: "text", text: createClaudeBillingHeader(billingSeed) },
@@ -89,17 +97,19 @@ function anthropicSystemBlocks(
   return blocks;
 }
 
-/** Anthropic extended-thinking budget by reasoning effort (kept under max_tokens). Cross-provider
- *  parity (matches Gemini's tiers): minimal/low/medium/high ALL enable thinking with scaling
+/** Anthropic extended-thinking budget by reasoning effort (kept under max_tokens). Tiers match
+ *  gjc's ANTHROPIC_THINKING table: minimal/low/medium/high ALL enable thinking with scaling
  *  depth — reasoning works at every thinking level (gajae parity: Minimal is a real effort).
- *  Only an UNSET effort stays non-thinking (the explicit /fast off path). */
-function anthropicThinkingBudget(effort: CallOptions["reasoningEffort"], maxTokens: number): number | undefined {
+ *  Only an UNSET effort stays non-thinking (the explicit /fast off path). The "xhigh" row is
+ *  correct-by-table even though upstream currently folds xhigh→high before it arrives. */
+function anthropicThinkingBudget(effort: CallOptions["reasoningEffort"] | "xhigh", maxTokens: number): number | undefined {
   let budget: number;
   switch (effort) {
-    case "minimal": budget = 2000; break;
-    case "low": budget = 4000; break;
-    case "medium": budget = 10000; break;
-    case "high": budget = 24000; break;
+    case "minimal": budget = 1024; break;
+    case "low": budget = 4096; break;
+    case "medium": budget = 8192; break;
+    case "high": budget = 16384; break;
+    case "xhigh": budget = 32768; break;
     default: return undefined;
   }
   return Math.min(budget, Math.max(1024, maxTokens - 1024));
@@ -264,7 +274,7 @@ export function anthropicPayload(
     // Extended thinking requires max_tokens strictly above the thinking budget.
     max_tokens: thinkingBudget !== undefined ? Math.max(maxTokens, thinkingBudget + 1024) : maxTokens,
   };
-  if (credential.kind === "oauth") payload.metadata = { user_id: createClaudeCloakingUserId() };
+  if (shouldUseClaudeCodeOAuthShape(model, credential, options.baseUrl)) payload.metadata = { user_id: createClaudeCloakingUserId() };
   if (effort !== undefined) {
     // Enable Claude extended thinking. Extended thinking forbids a custom temperature, so
     // temperature is only set on the non-thinking path.
@@ -294,7 +304,7 @@ export function anthropicPayload(
     payload.tool_choice = { type: "auto" };
   }
   if (stream) payload.stream = true;
-  const system = anthropicSystemBlocks(systemPrompt, model, credential, payload);
+  const system = anthropicSystemBlocks(systemPrompt, model, credential, payload, options.baseUrl);
   if (system) payload.system = system;
   return JSON.stringify(payload);
 }
@@ -311,7 +321,7 @@ export function anthropicRequest(
     // 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, stripAnthropicPrefix(options.model)),
+    headers: { ...headersFor(credential, stream, stripAnthropicPrefix(options.model), options.baseUrl), ...options.extraHeaders },
     body: anthropicPayload(messages, options, stream, includeTemperature, credential, stripArtifacts),
   };
 }
@@ -327,6 +337,22 @@ function isReasoningArtifactError(status: number, detail: string): boolean {
   return status === 400 && /thinking|signature|redacted_thinking/i.test(detail);
 }
 
+/** gjc parity (getSafeAnthropicHeaderEvidence): fold Anthropic's rate-limit response
+ *  headers into a 429's error detail so the retry classifier can see them. The decisive
+ *  usage-exhaustion signal (`anthropic-ratelimit-unified-overage-disabled-reason:
+ *  out_of_credits`) often arrives ONLY as a header — without this, an out-of-credits 429
+ *  reads like a generic per-minute rate limit and is retried pointlessly. */
+function anthropicRateLimitEvidence(headers: Headers): string {
+  const evidence: string[] = [];
+  for (const [name, value] of headers) {
+    const lower = name.toLowerCase();
+    if (lower === "retry-after" || lower === "retry-after-ms" || lower.startsWith("anthropic-ratelimit-")) {
+      evidence.push(`${lower}=${value}`);
+    }
+  }
+  return evidence.length > 0 ? ` Anthropic rate-limit evidence: ${evidence.sort().join(", ")}` : "";
+}
+
 async function postAnthropic(
   messages: Message[],
   options: CallOptions,
@@ -354,10 +380,13 @@ async function postAnthropic(
     throw await providerHttpError("Anthropic", response, stream ? "(stream)" : undefined);
   }
 
+  // 429s carry their rate-limit headers in the DETAIL so isUsageLimitError /
+  // friendlyProviderError can classify on the full evidence (gjc parity).
+  const enrichedDetail = response.status === 429 ? `${detail}${anthropicRateLimitEvidence(response.headers)}` : detail;
   throw new ProviderHttpError(
     "Anthropic",
     response.status,
-    detail,
+    enrichedDetail,
     stream ? "(stream)" : undefined,
     parseRetryAfter(response.headers.get("retry-after")) ?? parseRetryFromBody(detail),
   );
@@ -543,8 +572,18 @@ function claudeCodeOAuthHeaders(stream: boolean, model: string): Record<string,
   };
 }
 
-function headersFor(credential: Credential, stream: boolean, model: string): Record<string, string> {
+function headersFor(credential: Credential, stream: boolean, model: string, baseUrl?: string): Record<string, string> {
   if (credential.kind === "oauth") {
+    // OAuth against a NON-Anthropic base (Kimi Code, …): plain bearer, no Claude-Code
+    // cloaking headers/betas. gjc parity: buildAnthropicHeaders' generic-bearer branch.
+    if (baseUrl) {
+      return {
+        accept: stream ? "text/event-stream" : "application/json",
+        "content-type": "application/json",
+        authorization: `Bearer ${credential.token}`,
+        "anthropic-version": "2023-06-01",
+      };
+    }
     return {
       "content-type": "application/json",
       authorization: `Bearer ${credential.token}`,

package/src/ai/providers/antigravity.ts

@@ -4,7 +4,7 @@ import type { CallOptions, Message, ProviderAdapter } from "../types";
 import { readSse } from "../sse";
 import { providerHttpError } from "./errors";
 import { serializeToolCalls } from "../../agent/tool-schemas";
-import { geminiThinkingBudget } from "./gemini";
+import { geminiThinkingConfig, getGeminiCliHeaders, type GeminiThinkingConfig } from "./gemini";
 
 const ANTIGRAVITY_DAILY_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
 const ANTIGRAVITY_SANDBOX_ENDPOINT = "https://daily-cloudcode-pa.sandbox.googleapis.com";
@@ -37,15 +37,24 @@ function antigravityModelId(model: string): string {
   return model.replace(/^antigravity\//, "");
 }
 
-/** The thinking budget actually requested for an Antigravity turn — Claude-via-CCA uses an
- *  Anthropic-style budget, native Gemini scales via geminiThinkingBudget (which also honours
- *  in-name depth markers like `-high`/`-low`). Centralised so the request builder and the
- *  streaming start-signal stay in agreement. */
-function antigravityThinkingBudget(options: CallOptions): number | undefined {
+/** The thinkingConfig actually requested for an Antigravity turn — Claude-via-CCA uses an
+ *  Anthropic-style numeric budget, native Gemini goes through geminiThinkingConfig
+ *  (gemini-3.x → thinkingLevel enum, 2.5/latest → numeric budget; in-name depth markers
+ *  like `-high`/`-low` honoured). Centralised so the request builder and the streaming
+ *  start-signal stay in agreement. */
+function antigravityThinkingConfig(options: CallOptions): GeminiThinkingConfig | undefined {
   const model = antigravityModelId(options.model);
-  return model.toLowerCase().includes("claude")
-    ? antigravityClaudeThinkingBudget(options.reasoningEffort)
-    : geminiThinkingBudget(model, options.reasoningEffort);
+  if (model.toLowerCase().includes("claude")) {
+    const budget = antigravityClaudeThinkingBudget(options.reasoningEffort);
+    return budget === undefined ? undefined : { includeThoughts: true, thinkingBudget: budget };
+  }
+  return geminiThinkingConfig(model, options.reasoningEffort);
+}
+
+/** True when this turn requested thinking (a thinkingLevel or a positive budget). */
+function antigravityThinkingActive(options: CallOptions): boolean {
+  const cfg = antigravityThinkingConfig(options);
+  return cfg !== undefined && ("thinkingLevel" in cfg || cfg.thinkingBudget > 0);
 }
 
 function projectIdFor(credential: Credential): string | undefined {
@@ -89,8 +98,8 @@ export async function resolveAntigravityProjectId(
     // Antigravity-client tokens discover with ANTIGRAVITY metadata; gemini-cli
     // tokens use the default gemini-cli metadata shape.
     return discoverGoogleProjectId(token, credential.provider === "antigravity"
-      ? { metadata: { ...ANTIGRAVITY_DISCOVERY_METADATA }, extraHeaders: { "User-Agent": getAntigravityUserAgent() }, signal: opts.signal }
-      : { signal: opts.signal });
+      ? { metadata: { ...ANTIGRAVITY_DISCOVERY_METADATA }, extraHeaders: { "User-Agent": getAntigravityUserAgent() }, alwaysOnboard: true, signal: opts.signal }
+      : { extraHeaders: getGeminiCliHeaders(), signal: opts.signal });
   });
   let projectId: string;
   try {
@@ -165,18 +174,21 @@ export function antigravityRequest(messages: Message[], options: CallOptions, cr
   const isClaude = model.toLowerCase().includes("claude");
   // Upstream Antigravity strips maxOutputTokens for non-Claude models; do the same.
   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 = antigravityThinkingBudget(options);
-  const claudeThinkingOn = isClaude && agThinkingBudget !== undefined;
-  if (agThinkingBudget !== undefined) {
-    generationConfig.thinkingConfig = { includeThoughts: true, thinkingBudget: agThinkingBudget };
+  // Apply the thinking config. CCA emits `thought` parts ONLY when thinkingConfig has
+  // includeThoughts set. Gemini scales via geminiThinkingConfig (level enum on 3.x,
+  // numeric budget otherwise); 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 agThinking = antigravityThinkingConfig(options);
+  const claudeThinkingOn = isClaude && agThinking !== undefined;
+  if (agThinking !== undefined) {
+    generationConfig.thinkingConfig = agThinking;
     // 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);
+    if (claudeThinkingOn && "thinkingBudget" in agThinking) {
+      generationConfig.maxOutputTokens = Math.max((options.maxTokens ?? 4000), agThinking.thinkingBudget + 1024);
+    }
   }
 
   const request: Record<string, unknown> = {
@@ -288,7 +300,7 @@ export const antigravityAdapter: ProviderAdapter = {
     if (!response.body) return;
     // Signal the thinking phase up front (parity with anthropic's content_block_start) so the
     // UI shows it even before/without `thought` parts — otherwise reasoning looked dead here.
-    if ((antigravityThinkingBudget(options) ?? 0) > 0) options.onReasoningStart?.();
+    if (antigravityThinkingActive(options)) options.onReasoningStart?.();
     let yielded = false;
     let usage: CcaUsage | undefined;
     const fnCalls: { tool: string; arguments: Record<string, unknown> }[] = [];

package/src/ai/providers/gemini.ts

@@ -11,7 +11,7 @@ import { serializeToolCalls } from "../../agent/tool-schemas";
  *  Pin an explicit budget: off unless reasoning was requested. Pro-class models
  *  cannot disable thinking (API minimum 128), so they keep a floor instead of 0.
  *  Older models (1.5/2.0) reject `thinkingConfig` entirely → undefined (omit). */
-export function geminiThinkingBudget(model: string, effort?: CallOptions["reasoningEffort"], maxTokens?: number): number | undefined {
+export function geminiThinkingBudget(model: string, effort?: CallOptions["reasoningEffort"] | "xhigh", maxTokens?: number): number | undefined {
   const m = model.toLowerCase();
   // 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
@@ -22,41 +22,85 @@ export function geminiThinkingBudget(model: string, effort?: CallOptions["reason
   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
-  // An UNSET effort normally falls to the floor (off for flash-class). But when the model
-  // VARIANT name itself encodes a thinking depth — `-high`/`-low` (e.g. gemini-3-pro-high)
-  // or an explicit `-thinking` suffix (gemini-2.5-flash-thinking) — that selection IS the
-  // user's thinking opt-in, so it overrides the silent floor and maps to a real budget.
-  // Unmarked ids (gemini-3-flash, gemini-2.5-flash) keep the off-by-default floor (parity
-  // with the other providers + the documented thought-token burn protection).
-  const named: CallOptions["reasoningEffort"] | undefined =
-    m.includes("-high") ? "high"
-    : m.includes("-low") ? "low"
-    : m.includes("thinking") ? "medium"
-    : undefined;
-  const effectiveEffort = effort ?? named;
+  const effectiveEffort = effort ?? geminiNamedEffort(m);
   let budget: number;
   switch (effectiveEffort) {
     // minimal/low/medium/high ALL enable thinking with scaling depth — reasoning works at
     // every thinking level (gajae parity: Minimal is a real effort). Only an UNSET effort
     // (and no in-name depth marker) falls through to the floor.
-    case "minimal": budget = Math.max(floor, 2000); break;
-    case "low": budget = 4000; break;
-    case "medium": budget = 10000; break;
-    case "high": budget = 24000; break;
+    // Tier values mirror gjc's GOOGLE_THINKING table (stream.ts).
+    case "minimal": budget = Math.max(floor, 1024); break;
+    case "low": budget = 4096; break;
+    case "medium": budget = 8192; break;
+    case "high": budget = 16384; break;
+    case "xhigh": budget = 24575; break;
     default: budget = floor;
   }
   if (typeof maxTokens === "number") budget = Math.min(budget, Math.max(floor, maxTokens - 1024));
   return budget;
 }
 
-/** True when this turn was asked to think (a positive budget) — lets the streaming paths
- *  fire onReasoningStart so the UI shows the thinking phase even before/without any `thought`
- *  parts arrive (the Gemini/CCA analog of Anthropic's content_block_start thinking signal,
- *  which is why reasoning otherwise appeared "not to run" on gemini/antigravity). */
+/** In-name thinking depth marker. An UNSET effort normally falls to the floor (off for
+ *  flash-class). But when the model VARIANT name itself encodes a depth — `-high`/`-low`
+ *  (e.g. gemini-3-pro-high) or an explicit `-thinking` suffix (gemini-2.5-flash-thinking) —
+ *  that selection IS the user's thinking opt-in. Unmarked ids (gemini-3-flash,
+ *  gemini-2.5-flash) keep the off-by-default behavior (parity with the other providers +
+ *  the documented thought-token burn protection). Expects a lowercased id. */
+function geminiNamedEffort(m: string): CallOptions["reasoningEffort"] | undefined {
+  return m.includes("-high") ? "high"
+    : m.includes("-low") ? "low"
+    : m.includes("thinking") ? "medium"
+    : undefined;
+}
+
+/** Gemini 3.x is driven by the `thinkingLevel` ENUM, not a numeric budget (gjc
+ *  inferThinkingControlMode: gemini family with version.major === 3 → "google-level";
+ *  everything else stays on the numeric thinkingBudget). */
+export function geminiUsesThinkingLevel(model: string): boolean {
+  const ver = model.toLowerCase().match(/gemini-(\d+)(?:\.(\d+))?/);
+  return !!ver && Number(ver[1]) === 3;
+}
+
+/** Effort → Google `thinkingLevel` enum value (gjc mapEffortToGoogleThinkingLevel):
+ *  minimal→MINIMAL, low→LOW, medium→MEDIUM, high/xhigh→HIGH. */
+export function geminiThinkingLevel(effort: NonNullable<CallOptions["reasoningEffort"]> | "xhigh"): "MINIMAL" | "LOW" | "MEDIUM" | "HIGH" {
+  switch (effort) {
+    case "minimal": return "MINIMAL";
+    case "low": return "LOW";
+    case "medium": return "MEDIUM";
+    case "high":
+    case "xhigh": return "HIGH";
+  }
+}
+
+/** The `thinkingConfig` object for a Gemini request, or undefined to omit it entirely:
+ *  gemini-3.x → thinkingLevel enum (numeric budgets are NOT sent — gjc emits level XOR
+ *  budget, never both); with no effort requested (and no in-name marker) the config is
+ *  omitted so the model keeps its default (gjc parity: thinking not enabled → no config).
+ *  Other thinking-capable models → numeric thinkingBudget; pre-2.5 → undefined. */
+export type GeminiThinkingConfig =
+  | { includeThoughts: true; thinkingLevel: "MINIMAL" | "LOW" | "MEDIUM" | "HIGH" }
+  | { includeThoughts: true; thinkingBudget: number };
+
+export function geminiThinkingConfig(model: string, effort?: CallOptions["reasoningEffort"], maxTokens?: number): GeminiThinkingConfig | undefined {
+  if (geminiUsesThinkingLevel(model)) {
+    const effective = effort ?? geminiNamedEffort(model.toLowerCase());
+    if (effective === undefined) return undefined;
+    return { includeThoughts: true, thinkingLevel: geminiThinkingLevel(effective) };
+  }
+  const budget = geminiThinkingBudget(model, effort, maxTokens);
+  return budget === undefined ? undefined : { includeThoughts: true, thinkingBudget: budget };
+}
+
+/** True when this turn was asked to think (a thinkingLevel or a positive budget) — lets
+ *  the streaming paths fire onReasoningStart so the UI shows the thinking phase even
+ *  before/without any `thought` parts arrive (the Gemini/CCA analog of Anthropic's
+ *  content_block_start thinking signal, which is why reasoning otherwise appeared
+ *  "not to run" on gemini/antigravity). */
 export function geminiThinkingActive(options: CallOptions): boolean {
   const model = options.model.replace(/^(google|gemini)\//, "");
-  const tb = geminiThinkingBudget(model, options.reasoningEffort, options.maxTokens);
-  return tb !== undefined && tb > 0;
+  const cfg = geminiThinkingConfig(model, options.reasoningEffort, options.maxTokens);
+  return cfg !== undefined && ("thinkingLevel" in cfg || cfg.thinkingBudget > 0);
 }
 
 
@@ -76,8 +120,8 @@ export function buildGeminiPayload(messages: Message[], options: CallOptions, st
   if (!geminiModel || geminiModel.startsWith("claude-")) geminiModel = "gemini-2.0-flash";
 
   const systemPrompt = options.systemPrompt ?? messages.find(m => m.role === "system")?.content;
-  const thinkingBudget = geminiThinkingBudget(geminiModel, options.reasoningEffort, options.maxTokens);
-  const thinkingEnabled = thinkingBudget !== undefined && !stripArtifacts;
+  const thinking = geminiThinkingConfig(geminiModel, options.reasoningEffort, options.maxTokens);
+  const thinkingEnabled = thinking !== undefined && !stripArtifacts;
   // Gemini requires strictly ALTERNATING user/model turns. jeo histories can carry
   // consecutive same-role messages (a compaction summary prepended before a tool-result,
   // back-to-back tool results, etc.), so coalesce adjacent same-role turns into one
@@ -126,7 +170,17 @@ export function buildGeminiPayload(messages: Message[], options: CallOptions, st
 
   // 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 };
+  if (thinking !== undefined) {
+    generationConfig.thinkingConfig = thinking;
+    if ("thinkingBudget" in thinking && thinking.thinkingBudget > 0) {
+      // Additive budget (gjc stream.ts): the caller's maxTokens is the DESIRED OUTPUT;
+      // thought tokens ride ON TOP of it, capped at the model's output limit — otherwise
+      // thinking silently eats the visible-answer budget (the MAX_TOKENS empty-reply bug).
+      // ponytail: 65536 hard cap — swap in the model's catalog max-output once a cheap
+      // per-model lookup is available at this layer.
+      generationConfig.maxOutputTokens = Math.min((options.maxTokens ?? 4000) + thinking.thinkingBudget, 65536);
+    }
+  }
 
   const payload: Record<string, unknown> = { contents, generationConfig };
   if (systemPrompt) payload.systemInstruction = { parts: [{ text: systemPrompt }] };
@@ -158,7 +212,7 @@ const CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
 
 /** gemini-cli identification headers Cloud Code Assist expects (gjc parity). */
 export function getGeminiCliHeaders(modelId?: string): Record<string, string> {
-  const version = jeoEnv("GEMINI_CLI_VERSION") || "0.45.2";
+  const version = jeoEnv("GEMINI_CLI_VERSION") || "0.49.0";
   return {
     "User-Agent": `GeminiCLI/${version}/${modelId ?? "gemini-2.5-flash"} (${process.platform}; ${process.arch}; terminal)`,
     "Client-Metadata": "ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI",

package/src/ai/providers/kimi.ts

@@ -1,15 +1,54 @@
 import type { Credential } from "../../auth";
+import { getKimiCommonHeaders } from "../../auth/flows/kimi";
+import type { CallOptions, ProviderAdapter } from "../types";
+import { anthropicAdapter } from "./anthropic";
 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.
+ * Kimi (Moonshot) — two credential-dependent backends (gjc parity):
+ * - API key (KIMI_API_KEY / `providers.kimi`): OpenAI-compatible cloud API at
+ *   https://api.moonshot.ai/v1. Thinking models (kimi-thinking-preview) stream
+ *   reasoning via `reasoning_content`/`<think>` → onReasoning.
+ * - OAuth (Kimi Code subscription, device-code login): Anthropic-compatible API at
+ *   https://api.kimi.com/coding (`${base}/v1/messages` pinned by the anthropic
+ *   adapter), authenticated with `Authorization: Bearer` + X-Msh-* device headers.
  */
 export const KIMI_BASE_URL = "https://api.moonshot.ai/v1";
+// gjc: KIMI_ANTHROPIC_BASE_URL — the SDK/adapter appends /v1/messages, so no /v1 here.
+export const KIMI_ANTHROPIC_BASE_URL = "https://api.kimi.com/coding";
 
-export const kimiAdapter = makeOpenAICompatibleAdapter({ name: "kimi", baseUrl: KIMI_BASE_URL });
+const openaiCompatKimi = makeOpenAICompatibleAdapter({ name: "kimi", baseUrl: KIMI_BASE_URL });
+
+/** Route the `kimi/` prefix + OAuth base/headers onto the anthropic adapter. */
+// ponytail: model ids pass through untranslated — the moonshot catalog ids (kimi-latest, …)
+// may not exist on the Kimi Code endpoint (which serves e.g. kimi-for-coding). Upgrade path:
+// add kimi-code entries to model-catalog.ts and map them here per credential kind.
+function prepOAuth(o: CallOptions): CallOptions {
+  return {
+    ...o,
+    model: o.model.startsWith("kimi/") ? o.model.slice(5) : o.model,
+    baseUrl: o.baseUrl ?? KIMI_ANTHROPIC_BASE_URL,
+    extraHeaders: { ...getKimiCommonHeaders(), ...o.extraHeaders },
+  };
+}
+
+/** Dispatch on credential kind: OAuth → Kimi Code Anthropic endpoint; else the
+ *  original OpenAI-compatible moonshot adapter (API-key behavior unchanged). */
+export const kimiAdapter: ProviderAdapter = {
+  name: "kimi",
+  supportsNativeTools: openaiCompatKimi.supportsNativeTools,
+  call: (messages, options, credential) =>
+    credential.kind === "oauth"
+      ? anthropicAdapter.call(messages, prepOAuth(options), credential)
+      : openaiCompatKimi.call(messages, options, credential),
+  async *stream(messages, options, credential) {
+    if (credential.kind === "oauth") {
+      yield* anthropicAdapter.stream!(messages, prepOAuth(options), credential);
+    } else {
+      yield* openaiCompatKimi.stream!(messages, options, credential);
+    }
+  },
+};
 
 /** Credential carrier for Kimi calls — an api_key bearer (the adapter only reads the
  *  token); a keyless `none` when no key is set. */

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

@@ -15,11 +15,21 @@ import type { CallOptions, Message } from "../types";
 import { readSse } from "../sse";
 import { providerHttpError, fetchWithArtifactFailSafe } from "./errors";
 import { serializeAccumulatedToolCalls } from "../../agent/tool-schemas";
+import os from "node:os";
+import pkg from "../../../package.json";
 
 export const CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
 
 export const VALID_REASONING_EFFORTS = new Set(["minimal", "low", "medium", "high"]);
 
+const CODEX_ORIGINATOR = "codex_cli_rs";
+
+/** Codex-CLI-shaped User-Agent (gjc getCodexUserAgent parity: `originator/version (platform release; arch)`).
+ *  Sent on BOTH the OAuth and api-key paths — without it Bun's default UA leaks to the backend. */
+export function codexUserAgent(): string {
+  return `${CODEX_ORIGINATOR}/${pkg.version} (${os.platform()} ${os.release()}; ${os.arch()})`;
+}
+
 /** Extract `chatgpt_account_id` from a ChatGPT/Codex OAuth access JWT. */
 export function extractChatgptAccountId(token: string): string | undefined {
   const parts = token.split(".");
@@ -93,12 +103,16 @@ export function codexResponsesRequest(
   const token = credential.kind === "none" ? "" : credential.token;
   const systemPrompt = options.systemPrompt ?? messages.find(m => m.role === "system")?.content;
   const input = buildResponsesInput(messages, options.model, stripArtifacts);
+  const promptCacheKey = normalizePromptCacheKey(options.sessionKey);
   const payload: Record<string, unknown> = {
     model,
     instructions: systemPrompt ?? "You are a helpful coding assistant.",
     input,
     stream: true, // the Codex backend only streams
     store: false,
+    // Provider-side prompt caching (gjc parity): key the cache on the stable session id
+    // so an agent loop replaying the same history each step re-reads a cached prefix.
+    ...(promptCacheKey ? { prompt_cache_key: promptCacheKey } : {}),
   };
   if (options.tools?.length) {
     // Responses API function tools (flat shape). tool_choice "auto" keeps prose + `done`.
@@ -112,6 +126,9 @@ export function codexResponsesRequest(
     // frame can show the model's thinking instead of a frozen "calling model (Ns)…".
     payload.reasoning = { effort: options.reasoningEffort, summary: "auto" };
   }
+  // Cap the response length (gjc parity): the computed per-call budget must reach the wire,
+  // otherwise the backend free-runs to its own default.
+  if (options.maxTokens) payload.max_output_tokens = options.maxTokens;
   // 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.
@@ -122,7 +139,7 @@ export function codexResponsesRequest(
     payload.include = ["reasoning.encrypted_content"];
     return {
       url: `${base}/responses`,
-      headers: { "content-type": "application/json", authorization: `Bearer ${token}`, accept: "text/event-stream" },
+      headers: { "content-type": "application/json", authorization: `Bearer ${token}`, accept: "text/event-stream", "user-agent": codexUserAgent() },
       body: JSON.stringify(payload),
     };
   }
@@ -131,13 +148,30 @@ export function codexResponsesRequest(
     "content-type": "application/json",
     authorization: `Bearer ${token}`,
     "OpenAI-Beta": "responses=experimental",
-    originator: "codex_cli_rs",
+    originator: CODEX_ORIGINATOR,
+    "user-agent": codexUserAgent(),
     accept: "text/event-stream",
   };
   if (accountId) headers["chatgpt-account-id"] = accountId;
+  // Correlation headers (gjc parity): the Codex backend keys its prompt cache on the
+  // session/conversation pair; x-client-request-id aids server-side tracing.
+  if (promptCacheKey) {
+    headers.session_id = promptCacheKey;
+    headers.conversation_id = promptCacheKey;
+    headers["x-client-request-id"] = promptCacheKey;
+  }
   return { url: CODEX_RESPONSES_URL, headers, body: JSON.stringify(payload) };
 }
 
+/** gjc parity (normalizeOpenAIResponsesPromptCacheKey): well-formed unicode, ≤64 chars
+ *  verbatim, longer keys hashed to a stable compact form. */
+export function normalizePromptCacheKey(sessionKey: string | undefined): string | undefined {
+  if (!sessionKey || sessionKey.length === 0) return undefined;
+  const wellFormed = sessionKey.toWellFormed();
+  if (wellFormed.length <= 64) return wellFormed;
+  return `pc_${Bun.hash(wellFormed).toString(36)}`;
+}
+
 export interface ResponsesEvent {
   delta?: string;
   /** Reasoning-summary text delta (`response.reasoning_summary_text.delta` and the

package/src/ai/types.ts

@@ -113,6 +113,12 @@ export interface CallOptions {
    *  `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";
+  /** Stable per-conversation key (the session id) for provider-side prompt caching.
+   *  gjc parity: the Codex/Responses backends key their prompt cache on
+   *  `prompt_cache_key` (+ `session_id`/`conversation_id` headers on the Codex
+   *  backend), so an agent loop replaying the same history each step gets cache
+   *  hits instead of full-prompt re-reads. Optional — absent for one-shot calls. */
+  sessionKey?: string;
   /** 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;
@@ -140,6 +146,10 @@ export interface CallOptions {
    *  these on the wire and re-serialize the structured tool call back into the engine's
    *  canonical {"tool":...}/{"tools":[...]} string; others ignore it. */
   tools?: NativeToolSchema[];
+  /** Extra HTTP headers merged into the outgoing provider request (adapter-specific;
+   *  currently honored by the anthropic adapter). Used by Anthropic-compatible OAuth
+   *  providers — e.g. Kimi Code sends its X-Msh-* device headers on every call. */
+  extraHeaders?: Record<string, string>;
 }
 
 export interface ProviderAdapter {

package/src/auth/callback-server.ts

@@ -27,6 +27,19 @@ export interface OAuthCallbackFlowOptions {
 
 export type CallbackResult = { code: string; state: string };
 
+/** Thrown when the fixed callback port cannot be bound and the provider forbids a
+ *  port fallback (fixed redirect URI). Typed so callers (e.g. the OpenAI flow) can
+ *  detect the bind failure and fall back to the device-code flow instead of
+ *  string-matching the error message. */
+export class CallbackPortUnavailableError extends Error {
+  readonly port: number;
+  constructor(port: number) {
+    super(`OAuth callback port ${port} unavailable and this provider requires a fixed redirect URI.`);
+    this.name = "CallbackPortUnavailableError";
+    this.port = port;
+  }
+}
+
 // "jeo" wordmark — bold forged monospace lettering on a neon blue→violet→pink
 // gradient (the mascot's synthwave palette), generated via god-tibo-imagen and
 // matching jeo-pi's bold-wordmark typographic treatment. Embedded as a data URI
@@ -125,6 +138,7 @@ export abstract class OAuthCallbackFlow {
       Bun.serve({
         hostname: this.callbackHostname,
         port,
+        reusePort: false, // gjc parity: never share the port — a busy port must FAIL, not silently split traffic
         fetch: req => this.#handle(req, expectedState),
       });
     try {
@@ -134,9 +148,7 @@ export abstract class OAuthCallbackFlow {
       return { server, redirectUri };
     } catch {
       if (this.fixedRedirectUri) {
-        throw new Error(
-          `OAuth callback port ${this.preferredPort} unavailable and this provider requires a fixed redirect URI.`
-        );
+        throw new CallbackPortUnavailableError(this.preferredPort);
       }
       const server = serve(0);
       const redirectUri = `http://${this.callbackHostname}:${server.port}${this.callbackPath}`;
@@ -172,7 +184,7 @@ export abstract class OAuthCallbackFlow {
     });
 
     return new Response(renderHtml(ok, message), {
-      status: ok ? 200 : 400,
+      status: ok ? 200 : 500, // gjc parity: provider/CSRF failures are server-side errors (500), not 400
       headers: { "content-type": "text/html" },
     });
   }
@@ -206,7 +218,9 @@ export abstract class OAuthCallbackFlow {
               .then(input => {
                 const parsed = parseCallbackInput(input);
                 if (!parsed.code) return null;
-                if (expectedState && parsed.state !== expectedState) return null; // reject missing OR mismatched state
+                // gjc parity: a bare pasted code WITHOUT a state is accepted (the provider
+                // may strip it); only an explicitly MISMATCHED state is rejected.
+                if (expectedState && parsed.state && parsed.state !== expectedState) return null;
                 return { code: parsed.code, state: parsed.state ?? "" } as CallbackResult;
               })
               .catch(() => null),