cartethyia 2.7.4 → 2.7.6

package/src/providers/integrations/antigravity/antigravity-protocol.ts

@@ -96,7 +96,8 @@ interface AntigravityModelWireProfile {
 
 /**
  * `maxOutputTokens` the backend enforces per wire id (captured from the real
- * `antigravity/hub` client). Claude on `daily-cloudcode-pa` rejects
+ * `antigravity/hub` client and verified live against `fetchAvailableModels`
+ * on 2026-11-03). Claude on `daily-cloudcode-pa` rejects
  * `maxOutputTokens > 64000` with a `400 Request contains an invalid argument`
  * regardless of the thinking budget; Gemini SKUs accept their discovered
  * output ceiling. Keyed by the routed upstream wire id (post effort-routing),
@@ -106,22 +107,75 @@ interface AntigravityModelWireProfile {
 const ANTIGRAVITY_MODEL_WIRE_PROFILES: Readonly<
   Record<string, AntigravityModelWireProfile>
 > = Object.freeze({
-  // Anthropic on Antigravity caps at 64000 output tokens.
-  "claude-opus-4-6-thinking": { maxOutputTokens: 64000 },
-  "claude-sonnet-4-6": { maxOutputTokens: 64000 },
-  // Gemini effort-routed wire ids (real deployment names).
-  "gemini-3-flash-agent": {
-    modelEnum: "MODEL_PLACEHOLDER_M132",
+  // Anthropic on Antigravity caps at 64000 output tokens (verified live).
+  "claude-opus-4-6-thinking": {
+    modelEnum: "MODEL_PLACEHOLDER_M26",
+    maxOutputTokens: 64000,
+  },
+  "claude-sonnet-4-6": {
+    modelEnum: "MODEL_PLACEHOLDER_M35",
+    maxOutputTokens: 64000,
+  },
+  // Gemini SKUs, as the live roster publishes them (2026-11-03).
+  "gemini-2.5-flash": {
+    modelEnum: "MODEL_GOOGLE_GEMINI_2_5_FLASH",
+    maxOutputTokens: 65535,
+  },
+  "gemini-2.5-flash-thinking": {
+    modelEnum: "MODEL_GOOGLE_GEMINI_2_5_FLASH_THINKING",
+    maxOutputTokens: 65535,
+  },
+  "gemini-2.5-flash-lite": {
+    modelEnum: "MODEL_GOOGLE_GEMINI_2_5_FLASH_LITE",
+    maxOutputTokens: 65535,
+  },
+  "gemini-2.5-pro": {
+    modelEnum: "MODEL_GOOGLE_GEMINI_2_5_PRO",
+    maxOutputTokens: 65535,
+  },
+  "gemini-3-flash": {
+    modelEnum: "MODEL_PLACEHOLDER_M18",
     maxOutputTokens: 65536,
   },
-  "gemini-3.1-pro-low": {
-    modelEnum: "MODEL_PLACEHOLDER_M36",
+  "gemini-3.1-flash-lite": {
+    modelEnum: "MODEL_PLACEHOLDER_M50",
     maxOutputTokens: 65535,
   },
-  "gemini-pro-agent": {
-    modelEnum: "MODEL_PLACEHOLDER_M16",
+  "gemini-3.1-flash-image": {
+    modelEnum: "MODEL_PLACEHOLDER_M21",
+    maxOutputTokens: 65536,
+  },
+  "gemini-3.5-flash-lite": {
+    modelEnum: "MODEL_PLACEHOLDER_M198",
     maxOutputTokens: 65535,
   },
+  // Gemini 3.8 Flash effort tiers (real deployment names).
+  "gemini-3.8-flash-low": {
+    modelEnum: "MODEL_PLACEHOLDER_M320",
+    maxOutputTokens: 65536,
+  },
+  "gemini-3.8-flash-medium": {
+    modelEnum: "MODEL_PLACEHOLDER_M319",
+    maxOutputTokens: 65536,
+  },
+  "gemini-3.8-flash-high": {
+    modelEnum: "MODEL_PLACEHOLDER_M318",
+    maxOutputTokens: 65536,
+  },
+  "gemini-3.8-flash-tiered": {
+    modelEnum: "MODEL_PLACEHOLDER_M322",
+    maxOutputTokens: 65536,
+  },
+  // GPT-OSS via Antigravity (verified live).
+  "gpt-oss-120b-medium": {
+    modelEnum: "MODEL_OPENAI_GPT_OSS_120B_MEDIUM",
+    maxOutputTokens: 32768,
+  },
+  // Tab (laptop-class) preview SKU.
+  "tab_flash_lite_preview": {
+    modelEnum: "MODEL_PLACEHOLDER_M19",
+    maxOutputTokens: 4096,
+  },
 });
 
 export function getAntigravityModelWireProfile(
@@ -257,8 +311,6 @@ export function normalizeAntigravityToolSchemas(request: CanonicalRequest): Cano
 const lastGoodEndpoints = new Map<string, string>();
 const LAST_GOOD_ENDPOINT_MAX = 256;
 
-const DEFAULT_ORDER_INDEX = Number.MAX_SAFE_INTEGER;
-
 /**
  * Records the endpoint that just served a successful turn. Call this with the
  * `endpoint` reported by empty-stream recovery (or the URL that produced a
@@ -301,18 +353,6 @@ export function orderAntigravityEndpoints(
   return [sticky, ...endpoints.slice(0, index), ...endpoints.slice(index + 1)];
 }
 
-/**
- * Position of `endpoint` in the caller's own endpoint order, used to log a
- * failover without the caller re-deriving the list.
- */
-export function antigravityEndpointOrderIndex(
-  endpoints: readonly string[],
-  endpoint: string,
-): number {
-  const index = endpoints.indexOf(endpoint);
-  return index < 0 ? DEFAULT_ORDER_INDEX : index;
-}
-
 // Model discovery (`v1internal:fetchAvailableModels`) — live catalog.
 
 const ANTIGRAVITY_DISCOVERY_PATH = "/v1internal:fetchAvailableModels";
@@ -412,6 +452,7 @@ export async function discoverAntigravityModels(
     readonly baseUrl?: string;
     readonly fetcher?: typeof fetch;
     readonly signal?: AbortSignal;
+    readonly projectId?: string;
   } = {},
 ): Promise<readonly ModelDefinition[] | null> {
   const fetcher = options.fetcher ?? fetch;
@@ -433,7 +474,10 @@ export async function discoverAntigravityModels(
           "content-type": "application/json",
           "user-agent": getAntigravityUserAgent(),
         },
-        body: "{}",
+        // The reference client always sends the resolved project
+        // (`cloudCodeMainService.js`); the live backend accepts both, but the
+        // project is required for billing-gated endpoints.
+        body: JSON.stringify(options.projectId === undefined ? {} : { project: options.projectId }),
         signal,
       });
       if (!response.ok) continue;
