cartethyia 2.7.9 → 2.8.1

package/src/providers/integrations/buddy/{buddy-chat-shared.ts → chat.ts}

@@ -21,15 +21,16 @@ import { createHash } from "node:crypto";
 import { completeRequiredSchema } from "../../../protocol/codecs";
 import type { CanonicalRequest } from "../../../protocol/canonical-model";
 import { isRecord } from "../../../protocol/codecs";
+import { GatewayError } from "../../../protocol/gateway-error";
 import { applyDeepSeekReasoning, applyOpenAIReasoning, backfillDeepSeekReasoningContent, clampedEffortOutputFloor, ensureChatReasoningReplayPresence } from "../../../protocol/reasoning";
-import { BUDDY_CN_EFFORTS, BUDDY_INTL_EFFORTS, BUDDY_SHARED_RAW } from "./buddy-catalog-shared";
+import { BUDDY_CN_EFFORTS, BUDDY_INTL_EFFORTS, BUDDY_SHARED_RAW } from "./catalog";
 // Imported for the CN roster only: a CN-only id has no row in the shared
 // table, and without one `raiseOutputForRaisedEffort` silently no-ops, so a
 // raised effort still answers inside a budget sized for the lower one. It is
 // read inside the function below — never at module init — so the cycle with
 // cn-provider (which imports this module) resolves before any call.
-import { CODEBUDDY_CN_RAW } from "./codebuddy/cn-catalog";
-import { buddyAccountUid } from "./buddy-oauth-shared";
+import { CODEBUDDY_CN_RAW } from "./catalog";
+import { buddyAccountUid } from "./account";
 import { SYSTEM_PROMPT_WRAPPER_PREFIX, SYSTEM_PROMPT_WRAPPER_SUFFIX } from "../../../console/system-prompt/contracts";
 import type { ProviderDispatchContext } from "../../provider-contracts";
 
@@ -55,6 +56,123 @@ function normalizedToolName(value: string, index: number, used: Set<string>): st
   return uniqueToolName(base || `tool_${index + 1}`, used);
 }
 
