jeo-code 0.7.27 → 0.7.28

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),

package/src/auth/flows/AGENTS.md

@@ -9,12 +9,13 @@ Specific OAuth flow implementations for various providers.
 ## Key Files
 | File | Description |
 |------|-------------|
-| `anthropic.ts` | Brief description of purpose |
-| `antigravity.ts` | Brief description of purpose |
-| `google-project.ts` | Brief description of purpose |
-| `google.ts` | Brief description of purpose |
-| `index.ts` | Brief description of purpose |
-| `openai.ts` | Brief description of purpose |
+| `anthropic.ts` | Anthropic (claude.ai) PKCE OAuth |
+| `antigravity.ts` | Google Antigravity OAuth (desktop-app client, dedicated project discovery) |
+| `google-project.ts` | Cloud Code Assist project discovery/onboarding shared by gemini + antigravity |
+| `google.ts` | Google Gemini CLI OAuth (authorization-code) |
+| `index.ts` | OAUTH_FLOW_REGISTRY wiring flows to providers |
+| `kimi.ts` | Kimi Code (Moonshot subscription) device-authorization OAuth — no callback server |
+| `openai.ts` | OpenAI Codex PKCE OAuth + device-code fallback when port 1455 is busy |
 
 ## Subdirectories
 *(None)*

package/src/auth/flows/antigravity.ts

@@ -56,6 +56,9 @@ export function discoverAntigravityProjectId(
   return discoverGoogleProjectId(accessToken, {
     metadata: { ...ANTIGRAVITY_DISCOVERY_METADATA },
     extraHeaders: { "User-Agent": getAntigravityUserAgent() },
+    // gjc antigravity parity: a reported tier without a project ONBOARDS the
+    // default/legacy tier instead of throwing the workspace-project hint.
+    alwaysOnboard: true,
     onProgress: opts.onProgress,
   });
 }

package/src/auth/flows/google-project.ts

@@ -56,6 +56,11 @@ export interface DiscoverProjectOptions {
   /** Per-request deadline; a stalled discovery fetch must NEVER hang the turn
    *  forever (round-5 #2 — this path runs BEFORE the manager's guarded call). */
   requestTimeoutMs?: number;
+  /** Antigravity semantics (gjc google-antigravity discoverProject): when the account
+   *  reports a tier but names no project, ONBOARD the default/legacy tier instead of
+   *  demanding an explicit workspace project. The gemini-cli flow keeps the strict
+   *  workspace hint (default false). */
+  alwaysOnboard?: boolean;
 }
 
 const DISCOVERY_REQUEST_TIMEOUT_MS = 30_000;
@@ -147,12 +152,13 @@ export async function discoverGoogleProjectId(
   if (data.currentTier) {
     const existing = readProjectId(data.cloudaicompanionProject) ?? envProjectId;
     if (existing) return existing;
-    throw new Error(WORKSPACE_PROJECT_HINT);
+    if (!opts.alwaysOnboard) throw new Error(WORKSPACE_PROJECT_HINT);
+    // alwaysOnboard: fall through and provision the default/legacy tier (gjc antigravity parity).
   }
 
   // Not onboarded yet: provision the default tier (free tier needs no project).
   const tierId = defaultTierId(data.allowedTiers) || TIER_FREE;
-  if (tierId !== TIER_FREE && tierId !== TIER_LEGACY && !envProjectId) {
+  if (!opts.alwaysOnboard && tierId !== TIER_FREE && tierId !== TIER_LEGACY && !envProjectId) {
     throw new Error(WORKSPACE_PROJECT_HINT);
   }
 

package/src/auth/flows/google.ts

@@ -9,8 +9,22 @@
  */
 import { OAuthCallbackFlow } from "../callback-server";
 import { discoverGoogleProjectId } from "./google-project";
+import { getGeminiCliHeaders } from "../../ai/providers/gemini";
 import type { OAuthController, OAuthCredentials } from "../types";
 
+/** Login-time Cloud Code Assist project discovery for a gemini-cli token. Sends the
+ *  gemini-cli identity headers (User-Agent + Client-Metadata) on loadCodeAssist/
+ *  onboardUser, matching gjc's google-gemini-cli discovery requests. */
+export function discoverGeminiProjectId(
+  accessToken: string,
+  opts: { onProgress?: (message: string) => void } = {},
+): Promise<string> {
+  return discoverGoogleProjectId(accessToken, {
+    extraHeaders: getGeminiCliHeaders(),
+    onProgress: opts.onProgress,
+  });
+}
+
 const decode = (s: string) => atob(s);
 const CLIENT_ID = decode(
   [
@@ -101,7 +115,7 @@ class GoogleOAuthFlow extends OAuthCallbackFlow {
       // gjc parity: auto-discover (or provision) the Cloud Code Assist project so
       // Antigravity models work straight after login — best-effort, never fails login.
       try {
-        projectId = await discoverGoogleProjectId(data.access_token);
+        projectId = await discoverGeminiProjectId(data.access_token);
       } catch {
         projectId = undefined;
       }

package/src/auth/flows/index.ts

@@ -5,6 +5,7 @@ import { loginAnthropic, refreshAnthropicToken } from "./anthropic";
 import { loginOpenAI, refreshOpenAIToken } from "./openai";
 import { loginGoogle, refreshGoogleToken } from "./google";
 import { loginAntigravity, refreshAntigravityToken } from "./antigravity";
+import { loginKimi, refreshKimiToken } from "./kimi";
 
 export interface OAuthFlow {
   readonly provider: OAuthProvider;
@@ -52,9 +53,18 @@ export const OAUTH_FLOW_REGISTRY: Record<OAuthProvider, OAuthFlow> = {
     verifiedEndToEnd: true,
     note: "Antigravity desktop-app OAuth client; serves antigravity/* models (Gemini 3, Claude, GPT-OSS via Cloud Code Assist). The Google Cloud projectId is discovered automatically at login.",
   },
+  kimi: {
+    provider: "kimi",
+    label: "Kimi Code (Moonshot subscription)",
+    login: loginKimi,
+    refresh: refreshKimiToken,
+    verifiedEndToEnd: true,
+    note: "Device-code OAuth (auth.kimi.com); the token is served via the Anthropic-compatible endpoint at api.kimi.com/coding. A KIMI_API_KEY, when set and no OAuth is stored, uses the OpenAI-compatible api.moonshot.ai/v1.",
+  },
 };
 
 export { loginAnthropic, refreshAnthropicToken } from "./anthropic";
 export { loginOpenAI, refreshOpenAIToken } from "./openai";
 export { loginGoogle, refreshGoogleToken } from "./google";
 export { loginAntigravity, refreshAntigravityToken, discoverAntigravityProjectId, antigravityClientSecret } from "./antigravity";
+export { loginKimi, refreshKimiToken, getKimiCommonHeaders } from "./kimi";