@@ -503,9 +547,16 @@ export function applySkipThoughtSignatureBypass(
  * Sending the Gemini shape makes the backend treat the call as a different
  * client and refuse to enroll the account, which the operator sees as
  * "You do not have a valid license of this product".
+ *
+ * The reference client (`cloudCodeMainService.js`) sends the full product
+ * identity: `ideName`, `ideType`, and `ideVersion`. `ideType` alone was
+ * accepted live, but the full shape is the captured wire and avoids any
+ * client-class gating on the control plane.
  */
 export const ANTIGRAVITY_LOAD_CODE_ASSIST_METADATA = Object.freeze({
+  ideName: "antigravity",
   ideType: "ANTIGRAVITY",
+  ideVersion: getAntigravityVersion(),
 });
 
 const projectIdCache = new Map<string, string>();
@@ -584,7 +635,9 @@ const FREE_TIER_ID = "free-tier";
 const ONBOARD_USER_PATH = "/v1internal:onboardUser";
 const ONBOARD_OPERATIONS_PATH = "/v1internal";
 const ONBOARD_TIMEOUT_MS = 30_000;
-const ONBOARD_POLL_INTERVAL_MS = 1_000;
+// Reference client (`cloudCodeMainService.js`) polls the operation every
+// 500ms (`gXa = 500`).
+const ONBOARD_POLL_INTERVAL_MS = 500;
 
 /** Thrown when an account cannot be enrolled in the Antigravity free tier. */
 export class AntigravityProvisioningError extends Error {
@@ -713,6 +766,9 @@ async function onboardUser(
     if (left <= 0) throw new AntigravityProvisioningError("onboardUser timed out");
     return left;
   };
+  const projectId = extractProjectId(
+    await loadCodeAssist(fetcher, base, accessToken, signal),
+  );
   let operation = await cloudCodeAssistCall(
     fetcher,
     base,
@@ -720,7 +776,11 @@ async function onboardUser(
     ONBOARD_USER_PATH,
     {
       method: "POST",
-      body: { tierId: FREE_TIER_ID, metadata: ANTIGRAVITY_LOAD_CODE_ASSIST_METADATA },
+      body: {
+        tierId: FREE_TIER_ID,
+        ...(projectId === undefined ? {} : { cloudaicompanionProject: projectId }),
+        metadata: ANTIGRAVITY_LOAD_CODE_ASSIST_METADATA,
+      },
     },
     signal,
   );

package/src/providers/integrations/antigravity/antigravity-quota.ts

@@ -118,9 +118,6 @@ function keepWorse(
   return candidateRemaining < currentRemaining ? candidate : current;
 }
 
-/** Total the upstream's fractional allowance is normalized against. */
-const QUOTA_TOTAL = 1000;
-
 /** Builds a window from a `remainingFraction` + `resetTime` pair. */
 function fractionWindow(
   kind: string,
@@ -129,9 +126,8 @@ function fractionWindow(
   resetsAt: string | null,
 ): ProviderQuotaWindow {
   const fraction = Math.min(1, Math.max(0, remainingFraction));
-  const used = QUOTA_TOTAL - Math.round(QUOTA_TOTAL * fraction);
   return {
-    ...percentWindow(kind, label, (1 - fraction) * 100, resetsAt, used, QUOTA_TOTAL, "independent"),
+    ...percentWindow(kind, label, (1 - fraction) * 100, resetsAt, null, null, "independent"),
     recurring: true,
   };
 }
@@ -316,7 +312,23 @@ export async function fetchAntigravityQuota(
           ...(project === undefined ? {} : { project }),
         }),
       );
-      windows.push(...parseModelQuotas(models));
+      // The summary endpoint already covers a family with a weekly window; the
+      // per-model windows are a subset of that same allowance, so rendering
+      // both doubles every row the operator sees. Per-model windows stay as a
+      // fallback when the summary was unavailable, so a family still reports
+      // something.
+      const summaryLabels = windows.map((window) => window.label.toLowerCase());
+      // Model family key → the summary family label it falls under.
+      const summaryLabelForModel = (key: string): string =>
+        key === "google" ? "gemini" : "claude";
+      const modelWindows = parseModelQuotas(models);
+      windows.push(
+        ...modelWindows.filter((window) => {
+          const familyKey = window.kind.split(":")[0] ?? "";
+          const summaryLabel = summaryLabelForModel(familyKey);
+          return !summaryLabels.some((label) => label.includes(summaryLabel));
+        }),
+      );
       plan = plan ?? text(models.tier) ?? text(models.plan);
       break;
     } catch {

package/src/providers/integrations/antigravity/antigravity.ts

@@ -94,22 +94,26 @@ export const ANTIGRAVITY_MODELS: readonly ModelDefinition[] = [
   antigravityModel("claude-opus-4-6", 250_000, 64_000, true),
   antigravityModel("claude-sonnet-5-5", 1_000_000, 128_000, true),
   antigravityModel("claude-opus-5-5", 1_000_000, 128_000, true),
-  // Gemini text SKUs, as the Antigravity roster publishes them.
-  antigravityModel("gemini-2.5-flash", 1_000_000, 66_000, true),
-  antigravityModel("gemini-2.5-flash-thinking", 1_000_000, 66_000, true),
-  antigravityModel("gemini-3-flash", 1_000_000, 66_000, true),
-  antigravityModel("gemini-3.1-flash-lite", 1_000_000, 66_000, true),
-  antigravityModel("gemini-2.5-flash-lite", 1_000_000, 66_000, true),
-  antigravityModel("gemini-3.5-flash-lite", 1_000_000, 66_000, true),
-  antigravityModel("gemini-3.8-flash", 1_000_000, 66_000, true),
+  // Gemini text SKUs, as the Antigravity roster publishes them (verified live
+  // 2026-11-03): Gemini SKUs ceiling at 65535/65536 output tokens.
+  antigravityModel("gemini-2.5-flash", 1_000_000, 65_535, true),
+  antigravityModel("gemini-2.5-flash-thinking", 1_000_000, 65_535, true),
+  antigravityModel("gemini-2.5-flash-lite", 1_000_000, 65_535, true),
+  antigravityModel("gemini-2.5-pro", 1_000_000, 65_535, true),
+  antigravityModel("gemini-3-flash", 1_000_000, 65_536, true),
+  antigravityModel("gemini-3.1-flash-lite", 1_000_000, 65_535, true),
+  antigravityModel("gemini-3.5-flash-lite", 1_000_000, 65_535, true),
+  antigravityModel("gemini-3.8-flash", 1_000_000, 65_536, true),
   antigravityModel("gemini-4-argon", 1_000_000, 65_536, true),
   antigravityModel("gemini-4-carbon", 1_000_000, 65_536, true),
   // Tab (laptop-class) preview SKU.
   antigravityModel("tab_flash_lite_preview", 16_000, 4_000, true),
   // Gemini image generation. `gemini-3-pro-image` uses the same catalog
   // limits/capabilities as the existing `gemini-3.1-flash-image` row.
-  antigravityModel("gemini-3.1-flash-image", 200_000, 64_000, false, true),
-  antigravityModel("gemini-3-pro-image", 200_000, 64_000, false, true),
+  antigravityModel("gemini-3.1-flash-image", 65_536, 65_536, false, true),
+  antigravityModel("gemini-3-pro-image", 65_536, 65_536, false, true),
+  // GPT-OSS via Antigravity (verified live 2026-11-03).
+  antigravityModel("gpt-oss-120b", 131_072, 32_768, true),
 ];
 
 function normalizeAntigravityGrounding(data: unknown, maxResults: number): readonly WebSearchResult[] {
@@ -758,7 +762,7 @@ export class AntigravitySessionStore {
  * `"-" + (sha256(first-user-text)[0:8] & INT63 | random <9e18)`.
  * A positive or hyphenated-UUID value here is a one-glance synthetic signal.
  */
-export function signedAntigravitySessionId(seed?: string): string {
+function signedAntigravitySessionId(seed?: string): string {
   if (seed !== undefined && /^-?\d+$/.test(seed)) return seed;
   const text = seed !== undefined && seed.length > 0 ? seed : randomUUID();
   const head = BigInt(`0x${createHash("sha256").update(text).digest("hex").slice(0, 8)}`);
@@ -769,7 +773,7 @@ export function signedAntigravitySessionId(seed?: string): string {
 }
 
 /** Thinking budget per wire model, matching the client's effort tiers. */
-export function antigravityThinkingBudget(modelId: string): number | undefined {
+function antigravityThinkingBudget(modelId: string): number | undefined {
   if (!modelId.includes("claude") && !modelId.includes("gemini-3")) return undefined;
   if (modelId.endsWith("-low")) return 1_000;
   if (modelId.endsWith("-medium")) return 4_000;
@@ -777,8 +781,13 @@ export function antigravityThinkingBudget(modelId: string): number | undefined {
   return modelId.includes("3.1-pro") ? 10_001 : 10_000;
 }
 
+// Original reference instruction (captured from the Antigravity client):
+//   "You are Antigravity, a powerful agentic AI coding assistant designed by the Google Deepmind team working on Advanced Agentic Coding.You are pair programming with a USER to solve their coding task. The task may require creating a new codebase, modifying or debugging an existing codebase, or simply answering a question.**Absolute paths only****Proactiveness**"
+// Generalized to a neutral identity so the gateway does not impersonate the
+// vendor's branded assistant. The brand-specific wording is kept above for
+// reference; re-enable it if an upstream behavior ever depends on it.
 const ANTIGRAVITY_SYSTEM_INSTRUCTION =
-  "You are Antigravity, a powerful agentic AI coding assistant designed by the Google Deepmind team working on Advanced Agentic Coding.You are pair programming with a USER to solve their coding task. The task may require creating a new codebase, modifying or debugging an existing codebase, or simply answering a question.**Absolute paths only****Proactiveness**";
+  "You are a helpful assistant.";
 
 /**
  * Restatement appended as a trailing user turn when a Gemini route carries a

package/src/providers/integrations/buddy/buddy-catalog-shared.ts

@@ -160,7 +160,7 @@ export function makeBuddyCnImageModels(
  * plan rather than about the model. A pro account serves all six. The pill is
  * therefore a hint about a free account, and a dispatch is what settles it.
  *
- * @see `.skills/cartethyia-reverse-engineering/references/codebuddy-dispatch-headers.md`
+ * @see `documentation/research/codebuddy/2026-10-19-codebuddy-chat-dispatch-headers.md`
  */
 export const BUDDY_PRO_ONLY_MODEL_IDS: ReadonlySet<string> = new Set([
   "primary-model",

package/src/providers/integrations/buddy/buddy-chat-shared.ts

@@ -168,10 +168,11 @@ export function normalizeBuddyToolNames(payload: Record<string, unknown>): void
  * Both realms have a "let the backend choose" id, and the reference rewrites
  * `auto` onto it before anything downstream keys on the name — so eligibility,
  * cooldowns and the catalog all see one id. CN's is `default`; intl's is
- * `default-model`.
+ * `default-model` (confirmed from live CLI session logs, which send
+ * `model=default-model` for the intl auto path).
  */
 const BUDDY_AUTO_TARGET: Readonly<Record<"intl" | "cn", string>> = {
-  intl: "auto",
+  intl: "default-model",
   cn: "default",
 };
 
@@ -348,8 +349,8 @@ const DSH_MINIMAL_PATTERN = buddyTemplatePattern("You are a helpful software eng
 const DSH_DIRECT_PATTERN = buddyTemplatePattern("You are DeepSeek Harness");
 const DSH_WEB_GUI_PATTERN = buddyTemplatePattern("DeepSeek Harness Web GUI");
 
-/** The identity DSH role prompts are rewritten to; matches the donor gateway. */
-const DSH_WORKBUDDY_IDENTITY = "You are WorkBuddy, a powerful AI assistant";
+/** The identity DSH role prompts are rewritten to; neutral and minimal. */
+const DSH_WORKBUDDY_IDENTITY = "You are a helpful assistant";
 
 /**
  * Rewrites DeepSeek Harness role identities in one message's text back to the
@@ -425,6 +426,20 @@ export const clineReasoningReplayPrepares: readonly ((
   },
 ];
 
+/**
+ * The reference injects `cache_retention` on every chat body: `long` by
+ * default, `short` when prompt caching for 1h is disabled
+ * (`CODEBUDDY_DISABLE_PROMPT_CACHING_1H`). Matching the client keeps the
+ * upstream's prompt-caching behavior and price on the same path the CLI uses.
+ */
+function injectBuddyCacheRetention(payload: Record<string, unknown>): void {
+  if (payload["cache_retention"] !== undefined) return;
+  const disabled =
+    process.env.CODEBUDDY_DISABLE_PROMPT_CACHING_1H?.trim() === "1" ||
+    process.env.CODEBUDDY_DISABLE_PROMPT_CACHING_1H?.trim().toLowerCase() === "true";
+  payload["cache_retention"] = disabled ? "short" : "long";
+}
+
 /**
  * Payload prefix shared by the buddy pre-payload hooks: force `stream=true`,
  * apply the provider's DeepSeek thinking contract, opt `reasoning_summary` in
@@ -437,6 +452,7 @@ export function buddyPrePayloadCommon(
   context?: ProviderDispatchContext,
 ): void {
   injectBuddyPromptCacheKey(payload, request, context);
+  injectBuddyCacheRetention(payload);
   // `auto` and `default-model` are the same upstream model under two names, and
   // the reference resolves one to the other everywhere — catalog, eligibility,
   // cooldown keys. Treating them as two independent rows meant a client that

package/src/providers/integrations/buddy/buddy-cli-headers.ts

@@ -3,51 +3,19 @@
  *
  * Everything here comes from the two reference gateways, which agree: the
  * desktop product sends conversation/tracing headers and a device token, while
- * the CLI sends the agent envelope plus the OpenAI Node SDK fingerprint. The
- * CLI still drops the browser *transport* headers (`origin`, `referer`,
- * `accept-language`) and the device token, but keeps the request-shape markers
- * (`x-requested-with`, `x-codebuddy-request`) the reference sends on every call
- * regardless of transport — see the CLI branches in each provider's
- * `*-shared.ts`.
+ * the CLI sends the agent envelope. The CLI still drops the browser *transport*
+ * headers (`origin`, `referer`, `accept-language`) and the device token, but
+ * keeps the request-shape markers (`x-requested-with`, `x-codebuddy-request`)
+ * the reference sends on every call regardless of transport — see the CLI
+ * branches in each provider's `*-shared.ts`.
  *
- * The SDK fingerprint is pinned, not host-derived. Both references pin a fixed
- * set (codebuddy2api pins Linux/x64/v24.21.0); this gateway pins the macOS set
- * instead, so every CLI dispatch presents one consistent client fingerprint no
- * matter which machine the gateway runs on. A host-derived fingerprint would
- * advertise whatever OS the process happens to run under — a value no upstream
- * risk model has seen for this client brand, and an easy outlier to key on.
+ * The CLI's cloud chat transport is axios (`RestOperations`), not the OpenAI
+ * Node SDK, so it sends **no** `x-stainless-*` fingerprint. The reference's
+ * chat request helper sets only `Content-Type`, `Accept`, and `Authorization`
+ * before the conversation/agent/identity headers are injected; the stainless
+ * set belongs to the SDK-backed secondary clients, not to CodeBuddy chat.
  */
 
-/** OpenAI Node SDK 6.25.0 `x-stainless-*` fingerprint; both references agree. */
-const STAINLESS_PACKAGE_VERSION = "6.25.0";
-
-/**
- * The pinned Node runtime the fingerprint claims. Held constant across
- * dispatches: a drifting `process.version` would advertise a different Node
- * build per deployment, which is not what one installed client looks like.
- */
-const STAINLESS_RUNTIME_VERSION = "v24.21.0";
-
-/**
- * The SDK fingerprint headers.
- *
- * `x-stainless-timeout` is in the hub only and `x-stainless-retry-count` is in
- * both; the SDK sends both, so both go out. The OS/arch pair is the pinned
- * macOS fingerprint rather than this process's host.
- */
-export function buddyStainlessHeaders(): Record<string, string> {
-  return {
-    "x-stainless-lang": "js",
-    "x-stainless-package-version": STAINLESS_PACKAGE_VERSION,
-    "x-stainless-os": "MacOS",
-    "x-stainless-arch": "x64",
-    "x-stainless-runtime": "node",
-    "x-stainless-runtime-version": STAINLESS_RUNTIME_VERSION,
-    "x-stainless-retry-count": "0",
-    "x-stainless-timeout": "1200",
-  };
-}
-
 /**
  * The trace family the CLI carries as a child span.
  *
@@ -69,13 +37,18 @@ export function buddyCliTraceHeaders(
 /**
  * The full CLI identity envelope, minus what each caller already supplies.
  *
- * The caller keeps ownership of `User-Agent`, `X-IDE-*`, `X-Domain`, and the
- * conversation family, because those vary by provider and realm: only the
- * headers that are the same for every CLI dispatch are built here.
+ * The caller keeps ownership of `User-Agent`, `X-IDE-*`, `X-Domain`, the
+ * conversation family, and the OAuth identity headers; only the headers that
+ * are the same for every CLI dispatch are built here.
+ *
+ * No `x-stainless-*` fingerprint: the CLI's chat transport is axios, not the
+ * OpenAI Node SDK. `X-Private-Data` is added by the caller only when the
+ * dispatch is actually private — the reference never sends it as `false`.
  */
 export function buddyCliHeaders(args: {
   readonly userId: string;
   readonly enterpriseId?: string | undefined;
+  readonly privateData?: boolean;
 }): Record<string, string> {
   const enterpriseId =
     args.enterpriseId !== undefined && args.enterpriseId.trim().length > 0
@@ -89,12 +62,7 @@ export function buddyCliHeaders(args: {
     // of the three, so "other" is the honest value rather than a guess.
     "X-Agent-Runtime": "other",
     "X-User-Id": args.userId,
-    // The reference sends the flag either way, `true` only for an enterprise
-    // id. A personal account stays `false`; an enterprise account flips to
-    // `true` and names the enterprise, because the two travel together — a
-    // `true` with no id, or an id under `false`, is a combination no real
-    // client produces.
-    "X-Private-Data": enterpriseId === undefined ? "false" : "true",
+    ...(args.privateData === true ? { "X-Private-Data": "true" } : {}),
     ...(enterpriseId === undefined
       ? {}
       : {
@@ -104,6 +72,5 @@ export function buddyCliHeaders(args: {
           // reads both.
           "X-Tenant-Id": enterpriseId,
         }),
-    ...buddyStainlessHeaders(),
   };
 }

package/src/providers/integrations/buddy/buddy-identity.ts

@@ -1,6 +1,8 @@
 import type { ProviderDispatchContext } from "../../provider-contracts";
 import { createHash } from "node:crypto";
 import { decodeJwtPayload } from "../../authentication/oauth-flow-store";
+import { buddyAccountUid } from "./buddy-oauth-shared";
+import type { CanonicalRequest } from "../../../protocol/canonical-model";
 
 /**
  * Which upstream client a buddy provider presents itself as.
@@ -41,8 +43,17 @@ export function resolveBuddyIdentity(
  * The reference CLI sends the literal `anonymous` when it has no uid rather
  * than omitting the header, so an unauthenticated dispatch still looks like a
  * client rather than like a caller that forgot a header.
+ *
+ * When the credential carries a JWT, the `sub` claim is the upstream uid and
+ * wins over the gateway's internal account id — the two can differ after an
+ * import, and the channel check keys on the upstream identity. Opaque API keys
+ * carry no identity, so the internal account id is the fallback.
  */
 export function buddyUserId(context?: ProviderDispatchContext): string {
+  const secret = context?.credential?.secret;
+  const token = secret ? new TextDecoder().decode(secret).trim() : "";
+  const uid = buddyAccountUid(token);
+  if (uid !== undefined) return uid;
   const accountId = context?.credential.account_id;
   return accountId !== undefined && accountId.length > 0 ? accountId : "anonymous";
 }
@@ -142,3 +153,78 @@ export function materializeBuddyDeviceBinding(
   const derived = createHash("sha256").update(`wb2a:qimei36:${accountId}`).digest("hex").slice(0, 32);
   return { ...(authState ?? {}), qimei36: derived };
 }
+
+/**
+ * The OAuth identity header family the reference ships on every cloud API call
+ * (`runIdentityHeaders`): `X-User-Id` plus the base64 `X-Userinfo` envelope and
+ * the auth-method / id-source markers.
+ *
+ * The JWT `sub` is the uid; the base64 envelope mirrors the reference exactly:
+ * `{ uin, owner_uin?, id_source?, token_source? }` — one leg per identity
+ * field that exists, so a personal account sends `{uin}` while an enterprise
+ * account adds `owner_uin`. `X-Auth-Method` / `X-Id-Source` are only sent when
+ * the operator pinned them in `auth_state` (there is no reliable source to
+ * invent them from). An opaque API key carries no uid and yields nothing.
+ */
+export function buddyOAuthIdentityHeaders(
+  context?: ProviderDispatchContext,
+): Record<string, string> {
+  const secret = context?.credential?.secret;
+  const token = secret ? new TextDecoder().decode(secret).trim() : "";
+  const uid = buddyAccountUid(token) ?? context?.credential.account_id ?? "";
+  if (uid.length === 0) return {};
+  const enterpriseId = buddyEnterprise(context);
+  const state = context?.credential.auth_state;
+  const idSource =
+    typeof state?.["idSource"] === "string" && (state["idSource"] as string).trim().length > 0
+      ? (state["idSource"] as string).trim()
+      : undefined;
+  const method =
+    typeof state?.["authMethod"] === "string" && (state["authMethod"] as string).trim().length > 0
+      ? (state["authMethod"] as string).trim()
+      : undefined;
+  const headers: Record<string, string> = { "X-User-Id": uid };
+  if (method !== undefined) headers["X-Auth-Method"] = method;
+  if (idSource !== undefined) headers["X-Id-Source"] = idSource;
+  if (enterpriseId !== undefined || idSource !== undefined || method !== undefined) {
+    const info: Record<string, string> = { uin: uid };
+    if (enterpriseId !== undefined) info["owner_uin"] = enterpriseId;
+    if (idSource !== undefined) info["id_source"] = idSource;
+    if (method !== undefined) info["token_source"] = method;
+    headers["X-Userinfo"] = Buffer.from(JSON.stringify(info), "utf-8").toString("base64");
+  }
+  return headers;
+}
+
+/**
+ * Whether this dispatch is in the reference's private-data mode. The CLI only
+ * sends `X-Private-Data: true` while the session is private; otherwise the
+ * header is deleted, never sent as `false`. The gateway has no session-level
+ * private flag, so the operator pins one per account in `auth_state.privateData`.
+ */
+export function buddyPrivateData(context?: ProviderDispatchContext): boolean {
+  return context?.credential.auth_state?.["privateData"] === true;
+}
+
+/**
+ * The effective agent purpose for one dispatch, matching the reference's
+ * `getEffectiveAgentPurpose` behavior as closely as the gateway can:
+ *
+ * - `PERSONAL_AGENT_ROLE` set → `person_agent` (same env the CLI reads);
+ * - otherwise an inbound `x-agent-purpose` header is preserved (the caller
+ *   already stated a purpose — same shape the reference passes through);
+ * - otherwise the header is omitted. The reference does not invent `conversation`.
+ */
+export function buddyAgentPurpose(
+  context?: ProviderDispatchContext,
+  request?: CanonicalRequest,
+): string | undefined {
+  if (process.env.PERSONAL_AGENT_ROLE && process.env.PERSONAL_AGENT_ROLE.trim().length > 0) {
+    return "person_agent";
+  }
+  const inbound = context?.request_headers?.["x-agent-purpose"]?.trim();
+  if (inbound !== undefined && inbound.length > 0) return inbound;
+  const fromRequest = request?.metadata?.["agent_purpose"];
+  if (typeof fromRequest === "string" && fromRequest.trim().length > 0) return fromRequest.trim();
+  return undefined;
+}

package/src/providers/integrations/buddy/buddy-oauth-shared.ts

@@ -120,7 +120,7 @@ export function buddyAccountUid(accessToken: string): string | undefined {
  * Falls back to `undefined` when the token carries no usable identity, letting
  * the console keep the operator-supplied label.
  */
-export function buddyAccountLabel(accessToken: string): string | undefined {
+function buddyAccountLabel(accessToken: string): string | undefined {
   const claims = decodeJwtPayload(accessToken);
   if (!claims) return undefined;
   const email = nonEmptyTrimmedString(claims.email) ?? nonEmptyTrimmedString(claims.preferred_username);

package/src/providers/integrations/buddy/codebuddy/cn-provider.ts

@@ -48,8 +48,7 @@ function isAgentPromptText(text: string): boolean {
   );
 }
 
-const CODEBUDDY_CN_NEUTRAL_PROMPT =
-  "You are a helpful AI assistant that helps with software engineering tasks.";
+const CODEBUDDY_CN_NEUTRAL_PROMPT = "You are a helpful assistant.";
 
 function flattenContent(content: unknown): string {
   if (typeof content === "string") return content;

package/src/providers/integrations/buddy/codebuddy/provider.ts

@@ -51,22 +51,11 @@ export const CODEBUDDY_BASE_URL = providerBaseUrl("cb");
  *
  * The wire contract is that the request *opens* with a `system` turn (code
  * `11128`); the gateway replaces any caller `system`/`developer` turn with this
- * fixed prompt. The text is the CodeBuddy CLI's own leading prompt — the same
- * one the reference client (and the donor gateway's `prepend` prompt mode)
- * sends — so a proxied request is byte-faithful to an official client rather
- * than a neutral stand-in.
- *
- * Keeping the official identity is forward-compatible: the upstream is not
- * observed to validate this text today, but a proxy that claims the real
- * client's identity cannot be caught out if it starts to. A previous neutral
- * persona ("You are a pragmatic and direct software engineering assistant…")
- * worked, but diverged from every request the official CLI emits.
+ * fixed prompt. Deliberately neutral: a simple helpful-assistant persona with
+ * no client/CLI branding, kept minimal so the text reads naturally to any
+ * model and does not advertise a channel identity upstream.
  */
-export const CODEBUDDY_SYSTEM_PROMPT =
-  "You are CodeBuddy Code.\n\n" +
-  "You are an interactive CLI tool that helps users with software engineering tasks. " +
-  "Use the instructions below and the tools available to you to assist the user. " +
-  "Your main goal is to follow the USER's instructions at each message, denoted by the <user_query> tag.";
+export const CODEBUDDY_SYSTEM_PROMPT = "You are a helpful assistant.";
 
 function codeBuddyIntlPrePayload(
   payload: Record<string, unknown>,