cartethyia 2.7.8 → 2.7.9

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

@@ -267,6 +267,85 @@ export function normalizeAntigravityToolSchema(schema: unknown): unknown {
   return schema;
 }
 
+/**
+ * Flattens JSON-Schema constructs the Antigravity upstream rejects.
+ *
+ * Verified live (2026-11-05): the Claude-route upstream validates tool
+ * schemas as strict JSON Schema draft 2020-12 and refuses every `anyOf` /
+ * `oneOf` / multi-type `type: [...]` declaration — even a degenerate
+ * `anyOf` of two identical string schemas, and even at the root. The Gemini
+ * builder's sanitizer keeps those constructs (Gemini itself accepts them), so
+ * a tool that declares a union (e.g. OMP's `task` tool's `model` field)
+ * ships an invalid schema and the upstream 400s the whole request with
+ * `tools.N.custom.input_schema: JSON schema is invalid`.
+ *
+ * The rewrite replaces `anyOf`/`oneOf` with the single most permissive
+ * alternative's type (string when a choice is a string, otherwise any
+ * surviving type), and a multi-type `type: [...]` with its first entry —
+ * the most permissive shape a strict single-type validator can express.
+ * Recurses through `properties` and `items`.
+ */
+export function flattenAntigravitySchema(schema: unknown): unknown {
+  if (!isRecord(schema)) return schema;
+  const out: Record<string, unknown> = {};
+  for (const [key, child] of Object.entries(schema)) {
+    if (key === "anyOf" || key === "oneOf") {
+      if (!Array.isArray(child)) continue;
+      const chosen = child.map((entry) => flattenAntigravitySchema(entry)).find(isRecord);
+      if (chosen === undefined) continue;
+      if (typeof chosen["type"] === "string") out["type"] = chosen["type"];
+      for (const [nestedKey, nestedValue] of Object.entries(chosen)) {
+        if (nestedKey === "type") continue;
+        out[nestedKey] = nestedValue;
+      }
+      continue;
+    }
+    if (key === "type" && Array.isArray(child)) {
+      const first = child.find((entry): entry is string => typeof entry === "string");
+      if (first !== undefined) out["type"] = first;
+      continue;
+    }
+    if (key === "properties" && isRecord(child)) {
+      out["properties"] = Object.fromEntries(
+        Object.entries(child).map(([name, entry]) => [name, flattenAntigravitySchema(entry)]),
+      );
+      continue;
+    }
+    if (key === "items" && Array.isArray(child)) {
+      out["items"] = child.map((entry) => flattenAntigravitySchema(entry));
+      continue;
+    }
+    if (key === "items" && isRecord(child)) {
+      out["items"] = flattenAntigravitySchema(child);
+      continue;
+    }
+    out[key] = child;
+  }
+  return out;
+}
+
+/**
+ * Applies both tool-schema normalizations (unwrap `parametersJsonSchema`,
+ * flatten rejected union constructs) and reports whether anything changed.
+ *
+ * When flattening is a no-op, the *original* reference is returned so the
+ * request-level helper can detect an unchanged request without a deep compare.
+ */
+export function normalizeAntigravityToolSchemaForWire(schema: unknown): {
+  readonly schema: unknown;
+  readonly changed: boolean;
+} {
+  const unwrapped = normalizeAntigravityToolSchema(schema);
+  const flattened = flattenAntigravitySchema(unwrapped);
+  const unwrapChanged = unwrapped !== schema;
+  const flattenChanged =
+    flattened !== unwrapped && JSON.stringify(flattened) !== JSON.stringify(unwrapped);
+  return {
+    schema: flattenChanged ? flattened : unwrapped,
+    changed: unwrapChanged || flattenChanged,
+  };
+}
+
 /**
  * Normalizes every declared tool's schema on a canonical request, returning a
  * shallow copy of the request when anything changed and the original object
@@ -286,14 +365,50 @@ export function normalizeAntigravityToolSchemas(request: CanonicalRequest): Cano
   if (tools === undefined || tools.length === 0) return request;
   let changed = false;
   const normalized = tools.map((tool) => {
-    const schema = normalizeAntigravityToolSchema(tool.jsonSchema);
-    if (schema === tool.jsonSchema) return tool;
+    const { schema, changed: schemaChanged } = normalizeAntigravityToolSchemaForWire(tool.jsonSchema);
+    if (!schemaChanged) return tool;
     changed = true;
     return { ...tool, jsonSchema: schema };
   });
   return changed ? { ...request, tools: normalized } : request;
 }
 
+/**
+ * Drops replayed reasoning blocks that carry no signature on a Claude route.
+ *
+ * The Claude-route upstream requires every `thinking` block in a replayed
+ * assistant turn to carry a `signature`; an unsigned block is rejected with
+ * `400 messages.N.content.0.thinking.signature: Field required`. Chat-surface
+ * clients (e.g. OMP) replay reasoning as a bare `reasoning_content` string
+ * that has no signature — there is nothing to forward, and sending it as an
+ * unsigned `thought` part guarantees the 400.
+ *
+ * The reference client solves this with a `drop-unsigned-thinking` compat flag
+ * on `google-antigravity` (donor `anthropic.kdl:743-748`): a thinking block
+ * without a signature is simply not replayed. This mirrors that behavior —
+ * reasoning with a real signature still replays; reasoning without one is
+ * dropped so the upstream never sees an unsigned `thinking` part.
+ */
+export function dropAntigravityUnsignedReasoning(
+  request: CanonicalRequest,
+  isClaudeRoute: boolean,
+): CanonicalRequest {
+  if (!isClaudeRoute) return request;
+  const messages = request.messages;
+  let changed = false;
+  const next = messages.map((message) => {
+    if (message.role !== "assistant") return message;
+    const content = message.content.filter((part) => {
+      if (part.kind !== "reasoning") return true;
+      if (part.signature !== undefined) return true;
+      changed = true;
+      return false;
+    });
+    return changed ? { ...message, content } : message;
+  });
+  return changed ? { ...request, messages: next } : request;
+}
+
 // Last-good-endpoint stickiness
 
 /**

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

@@ -41,6 +41,7 @@ import {
 import {
   antigravityWireModelId,
   applySkipThoughtSignatureBypass,
+  dropAntigravityUnsignedReasoning,
   getAntigravityModelWireProfile,
   getAntigravityUserAgent,
   loadAntigravityProject,
@@ -334,6 +335,7 @@ class AntigravityAdapter implements ProviderAdapter {
               kind: "reasoning",
               payload: null,
               summary: output.thought,
+              ...(output.thoughtSignature ? { signature: output.thoughtSignature } : {}),
             },
           } as CanonicalEvent;
         }
@@ -448,6 +450,7 @@ class AntigravityAdapter implements ProviderAdapter {
               kind: "reasoning",
               payload: null,
               summary: output.thought,
+              ...(output.thoughtSignature ? { signature: output.thoughtSignature } : {}),
             },
           } as CanonicalEvent;
         }
@@ -912,7 +915,16 @@ export function buildAntigravityEnvelope(
   // for that key and would drop both the wrapper and the schema inside it —
   // the tool would ship as `{"type":"object"}` with every property gone.
   // Rewriting after the payload is built leaves nothing to recover.
-  const geminiPayload = buildGeminiPayload(normalizeAntigravityToolSchemas(request));
+  //
+  // Claude routes also drop replayed reasoning without a signature (donor
+  // `drop-unsigned-thinking`): upstream rejects an unsigned `thinking` part
+  // with 400 `messages.N.content.0.thinking.signature: Field required`.
+  const isClaudeRoute = logicalModelId.toLowerCase().includes("claude");
+  const geminiPayload = buildGeminiPayload(
+    normalizeAntigravityToolSchemas(
+      dropAntigravityUnsignedReasoning(request, isClaudeRoute),
+    ),
+  );
   const profile = getAntigravityModelWireProfile(wireModelId);
 
   const generationConfig = isRecord(geminiPayload["generationConfig"])
@@ -946,7 +958,6 @@ export function buildAntigravityEnvelope(
   const existingContents = Array.isArray(geminiPayload["contents"])
     ? (geminiPayload["contents"] as Record<string, unknown>[])
     : [];
-  const isClaudeRoute = logicalModelId.toLowerCase().includes("claude");
   // Forced choice on Gemini routes: the backend drops `toolConfig` here, so a
   // canonical `tool_choice=required` with no declared change is restated as a
   // trailing user directive (reference behavior). Claude routes implement

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

@@ -8,10 +8,9 @@
  * declarations.
  *
  * Only the row shape and the builder are shared. Identity headers are not:
- * `codebuddyHeaders` and `workbuddyHeaders` send genuinely different bytes
- * (`X-Product`/`X-IDE-Type`/`X-Domain` versus `origin`/`referer` and the
- * account-derived `x-user-id`/`x-machine-id`/`x-session-id`), and those stay
- * with their own provider.
+ * `codebuddyHeaders` sends genuinely different bytes per realm
+ * (`X-Product`/`X-IDE-Type`/`X-Domain` versus the CN CLI profile), and those
+ * stay with the provider.
  */
 import { GatewayError } from "../../../protocol/gateway-error";
 import { defineModel } from "../../provider-model-definition";