+/**
+ * Schema keywords whose values are schemas (recursed as schema objects).
+ * Mirrors the donor gateway's `upstream_compat._SCHEMA_MAPS/_ARRAYS/CHILDREN`.
+ */
+const RE2_SCHEMA_MAPS: ReadonlySet<string> = new Set([
+  "properties",
+  "patternProperties",
+  "$defs",
+  "definitions",
+  "dependentSchemas",
+  "dependencies",
+]);
+const RE2_SCHEMA_ARRAYS: ReadonlySet<string> = new Set([
+  "allOf",
+  "anyOf",
+  "oneOf",
+  "prefixItems",
+  "items",
+]);
+const RE2_SCHEMA_CHILDREN: ReadonlySet<string> = new Set([
+  "items",
+  "additionalItems",
+  "contains",
+  "unevaluatedItems",
+  "additionalProperties",
+  "unevaluatedProperties",
+  "propertyNames",
+  "not",
+  "if",
+  "then",
+  "else",
+  "contentSchema",
+]);
+
+/**
+ * Removes unescaped backslashes before underscores in one regex pattern. The
+ * CodeBuddy upstream validates tool schemas with RE2, which does not support
+ * `\_` escapes — a client schema that serializes `\_` (a common JSON
+ * representation of a literal underscore) is rejected with a 400. The donor
+ * gateway normalizes this before dispatch; a backslash that escapes a
+ * backslash is preserved.
+ */
+function normalizeRe2Pattern(value: string): string {
+  let out = "";
+  for (let i = 0; i < value.length; i++) {
+    const char = value[i];
+    if (char === "\\" && value[i + 1] === "\\") {
+      // Escaped backslash: keep the pair so a following `_` stays escaped.
+      out += "\\\\";
+      i += 1;
+      continue;
+    }
+    if (char === "\\" && value[i + 1] === "_") {
+      // `\_` — the upstream's RE2 rejects it; drop the backslash.
+      out += "_";
+      i += 1;
+      continue;
+    }
+    out += char;
+  }
+  return out;
+}
+
+/** Normalizes RE2-incompatible underscore escapes in schema pattern positions. */
+function normalizeRe2SchemaPatterns(schema: unknown): void {
+  if (!isRecord(schema)) return;
+  const pattern = schema["pattern"];
+  if (typeof pattern === "string") schema["pattern"] = normalizeRe2Pattern(pattern);
+  const patternProperties = schema["patternProperties"];
+  if (isRecord(patternProperties)) {
+    const normalized: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(patternProperties)) {
+      const key2 = normalizeRe2Pattern(key);
+      if (key2 in normalized) {
+        normalized[key2] = { allOf: [normalized[key2], value] };
+      } else {
+        normalized[key2] = value;
+      }
+    }
+    schema["patternProperties"] = normalized;
+  }
+  for (const key of RE2_SCHEMA_MAPS) {
+    const map = schema[key];
+    if (!isRecord(map)) continue;
+    for (const child of Object.values(map)) normalizeRe2SchemaPatterns(child);
+  }
+  for (const key of RE2_SCHEMA_ARRAYS) {
+    const list = schema[key];
+    if (!Array.isArray(list)) continue;
+    for (const child of list) normalizeRe2SchemaPatterns(child);
+  }
+  for (const key of RE2_SCHEMA_CHILDREN) {
+    normalizeRe2SchemaPatterns(schema[key]);
+  }
+}
+
+/** JSON-serializes a value to cheaply detect a backslash-before-underscore. */
+function hasUnderscoreEscape(value: unknown): boolean {
+  try {
+    return JSON.stringify(value).includes("\\_");
+  } catch {
+    return true;
+  }
+}
+
+/** Returns the declaration with RE2-safe schema patterns, or the same object. */
+function normalizeRe2Declaration(declaration: Record<string, unknown>): Record<string, unknown> {
+  const parameters = declaration["parameters"];
+  if (!hasUnderscoreEscape(parameters)) return declaration;
+  // Deep-copy only when a rewrite is needed; the shared object must not be
+  // mutated for every dispatch.
+  const out: Record<string, unknown> = { ...declaration };
+  out["parameters"] = structuredClone(parameters);
+  normalizeRe2SchemaPatterns(out["parameters"]);
+  return out;
+}
+
 /**
  * Buddy's Chat Completions wire has no `web_search_preview` hosted tool; its
  * search is an ordinary function named `web_search` with a `{query}` schema.
@@ -102,29 +220,28 @@ export function normalizeBuddyToolNames(payload: Record<string, unknown>): void
     const name = normalizedToolName(sourceName, index, used);
     used.add(name);
     if (!replacements.has(sourceName)) replacements.set(sourceName, name);
-    if (fn !== undefined)
-      return {
-        ...rawTool,
-        function: {
-          ...fn,
-          name,
-          ...(fn["parameters"] === undefined ? {} : { parameters: completeRequiredSchema(fn["parameters"]) }),
-        },
+    if (fn !== undefined) {
+      const fnOut = {
+        ...fn,
+        name,
+        ...(fn["parameters"] === undefined ? {} : { parameters: completeRequiredSchema(fn["parameters"]) }),
       };
-    if (custom !== undefined)
-      return {
-        ...rawTool,
-        custom: {
-          ...custom,
-          name,
-          ...(custom["format"] === undefined ? {} : { format: completeRequiredSchema(custom["format"]) }),
-        },
+      return { ...rawTool, function: normalizeRe2Declaration(fnOut) };
+    }
+    if (custom !== undefined) {
+      const customOut = {
+        ...custom,
+        name,
+        ...(custom["format"] === undefined ? {} : { format: completeRequiredSchema(custom["format"]) }),
       };
-    return {
+      return { ...rawTool, custom: normalizeRe2Declaration(customOut) };
+    }
+    const bareOut = {
       ...rawTool,
       name,
       ...(rawTool["parameters"] === undefined ? {} : { parameters: completeRequiredSchema(rawTool["parameters"]) }),
     };
+    return { ...bareOut, ...normalizeRe2Declaration(bareOut) };
   });
   const messages = payload["messages"];
   if (Array.isArray(messages)) {
@@ -138,6 +255,13 @@ export function normalizeBuddyToolNames(payload: Record<string, unknown>): void
       }
     }
   }
+  const responseFormat = payload["response_format"];
+  if (isRecord(responseFormat) && hasUnderscoreEscape(responseFormat)) {
+    const copied = structuredClone(responseFormat) as Record<string, unknown>;
+    const jsonSchema = copied["json_schema"];
+    if (isRecord(jsonSchema)) normalizeRe2SchemaPatterns(jsonSchema["schema"]);
+    payload["response_format"] = copied;
+  }
   const choice = payload["tool_choice"];
   if (!isRecord(choice)) return;
   if (choice["type"] === "allowed_tools" && Array.isArray(choice["tools"])) {
@@ -477,6 +601,10 @@ export function buddyPrePayloadCommon(
   normalizeBuddyImageUrl(payload);
   // developer role → system (buddy whitelist rejects developer, 11128)
   normalizeBuddyRoles(payload);
+  // Validate the *caller's* thinking controls before the DeepSeek contract may
+  // inject its own `thinking` (an injected `{type:"enabled"}` has no budget and
+  // must not be rejected as a malformed client shape).
+  validateBuddyThinking(payload);
   applyOpenAIReasoning(payload, request);
   applyDeepSeekReasoning(payload);
   // sol family defaults to high reasoning like reference thinking.go defaultDeepSeekEffort — sol without effort gets 500/invoke error otherwise
@@ -516,6 +644,34 @@ export function buddyPrePayloadCommon(
   delete payload["agent_prompt"];
 }
 
+/**
+ * Validates the reasoning controls the CodeBuddy Chat wire accepts, mirroring
+ * the donor gateway's `map_reasoning_controls`. The upstream rejects the whole
+ * request for shapes it does not model, so a client that sends an unsupported
+ * `thinking` shape is failed here with a 400 that names the field — instead of
+ * an opaque upstream error.
+ */
+function validateBuddyThinking(payload: Record<string, unknown>): void {
+  const thinking = isRecord(payload["thinking"]) ? payload["thinking"] : undefined;
+  if (thinking === undefined) return;
+  const mode = typeof thinking["type"] === "string" ? (thinking["type"] as string) : "";
+  if (mode !== "enabled" && mode !== "adaptive" && mode !== "disabled") {
+    throw new GatewayError("invalid_request", 400, `CodeBuddy thinking.type must be enabled, adaptive or disabled (got ${JSON.stringify(mode)}) (request {requestId}). Check the shape of what you sent — then resend 🪞`);
+  }
+  if (mode === "enabled") {
+    const budget = thinking["budget_tokens"];
+    if (typeof budget !== "number" || !Number.isInteger(budget) || budget < 1024) {
+      throw new GatewayError("invalid_request", 400, "CodeBuddy thinking.budget_tokens must be an integer >= 1024 (request {requestId}). Check the shape of what you sent — then resend 🪞");
+    }
+  } else if (thinking["budget_tokens"] !== undefined) {
+    throw new GatewayError("invalid_request", 400, "CodeBuddy thinking.budget_tokens requires thinking.type=enabled (request {requestId}). Check the shape of what you sent — then resend 🪞");
+  }
+  const display = thinking["display"];
+  if (display !== undefined && display !== null && display !== "summarized") {
+    throw new GatewayError("invalid_request", 400, "CodeBuddy thinking.display supports only summarized (request {requestId}). Check the shape of what you sent — then resend 🪞");
+  }
+}
+
 function injectSolReasoningDefault(payload: Record<string, unknown>): void {
   const model = typeof payload["model"] === "string" ? (payload["model"] as string) : "";
   const isSol = model.toLowerCase().includes("sol");

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

@@ -0,0 +1,429 @@
+import { BuddyMediaAdapter } from "../media";
+import type { ProviderDispatchContext, ProviderDispatchTarget, ProviderAdapter } from "../../../provider-contracts";
+import type { ModelDefinition } from "../../../provider-model-definition";
+import type { DiscoveryInput } from "../../../discovery/discovery-types";
+import { GatewayError } from "../../../../protocol/gateway-error";
+import type { CanonicalRequest } from "../../../../protocol/canonical-model";
+import { providerBaseUrl } from "../../../provider-metadata";
+import { ensurePayloadModel } from "../../../configured-provider";
+import { codebuddyAdapterConfig, codebuddyDomain, codebuddyHeaders } from "./shared";
+import {
+  BUDDY_SHARED_RAW,
+  BUDDY_IMAGE_MODEL_ID_SET,
+  BUDDY_VIDEO_MODEL_ID_SET,
+  BUDDY_INTL_MODELS_PATH,
+  BUDDY_CN_MODELS_PATH,
+  BUDDY_CN_IMAGE_MODEL_ID_SET,
+  BUDDY_CN_VIDEO_MODEL_ID_SET,
+  CODEBUDDY_CN_RAW,
+  type BuddyRawEntry,
+  makeBuddyModel,
+  makeBuddyImageModels,
+  makeBuddyVideoModels,
+  makeBuddyCnImageModels,
+  makeBuddyCnVideoModels,
+  fetchBuddyDirectoryModels,
+} from "../catalog";
+import {
+  applyBuddySystemPrompt,
+  buddyPrePayloadCommon,
+  finalizeBuddyMessages,
+  injectBuddyParallelToolCalls,
+  normalizeBuddyToolNames,
+} from "../chat";
+import {
+  BuddyOAuthClient,
+  type BuddyOAuthVariant,
+  strictResponseCode,
+  fetchTencentBillingQuota,
+  fetchBuddyRequestUsage,
+  type BuddyUsageResult,
+} from "../account";
+import { buildCodeBuddyUserAgent } from "../../../operations/client-versions";
+import type { FetchLike, ProviderQuotaResult } from "../../../quota/quota-contracts";
+
+// ── codebuddy/provider ──────────────────────────────────────────
+
+export const CODEBUDDY_PROVIDER_ID = "cb" as const;
+
+export const CODEBUDDY_BASE_URL = providerBaseUrl("cb");
+
+export const CODEBUDDY_SYSTEM_PROMPT = "You are a helpful assistant.";
+
+function codeBuddyIntlPrePayload(
+  payload: Record<string, unknown>,
+  request: CanonicalRequest,
+  candidate: ProviderDispatchTarget,
+  context?: ProviderDispatchContext,
+): void {
+  // International ladder: DeepSeek Flash and friends serve only `high`.
+  buddyPrePayloadCommon(payload, request, "intl", context);
+  const rawModel = payload["model"];
+  const source =
+    typeof rawModel === "string" && rawModel.length > 0
+      ? rawModel
+      : candidate.model_id;
+  if (!source) throw new GatewayError("invalid_request", 400, "CodeBuddy model is required (request {requestId}). Check the shape of what you sent — then resend 🪞");
+  const messages = payload["messages"];
+  if (Array.isArray(messages)) {
+    applyBuddySystemPrompt(
+      messages as Array<Record<string, unknown>>,
+      CODEBUDDY_SYSTEM_PROMPT,
+      context?.tenant_system_prompt,
+    );
+  }
+  normalizeBuddyToolNames(payload);
+  injectBuddyParallelToolCalls(payload, request);
+  void request;
+}
+
+const CODEBUDDY_INTL_RAW: readonly BuddyRawEntry[] = BUDDY_SHARED_RAW;
+
+export const CODEBUDDY_IMAGE_MODELS: readonly ModelDefinition[] = makeBuddyImageModels(
+  "cb",
+  "/images/generations",
+);
+
+export const CODEBUDDY_VIDEO_MODELS: readonly ModelDefinition[] = makeBuddyVideoModels(
+  "cb",
+  "/videos/generations",
+);
+
+export const CODEBUDDY_MODELS: readonly ModelDefinition[] = [
+  ...CODEBUDDY_INTL_RAW.filter(
+    (entry) => !BUDDY_IMAGE_MODEL_ID_SET.has(entry[0]) && !BUDDY_VIDEO_MODEL_ID_SET.has(entry[0]),
+  ).map((entry) => makeBuddyModel(entry, "cb")),
+  ...CODEBUDDY_IMAGE_MODELS,
+  ...CODEBUDDY_VIDEO_MODELS,
+];
+
+export async function discoverCodeBuddyModels(
+  input: DiscoveryInput,
+): Promise<readonly ModelDefinition[] | null> {
+  return fetchBuddyDirectoryModels({
+    siteUrl: CODEBUDDY_BASE_URL,
+    providerId: CODEBUDDY_PROVIDER_ID,
+    credential: input.credential,
+    modelsPath: BUDDY_INTL_MODELS_PATH,
+    endpoint: undefined,
+    ...(input.signal ? { signal: input.signal } : {}),
+    ...(input.fetcher ? { fetcher: input.fetcher } : {}),
+  });
+}
+
+export function createCodeBuddyAdapter(fetchImpl?: typeof fetch): ProviderAdapter {
+  return new BuddyMediaAdapter(
+    codebuddyAdapterConfig({
+      providerId: CODEBUDDY_PROVIDER_ID,
+      baseUrl: CODEBUDDY_BASE_URL,
+      variant: "IDE",
+      cliIdentity: true,
+      prePayload: codeBuddyIntlPrePayload,
+      // The intl CLI profile gzips the chat body and recovers a channel-check
+      // 400 by retrying once on the console chat endpoint (donor behavior).
+      requestCompression: "gzip",
+      channelFallbackPath: "/console/chat/completions",
+      ...(fetchImpl ? { fetchImpl } : {}),
+    }),
+    {
+      variant: "IDE",
+      // BuddyMediaConfig has no `cliIdentity`; the CLI identity is selected by
+      // supplying the builder that takes it.
+      buildHeaders: (context, request) => codebuddyHeaders("IDE", context, request, true),
+      systemPrompt: CODEBUDDY_SYSTEM_PROMPT,
+      baseUrl: CODEBUDDY_BASE_URL,
+      imageGenerationPath: "/images/generations",
+    },
+  );
+}
+
+// ── codebuddy/cn-provider ──────────────────────────────────────────
+
+export const CODEBUDDY_CN_PROVIDER_ID = "cbcn" as const;
+
+export const CODEBUDDY_CN_BASE_URL = providerBaseUrl("cbcn");
+
+function isAgentPromptText(text: string): boolean {
+  return /you are claude code|claude.?code.+official.+cli|anthropic.+official.+cli|anxthxropic.+official.+cli|you are (?:cursor|windsurf|cline|aider|continue|copilot|cody)|you are an? (?:ai )?(?:coding |code )?agent|cc_entrypoint\s*=\s*(?:cli|vscode|jetbrains|gui)|claude.?code.+issues|give feedback.+claude.?code|you are .{0,30}(?:powerful )?ai agent|orchestration capabilities|OhMyOpenCode|<agent-identity>|<Role>|<Behavior_Instructions>/i.test(
+    text,
+  );
+}
+
+const CODEBUDDY_CN_NEUTRAL_PROMPT = "You are a helpful assistant.";
+
+function flattenContent(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((part) =>
+      part !== null && typeof part === "object" && "text" in part
+        ? String((part as Record<string, unknown>)["text"] ?? "")
+        : "",
+    )
+    .join("\n");
+}
+
+function neutralizeCnMessages(messages: Array<Record<string, unknown>>): void {
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (!message || message["role"] !== "system") continue;
+    const content = message["content"];
+    const text = flattenContent(content);
+    if (text.length <= 2_000 && !isAgentPromptText(text)) continue;
+    messages[index] =
+      typeof content === "string"
+        ? { ...message, content: CODEBUDDY_CN_NEUTRAL_PROMPT }
+        : {
+            ...message,
+            content: [{ type: "text", text: CODEBUDDY_CN_NEUTRAL_PROMPT }],
+          };
+  }
+}
+
+export function codeBuddyCnPrePayload(
+  payload: Record<string, unknown>,
+  request: CanonicalRequest,
+  candidate: ProviderDispatchTarget,
+  context?: ProviderDispatchContext,
+): void {
+  // CN ladder: the CN backend serves `low`/`max` levels the international one
+  // rejects, so the realm must be named rather than left to default to intl.
+  buddyPrePayloadCommon(payload, request, "cn", context);
+  if (Array.isArray(payload["messages"])) {
+    const messages = payload["messages"] as Array<Record<string, unknown>>;
+    neutralizeCnMessages(messages);
+    finalizeBuddyMessages(messages, { leadPrompt: CODEBUDDY_CN_NEUTRAL_PROMPT });
+  }
+  ensurePayloadModel(payload, candidate, "CodeBuddy CN");
+  normalizeBuddyToolNames(payload);
+  injectBuddyParallelToolCalls(payload, request);
+  void request;
+}
+
+export { CODEBUDDY_CN_RAW };
+
+export const CODEBUDDY_CN_IMAGE_MODELS: readonly ModelDefinition[] = makeBuddyCnImageModels(
+  CODEBUDDY_CN_PROVIDER_ID,
+  "/images/generations",
+);
+
+export const CODEBUDDY_CN_VIDEO_MODELS: readonly ModelDefinition[] = makeBuddyCnVideoModels(
+  CODEBUDDY_CN_PROVIDER_ID,
+  "/videos/generations",
+);
+
+export const CODEBUDDY_CN_MODELS: readonly ModelDefinition[] = [
+  ...CODEBUDDY_CN_RAW.filter(
+    (entry) =>
+      !BUDDY_CN_IMAGE_MODEL_ID_SET.has(entry[0]) &&
+      !BUDDY_CN_VIDEO_MODEL_ID_SET.has(entry[0]),
+  ).map((entry) =>
+    makeBuddyModel(entry, CODEBUDDY_CN_PROVIDER_ID, undefined, "cn"),
+  ),
+  ...CODEBUDDY_CN_IMAGE_MODELS,
+  ...CODEBUDDY_CN_VIDEO_MODELS,
+];
+
+export async function discoverCodeBuddyCnModels(
+  input: DiscoveryInput,
+): Promise<readonly ModelDefinition[] | null> {
+  return fetchBuddyDirectoryModels({
+    siteUrl: CODEBUDDY_CN_BASE_URL,
+    providerId: CODEBUDDY_CN_PROVIDER_ID,
+    credential: input.credential,
+    modelsPath: BUDDY_CN_MODELS_PATH,
+    endpoint: undefined,
+    ...(input.signal ? { signal: input.signal } : {}),
+    ...(input.fetcher ? { fetcher: input.fetcher } : {}),
+  });
+}
+
+export function createCodeBuddyCnAdapter(fetchImpl?: typeof fetch): ProviderAdapter {
+  // BuddyMediaAdapter, not OpenAICompatibleAdapter: the CN realm publishes an
+  // image-generation row, and the plain compatible adapter has no image path,
+  // so `hunyuan-image-alpha` would route to /chat/completions and fail.
+  return new BuddyMediaAdapter(
+    codebuddyAdapterConfig({
+      providerId: CODEBUDDY_CN_PROVIDER_ID,
+      baseUrl: CODEBUDDY_CN_BASE_URL,
+      variant: "CLI",
+      prePayload: codeBuddyCnPrePayload,
+      // The CN CLI profile gzips the chat body (donor behavior). The console
+      // channel fallback is an intl-only recovery; CN has no second endpoint.
+      requestCompression: "gzip",
+      ...(fetchImpl ? { fetchImpl } : {}),
+    }),
+    {
+      variant: "CLI",
+      // The CN realm has no separate system prompt of its own; the neutral CN
+      // prompt is applied by `codeBuddyCnPrePayload`, so the media config
+      // reuses the intl one purely to satisfy the required field. Image
+      // generation sends a prompt, not a conversation, so this turn is
+      // discarded by the image path in every case.
+      systemPrompt: CODEBUDDY_SYSTEM_PROMPT,
+      baseUrl: CODEBUDDY_CN_BASE_URL,
+      imageGenerationPath: "/images/generations",
+    },
+  );
+}
+
+// ── codebuddy/oauth ──────────────────────────────────────────
+
+const CODEBUDDY_INTL_DEVICE_START_URL = `${providerBaseUrl("cb")}/plugin/auth/state`;
+
+const CODEBUDDY_INTL_DEVICE_POLL_URL = `${providerBaseUrl("cb")}/plugin/auth/token`;
+
+const CODEBUDDY_INTL_REFRESH_URL = `${providerBaseUrl("cb")}/plugin/auth/token/refresh`;
+
+const CODEBUDDY_CN_DEVICE_START_URL = `${providerBaseUrl("cbcn")}/plugin/auth/state`;
+
+const CODEBUDDY_CN_DEVICE_POLL_URL = `${providerBaseUrl("cbcn")}/plugin/auth/token`;
+
+const CODEBUDDY_CN_REFRESH_URL = `${providerBaseUrl("cbcn")}/plugin/auth/token/refresh`;
+
+export const CODEBUDDY_INTL_VARIANT: BuddyOAuthVariant = {
+  providerId: "cb",
+  providerLabel: "CodeBuddy",
+  domain: "www.codebuddy.ai",
+  platform: "ide",
+  userAgent: async () => {
+    return buildCodeBuddyUserAgent("IDE");
+  },
+  deviceStartUrl: CODEBUDDY_INTL_DEVICE_START_URL,
+  devicePollUrl: CODEBUDDY_INTL_DEVICE_POLL_URL,
+  refreshUrl: CODEBUDDY_INTL_REFRESH_URL,
+  responseCode: strictResponseCode,
+};
+
+export const CODEBUDDY_CN_VARIANT: BuddyOAuthVariant = {
+  providerId: "cbcn",
+  providerLabel: "CodeBuddy",
+  domain: "copilot.tencent.com",
+  platform: "CLI",
+  userAgent: async () => {
+    return buildCodeBuddyUserAgent("CLI");
+  },
+  deviceStartUrl: CODEBUDDY_CN_DEVICE_START_URL,
+  devicePollUrl: CODEBUDDY_CN_DEVICE_POLL_URL,
+  refreshUrl: CODEBUDDY_CN_REFRESH_URL,
+  responseCode: strictResponseCode,
+};
+
+export const codeBuddyOAuthClient = new BuddyOAuthClient(CODEBUDDY_INTL_VARIANT);
+
+export const codeBuddyCnOAuthClient = new BuddyOAuthClient(CODEBUDDY_CN_VARIANT);
+
+// ── codebuddy/quota ──────────────────────────────────────────
+
+export const CODEBUDDY_CN_USAGE_URL =
+  `${providerBaseUrl("cbcn")}/billing/meter/get-user-resource`;
+
+export const CODEBUDDY_INTL_USAGE_URL =
+  `${providerBaseUrl("cb")}/billing/meter/get-user-resource`;
+
+const CODEBUDDY_CN_REQUEST_USAGE_URL =
+  `${providerBaseUrl("cbcn")}/billing/meter/get-user-request-usage`;
+
+const CODEBUDDY_INTL_REQUEST_USAGE_URL =
+  `${providerBaseUrl("cb")}/billing/meter/get-user-request-usage`;
+
+type CodeBuddyProviderId = "cb" | "cbcn";
+
+async function cnHeaders(enterpriseId?: string): Promise<Record<string, string>> {
+  return {
+    "User-Agent": buildCodeBuddyUserAgent("CLI"),
+    "X-Product": "SaaS",
+    "X-IDE-Type": "CLI",
+    "X-IDE-Name": "CLI",
+    "X-Domain": codebuddyDomain("CLI"),
+    "x-requested-with": "XMLHttpRequest",
+    "x-codebuddy-request": "1",
+    ...(enterpriseId === undefined || enterpriseId.length === 0
+      ? {}
+      : { "X-Tenant-Id": enterpriseId, "X-Enterprise-Id": enterpriseId }),
+  };
+}
+
+async function intlHeaders(enterpriseId?: string): Promise<Record<string, string>> {
+  return {
+    "User-Agent": buildCodeBuddyUserAgent("IDE"),
+    "X-Product": "SaaS",
+    "X-IDE-Type": "IDE",
+    "X-IDE-Name": "IDE",
+    "X-Domain": codebuddyDomain("IDE"),
+    "x-requested-with": "XMLHttpRequest",
+    "x-codebuddy-request": "1",
+    ...(enterpriseId === undefined || enterpriseId.length === 0
+      ? {}
+      : { "X-Tenant-Id": enterpriseId, "X-Enterprise-Id": enterpriseId }),
+  };
+}
+
+function parseProviderId(providerId: string): CodeBuddyProviderId {
+  const value = providerId.trim().toLowerCase();
+  if (value === "cb") return "cb";
+  if (value === "cbcn") return "cbcn";
+  throw new Error(`Unsupported CodeBuddy provider ${providerId}`);
+}
+
+async function providerConfig(
+  providerId: CodeBuddyProviderId,
+  enterpriseId?: string,
+): Promise<{
+  url: string;
+  headers: Record<string, string>;
+  display: string;
+}> {
+  if (providerId === "cb") {
+    return { url: CODEBUDDY_INTL_USAGE_URL, headers: await intlHeaders(enterpriseId), display: "CodeBuddy" };
+  }
+  return { url: CODEBUDDY_CN_USAGE_URL, headers: await cnHeaders(enterpriseId), display: "CodeBuddy CN" };
+}
+
+export async function fetchCodeBuddyQuota(
+  credential: string,
+  fetcher: FetchLike,
+  providerId: string = "cbcn",
+  enterpriseId?: string,
+): Promise<ProviderQuotaResult> {
+  const source = parseProviderId(providerId);
+  const cfg = await providerConfig(source, enterpriseId);
+  return fetchTencentBillingQuota({
+    source,
+    display: cfg.display,
+    url: cfg.url,
+    headers: cfg.headers,
+    credential,
+    fetcher,
+    defaultPlan: "CodeBuddy",
+  });
+}
+
+export const fetchCodeBuddyCnQuota = (
+  credential: string,
+  fetcher: FetchLike,
+): Promise<ProviderQuotaResult> => fetchCodeBuddyQuota(credential, fetcher, "cbcn");
+
+export const fetchCodeBuddyIntlQuota = (
+  credential: string,
+  fetcher: FetchLike,
+): Promise<ProviderQuotaResult> => fetchCodeBuddyQuota(credential, fetcher, "cb");
+
+export async function fetchCodeBuddyRequestUsage(
+  credential: string,
+  fetcher: FetchLike,
+  providerId: string = "cbcn",
+  days: number = 30,
+  enterpriseId?: string,
+): Promise<BuddyUsageResult> {
+  const source = parseProviderId(providerId);
+  const cfg = await providerConfig(source, enterpriseId);
+  return fetchBuddyRequestUsage({
+    url:
+      source === "cb" ? CODEBUDDY_INTL_REQUEST_USAGE_URL : CODEBUDDY_CN_REQUEST_USAGE_URL,
+    headers: cfg.headers,
+    credential,
+    fetcher,
+    days,
+  });
+}