cartethyia 2.7.0 → 2.7.1

package/src/providers/discovery/probing-service.ts

@@ -192,7 +192,7 @@ export class ProviderProbingService {
     const providerWireRow = await this.loadProviderWireRow(providerId);
     const requiresAccount = providerWireRow?.requiresAccount ?? true;
 
-    const { wireFamily, serviceKind, endpointPath, sourceSurface, capabilityProfile } = await resolveProbeTarget({
+    const { wireFamily, serviceKind, endpointPath, sourceSurface, capabilityProfile, outputLimit } = await resolveProbeTarget({
       db: this.db,
       bundledModelCatalog: this.bundledModelCatalog,
       defaultEndpoints: this.defaultEndpoints,
@@ -253,6 +253,9 @@ export class ProviderProbingService {
       // over capabilities the route actually has (`prompt_caching`, `tools`,
       // `reasoning`), reporting a healthy provider as broken.
       capabilities: capabilityProfile,
+      // The model row's own output ceiling, so a probe with a max-output
+      // ceiling (OpenCode free) shapes with the model's limit, not a guess.
+      ...(outputLimit == null ? {} : { output_limit: outputLimit }),
     };
 
     const probeSignal = AbortSignal.timeout(30_000);

package/src/providers/integrations/anthropic.ts

@@ -17,7 +17,7 @@ import type { CanonicalEvent, CanonicalRequest } from "../../protocol/canonical-
 import { GatewayError } from "../../protocol/gateway-error";
 import { buildClaudeMessagesRequest, filterClaudeCustomHeaders } from "./shared/claude-messages";
 import { sendClaudeMessagesRequest } from "../../protocol/upstream/send-claude-messages";
-import { applyParamQuirks } from "../../transport/translation/quirks";
+import { applyParamQuirks } from "../../protocol/translation/quirks";
 import type { ProviderDispatchTarget, ProviderAdapter, ProviderDispatchContext, ProviderId } from "../provider-contracts";
 import { providerBaseUrl } from "../provider-metadata";
 

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

@@ -42,7 +42,6 @@ export const BUDDY_INTL_EFFORTS: Readonly<Record<string, readonly string[]>> = {
   "glm-5.2": ["high", "xhigh"],
   "glm-5.3": ["low", "high", "max"],
   hy3: ["low", "high"],
-  "hy3-preview": ["low", "high"],
   "hy4-preview-f": ["high"],
 };
 export const BUDDY_CN_EFFORTS: Readonly<Record<string, readonly string[]>> = {
@@ -54,7 +53,6 @@ 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"],
-  "hy3-preview": ["low", "high"],
   "hy4-preview": ["high"],
 };
 
@@ -336,7 +334,7 @@ export const BUDDY_SHARED_RAW: readonly BuddyRawEntry[] = [
   ["glm-5.1", "GLM-5.1", true, false, 200_000, 131_072],
   ["glm-5.2", "GLM-5.2", true, true, 1_000_000, 48_000],
   ["glm-5.3", "GLM-5.3", true, true, 1_000_000, 48_000],
-  ["glm-5.3-flash", "GLM-5.3 Flash", true, true, 1_000_000, 32_000],
+  ["glm-5.3-flash", "GLM-5.3 Flash", true, false, 1_000_000, 32_000],
   ["glm-5v-turbo", "GLM-5V Turbo", true, true, 200_000, 131_072],
   ["gpt-5.3-codex", "GPT-5.3 Codex", true, true, 400_000, 128_000],
   ["gpt-5.4", "GPT-5.4", true, true, 272_000, 72_000],
@@ -351,7 +349,6 @@ 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],
-  ["hy3-preview", "Hy3 Preview", true, false, 262_144, 64_000],
   ["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],
   ["kimi-k2.5", "Kimi K2.5", true, false, 164_000, 262_144],

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

@@ -21,14 +21,14 @@ import { createHash } from "node:crypto";
 import { completeRequiredSchema } from "../../../protocol/codecs";
 import type { CanonicalRequest } from "../../../protocol/canonical-model";
 import { isRecord } from "../../../protocol/codecs";
-import { applyDeepSeekReasoning, applyOpenAIReasoning, backfillDeepSeekReasoningContent, clampedEffortOutputFloor } from "../../provider-reasoning";
+import { applyDeepSeekReasoning, applyOpenAIReasoning, backfillDeepSeekReasoningContent, clampedEffortOutputFloor } from "../../../protocol/reasoning";
 import { BUDDY_CN_EFFORTS, BUDDY_INTL_EFFORTS, BUDDY_SHARED_RAW } from "./buddy-catalog-shared";
 // 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-provider";
+import { CODEBUDDY_CN_RAW } from "./codebuddy/cn-catalog";
 import { buddyAccountUid } from "./buddy-oauth-shared";
 import type { ProviderDispatchContext } from "../../provider-contracts";
 
@@ -987,13 +987,146 @@ export function ensureBuddyLeadingSystem(
  * (`11151`), then guarantee a leading system turn (`11128`). The system text
  * is the variant's own prompt, so each pre-payload hook passes its prompt in.
  */
-function finalizeBuddyMessages(
+/**
+ * Longest message text that gets an automatic ephemeral prompt-cache marker,
+ * mirroring the reference gateway (`MIN_AUTO_CACHE_TEXT_LENGTH`).
+ */
+const MIN_AUTO_CACHE_TEXT_LENGTH = 1024;
+
+/**
+ * Marks one message's text content cacheable in place: the system turn and the
+ * last user turn are the long, stable ones a prefix cache serves best. A
+ * string message becomes a typed text block; a text part inside an array gets
+ * `cache_control: {type: "ephemeral"}`. Only the first qualifying text part of
+ * a message is marked, like the reference.
+ */
+function markCacheableTextContent(message: Record<string, unknown>): void {
+  const content = message["content"];
+  if (typeof content === "string") {
+    if (content.trim().length >= MIN_AUTO_CACHE_TEXT_LENGTH) {
+      message["content"] = [
+        { type: "text", text: content, cache_control: { type: "ephemeral" } },
+      ];
+    }
+    return;
+  }
+  if (!Array.isArray(content)) return;
+  for (let index = 0; index < content.length; index += 1) {
+    const part = content[index];
+    if (!isRecord(part) || part["type"] !== "text") continue;
+    const text = typeof part["text"] === "string" ? part["text"] : "";
+    if (text.trim().length >= MIN_AUTO_CACHE_TEXT_LENGTH && part["cache_control"] === undefined) {
+      content[index] = { ...part, cache_control: { type: "ephemeral" } };
+      return;
+    }
+  }
+}
+
+/**
+ * Auto-injects ephemeral prompt-cache markers on the system turn and the last
+ * user turn when the caller declared none. Mirrors `applyPromptCacheControl` in
+ * the reference gateway: an explicit `cache_control` anywhere is respected and
+ * disables the auto-pass so the caller's own caching strategy wins.
+ */
+export function applyBuddyAutoPromptCache(messages: Array<Record<string, unknown>>): void {
+  const hasExplicit = messages.some((message) =>
+    Array.isArray(message["content"]) &&
+    (message["content"] as Array<Record<string, unknown>>).some(
+      (part) => isRecord(part) && part["cache_control"] !== undefined,
+    ),
+  );
+  if (hasExplicit) return;
+  if (messages.length === 0) return;
+  const first = messages[0];
+  if (isRecord(first) && first["role"] === "system") markCacheableTextContent(first);
+  let lastUser = -1;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (isRecord(messages[index]) && messages[index]!["role"] === "user") {
+      lastUser = index;
+      break;
+    }
+  }
+  if (lastUser >= 0) markCacheableTextContent(messages[lastUser]!);
+}
+
+/**
+ * Strips the `content` key from assistant tool_calls-only turns.
+ *
+ * Mirrors the reference gateway's OpenAI transcript: an assistant turn that
+ * only asks for tools carries `tool_calls` and no content at all (Go's
+ * `omitzero`-style SDKs omit the key rather than send `null`/`""`). Keeping
+ * an empty string content invites the upstream to fall back to its prose/DSML
+ * channel; omitting the key keeps it on the structured `tool_calls` channel.
+ */
+export function omitBuddyAssistantToolCallContent(messages: Array<Record<string, unknown>>): void {
+  for (const message of messages) {
+    if (!isRecord(message) || message["role"] !== "assistant") continue;
+    const calls = message["tool_calls"];
+    if (!Array.isArray(calls) || calls.length === 0) continue;
+    const content = message["content"];
+    if (typeof content === "string" && content.trim().length === 0) {
+      delete message["content"];
+    } else if (Array.isArray(content) && content.length === 0) {
+      delete message["content"];
+    }
+  }
+}
+
+/**
+ * Forwards the caller's parallel tool-call intent onto the buddy wire.
+ *
+ * The canonical control is `generation_controls.parallel_tool_calls`; the
+ * reference gateway always passes it through so upstream keeps the structured
+ * tool channel, and the same is applied here.
+ */
+export function injectBuddyParallelToolCalls(
+  payload: Record<string, unknown>,
+  request: CanonicalRequest,
+): void {
+  const parallel = request.generation_controls?.parallel_tool_calls;
+  if (parallel !== undefined) payload["parallel_tool_calls"] = parallel;
+}
+
+export interface BuddyMessageFinalizeOptions {
+  /** The fixed leading system prompt installed on the wire. */
+  readonly leadPrompt: string;
+  /** Coalesce consecutive user turns (default true). */
+  readonly coalesceConsecutiveUser?: boolean;
+  /** Drop empty-content turns the upstream rejects (default true). */
+  readonly dropEmpty?: boolean;
+  /** Guarantee the wire opens with a system turn (default true). */
+  readonly ensureLeadingSystem?: boolean;
+  /** Omit content on assistant tool_calls-only turns (default true). */
+  readonly omitToolCallContent?: boolean;
+  /** Auto-inject ephemeral prompt-cache markers (default true). */
+  readonly autoPromptCache?: boolean;
+}
+
+/**
+ * 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.
+ */
+export function finalizeBuddyMessages(
   messages: Array<Record<string, unknown>>,
-  systemPrompt: string,
+  options: BuddyMessageFinalizeOptions,
 ): void {
-  coalesceConsecutiveUserMessages(messages);
-  dropEmptyBuddyMessages(messages);
-  ensureBuddyLeadingSystem(messages, systemPrompt);
+  if (options.coalesceConsecutiveUser !== false) {
+    coalesceConsecutiveUserMessages(messages);
+  }
+  if (options.dropEmpty !== false) {
+    dropEmptyBuddyMessages(messages);
+  }
+  if (options.ensureLeadingSystem !== false) {
+    ensureBuddyLeadingSystem(messages, options.leadPrompt);
+  }
+  if (options.omitToolCallContent !== false) {
+    omitBuddyAssistantToolCallContent(messages);
+  }
+  if (options.autoPromptCache !== false) {
+    applyBuddyAutoPromptCache(messages);
+  }
 }
 
 /**
@@ -1035,5 +1168,5 @@ export function applyBuddySystemPrompt(
       messages.push({ ...message });
     }
   }
-  finalizeBuddyMessages(messages, systemPrompt);
+  finalizeBuddyMessages(messages, { leadPrompt: systemPrompt });
 }

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

@@ -24,6 +24,7 @@ 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,
@@ -38,7 +39,10 @@ import { codebuddyDomain, type CodeBuddyVariant } from "./codebuddy/shared";
  * shared family set so this list cannot drift from the health recorder's or the
  * request preparer's.
  */
-export const DAILY_CHECKIN_PROVIDER_IDS: readonly string[] = [...BUDDY_PROVIDER_IDS];
+export const DAILY_CHECKIN_PROVIDER_IDS: readonly string[] = [
+  ...BUDDY_PROVIDER_IDS,
+  ...QODER_CHECKIN_PROVIDER_IDS,
+];
 
 /** Abort budget for one upstream check-in request. */
 const TIMEOUT_MS = 15_000;

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

@@ -337,35 +337,6 @@ export async function redeemBuddyStreakTier(
 // 3. Streak lottery
 // ---------------------------------------------------------------------------
 
-const LOTTERY_CHANCES_PATH = "/activity/growth/lottery/chances";
-const LOTTERY_DRAW_PATH = "/activity/growth/lottery/draw";
-
-/** Remaining draw chances granted by a redeemed tier. */
-export async function readBuddyLotteryChances(
-  options: BuddyGrowthCall,
-): Promise<number | null> {
-  const reply = await call(options, "GET", LOTTERY_CHANCES_PATH);
-  if (!reply.ok || reply.data === null) return null;
-  const value = Number(reply.data["balance"]);
-  return Number.isFinite(value) ? value : null;
-}
-
-/**
- * Draws once. A fresh `client_token` per draw: reusing one lets the upstream
- * treat the draw as a duplicate and swallow it.
- */
-export async function drawBuddyLottery(
-  options: BuddyGrowthCall,
-): Promise<BuddyGrowthResult> {
-  const reply = await call(options, "POST", LOTTERY_DRAW_PATH, {
-    client_token: clientToken(options, "draw"),
-  });
-  if (refused(reply, 400, ["insufficient", "disabled", "no chance", "未开启"])) {
-    return { state: "not_eligible", error: null, credit: null };
-  }
-  return done(reply);
-}
-
 // ---------------------------------------------------------------------------
 // 4. Cat travel
 // ---------------------------------------------------------------------------
@@ -523,56 +494,3 @@ export async function adoptFirstBuddy(
   return done(reply);
 }
 
-// ---------------------------------------------------------------------------
-// 6. Trial gift pack + gift/compensation claims
-// ---------------------------------------------------------------------------
-
-const TRIAL_PATH = "/billing/ide/trial";
-const GIFT_PATH = "/billing/meter/claim-gift";
-const COMPENSATION_PATH = "/billing/meter/claim-compensation";
-/** "Already claimed" on the trial pack. */
-const TRIAL_ALREADY_CODE = 14051;
-
-/**
- * Claims the one-off trial credit pack.
- *
- * International only: the reference reports the CN hosts do not serve this
- * endpoint at all, and a 404 there is a `skip`, not a failure.
- */
-export async function claimBuddyTrial(
-  options: BuddyGrowthCall,
-): Promise<BuddyGrowthResult> {
-  const reply = await call(options, "POST", TRIAL_PATH, {});
-  if (coded(reply, TRIAL_ALREADY_CODE) || refused(reply, 400, ["14051"])) {
-    return { state: "already", error: null, credit: null };
-  }
-  // Not served on this host at all — a 404/405 here is a routing fact, not an
-  // account problem.
-  if (reply.status === 404 || reply.status === 405) {
-    return { state: "skipped", error: null, credit: null };
-  }
-  return done(reply);
-}
-
-/**
- * Claims the newcomer gift, if one is present.
- *
- * Once per account; a business error afterwards is the normal "already claimed"
- * answer and is never a failure.
- */
-export async function claimBuddyGift(
-  options: BuddyGrowthCall,
-): Promise<BuddyGrowthResult> {
-  const reply = await call(options, "POST", GIFT_PATH, {});
-  if (!reply.ok) return { state: "already", error: null, credit: null };
-  return done(reply);
-}
-
-/** Claims an activity compensation, if one is present. Same once-only semantics. */
-export async function claimBuddyCompensation(
-  options: BuddyGrowthCall,
-): Promise<BuddyGrowthResult> {
-  const reply = await call(options, "POST", COMPENSATION_PATH, {});
-  if (!reply.ok) return { state: "already", error: null, credit: null };
-  return done(reply);
-}

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

@@ -1,4 +1,5 @@
 import type { ProviderDispatchContext } from "../../provider-contracts";
+import { createHash } from "node:crypto";
 import { decodeJwtPayload } from "../../authentication/oauth-flow-store";
 
 /**
@@ -96,3 +97,27 @@ export function buddyEnterprise(context?: ProviderDispatchContext): string | und
   }
   return undefined;
 }
+
+/**
+ * Per-account device binding (`qimei36`) for the buddy providers.
+ *
+ * The desktop auth state sends `X-Device-Id-List: {"qimei36":"…"}` alongside
+ * the Turing token — a second, independent device identity. Pinning it per
+ * account makes every account in a pool present a distinct device to the
+ * upstream risk control instead of sharing the machine's single fingerprint.
+ *
+ * Resolution order:
+ * 1. `auth_state.qimei36` — explicit operator-set binding (imported or edited).
+ * 2. Determinstic derivation from the internal account id (sha256 → 32 hex).
+ *    This keeps the binding stable across restarts without a database write,
+ *    and gives each freshly-added account its own id automatically.
+ *
+ * Returns `undefined` only when no account id is available (unauthenticated).
+ */
+export function resolveBuddyDeviceBinding(context?: ProviderDispatchContext): string | undefined {
+  const explicit = context?.credential.auth_state?.["qimei36"];
+  if (typeof explicit === "string" && explicit.trim().length > 0) return explicit.trim();
+  const accountId = context?.credential.account_id;
+  if (accountId === undefined || accountId.length === 0) return undefined;
+  return createHash("sha256").update(`wb2a:qimei36:${accountId}`).digest("hex").slice(0, 32);
+}

package/src/providers/integrations/buddy/buddy-server-tools.ts

@@ -0,0 +1,240 @@
+/**
+ * Gateway-executed "server tools" for the Buddy family, ported from the
+ * reference gateway (`lib/server/proxy/server-tools/` in `codebuddy2api`).
+ *
+ * Some clients ask the *provider* to run a web tool by declaring a
+ * provider-executed type: Anthropic sends `web_search_20250305` /
+ * `web_fetch_20250910`, the Responses API sends `web_search_preview`.
+ * Upstream CodeBuddy has none of these, so the gateway executes the call
+ * against a backend and hands the findings back as if upstream had produced
+ * them.
+ *
+ * The distinction is declaration-driven, never name-driven: a client's own
+ * ordinary `function` named `WebSearch` (Claude Code) is resolved by the
+ * client, and the gateway must not pick it up. Only calls whose *declared
+ * type* carries the provider-executed prefix are server tools.
+ *
+ * This module is the pure engine: classification, invocation building,
+ * execution against injected backends, and the transcript messages a follow-up
+ * upstream call needs. The streaming loop that re-drives the upstream within
+ * one request is the adapter-side consumer.
+ */
+import type { ToolDefinition } from "../../../protocol/canonical-model";
+
+export type ServerToolKind = "web_search" | "web_fetch";
+
+export interface ServerToolDeclaration {
+  readonly kind: ServerToolKind;
+  readonly name: string;
+}
+
+export interface ServerToolInvocation {
+  readonly id: string;
+  readonly kind: ServerToolKind;
+  readonly rawArguments: string;
+}
+
+export interface ServerToolRunResult {
+  /** Text handed back upstream as the tool's result message. */
+  readonly content: string;
+  readonly toolCallId: string;
+}
+
+export interface ServerToolExecutor {
+  /** Runs one web fetch; `null` means the backend is unavailable. */
+  readonly fetch?: ((input: { url: string }) => Promise<string>) | undefined;
+  /** Runs one web search; `null` means the backend is unavailable. */
+  readonly search?: ((input: { query: string }) => Promise<string>) | undefined;
+}
+
+/** The declared-type prefixes the provider-executed tools carry. */
+const SEARCH_TYPE_PREFIX = "web_search_";
+const FETCH_TYPE_PREFIX = "web_fetch_";
+
+function normalizeTypeName(value: string): string {
+  return value.trim().toLowerCase().replace(/[_-]+/g, " ");
+}
+
+function classifyByType(type: string): ServerToolKind | null {
+  const normalized = normalizeTypeName(type);
+  if (normalized.startsWith(normalizeTypeName(SEARCH_TYPE_PREFIX))) return "web_search";
+  if (normalized.startsWith(normalizeTypeName(FETCH_TYPE_PREFIX))) return "web_fetch";
+  return null;
+}
+
+/**
+ * Classifies one canonical tool declaration, or returns `null` for a
+ * client-owned tool. Only the declared type counts; the name is never
+ * consulted, so a client function named `WebSearch` is never mistaken for the
+ * server tool. `native_type` retains the raw Anthropic/OpenAI type spelling
+ * (`web_search_20250305`, `web_fetch_20250910`) when the surface carries one;
+ * otherwise the normalized `tool_type` decides.
+ */
+export function classifyServerToolDeclaration(tool: ToolDefinition): ServerToolKind | null {
+  const raw = tool.native_type?.trim();
+  if (raw !== undefined && raw.length > 0) {
+    const byRaw = classifyByType(raw);
+    if (byRaw !== null) return byRaw;
+  }
+  if (tool.tool_type === "web_search") return "web_search";
+  if (tool.tool_type !== undefined && tool.tool_type !== "function") {
+    const byType = classifyByType(tool.tool_type);
+    if (byType !== null) return byType;
+  }
+  return null;
+}
+
+/** Indexes declared server tools by the name a call would carry. */
+export function findServerToolDeclarations(
+  tools: readonly ToolDefinition[] | undefined,
+): Map<string, ServerToolKind> {
+  const out = new Map<string, ServerToolKind>();
+  for (const tool of tools ?? []) {
+    const kind = classifyServerToolDeclaration(tool);
+    if (kind !== null) out.set(tool.name, kind);
+  }
+  return out;
+}
+
+/** True when a call's name matches a declared server tool. */
+export function isServerToolCall(
+  name: string,
+  declared: ReadonlyMap<string, ServerToolKind>,
+): boolean {
+  return declared.has(name);
+}
+
+function parseJsonArguments(raw: string): Record<string, unknown> {
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>;
+    }
+  } catch {
+    // fall through
+  }
+  return {};
+}
+
+/** Builds one invocation from a tool call, kind already classified. */
+export function buildServerToolInvocation(
+  callId: string,
+  name: string,
+  kind: ServerToolKind,
+  rawArguments: string,
+): ServerToolInvocation {
+  return { id: callId || `server_tool_${name}`, kind, rawArguments };
+}
+
+function textOf(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function safeFetchUrl(url: string): string | null {
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return null;
+  return parsed.toString();
+}
+
+/**
+ * Runs one invocation against the injected backend. Failures become text
+ * rather than exceptions: the arguments came from the model, so the useful
+ * outcome is for it to see what went wrong and retry or answer without the
+ * findings — not for the whole turn to fail.
+ */
+async function runOne(
+  executor: ServerToolExecutor,
+  invocation: ServerToolInvocation,
+): Promise<ServerToolRunResult> {
+  const args = parseJsonArguments(invocation.rawArguments);
+  if (invocation.kind === "web_fetch") {
+    const url = safeFetchUrl(textOf(args["url"] ?? args["target"]));
+    if (url === null) {
+      return {
+        toolCallId: invocation.id,
+        content: "web_fetch failed: the model supplied an invalid or unsupported URL and nothing was fetched.",
+      };
+    }
+    if (executor.fetch === undefined) {
+      return {
+        toolCallId: invocation.id,
+        content: "web_fetch unavailable: the gateway has no fetch backend configured.",
+      };
+    }
+    try {
+      const content = await executor.fetch({ url });
+      return { toolCallId: invocation.id, content };
+    } catch (error) {
+      return {
+        toolCallId: invocation.id,
+        content: `web_fetch failed: ${error instanceof Error ? error.message : String(error)}`,
+      };
+    }
+  }
+  const query = textOf(args["query"]);
+  if (query.length === 0) {
+    return {
+      toolCallId: invocation.id,
+      content: "web_search failed: the model supplied an empty query and nothing was searched.",
+    };
+  }
+  if (executor.search === undefined) {
+    return {
+      toolCallId: invocation.id,
+      content: "web_search unavailable: the gateway has no search backend configured.",
+    };
+  }
+  try {
+    const content = await executor.search({ query });
+    return { toolCallId: invocation.id, content };
+  } catch (error) {
+    return {
+      toolCallId: invocation.id,
+      content: `web_search failed: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+/** Runs every invocation and returns one tool message per call. */
+export async function executeServerToolInvocations(
+  executor: ServerToolExecutor,
+  invocations: readonly ServerToolInvocation[],
+): Promise<readonly ServerToolRunResult[]> {
+  return Promise.all(invocations.map((invocation) => runOne(executor, invocation)));
+}
+
+/**
+ * Builds the transcript messages a follow-up upstream call needs: the
+ * assistant turn carrying the calls, then one `tool` result per call. Matches
+ * the OpenAI-shaped transcript the buddy upstream expects.
+ */
+export function buildServerToolFollowUpMessages(
+  assistantToolCalls: Array<{ id: string; name: string; arguments: string }>,
+  results: readonly ServerToolRunResult[],
+): Array<Record<string, unknown>> {
+  const messages: Array<Record<string, unknown>> = [];
+  if (assistantToolCalls.length > 0) {
+    messages.push({
+      role: "assistant",
+      content: "",
+      tool_calls: assistantToolCalls.map((call) => ({
+        id: call.id,
+        type: "function",
+        function: { name: call.name, arguments: call.arguments },
+      })),
+    });
+  }
+  for (const result of results) {
+    messages.push({
+      role: "tool",
+      tool_call_id: result.toolCallId,
+      content: result.content,
+    });
+  }
+  return messages;
+}

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

@@ -0,0 +1,36 @@
+/**
+ * CodeBuddy CN model roster, isolated in a leaf module.
+ *
+ * `buddy-chat-shared` needs the raw table to answer output-limit lookups for
+ * CN-only ids, and `cn-provider` builds its catalog from it. Keeping the table
+ * here — instead of inside `cn-provider` — removes the load-time import cycle
+ * between `buddy-chat-shared` ⇄ `cn-provider` (and its buddy-media/provider
+ * variants): both sides import this module, and this module imports nothing
+ * back.
+ */
+import type { BuddyRawEntry } from "../buddy-catalog-shared";
+
+export const CODEBUDDY_CN_RAW: readonly BuddyRawEntry[] = [
+  ["glm-5.1", "GLM 5.1", true, true, 200_000, 48_000],
+  ["glm-5.2", "GLM 5.2", true, true, 1_000_000, 64_000],
+  ["glm-5.3", "GLM 5.3", true, true, 1_000_000, 64_000],
+  ["glm-5.3-flash", "GLM 5.3 Flash", true, true, 1_000_000, 131_072],
+  ["glm-5v-turbo", "GLM 5v Turbo", true, true, 200_000, 64_000],
+  ["minimax-m3", "MiniMax M3", true, true, 512_000, 64_000],
+  // 1M context, reasoning always on (upstream states both); vision inherited
+  // from the M3 row, which is the same family.
+  ["minimax-m3.1-flash", "MiniMax M3.1 Flash", true, true, 1_000_000, 128_000],
+  ["mimo-v2.6-pro", "MiMo V2.6 Pro", true, true, 1_000_000, 128_000],
+  ["kimi-k2.8-preview", "Kimi K2.8 Preview", true, true, 1_000_000, 64_000],
+  ["kimi-k3.1-pro", "Kimi K3.1 Pro", true, true, 1_000_000, 32_000],
+  ["hy3", "Hy3", true, true, 192_000, 64_000],
+  ["hy4-preview", "Hy4 Preview", true, true, 960_000, 64_000],
+  ["space-bunny", "Space Bunny", true, true, 1_000_000, 128_000],
+  ["step-5-preview", "Step 5 Preview", true, true, 1_000_000, 64_000],
+  ["deepseek-v4-pro", "DeepSeek V4 Pro", true, true, 1_000_000, 128_000],
+  ["deepseek-v4.1-flash", "DeepSeek V4.1 Flash", true, true, 1_000_000, 128_000],
+  // Live on the CN roster but absent here, so a request for it resolved to
+  // nothing. Limits as published by /v3/config.
+  ["kimi-k3-1", "Kimi K3-1", true, true, 1_000_000, 32_000],
+  ["minimax-m2.7", "MiniMax M2.7", true, true, 200_000, 48_000],
+];