cartethyia 2.7.4 → 2.7.6

package/src/providers/integrations/commandcode/quota.ts

@@ -1,10 +1,8 @@
 /**
- * Command Code quota, read from the four billing endpoints its client reads.
+ * Command Code quota, read from the billing endpoints its client reads.
  *
- * Command Code bills in credits, not in rate-limit windows, so a quota row here
- * is a credit balance rather than a 5-hour/weekly pair. The shape the console
- * renders still expects windows, so the balance is reported as one independent
- * window — the honest reading, since credits are the only thing consumed.
+ * Monthly allowance and purchased/free credits are separate pooled windows:
+ * the monthly cap and reset do not limit or expire the additional balance.
  *
  * The endpoints, all on `https://api.commandcode.ai` (not the Provider API
  * origin the model catalog lives on):
@@ -12,17 +10,42 @@
  *   `/alpha/whoami`                  identity, and the `orgId` when one exists
  *   `/alpha/billing/credits`         the balance and any window limits
  *   `/alpha/billing/subscriptions`   the plan, when there is one
- *   `/alpha/usage/summary`           spend in the period, for context
  *
- * Every call is optional to the result: a failure reports what is still known
- * rather than failing the whole read, because an operator who can see a zero
- * balance has already got the answer even if the usage summary never came back.
+ * Identity resolves the organization before billing is read. Billing reads are
+ * independent: retain the balance or subscription when the other is unavailable.
  */
 import type { FetchLike, ProviderQuotaResult, ProviderQuotaWindow } from "../../quota/quota-contracts";
 
 const COMMANDCODE_API_BASE = "https://api.commandcode.ai" as const;
 const REQUEST_TIMEOUT_MS = 15_000;
 
+const PLAN_CAPS: Readonly<Record<string, number>> = {
+  "individual-go": 10,
+  "individual-goat": 70,
+  "individual-pro": 30,
+  "individual-provider": 15,
+  "individual-max": 150,
+  "individual-ultra": 300,
+  "teams-pro": 40,
+};
+
+const PLAN_CAP_OVERRIDES: Readonly<Record<string, number>> = {
+  "individual-pro-v1": 80,
+};
+
+function commandCodePlan(planId: string): { readonly label: string; readonly cap: number | null } {
+  const [scope, tier] = planId.toLowerCase().split("-");
+  if ((scope !== "individual" && scope !== "teams") || !tier) {
+    return { label: planId, cap: PLAN_CAP_OVERRIDES[planId] ?? PLAN_CAPS[planId] ?? null };
+  }
+  const tierLabel = tier === "goat" ? "GOAT" : `${tier[0]?.toUpperCase() ?? ""}${tier.slice(1)}`;
+  const normalizedId = `${scope}-${tier}`;
+  return {
+    label: `CommandCode ${scope === "teams" ? "Teams " : ""}${tierLabel}`,
+    cap: PLAN_CAP_OVERRIDES[planId] ?? PLAN_CAPS[normalizedId] ?? null,
+  };
+}
+
 interface RequestOk {
   readonly ok: true;
   readonly value: unknown;
@@ -57,31 +80,69 @@ function recordValue(value: unknown): Record<string, unknown> | undefined {
 }
 
 function numberOrNull(value: unknown): number | null {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim() && Number.isFinite(Number(value))) {
+    return Number(value);
+  }
+  return null;
+}
+
+function isoTimestamp(value: unknown): string | null {
+  const numeric = numberOrNull(value);
+  if (numeric !== null) {
+    if (numeric <= 0) return null;
+    const date = new Date(numeric > 1_000_000_000_000 ? numeric : numeric * 1000);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : null;
+  }
+  if (typeof value !== "string" || !Number.isFinite(Date.parse(value))) return null;
+  return new Date(value).toISOString();
 }
 
