cartethyia 2.7.9 → 2.8.1

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

@@ -1,417 +0,0 @@
-import { asNumber as sharedAsNumber } from "../../../shared/coerce";
-
-/**
- * Shared Tencent billing-meter parsing for the CodeBuddy family
- * (`cb`, `cbcn`).
- *
- * All three read the same endpoint shape — POST
- * `{base}/v2/billing/meter/get-user-resource` answering
- * `{ code, data: { Response: { Data: { Accounts: [...] } } } }` — and derive
- * the same windows from it: refill vs bonus is split by
- * `DeductionEndTime - CycleEndTime > 2d`, cadence labels are
- * Daily/Weekly/Monthly with dedup, and bonuses are `Bonus Pack N` sorted by
- * expiry. Only the endpoint, the identity headers, and the display name differ,
- * so those stay in each provider module and the envelope arithmetic lives here.
- */
-import type {
-  FetchLike,
-  ProviderQuotaResult,
-  ProviderQuotaWindow,
-} from "../../quota/quota-contracts";
-import { cleanError, percentWindow, record as asRecord, text as asText } from "../../quota/quota-contracts";
-
-/**
- * One `Accounts[]` entry of the Tencent billing envelope.
- *
- * The `*Precise` string fields are exact and preferred; the plain numeric
- * fields are the lossy fallback. Extra fields are tolerated rather than
- * rejected, matching the upstream payload's open shape.
- */
-export interface TencentBillingAccount {
-  readonly PackageName?: string | null;
-  readonly SubProductName?: string | null;
-  // Refill cycle live numbers.
-  readonly CycleCapacityUsedPrecise?: string | number | null;
-  readonly CycleCapacityUsed?: number | null;
-  readonly CycleCapacitySizePrecise?: string | number | null;
-  readonly CycleCapacitySize?: number | null;
-  // Bonus lifetime numbers.
-  readonly CapacityUsedPrecise?: string | number | null;
-  readonly CapacityUsed?: number | null;
-  readonly CapacitySizePrecise?: string | number | null;
-  readonly CapacitySize?: number | null;
-  // Cadence + expiry.
-  readonly CycleStartTime?: string | number | null;
-  readonly CycleEndTime?: string | number | null;
-  readonly DeductionEndTime?: string | number | null;
-  readonly [key: string]: unknown;
-}
-
-/** A bonus window whose expiry trails the cycle end by more than this is a refill. */
-const REFILL_GAP_MS = 2 * 24 * 60 * 60 * 1000;
-const TIMEOUT_MS = 15_000;
-
-/**
- * Handles Date | seconds/ms | numeric string | ISO → ISO string.
- *
- * Values below 1e12 are read as seconds; the upstream mixes both units across
- * accounts, so the magnitude decides rather than the field.
- */
-export function parseBillingResetTime(value: unknown): string | null {
-  if (value === null || value === undefined || value === "") return null;
-  try {
-    if (value instanceof Date) return value.toISOString();
-    if (typeof value === "number") {
-      if (!Number.isFinite(value)) return null;
-      return new Date(value < 1e12 ? value * 1000 : value).toISOString();
-    }
-    if (typeof value === "string") {
-      const trimmed = value.trim();
-      if (!trimmed) return null;
-      if (/^\d+$/.test(trimmed)) {
-        const timestamp = Number(trimmed);
-        if (!Number.isFinite(timestamp)) return null;
-        return new Date(timestamp < 1e12 ? timestamp * 1000 : timestamp).toISOString();
-      }
-      const d = new Date(trimmed);
-      return Number.isFinite(d.getTime()) ? d.toISOString() : null;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-/** Prefer the `*Precise` string field (exact), fall back to the numeric one. */
-export function billingNum(precise: unknown, plain: unknown): number {
-  const n = Number(precise ?? plain);
-  return Number.isFinite(n) ? n : 0;
-}
-
-/** Cadence label derived from the refill cycle's own span. */
-function refillCadence(acc: TencentBillingAccount): string {
-  const start = parseBillingResetTime(acc.CycleStartTime);
-  const end = parseBillingResetTime(acc.CycleEndTime);
-  if (start && end) {
-    const days = (new Date(end).getTime() - new Date(start).getTime()) / 86_400_000;
-    if (days <= 1.5) return "Daily";
-    if (days <= 10) return "Weekly";
-  }
-  return "Monthly";
-}
-
-/**
- * Resolves the bearer secret from a stored credential.
- *
- * The same account can be stored as a bare API key or as the OAuth envelope
- * JSON (`{accessToken, apiKey, token, ...}`), so both shapes resolve here and a
- * non-JSON credential passes through unchanged.
- */
-// Exported: the usage-detail read (`buddy-usage-shared.ts`) needs the same
-// credential resolution and must not re-implement it — an account stored as an
-// OAuth envelope has to resolve identically on both surfaces.
-export function resolveBearerToken(credential: string): string | null {
-  const trimmed = credential.trim();
-  if (!trimmed) return null;
-  if (trimmed.startsWith("{")) {
-    try {
-      const parsed = JSON.parse(trimmed) as Record<string, unknown>;
-      const rec = asRecord(parsed);
-      if (rec) {
-        const candidate =
-          asText(rec.accessToken) ??
-          asText(rec.access_token) ??
-          asText(rec.apiKey) ??
-          asText(rec.api_key) ??
-          asText(rec.token);
-        if (candidate) return candidate;
-      }
-    } catch {
-      // fall through to raw credential
-    }
-  }
-  return trimmed;
-}
-
-/**
- * Reads `data.Response.Data.Accounts` (the double-wrapped Tencent envelope).
- *
- * The exact path is tried first; the lowercase and single-wrapped variants are
- * accepted because the two regional gateways differ in casing.
- */
-function extractBillingAccounts(parsed: unknown): TencentBillingAccount[] {
-  const root = asRecord(parsed) ?? {};
-  const outerData = asRecord(root.data) ?? root;
-  const responseRecord =
-    asRecord(outerData["Response"]) ?? asRecord(outerData["response"]) ?? outerData;
-  const innerData =
-    asRecord(responseRecord["Data"]) ?? asRecord(responseRecord["data"]) ?? responseRecord;
-  const rawAccounts = innerData["Accounts"] ?? innerData["accounts"] ?? [];
-  if (!Array.isArray(rawAccounts)) return [];
-  return rawAccounts
-    .map((item) => asRecord(item) as TencentBillingAccount | null)
-    .filter((v): v is TencentBillingAccount => v !== null);
-}
-
-function usedPercent(used: number, total: number): number | null {
-  if (!Number.isFinite(used) || !Number.isFinite(total) || total <= 0) return null;
-  const pct = (used / total) * 100;
-  if (!Number.isFinite(pct)) return null;
-  return Math.min(100, Math.max(0, pct));
-}
-
-function buildBillingWindows(
-  accounts: readonly TencentBillingAccount[],
-  defaultPlan: string,
-): { plan: string; windows: ProviderQuotaWindow[] } {
-  const cycleEndMs = (acc: TencentBillingAccount): number => {
-    const r = parseBillingResetTime(acc.CycleEndTime);
-    return r ? new Date(r).getTime() : Number.POSITIVE_INFINITY;
-  };
-  const isRefill = (acc: TencentBillingAccount): boolean => {
-    const ce = cycleEndMs(acc);
-    const parsedDeductionEnd = parseBillingResetTime(acc.DeductionEndTime);
-    const de = parsedDeductionEnd ? new Date(parsedDeductionEnd).getTime() : Number.NaN;
-    return Number.isFinite(ce) && Number.isFinite(de) && de - ce > REFILL_GAP_MS;
-  };
-  const byExpiry = (a: TencentBillingAccount, b: TencentBillingAccount): number =>
-    cycleEndMs(a) - cycleEndMs(b);
-
-  const refills = [...accounts].filter(isRefill).sort(byExpiry);
-  const bonuses = [...accounts].filter((a) => !isRefill(a)).sort(byExpiry);
-
-  const windows: ProviderQuotaWindow[] = [];
-  const seenRefill: Record<string, number> = {};
-
-  for (const acc of refills) {
-    const base = refillCadence(acc);
-    seenRefill[base] = (seenRefill[base] || 0) + 1;
-    const label = seenRefill[base] > 1 ? `${base} ${seenRefill[base]}` : base;
-    const used = billingNum(acc.CycleCapacityUsedPrecise, acc.CycleCapacityUsed);
-    const total = billingNum(acc.CycleCapacitySizePrecise, acc.CycleCapacitySize);
-    const resetAt = parseBillingResetTime(acc.CycleEndTime);
-    const pct = usedPercent(used, total);
-    // Kind encodes recurring semantics + cadence for Contract consumers that
-    // do not read the optional `recurring` field. Keep label human-readable.
-    const kind = `quota:${base.toLowerCase()}${seenRefill[base] > 1 ? `_${seenRefill[base]}` : ""}`;
-    const w = percentWindow(kind, label, pct, resetAt, used, total, "pooled");
-    windows.push({ ...w, kind, label, recurring: true });
-  }
-
-  bonuses.forEach((acc, idx) => {
-    const label = `Bonus Pack ${idx + 1}`;
-    const kind = `bonus:${idx + 1}`;
-    const used = billingNum(acc.CapacityUsedPrecise, acc.CapacityUsed);
-    const total = billingNum(acc.CapacitySizePrecise, acc.CapacitySize);
-    const resetAt = parseBillingResetTime(acc.CycleEndTime);
-    const pct = usedPercent(used, total);
-    const w = percentWindow(kind, label, pct, resetAt, used, total, "pooled");
-    windows.push({ ...w, kind, label, recurring: false });
-  });
-
-  const basePkg = (refills[0] ?? accounts[0] ?? {}) as TencentBillingAccount;
-  const plan = asText(basePkg.PackageName) ?? asText(basePkg.SubProductName) ?? defaultPlan;
-
-  return { plan, windows };
-}
-
-/** Everything provider-specific about one Tencent billing-meter read. */
-export interface TencentBillingFetchOptions {
-  /** Canonical source id reported in the result. */
-  readonly source: string;
-  /** Operator-facing provider name used in every message. */
-  readonly display: string;
-  /** `{base}/v2/billing/meter/get-user-resource` for this provider. */
-  readonly url: string;
-  /** Provider transport/identity headers; `Authorization` is added here. */
-  readonly headers: Record<string, string>;
-  readonly credential: string;
-  readonly fetcher: FetchLike;
-  /** Plan name used when the payload carries neither package field. */
-  readonly defaultPlan: string;
-  /** Account UID for the `X-User-Id` billing identity header. */
-  readonly uid?: string | undefined;
-}
-
-/**
- * Fetches one provider's quota from the Tencent billing endpoint.
- *
- * Auth is always `Authorization: Bearer <credential>` — both `api_key` and
- * `oauth` accounts store a secret the caller has already resolved. The filter
- * envelope is the reference shape (`ProductCode: p_tcaca`, statuses `[0, 3]`,
- * a 101-year package window): an empty `{}` can answer success with zero
- * credit packages for an account that has them.
- * Recurring semantics ride on the `kind` prefix (`quota:` vs `bonus:`) plus the optional
- * `recurring` boolean, so Contract consumers that ignore `recurring` still see
- * the split.
- */
-export async function fetchTencentBillingQuota(
-  options: TencentBillingFetchOptions,
-): Promise<ProviderQuotaResult> {
-  const { source, display, url, headers, credential, fetcher, defaultPlan, uid } = options;
-  const bearer = resolveBearerToken(credential);
-  if (!bearer) {
-    return { source, plan: null, windows: [], error: `${display} credential not available.` };
-  }
-
-  let response: Response;
-  const now = new Date();
-  const end = new Date(now.getTime() + 365 * 101 * 24 * 3600 * 1000);
-  const stamp = (value: Date): string => value.toISOString().slice(0, 19).replace("T", " ");
-  try {
-    response = await fetcher(url, {
-      method: "POST",
-      headers: {
-        ...headers,
-        ...(uid === undefined || uid.length === 0 ? {} : { "X-User-Id": uid }),
-        Authorization: `Bearer ${bearer}`,
-        "Content-Type": "application/json",
-        Accept: "application/json",
-      },
-      body: JSON.stringify({
-        PageNumber: 1,
-        PageSize: 100,
-        ProductCode: "p_tcaca",
-        Status: [0, 3],
-        PackageEndTimeRangeBegin: stamp(now),
-        PackageEndTimeRangeEnd: stamp(end),
-      }),
-      signal: AbortSignal.timeout(TIMEOUT_MS),
-    });
-  } catch (error) {
-    return { source, plan: null, windows: [], error: cleanError(error) };
-  }
-
-  if (response.status === 401 || response.status === 403) {
-    return { source, plan: null, windows: [], error: `${display} credential invalid or expired.` };
-  }
-  if (!response.ok) {
-    return {
-      source,
-      plan: null,
-      windows: [],
-      error: `${display} quota API error (${response.status}).`,
-    };
-  }
-
-  let textBody: string;
-  try {
-    textBody = await response.text();
-  } catch (error) {
-    return { source, plan: null, windows: [], error: cleanError(error) };
-  }
-
-  let json: unknown = null;
-  try {
-    json = textBody.length > 0 ? JSON.parse(textBody) : null;
-  } catch {
-    return {
-      source,
-      plan: null,
-      windows: [],
-      error: cleanError(new Error(`${display} quota response returned invalid JSON`)),
-    };
-  }
-
-  const envelope = asRecord(json);
-  // A non-zero `code` is a provider-side error even on HTTP 200.
-  if (envelope !== null && "code" in envelope) {
-    const code = Number(envelope["code"]);
-    if (Number.isFinite(code) && code !== 0) {
-      const msgText = asText(envelope["msg"]) ?? "unknown";
-      return { source, plan: null, windows: [], error: `${display} quota error: ${msgText}` };
-    }
-  }
-
-  const accounts = extractBillingAccounts(json);
-  if (accounts.length === 0) {
-    const enterprise = await fetchEnterpriseUsage(options, bearer);
-    if (enterprise !== undefined) return enterprise;
-    return { source, plan: null, windows: [], error: `${display} connected. No credit package found.` };
-  }
-
-  try {
-    const { plan, windows } = buildBillingWindows(accounts, defaultPlan);
-    return { source, plan, windows, error: null };
-  } catch (error) {
-    return {
-      source,
-      plan: null,
-      windows: [],
-      error: cleanError(error) || `${display} error: ${String(error)}`,
-    };
-  }
-}
-
-const ENTERPRISE_USAGE_PATH = "/v2/billing/meter/get-enterprise-user-usage";
-
-function enterpriseUsageUrl(resourceUrl: string): string {
-  return resourceUrl.replace(/\/(?:v2\/)?billing\/meter\/get-user-resource$/, ENTERPRISE_USAGE_PATH);
-}
-
-function finiteNumber(value: unknown): number | undefined {
-  return sharedAsNumber(value);
-}
-
-/**
- * Enterprise accounts answer the personal package endpoint with an empty list.
- * Their assigned credit lives on the enterprise usage endpoint, where `credit`
- * is spent and `limitNum` is the assignment.
- */
-async function fetchEnterpriseUsage(
-  options: TencentBillingFetchOptions,
-  bearer: string,
-): Promise<ProviderQuotaResult | undefined> {
-  const enterpriseId = options.headers["X-Enterprise-Id"] ?? options.headers["x-enterprise-id"];
-  if (enterpriseId === undefined || enterpriseId.length === 0) return undefined;
-  let response: Response;
-  try {
-    response = await options.fetcher(enterpriseUsageUrl(options.url), {
-      method: "POST",
-      headers: {
-        ...options.headers,
-        ...(options.uid === undefined || options.uid.length === 0 ? {} : { "X-User-Id": options.uid }),
-        Authorization: `Bearer ${bearer}`,
-        "Content-Type": "application/json",
-        Accept: "application/json",
-      },
-      body: "{}",
-      signal: AbortSignal.timeout(TIMEOUT_MS),
-    });
-  } catch {
-    return undefined;
-  }
-  if (!response.ok) return undefined;
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(await response.text());
-  } catch {
-    return undefined;
-  }
-  const envelope = asRecord(parsed);
-  const data = asRecord(envelope?.["data"]) ?? envelope;
-  if (data === null) return undefined;
-  const limit = finiteNumber(data["limitNum"]) ?? finiteNumber(data["limit_num"]);
-  const used = finiteNumber(data["credit"]) ?? finiteNumber(data["used_num"]) ?? 0;
-  if (limit === undefined) return undefined;
-  if (limit < 0) {
-    return {
-      source: options.source,
-      plan: "Enterprise",
-      windows: [percentWindow("quota:enterprise", "Enterprise", null, null, null, null, "independent")],
-      error: null,
-    };
-  }
-  const remaining = Math.max(0, limit - used);
-  const usedPercent = limit === 0 ? 100 : Math.min(100, (used / limit) * 100);
-  const resetsAt = typeof data["cycleEndTime"] === "string" ? data["cycleEndTime"] : null;
-  return {
-    source: options.source,
-    plan: "Enterprise",
-    windows: [{
-    ...percentWindow("quota:enterprise", "Enterprise", usedPercent, resetsAt, used, limit, "pooled"),
-      remaining,
-    }],
-    error: null,
-  };
-}

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

@@ -1,240 +0,0 @@
-/**
- * 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;
-}