@@ -42,7 +41,8 @@ export const BUDDY_INTL_EFFORTS: Readonly<Record<string, readonly string[]>> = {
   "glm-5.2": ["high", "xhigh"],
   "glm-5.3": ["low", "high", "max"],
   hy3: ["low", "high"],
-  "hy4-preview-f": ["high"],
+  hy4: ["high"],
+  hy4free: ["high"],
 };
 export const BUDDY_CN_EFFORTS: Readonly<Record<string, readonly string[]>> = {
   "deepseek-v4-flash": ["low", "high", "max"],
@@ -53,7 +53,8 @@ export const BUDDY_CN_EFFORTS: Readonly<Record<string, readonly string[]>> = {
   "glm-5.3": ["low", "high", "max"],
   "glm-5.3-flash": ["low", "high", "max"],
   hy3: ["low", "high"],
-  "hy4-preview": ["high"],
+  hy4: ["high"],
+  hy4free: ["high"],
 };
 
 /** The image-generation ids the international buddy providers serve. */
@@ -75,9 +76,9 @@ const BUDDY_IMAGE_MODEL_IDS: readonly { id: string; endpoint: string; ctx: numbe
  * `seedance-2.5` is the text-to-video model the buddy facade exposes. It is a
  * distinct service kind (`videoGeneration`), not a chat or image row, so it is
  * built by {@link makeBuddyVideoModels} and reached through
- * `/videos/generations` (relative to each variant's own base, which is why the
- * WorkBuddy rows carry the `/v2` segment themselves) rather than a chat wire.
- * CodeBuddy CN is deliberately absent — it publishes a different roster.
+ * `/videos/generations` (relative to each variant's own base) rather than a
+ * chat wire. CodeBuddy CN is deliberately absent — it publishes a different
+ * roster.
  */
 const BUDDY_VIDEO_MODEL_IDS: readonly { id: string; endpoint: string; ctx: number; out: number }[] = [
   { id: "seedance-2.5", endpoint: "/videos/generations", ctx: 1_000_000, out: 128_000 },
@@ -103,16 +104,15 @@ export const BUDDY_IMAGE_MODEL_ID_SET: ReadonlySet<string> = new Set(
  * The CN realm's image-generation ids.
  *
  * Separate from {@link BUDDY_IMAGE_MODEL_IDS} because the realms do not share
- * a roster: `hunyuan-image-alpha` is published by the CN `/v3/config` only, and
- * the intl image ids are not served there. Sharing one list would either leak
- * CN-only ids onto the international catalogs or force a realm check into
- * every consumer.
- *
- * `hunyuan-image-alpha-edit` carries `image-to-image` and is deliberately NOT
- * here: it is not in the CLI roster, so it is not a routable generation model.
+ * a roster: `hunyuan-image-alpha` (text-to-image) and
+ * `hunyuan-image-alpha-edit` (image-to-image) are published by the CN
+ * `/v3/config` only, and the intl image ids are not served there. Sharing one
+ * list would either leak CN-only ids onto the international catalogs or force
+ * a realm check into every consumer.
  */
 const BUDDY_CN_IMAGE_MODEL_IDS: readonly { id: string; ctx: number; out: number }[] = [
   { id: "hunyuan-image-alpha", ctx: 1_000_000, out: 64_000 },
+  { id: "hunyuan-image-alpha-edit", ctx: 1_000_000, out: 64_000 },
 ];
 
 /** The CN analogue of {@link BUDDY_IMAGE_MODEL_ID_SET}. */
@@ -145,10 +145,54 @@ export function makeBuddyCnImageModels(
   );
 }
 
+/**
+ * The CN realm's video-generation ids.
+ *
+ * `kling-video-v3` (text-to-video + image-to-video) and
+ * `minimax-video-h3` (text-to-video) are published by the CN `/v3/config`,
+ * sharing the async task surface the intl video rows use.
+ */
+const BUDDY_CN_VIDEO_MODEL_IDS: readonly { id: string; ctx: number; out: number }[] = [
+  { id: "kling-video-v3", ctx: 1_000_000, out: 128_000 },
+  { id: "minimax-video-h3", ctx: 1_000_000, out: 128_000 },
+];
+
+/** The CN analogue of {@link BUDDY_VIDEO_MODEL_ID_SET}. */
+export const BUDDY_CN_VIDEO_MODEL_ID_SET: ReadonlySet<string> = new Set(
+  BUDDY_CN_VIDEO_MODEL_IDS.map((entry) => entry.id),
+);
+
+/**
+ * Builds the CN video-generation rows for one buddy CN provider.
+ *
+ * Same shape as {@link makeBuddyVideoModels}, scoped to the CN roster: a video
+ * row produces `["video"]` on the `videoGeneration` surface and is reached
+ * through the native video route, not a chat wire.
+ */
+export function makeBuddyCnVideoModels(
+  providerId: string,
+  endpoint: string,
+): readonly ModelDefinition[] {
+  return BUDDY_CN_VIDEO_MODEL_IDS.map((entry) =>
+    defineModel({
+      id: entry.id,
+      providerId,
+      serviceKind: "videoGeneration",
+      wireFamily: "chat",
+      endpoint,
+      ctx: entry.ctx,
+      out: entry.out,
+      vision: true,
+      output: ["video"],
+      toolCall: false,
+    }),
+  );
+}
+
 /**
  * Ids the buddy facade refuses on a free plan.
  *
- * The international CodeBuddy and WorkBuddy catalogs share this roster and
+ * The international CodeBuddy catalog shares this roster and
  * the same Pro-tier model classification.
  *
  * Nothing in the console directory predicts it. `credits` does not — `kimi-k3`
@@ -186,12 +230,12 @@ export const BUDDY_PRO_ONLY_MODEL_IDS: ReadonlySet<string> = new Set([
 /**
  * Builds the image-generation rows for one buddy provider.
  *
- * Shared rather than copied per provider: cb and WorkBuddy serve the same image
+ * Shared rather than copied per provider: cb serves the same image
  * models from the same facade, so the roster and the declared capabilities are
  * one decision instead of two that drift. CodeBuddy CN is deliberately absent —
  * it publishes a different roster.
  *
- * `endpoint` is explicit because the two families disagree about the path their
+ * `endpoint` is explicit because the realms disagree about the path their
  * base URL expects, and a bare `defineModel` would infer the generic default
  * and produce a URL the upstream rejects.
  */
@@ -260,12 +304,9 @@ export const BUDDY_VIDEO_MODEL_ID_SET: ReadonlySet<string> = new Set(
  * Builds one buddy catalog row.
  *
  * `endpoint` is explicit rather than left to the generic `/chat/completions`
- * default because the two families disagree about it: CodeBuddy's base URL
- * carries a version segment the default joins onto correctly, while
- * WorkBuddy's does not — the default would produce
- * `https://www.workbuddy.ai/chat/completions`, which that upstream answers
- * with a 405 HTML page. Callers pass the endpoint their base URL actually
- * serves, and `undefined` for the default.
+ * default because the family's CN base URL differs from the intl one; callers
+ * pass the endpoint their base URL actually serves, and `undefined` for the
+ * default.
  */
 export function makeBuddyModel(
   entry: BuddyRawEntry,
@@ -297,14 +338,11 @@ export function makeBuddyModel(
 }
 
 /**
- * The shared model roster for the two international buddy sites.
+ * The shared model roster for the international buddy site.
  *
- * CodeBuddy intl and WorkBuddy serve the same model set from the same console
- * directory shape, so the two catalogs were kept as separate hand-written lists
- * and had already drifted: each carried ids the other lacked. One list is the
- * single source of truth, and each provider maps it with its own endpoint
- * (`workbuddy.ts` needs the explicit `/v2/chat/completions`, `codebuddy.ts`
- * takes the family default) — the endpoint is the only thing that differs.
+ * CodeBuddy intl serves the model set from the same console directory shape, so
+ * the catalog is one hand-written list as the single source of truth, mapped
+ * with the provider's own endpoint (`codebuddy.ts` takes the family default).
  *
  * CodeBuddy CN is deliberately NOT on this list: its console publishes a
  * different roster (its own `glm-5v-turbo` / `kimi-k3-1` ids and CN-specific
@@ -349,8 +387,8 @@ export const BUDDY_SHARED_RAW: readonly BuddyRawEntry[] = [
   ["grok-4.6", "Grok 4.6", true, true, 500_000, 500_000],
   ["grok-4.7", "Grok 4.7", true, true, 500_000, 128_000],
   ["hy3", "Hy3", true, true, 192_000, 64_000, true],
-  ["hy4-preview", "Hy4 Preview", true, true, 1_000_000, 64_000, true],
-  ["hy4-preview-f", "Hy4 Preview F", true, true, 1_000_000, 64_000, true],
+  ["hy4", "Hy4", true, true, 1_000_000, 64_000, true],
+  ["hy4free", "Hy4 Free", true, true, 1_000_000, 64_000, true],
   ["kimi-k2.5", "Kimi K2.5", true, false, 164_000, 262_144],
   ["kimi-k2.6", "Kimi K2.6", true, false, 256_000, 262_144],
   ["kimi-k2.7", "Kimi K2.7", true, false, 256_000, 65_536],

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

@@ -1,7 +1,7 @@
 /**
  * Chat-wire payload and message normalization shared by the Tencent "buddy"
- * family providers — CodeBuddy International (`cb`), CodeBuddy CN (`cbcn`),
- * and WorkBuddy. All three speak the same upstream contract for this part of
+ * family providers — CodeBuddy International (`cb`) and CodeBuddy CN (`cbcn`).
+ * Both speak the same upstream contract for this part of
  * the payload, so the rules live here once instead of being copied per
  * variant:
  *
@@ -332,10 +332,10 @@ function buddyTemplatePattern(text: string): RegExp {
   return new RegExp(`(?<!\\w)${buddyTemplateSource(text)}(?!\\w)`, "i");
 }
 
-// DeepSeek Harness (DSH) role identities. DSH is the harness behind WorkBuddy;
-// a history that still carries its self-description reads to the upstream as a
-// foreign channel, so the hardened client rewrites it back to the WorkBuddy
-// identity rather than forwarding a competing one.
+// DeepSeek Harness (DSH) role identities. DSH is the harness behind the buddy
+// family; a history that still carries its self-description reads to the
+// upstream as a foreign channel, so the hardened client rewrites it back to
+// the CodeBuddy identity rather than forwarding a competing one.
 const DSH_CODING_PATTERN = new RegExp(
   `(?<!\\w)${buddyTemplateSource("You are a coding agent powered by the")}` +
     `[\\s${BUDDY_ZWSP}]+([^\\r\\n]{1,200}?)[\\s${BUDDY_ZWSP}]+` +
@@ -350,17 +350,17 @@ 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; neutral and minimal. */
-const DSH_WORKBUDDY_IDENTITY = "You are a helpful assistant";
+const DSH_CODEBUDDY_IDENTITY = "You are a helpful assistant";
 
 /**
  * Rewrites DeepSeek Harness role identities in one message's text back to the
- * WorkBuddy identity. Port of the donor gateway's always-on
+ * CodeBuddy identity. Port of the donor gateway's always-on
  * `desensitize_channel_body`, scoped to text the wire actually carries.
  *
  * This normalizes a replayed history (or a surviving system turn) that still
- * claims the DSH harness, so a WorkBuddy request never advertises a competing
+ * claims the DSH harness, so a buddy request never advertises a competing
  * channel identity upstream. The coding persona keeps the model it named:
- * "You are a coding agent powered by the X model" becomes the WorkBuddy
+ * "You are a coding agent powered by the X model" becomes the CodeBuddy
  * identity plus "powered by the X model".
  */
 export function scrubBuddyChannelIdentityText(text: string): string {
@@ -368,13 +368,13 @@ export function scrubBuddyChannelIdentityText(text: string): string {
   const withCodingPersona = text.replace(
     DSH_CODING_PATTERN,
     (_match, model: string) =>
-      `${DSH_WORKBUDDY_IDENTITY}. This conversation is powered by the ${model.trim()} model`,
+      `${DSH_CODEBUDDY_IDENTITY}. This conversation is powered by the ${model.trim()} model`,
   );
   return withCodingPersona
-    .replace(DSH_CHANNEL_IDENTITY_PATTERN, DSH_WORKBUDDY_IDENTITY)
-    .replace(DSH_MINIMAL_PATTERN, DSH_WORKBUDDY_IDENTITY)
-    .replace(DSH_DIRECT_PATTERN, DSH_WORKBUDDY_IDENTITY)
-    .replace(DSH_WEB_GUI_PATTERN, "WorkBuddy Web GUI");
+    .replace(DSH_CHANNEL_IDENTITY_PATTERN, DSH_CODEBUDDY_IDENTITY)
+    .replace(DSH_MINIMAL_PATTERN, DSH_CODEBUDDY_IDENTITY)
+    .replace(DSH_DIRECT_PATTERN, DSH_CODEBUDDY_IDENTITY)
+    .replace(DSH_WEB_GUI_PATTERN, "CodeBuddy Web GUI");
 }
 
 function scrubBuddyMessageText(message: Record<string, unknown>, field: string): void {
@@ -504,8 +504,8 @@ export function buddyPrePayloadCommon(
     cleanupBuddyOrphanToolPairs(arr);
     coalesceConsecutiveAssistantMessages(arr);
     // Normalize a replayed harness history before the blocked-code rewrite
-    // below: DSH role identities are replaced with the WorkBuddy identity, so
-    // a WorkBuddy-family request never forwards a competing channel identity.
+    // below: DSH role identities are replaced with the CodeBuddy identity, so
+    // a buddy-family request never forwards a competing channel identity.
     scrubBuddyChannelIdentity(arr);
     // After every merge: a quoted `11128` in any surviving text blocks the
     // whole request, and the merges above are what produce the final text.
@@ -1138,7 +1138,7 @@ export interface BuddyMessageFinalizeOptions {
  * The single authoritative buddy message-shape pipeline. Every variant runs
  * the same sequence — coalesce, drop empty turns, guarantee the leading system
  * turn, omit content on tool_calls-only assistant turns, then auto-cache — so
- * the wire shape cannot drift between CodeBuddy intl, CN, and WorkBuddy.
+ * the wire shape cannot drift between CodeBuddy intl and CN.
  */
 export function finalizeBuddyMessages(
   messages: Array<Record<string, unknown>>,

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

@@ -1,7 +1,7 @@
 import { asCoercedNumber as sharedAsNumber, asRecord as sharedAsRecord } from "../../../shared/coerce";
 
-// Buddy-family daily check-in (daily login credit claim), shared by all three
-// variants (`cb`, `cbcn`, `workbuddy`): same Tencent billing facade, same
+// Buddy-family daily check-in (daily login credit claim), shared by both
+// variants (`cb`, `cbcn`): same Tencent billing facade, same
 // status/claim contract — only the endpoint base and identity headers differ
 // per variant, and those already live in each provider's own modules.
 //
@@ -22,15 +22,8 @@ import { asCoercedNumber as sharedAsNumber, asRecord as sharedAsRecord } from ".
 
 import { providerBaseUrl } from "../../provider-metadata";
 import { sleep } from "../../../shared/sleep";
-import { WORKBUDDY_DOMAIN } from "./workbuddy/shared";
 import { BUDDY_PROVIDER_IDS } from "../../provider-metadata";
 import { QODER_CHECKIN_PROVIDER_IDS } from "../qoder/qoder-checkin";
-import {
-  buildWorkBuddyUserAgent,
-  getWorkBuddyClientVersion,
-  getWorkBuddyCnClientVersion,
-  getWorkBuddyCliVersion,
-} from "../../operations/client-versions";
 import { buildCodeBuddyUserAgent } from "../../operations/client-versions";
 import { codebuddyDomain, type CodeBuddyVariant } from "./codebuddy/shared";
 /** Providers whose billing facade exposes the daily check-in routes. */
@@ -186,8 +179,8 @@ export function buildActivityReportEvent(args: {
  * chat send. A single event did not move the growth tasks; four events per
  * batch, sent twice with a pause between the rounds, is what does. The pause
  * is what keeps the two rounds from landing as one burst. Both numbers apply
- * to every buddy variant — the request is built the same way for `cb`,
- * `cbcn`, and `workbuddy`, so none of them can drift back to a single shot.
+ * to every buddy variant — the request is built the same way for `cb` and
+ * `cbcn`, so neither can drift back to a single shot.
  */
 export const ACTIVITY_REPORT_EVENTS_PER_BATCH = 4;
 export const ACTIVITY_REPORT_ROUNDS = 2;
@@ -196,8 +189,8 @@ export const ACTIVITY_REPORT_ROUND_DELAY_MS = 1_500;
 /**
  * Sends the growth-activity report (`POST {base}/v2/report`, the versioned
  * billing-meter path joined the same way as the status/claim routes:
- * `VERSION_SEGMENT` supplies `/v2` for the bare `workbuddy` base and nothing
- * for `cb`/`cbcn`, which already end in it).
+ * `VERSION_SEGMENT` supplies nothing for `cb`/`cbcn`, which already end in
+ * `/v2`).
  *
  * Two rounds of four events, paused between rounds. Each event carries its
  * own conversation and request id: the facade drops a repeated id as a
@@ -290,13 +283,10 @@ const CLAIM_RETRY_DELAYS_MS = [1_000, 2_000] as const;
 /**
  * Check-in paths are joined onto the provider's manifest base URL, which does
  * NOT carry a consistent version segment: `cb`/`cbcn` already end in `/v2`,
- * while WorkBuddy variants are bare and need `/v2` prepended. This map keeps that
- * join aligned with each provider's own quota collector, so the three
- * gateways cannot drift apart.
+ * so no segment is prepended. This map keeps the join aligned with each
+ * provider's own quota collector, so the gateways cannot drift apart.
  */
 const VERSION_SEGMENT: Readonly<Record<string, string>> = {
-  workbuddy: "/v2",
-  workbuddycn: "/v2",
   cb: "",
   cbcn: "",
 };
@@ -311,10 +301,9 @@ function claimUrl(providerId: string): string {
 
 /**
  * Per-provider billing headers. The Buddy gateways share the Tencent billing
- * facade but each risk-gates on its own client identity: WorkBuddy wants the
- * desktop brand, CodeBuddy intl wants the `IDE` identity, and CN wants `CLI`
- * (plus its own `X-Domain`). Sending the wrong one trips a 403 the same way
- * the chat surface does.
+ * facade but each risk-gates on its own client identity: CodeBuddy intl
+ * wants the `IDE` identity, and CN wants `CLI` (plus its own `X-Domain`).
+ * Sending the wrong one trips a 403 the same way the chat surface does.
  */
 async function checkinHeaders(providerId: string): Promise<Record<string, string>> {
   const common = {
@@ -324,24 +313,13 @@ async function checkinHeaders(providerId: string): Promise<Record<string, string
     "Content-Type": "application/json",
     Accept: "application/json",
   };
-  if (providerId === "cb" || providerId === "cbcn") {
-    const variant: CodeBuddyVariant = providerId === "cb" ? "IDE" : "CLI";
-    return {
-      ...common,
-      "User-Agent": buildCodeBuddyUserAgent(variant),
-      "X-IDE-Type": variant,
-      "X-IDE-Name": variant,
-      "X-Domain": codebuddyDomain(variant),
-    };
-  }
-  const clientVersion = providerId === "workbuddycn"
-    ? getWorkBuddyCnClientVersion()
-    : getWorkBuddyClientVersion();
+  const variant: CodeBuddyVariant = providerId === "cb" ? "IDE" : "CLI";
   return {
     ...common,
-    "User-Agent": buildWorkBuddyUserAgent(clientVersion, getWorkBuddyCliVersion()),
-    "X-Domain": providerId === "workbuddycn" ? "www.workbuddy.cn" : WORKBUDDY_DOMAIN,
-    "Accept-Language": "en-US",
+    "User-Agent": buildCodeBuddyUserAgent(variant),
+    "X-IDE-Type": variant,
+    "X-IDE-Name": variant,
+    "X-Domain": codebuddyDomain(variant),
   };
 }
 
@@ -392,7 +370,7 @@ function envelopeCode(payload: unknown): number | null {
 }
 
 /**
- * Unwraps the check-in payload. WorkBuddy returns a flat `{ code, data }`,
+ * Unwraps the check-in payload. The gateway returns a flat `{ code, data }`,
  * while the CodeBuddy billing facade nests Tencent's `data.Response.Data`
  * (the same double wrap its quota endpoint uses), so both shapes resolve.
  */

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

@@ -62,9 +62,9 @@ export interface BuddyConversationIds {
    * Wire format for the two message-scoped ids (`x-conversation-message-id`,
    * `x-request-id`).
    *
-   * The reference emits these as dashed UUIDs on the WorkBuddy desktop product
+   * The reference emits these as dashed UUIDs on the desktop product
    * and as 32-hex on CLI traffic (`build_attempt_headers` converts only the
-   * message/request ids, and only for the WorkBuddy profiles). The turn
+   * message/request ids, and only for the desktop profiles). The turn
    * aggregation key (`x-conversation-request-id` / `x-root-request-id`) and the
    * B3/W3C trace ids stay hex in both styles, because B3's spec accepts only
    * hex. Default `"hex"`.

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

@@ -1,10 +1,10 @@
 import { asNumber as sharedAsNumber, asRecord } from "../../../shared/coerce";
 
 /**
- * Model discovery for the buddy family (CodeBuddy intl / CN, WorkBuddy).
+ * Model discovery for the buddy family (CodeBuddy intl / CN).
  *
- * The three sites are protocol-isomorphic but NOT path-isomorphic, and the
- * difference is load-bearing: the international sites answer
+ * The two sites are protocol-isomorphic but NOT path-isomorphic, and the
+ * difference is load-bearing: the international site answers
  * `/v2/enterprises/personal/models`, while the CN site answers
  * `/console/enterprises/personal/models`. Probing the CN path on an
  * international host returns HTTP 500 from the edge (APISIX) rather than 404 —
@@ -34,8 +34,8 @@ import { buddyAccountUid } from "./buddy-oauth-shared";
 export const BUDDY_CN_MODELS_PATH = "/console/enterprises/personal/models" as const;
 
 /**
- * Console directory path on the international sites (`codebuddy.ai`,
- * `workbuddy.ai`). The CN path above answers 500 on these hosts.
+ * Console directory path on the international site (`codebuddy.ai`). The CN
+ * path above answers 500 on these hosts.
  */
 export const BUDDY_INTL_MODELS_PATH = "/v2/enterprises/personal/models" as const;