-/** The credit block: three balances that are summed, plus any window limits. */
-function creditWindow(credits: Record<string, unknown>): ProviderQuotaWindow | null {
+function withQuery(path: string, params: Readonly<Record<string, string | null>>): string {
+  const query = new URLSearchParams(
+    Object.entries(params).filter((entry): entry is [string, string] => entry[1] !== null),
+  ).toString();
+  return query ? `${path}?${query}` : path;
+}
+
+/** Only monthly credits share the subscription allowance and reset. */
+function creditWindows(
+  credits: Record<string, unknown>,
+  planCap: number | null,
+  resetsAt: string | null,
+): readonly ProviderQuotaWindow[] {
   const monthly = numberOrNull(credits["monthlyCredits"]) ?? 0;
   const purchased = numberOrNull(credits["purchasedCredits"]) ?? 0;
   const free = numberOrNull(credits["freeCredits"]) ?? 0;
-  const remaining = monthly + purchased + free;
-  // Command Code reports no ceiling for a credit balance, so there is no
-  // percentage to compute — unlike a rate-limit window, where the upstream
-  // states both sides. Reporting null is the truthful answer.
-  return {
+  const used = planCap === null ? null : Math.max(0, planCap - monthly);
+  const usedPercent = planCap !== null && planCap > 0 && used !== null
+    ? Math.min(100, Math.max(0, (used / planCap) * 100))
+    : null;
+  const windows: ProviderQuotaWindow[] = [{
     kind: "credits",
-    label: "Credits",
-    // These are credits in one unit that can be spent interchangeably, so
-    // they are pooled like Qoder's plan/granted balances — not independent
-    // rate-limit lanes. The account-row pill and the Quota page both sum
-    // pooled windows, so this must be `pooled` or the balance never renders.
+    label: "Monthly credits",
     accounting: "pooled",
-    usedPercent: null,
-    remainingPercent: null,
-    resetsAt: null,
-    remaining,
-  };
+    usedPercent,
+    remainingPercent: usedPercent === null ? null : Math.max(0, 100 - usedPercent),
+    resetsAt,
+    used,
+    limit: planCap,
+    remaining: monthly,
+  }];
+  if (purchased + free > 0) {
+    windows.push({
+      kind: "additional_credits",
+      label: "Purchased/free credits",
+      accounting: "pooled",
+      usedPercent: null,
+      remainingPercent: null,
+      resetsAt: null,
+      used: null,
+      limit: null,
+      remaining: purchased + free,
+    });
+  }
+  return windows;
 }
 
 function windowLimits(
@@ -92,17 +153,25 @@ function windowLimits(
   const weekly = recordValue(limits["weekly"]);
   const push = (source: Record<string, unknown> | undefined, kind: string, label: string) => {
     if (source === undefined) return;
+    const used = numberOrNull(source["used"]) ?? 0;
+    const limit = numberOrNull(source["cap"]);
+    if ((limit === null || limit <= 0) && used <= 0) return;
+    const usedPercent = limit !== null && limit > 0
+      ? Math.min(100, Math.max(0, (used / limit) * 100))
+      : null;
     out.push({
       kind,
       label,
       accounting: "independent",
-      usedPercent: numberOrNull(source["usedPercent"]),
-      remainingPercent: numberOrNull(source["remainingPercent"]),
-      resetsAt: typeof source["resetsAt"] === "string" ? source["resetsAt"] : null,
-      remaining: numberOrNull(source["remaining"]),
+      usedPercent,
+      remainingPercent: usedPercent === null ? null : Math.max(0, 100 - usedPercent),
+      resetsAt: isoTimestamp(source["resetAt"]),
+      used,
+      limit,
+      remaining: limit === null ? null : Math.max(0, limit - used),
     });
   };
-  push(fiveHour, "five_hour", "5 Hour");
+  push(fiveHour, "five_hour", "Session (5h)");
   push(weekly, "weekly", "Weekly");
   return out;
 }
@@ -112,12 +181,8 @@ export async function fetchCommandCodeQuota(
   fetcher: FetchLike,
 ): Promise<ProviderQuotaResult> {
   const source = "commandcode";
-  const [whoami, creditsRaw, subscriptionRaw] = await Promise.all([
-    readJson("/alpha/whoami", credential, fetcher),
-    readJson("/alpha/billing/credits", credential, fetcher),
-    readJson("/alpha/billing/subscriptions", credential, fetcher),
-  ]);
-  if (!whoami.ok && !creditsRaw.ok) {
+  const whoami = await readJson(withQuery("/alpha/whoami", { limits: "1" }), credential, fetcher);
+  if (!whoami.ok) {
     return {
       source,
       plan: null,
@@ -128,32 +193,47 @@ export async function fetchCommandCodeQuota(
 
   const whoamiBody = whoami.ok ? recordValue(whoami.value) : undefined;
   const user = recordValue(whoamiBody?.["user"]);
+  const organization = recordValue(whoamiBody?.["org"]);
+  const orgId = typeof organization?.["id"] === "string" ? organization["id"] : null;
   const accountLabel =
     (typeof user?.["email"] === "string" && user["email"]) ||
     (typeof user?.["userName"] === "string" && user["userName"]) ||
+    (typeof user?.["name"] === "string" && user["name"]) ||
     undefined;
 
+  const [creditsRaw, subscriptionRaw] = await Promise.all([
+    readJson(withQuery("/alpha/billing/credits", { orgId }), credential, fetcher),
+    readJson(withQuery("/alpha/billing/subscriptions", { orgId }), credential, fetcher),
+  ]);
+  if (!creditsRaw.ok && !subscriptionRaw.ok) {
+    return {
+      source,
+      plan: null,
+      windows: [],
+      error: "Command Code did not answer its billing endpoints",
+      ...(accountLabel === undefined ? {} : { accountLabel }),
+    };
+  }
+
+  const subscriptionBody = subscriptionRaw.ok ? recordValue(subscriptionRaw.value) : undefined;
+  const planRecord = recordValue(subscriptionBody?.["data"]);
+  const planId = typeof planRecord?.["planId"] === "string" ? planRecord["planId"] : null;
+  const parsedPlan = planId === null ? null : commandCodePlan(planId);
+  const plan =
+    parsedPlan?.label ??
+    (typeof planRecord?.["name"] === "string" ? planRecord["name"] : null) ??
+    (creditsRaw.ok ? "Credits" : null);
+  const periodEnd = isoTimestamp(planRecord?.["currentPeriodEnd"]);
+
   const creditsBody = creditsRaw.ok ? recordValue(creditsRaw.value) : undefined;
   const windows: ProviderQuotaWindow[] = [];
   if (creditsBody !== undefined) {
     const credits = recordValue(creditsBody["credits"]);
-    if (credits !== undefined) {
-      const window = creditWindow(credits);
-      if (window !== null) windows.push(window);
-    }
+    if (credits !== undefined) windows.push(...creditWindows(credits, parsedPlan?.cap ?? null, periodEnd));
     const limits = recordValue(creditsBody["windowLimits"]);
     if (limits !== undefined) windows.push(...windowLimits(limits));
   }
 
-  const subscriptionBody = subscriptionRaw.ok ? recordValue(subscriptionRaw.value) : undefined;
-  const planRecord = recordValue(subscriptionBody?.["data"]);
-  const plan =
-    typeof planRecord?.["name"] === "string"
-      ? planRecord["name"]
-      : creditsRaw.ok
-        ? "Credits"
-        : null;
-
   return {
     source,
     plan,

package/src/providers/integrations/cursor/cursor-http2.ts

@@ -295,6 +295,3 @@ function concat(left: Uint8Array, right: Uint8Array): Uint8Array {
   out.set(right, left.byteLength);
   return out;
 }
-
-/** Heartbeat cadence while a Run is held open waiting for a tool result. */
-export const RUN_HEARTBEAT_INTERVAL_MS = 20_000;

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

@@ -35,6 +35,7 @@ import {
 } from "../../quota/quota-contracts";
 import type { QuotaCollectionContext } from "../../quota/quota-support";
 import { cursorAccountIdentity } from "./cursor-auth";
+import { fnv1a32 } from "../shared/hash";
 import { CURSOR_API_HOST, CURSOR_WEBSITE_HOST } from "./cursor-shared";
 
 /** Timestamp keys naming the end of the current window. */
@@ -226,12 +227,7 @@ function authStateUserId(context: QuotaCollectionContext | undefined): string |
  * subject it replaces.
  */
 function cursorAccountTag(credential: string): string {
-  let hash = 0x811c9dc5;
-  for (let index = 0; index < credential.length; index += 1) {
-    hash ^= credential.charCodeAt(index);
-    hash = Math.imul(hash, 0x01000193) >>> 0;
-  }
-  return `cursor-${hash.toString(36).padStart(7, "0").slice(0, 7)}`;
+  return `cursor-${fnv1a32(credential).toString(36).padStart(7, "0").slice(0, 7)}`;
 }
 
 export async function fetchCursorQuota(

package/src/providers/integrations/cursor/cursor-request.ts

@@ -303,17 +303,6 @@ export function buildHeartbeat(): Uint8Array {
   return encodeMessage("AgentClientMessage", { client_heartbeat: {} });
 }
 
-/**
- * `ACM#5 exec_client_control_message.heartbeat{id}`: Cursor CLI sends one every
- * few seconds for each exec it is still running. A zero id is left out, as
- * proto3 does for a default scalar.
- */
-export function buildExecHeartbeat(execId: number): Uint8Array {
-  return encodeMessage("AgentClientMessage", {
-    exec_client_control_message: { heartbeat: execId === 0 ? {} : { id: execId } },
-  });
-}
-
 /** `ACM#5 exec_client_control_message.stream_close{id}` after an exec result. */
 export function buildExecStreamClose(execId: number, execIdString?: string): Uint8Array {
   return encodeMessage("AgentClientMessage", {
@@ -424,82 +413,6 @@ export function buildMcpResult(input: {
   });
 }
 
-/**
- * `ACM#2 exec_client_message{shell_result|write_result|read_result}` for a host
- * exec the canonical client executed locally.
- *
- * Cursor's executor replies to its own host requests with the variant's typed
- * result frame (the generic `mcp_result` leaves the server unmatched on a frame
- * it did rank), and after every exec result it sends `stream_close` — without
- * it the cloud waits forever on shell execs. `is_error` keeps the failure as
- * the variant's error/failure case rather than a crafted success.
- */
-export type CursorHostExecResultVariant = "shell" | "write" | "read";
-
-export function buildHostExecResult(input: {
-  readonly execId: number;
-  readonly execIdString?: string;
-  readonly variant: CursorHostExecResultVariant;
-  readonly text: string;
-  readonly isError: boolean;
-  readonly host: {
-    readonly command?: string;
-    readonly workingDirectory?: string;
-    readonly path?: string;
-    readonly lines?: number;
-    readonly fileSize?: number;
-  };
-}): Uint8Array[] {
-  const id = { id: input.execId, exec_id: input.execIdString ?? "" };
-  const variant = input.variant;
-  const text = input.text;
-  let result: Record<string, unknown>;
-  if (variant === "shell") {
-    result = {
-      shell_result: input.isError
-        ? { failure: { command: input.host.command ?? "", exit_code: 1, stderr: text } }
-        : {
-            success: {
-              command: input.host.command ?? "",
-              exit_code: 0,
-              stdout: text,
-              ...(input.host.workingDirectory === undefined ? {} : { working_directory: input.host.workingDirectory }),
-            },
-          },
-    };
-  } else if (variant === "write") {
-    result = {
-      write_result: input.isError
-        ? { error: { path: input.host.path ?? "", error: text } }
-        : {
-            success: {
-              path: input.host.path ?? "",
-              lines_created: input.host.lines ?? 0,
-              file_size: input.host.fileSize ?? 0,
-            },
-          },
-    };
-  } else {
-    result = {
-      read_result: input.isError
-        ? { error: { path: input.host.path ?? "", error: text } }
-        : {
-            success: {
-              path: input.host.path ?? "",
-              content: text,
-              total_lines: text.length > 0 ? text.split("\n").length : 0,
-            },
-          },
-    };
-  }
-  return [
-    encodeMessage("AgentClientMessage", { exec_client_message: { ...id, ...result } }),
-    // The real CLI pairs every typed exec result with stream_close — the cloud
-    // waits on it for shell execs specifically.
-    buildExecStreamClose(input.execId, input.execIdString),
-  ];
-}
-
 /**
  * `ACM#2 exec_client_message{mcp_result}` rejecting a tool the client never
  * declared.

package/src/providers/integrations/cursor/cursor-shared.ts

@@ -5,7 +5,6 @@
 // protocol was verified against: they are declared once so the auth flow, the
 // unary catalog calls, and the Run stream cannot drift apart on host, path, or
 // client id.
-import type { WireFamily } from "../../../protocol/canonical-model";
 
 /** Canonical bundled provider id. */
 export const CURSOR_PROVIDER_ID = "cursor";
@@ -72,9 +71,6 @@ export const SESSION_REFRESH_TIMEOUT_MS = 20_000;
  */
 export const RUN_IDLE_TTL_MS = 10 * 60_000;
 
-/** Chat wire is the declared default; the adapter owns the native protocol. */
-export const CURSOR_WIRE_FAMILY: WireFamily = "chat";
-
 /**
  * Any HTTPS subdomain of `cursor.sh` is an acceptable Run host: the region
  * Cursor routes an account to varies (`agentn.*`, `agent.*`, `api5`, …).

package/src/providers/integrations/cursor/cursor.ts

@@ -62,6 +62,7 @@ import { defaultParameterValues, fetchCursorModels } from "./cursor-catalog";
 import type { CursorModelInfo } from "./cursor-catalog";
 import { decodeValueToJson, decodeStructEntriesToJson } from "./protocol/struct";
 import { cursorVariantForExecArgs } from "./protocol/tool-canonical";
+import { fnv1a32 } from "../shared/hash";
 
 /**
  * Client-heartbeat cadence for every Cursor Run.
@@ -81,8 +82,38 @@ const CURSOR_HEARTBEAT_INTERVAL_MS = 5_000;
  * every dispatch.
  */
 const CURSOR_ROSTER_TTL_MS = 300_000;
-/** credential → { roster, fetchedAt } for the parameter lookup. */
+/**
+ * credential → { roster, fetchedAt } for the parameter lookup.
+ *
+ * Keyed by an FNV-1a digest of the credential rather than the raw token so a
+ * long-lived map does not hold live credentials as keys. Bounded by
+ * `ROSTER_CACHE_MAX` with oldest-first eviction: the TTL is only checked on
+ * read, so without a cap rotated tokens would grow the map without bound.
+ */
+const ROSTER_CACHE_MAX = 1024;
 const rosterCache = new Map<string, { roster: readonly CursorModelInfo[]; fetchedAt: number }>();
+
+function rosterCacheSet(credential: string, roster: readonly CursorModelInfo[]): void {
+  const key = String(fnv1a32(credential));
+  rosterCache.delete(key); // re-set moves the entry to newest position
+  rosterCache.set(key, { roster, fetchedAt: Date.now() });
+  while (rosterCache.size > ROSTER_CACHE_MAX) {
+    const oldest = rosterCache.keys().next().value;
+    if (oldest === undefined) break;
+    rosterCache.delete(oldest);
+  }
+}
+
+/**
+ * Test-only access to the roster cache (cap/eviction/TTL behavior is covered
+ * by `test/providers/cursor-roster-cache.test.ts` without a full dispatch).
+ */
+export const rosterCacheForTests = {
+  size: (): number => rosterCache.size,
+  set: rosterCacheSet,
+  get: (credential: string): { roster: readonly CursorModelInfo[]; fetchedAt: number } | undefined =>
+    rosterCache.get(String(fnv1a32(credential))),
+};
 /** Client-heartbeat cadence the Cursor edge expects (donor `heartbeatMs`). */
 const CURSOR_HEARTBEAT_INTERVAL_OVERRIDE = (() => {
   const raw = process.env.CARTETHYIA_CURSOR_HEARTBEAT_MS?.trim();
@@ -846,7 +877,8 @@ class CursorAdapter implements ProviderAdapter {
     credential: string,
     context: ProviderDispatchContext,
   ): Promise<readonly CursorModelInfo[]> {
-    const cached = rosterCache.get(credential);
+    const key = String(fnv1a32(credential));
+    const cached = rosterCache.get(key);
     if (cached !== undefined && Date.now() - cached.fetchedAt < CURSOR_ROSTER_TTL_MS) {
       return cached.roster;
     }
@@ -858,7 +890,7 @@ class CursorAdapter implements ProviderAdapter {
           : { fetcher: context.outbound_fetch as unknown as typeof fetch }),
         signal: context.abort_signal,
       });
-      rosterCache.set(credential, { roster, fetchedAt: Date.now() });
+      rosterCacheSet(credential, roster);
       return roster;
     } catch {
       return cached?.roster ?? [];

package/src/providers/integrations/cursor/protocol/framing.ts

@@ -71,59 +71,3 @@ export function* streamFrames(buffer: Uint8Array): Generator<Frame, void, void>
     offset = start + len
   }
 }
-
-export async function* asyncStreamFrames(
-  stream: ReadableStream<Uint8Array>,
-): AsyncGenerator<Frame, void, void> {
-  const reader = stream.getReader()
-  const chunks: Uint8Array[] = []
-  let pendingLength = 0
-
-  try {
-    while (true) {
-      const { done, value } = await reader.read()
-      if (done && chunks.length === 0) return
-      if (value) {
-        chunks.push(value)
-        pendingLength += value.length
-      }
-
-      // Try to parse frames from accumulated data
-      const merged = mergeChunks(chunks)
-      const frames = Array.from(streamFrames(merged))
-      const consumed = frames.reduce((sum, f) => sum + 5 + f.payload.length, 0)
-
-      if (frames.length > 0) {
-        for (const frame of frames) {
-          yield frame
-        }
-        // Keep any trailing bytes for next iteration
-        const remaining = merged.subarray(consumed)
-        chunks.length = 0
-        if (remaining.length > 0) {
-          chunks.push(remaining)
-          pendingLength = remaining.length
-        } else {
-          pendingLength = 0
-        }
-      }
-
-      if (done) return
-    }
-  } finally {
-    reader.releaseLock()
-  }
-}
-
-function mergeChunks(chunks: Uint8Array[]): Uint8Array {
-  const first = chunks[0]
-  if (chunks.length === 1 && first !== undefined) return first
-  const total = chunks.reduce((s, c) => s + c.length, 0)
-  const merged = new Uint8Array(total)
-  let offset = 0
-  for (const c of chunks) {
-    merged.set(c, offset)
-    offset += c.length
-  }
-  return merged
-}

package/src/providers/integrations/cursor/protocol/messages.ts

@@ -2282,99 +2282,3 @@ export function decodeMessage<T = Record<string, unknown>>(
   const decoded = type.decode(data)
   return type.toObject(decoded, { defaults: true, json: true, longs: Number }) as T
 }
-
-/** Decode without inventing absent proto defaults (used for byte-stable snapshots). */
-export function decodeMessageSparse<T = Record<string, unknown>>(
-  typeName: string,
-  data: Uint8Array,
-): T {
-  const root = getMessageTypes()
-  const type = root.lookupType(typeName)
-  const decoded = type.decode(data)
-  return type.toObject(decoded, { json: true, longs: Number }) as T
-}
-
-type RawField = {
-  field: number
-  wireType: number
-  varint?: string
-  fixed?: number | string
-  bytes?: Uint8Array
-}
-
-/** Schema-free walk of one message's top-level wire fields (no nested descent). */
-function readRawFields(buf: Uint8Array): RawField[] {
-  const reader = protobuf.Reader.create(buf)
-  const fields: RawField[] = []
-  while (reader.pos < reader.len) {
-    const tag = reader.uint32()
-    const field = tag >>> 3
-    const wireType = tag & 7
-    switch (wireType) {
-      case 0:
-        fields.push({ field, wireType, varint: reader.uint64().toString() })
-        break
-      case 1:
-        fields.push({ field, wireType, fixed: reader.fixed64().toString() })
-        break
-      case 2:
-        fields.push({ field, wireType, bytes: reader.bytes() })
-        break
-      case 5:
-        fields.push({ field, wireType, fixed: reader.fixed32() })
-        break
-      default:
-        // Groups (3/4) aren't used on this wire; bail rather than desync the reader.
-        return fields
-    }
-  }
-  return fields
-}
-
-/**
- * Diagnostic-only: walk AgentServerMessage.interaction_update(1).turn_ended(14)
- * without going through our hand-written TurnEnded schema, so a `cache_write`/
- * `reasoning_tokens` question can be checked against the raw wire instead of
- * guessed. Confirmed field ids 1-5 (input/output/cache_read/cache_write/
- * reasoning) decode correctly. Live captures routinely include `f4` explicitly
- * as `0` while `f3` (cache_read) and `f5` (reasoning) are non-zero — Cursor's
- * agent TurnEnded populates the field but does not report write counts here.
- */
-export function debugWalkTurnEnded(payload: Uint8Array): string {
-  try {
-    const top = readRawFields(payload)
-    const iuField = top.find((f) => f.field === 1 && f.wireType === 2)
-    if (!iuField?.bytes) return "(no interaction_update field)"
-    const iu = readRawFields(iuField.bytes)
-    const teField = iu.find((f) => f.field === 14 && f.wireType === 2)
-    if (!teField?.bytes) return "(no turn_ended field in interaction_update)"
-    const te = readRawFields(teField.bytes)
-    return te
-      .map(
-        (f) =>
-          `f${f.field}:wt${f.wireType}=${f.varint ?? f.fixed ?? (f.bytes ? `bytes[${f.bytes.length}]` : "?")}`,
-      )
-      .join(" ")
-  } catch (e) {
-    return `(walk failed: ${(e as Error).message})`
-  }
-}
-
-/**
- * Decode a protobuf sub-message from a frame payload that wraps it in
- * a top-level field key + length varint.  Skips the outer wrapper and
- * decodes the inner body as `typeName`.
- */
-export function decodeWrappedMessage<T = Record<string, unknown>>(
-  typeName: string,
-  data: Uint8Array,
-): T {
-  let offset = 1 // skip field key
-  // skip varint length
-  while (offset < data.length) {
-    const b = data[offset] ?? 0
-    offset++
-    if (!(b & 0x80)) break
-  }
-  return decodeMessage<T>(typeName, data.subarray(offset))
-}