cartethyia 2.7.4 → 2.7.5

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

@@ -6,20 +6,22 @@ import { canContainToolResult, joinTextParts, toolCallParts, toolResultParts } f
 import {
   classifyUpstreamError,
   extractUpstreamMessage,
+  mapUpstreamHttpError,
   upstreamErrorIdentifier,
 } from "../../../transport/failure-policy";
-import { createApiKeyAdapter } from "../../configured-provider";
-import type { CanonicalEvent, CanonicalRequest, CanonicalStopReason, ContentPart } from "../../../protocol/canonical-model";
+import { postUpstreamJson } from "../../../protocol/upstream/post-json";
+import type { CanonicalEvent, CanonicalRequest, CanonicalStopReason, ContentPart, UsageRecord } from "../../../protocol/canonical-model";
 import { isRecord, readNumber, readString, resolveImageSource, splitDataUrl } from "../../../protocol/codecs";
 import { usageFromProvider } from "../../provider-usage";
 import { readCredentialSecret, type ProviderDispatchTarget, type ProviderAdapter, type ProviderDispatchContext } from "../../provider-contracts";
+import { abortGatewayError } from "../../operations/upstream-deadline";
 import { providerBaseUrl } from "../../provider-metadata";
 import { defineModel } from "../../provider-model-definition";
 import type { ModelDefinition } from "../../provider-model-definition";
 import {
   getCommandCodeVersion,
 } from "../../operations/client-versions";
-import { MimoThinkSplitter } from "../xiaomi-mimo/think-stream";
+import { ThinkSplitter } from "../../../protocol/think-split";
 export const COMMANDCODE_PROVIDER_ID = "commandcode" as const;
 export const COMMANDCODE_BASE_URL = providerBaseUrl("commandcode");
 /**
@@ -37,10 +39,6 @@ export const COMMANDCODE_HOST = "https://api.commandcode.ai" as const;
  * generate.
  */
 export const COMMANDCODE_GENERATE_PATH = "/alpha/generate" as const;
-/** The three routes the Provider API serves, one per wire family. */
-export const COMMANDCODE_CHAT_PATH = "/chat/completions" as const;
-export const COMMANDCODE_RESPONSES_PATH = "/responses" as const;
-export const COMMANDCODE_MESSAGES_PATH = "/messages" as const;
 
 /**
  * Command Code's roster, as the Provider API publishes it.
@@ -426,7 +424,7 @@ export async function headers(sessionId: string, token: string): Promise<Record<
 }
 
 
-type StreamState = { toolIndexById: Map<string, number>; nextToolIndex: number; finishReason: string | undefined; usage: Record<string, unknown> | undefined; think: MimoThinkSplitter };
+type StreamState = { toolIndexById: Map<string, number>; nextToolIndex: number; finishReason: string | undefined; usage: Record<string, unknown> | undefined; think: ThinkSplitter };
 
 export function ccMapFinishReason(reason: string): CanonicalStopReason {
   return reason === "length" ? "length" : reason === "tool_calls" ? "tool_use" : reason === "content_filter" ? "content_filter" : "stop";
@@ -450,7 +448,7 @@ export function transformLine(line: string, state: StreamState, seqBase: number)
     if (!text) return [];
     const split = state.think.push(text);
     const events: CanonicalEvent[] = [];
-    if (split.reasoning) events.push({ type: "content_delta", sequence_number: seqBase, content: { kind: "reasoning", payload: null, summary: split.reasoning } } as CanonicalEvent);
+    if (split.reasoning) events.push({ type: "content_delta", sequence_number: seqBase++, content: { kind: "reasoning", payload: null, summary: split.reasoning } } as CanonicalEvent);
     if (split.text) events.push({ type: "content_delta", sequence_number: seqBase, content: { kind: "text", text: split.text } } as CanonicalEvent);
     return events;
   }
@@ -485,9 +483,11 @@ export function transformLine(line: string, state: StreamState, seqBase: number)
   if (type === "finish") {
     const reason = state.finishReason ?? readString(event, "finishReason") ?? "stop";
     const canonicalReason = ccMapFinishReason(reason);
-    const events: CanonicalEvent[] = [
-      { type: "terminal", sequence_number: seqBase, state: "complete", stop_reason: canonicalReason, provider_stop_reason: reason } as CanonicalEvent,
-    ];
+    const rest = state.think.flush();
+    const events: CanonicalEvent[] = [];
+    if (rest.reasoning) events.push({ type: "content_delta", sequence_number: seqBase++, content: { kind: "reasoning", payload: null, summary: rest.reasoning } });
+    if (rest.text) events.push({ type: "content_delta", sequence_number: seqBase++, content: { kind: "text", text: rest.text } });
+    let usage: UsageRecord | undefined;
     if (state.usage) {
       const prompt = readNumber(state.usage, "promptTokens") ?? readNumber(state.usage, "inputTokens") ?? 0;
       const completion = readNumber(state.usage, "completionTokens") ?? readNumber(state.usage, "outputTokens") ?? 0;
@@ -500,9 +500,9 @@ export function transformLine(line: string, state: StreamState, seqBase: number)
         cached_tokens: cached,
         cache_creation_input_tokens: readNumber(state.usage, "cacheWriteTokens") ?? undefined,
       } as unknown as Record<string, unknown>);
-      // Append usage to terminal
-      (events[0] as unknown as Record<string, unknown>)["usage"] = usageRecord;
+      usage = usageRecord;
     }
+    events.push({ type: "terminal", sequence_number: seqBase, state: "complete", stop_reason: canonicalReason, provider_stop_reason: reason, ...(usage === undefined ? {} : { usage }) });
     return events;
   }
   if (type === "error") {
@@ -546,30 +546,29 @@ export function transformLine(line: string, state: StreamState, seqBase: number)
   return [];
 }
 
-/** NDJSON transform — beta-style simple loop + signal-aware read for abort/timeout propagation. */
-export async function* transformNdjson(body: ReadableStream<Uint8Array>, signal: AbortSignal): AsyncIterable<CanonicalEvent> {
+/** NDJSON decoding uses the request signal after the opening deadline is released. */
+export async function* transformNdjson(body: ReadableStream<Uint8Array>, signal: AbortSignal, model: string): AsyncIterable<CanonicalEvent> {
   const reader = body.getReader();
   const decoder = new TextDecoder();
-  const state: StreamState = { toolIndexById: new Map(), nextToolIndex: 0, finishReason: undefined, usage: undefined, think: new MimoThinkSplitter() };
+  const state: StreamState = { toolIndexById: new Map(), nextToolIndex: 0, finishReason: undefined, usage: undefined, think: new ThinkSplitter() };
   let buffer = "";
-  let hasTerminal = false;
   let seq = 1;
-  // initial response_start
-  yield { type: "response_start", sequence_number: seq++, model: "commandcode" } as CanonicalEvent;
 
-  const readWithAbort = (): Promise<{ done: boolean; value?: Uint8Array }> => {
-    if (signal.aborted) throw new GatewayError("transport_closed", 499, "Command Code stream aborted (request {requestId}). Send it again whenever ready 🙃");
-    const { promise, resolve, reject } = Promise.withResolvers<{ done: boolean; value?: Uint8Array }>() as unknown as { promise: Promise<{ done: boolean; value?: Uint8Array }>; resolve: (v: unknown) => void; reject: (e: unknown) => void };
-    const onAbort = (): void => {
-      if (signal.aborted) reject(new GatewayError("transport_closed", 499, "Command Code stream aborted (request {requestId}). Send it again whenever ready 🙃"));
-      else reject(new GatewayError("platform_unavailable", 502, "Command Code stream error (request {requestId}). The upstream came back empty-handed — retry 🌙", {}, "upstream"));
-    };
+  const readWithAbort = async (): Promise<{ readonly done: boolean; readonly value?: Uint8Array | undefined }> => {
+    if (signal.aborted) throw signal.reason;
+    const { promise, resolve, reject } = Promise.withResolvers<{ readonly done: boolean; readonly value?: Uint8Array | undefined }>();
+    const onAbort = (): void => reject(signal.reason);
     signal.addEventListener("abort", onAbort, { once: true });
-    void reader.read().then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
-    return promise;
+    void reader.read().then(resolve, reject);
+    try {
+      return await promise;
+    } finally {
+      signal.removeEventListener("abort", onAbort);
+    }
   };
 
   try {
+    yield { type: "response_start", sequence_number: seq++, model };
     while (true) {
       const { done, value } = await readWithAbort();
       if (done) break;
@@ -579,20 +578,11 @@ export async function* transformNdjson(body: ReadableStream<Uint8Array>, signal:
         const line = buffer.slice(0, nl).trim();
         buffer = buffer.slice(nl + 1);
         if (line) {
-          let evs: CanonicalEvent[] = [];
-          try {
-            evs = transformLine(line, state, seq);
-          } catch (e) {
-            throw e;
-          }
-          for (const ev of evs) {
-            // Strictly increasing per line, in emission order: the Responses
-            // surface throws on any non-monotonic sequence mid-stream, after
-            // partial bytes are already flushed. No special-casing for
-            // dual-event lines — order is order.
-            (ev as unknown as Record<string, unknown>)["sequence_number"] = seq++;
-            if (ev.type === "terminal") hasTerminal = true;
-            yield ev;
+          const events = transformLine(line, state, seq);
+          seq += events.length;
+          for (const event of events) {
+            yield event;
+            if (event.type === "terminal") return;
           }
         }
         nl = buffer.indexOf("\n");
@@ -601,101 +591,71 @@ export async function* transformNdjson(body: ReadableStream<Uint8Array>, signal:
     buffer += decoder.decode();
     const tail = buffer.trim();
     if (tail) {
-      for (const ev of transformLine(tail, state, seq)) {
-        if (ev.type === "terminal") hasTerminal = true;
-        (ev as unknown as Record<string, unknown>)["sequence_number"] = seq++;
-        yield ev;
+      const events = transformLine(tail, state, seq);
+      seq += events.length;
+      for (const event of events) {
+        yield event;
+        if (event.type === "terminal") return;
       }
     }
     const rest = state.think.flush();
-    if (rest.reasoning) yield { type: "content_delta", sequence_number: seq++, content: { kind: "reasoning", payload: null, summary: rest.reasoning } } as CanonicalEvent;
-    if (rest.text) yield { type: "content_delta", sequence_number: seq++, content: { kind: "text", text: rest.text } } as CanonicalEvent;
-    if (!hasTerminal) {
-      // NDJSON ended with no terminal envelope: truncated, never complete.
-      yield { type: "terminal", sequence_number: seq++, state: "failed", stop_reason: ccMapFinishReason(state.finishReason ?? "stop"), provider_stop_reason: state.finishReason ?? "stop" } as CanonicalEvent;
-    }
+    if (rest.reasoning) yield { type: "content_delta", sequence_number: seq++, content: { kind: "reasoning", payload: null, summary: rest.reasoning } };
+    if (rest.text) yield { type: "content_delta", sequence_number: seq++, content: { kind: "text", text: rest.text } };
+    // NDJSON ended with no terminal envelope: truncated, never complete.
+    yield { type: "terminal", sequence_number: seq++, state: "failed", stop_reason: ccMapFinishReason(state.finishReason ?? "stop"), provider_stop_reason: state.finishReason ?? "stop" };
   } finally {
-    try {
-      reader.releaseLock?.();
-    } catch {
-      // Best-effort reader unlock during stream cleanup.
-    }
-    void reader.cancel().catch(() => {});
+    void reader.cancel(signal.reason).catch(() => {});
+    reader.releaseLock();
   }
 }
 
-// CommandCode model catalog.
-
-
-
-// ProviderAdapter — the Provider API serves three wires, so dispatch is the
-// shared OpenAI-compatible adapter rather than one bespoke NDJSON reader.
-//
-// Generation goes to `/alpha/generate` for every model: that is the CLI's own
-// surface and the one the reference client calls, and it does not vary the path
-// by the wire a model row declares. `/provider/v1` is the catalog surface — it
-// answers `GET /models`, which discovery still uses — so a completion posted to
-// `/provider/v1/<wire>` was reaching a surface the CLI never calls to
-// generate. The wire family still decides how the body is shaped; only the
-// endpoint is shared.
+// The CLI generation surface takes a proprietary envelope and returns NDJSON
+// regardless of the catalog row's wire family.
 
 interface CommandCodeAdapterOptions {
   readonly fetch?: typeof fetch;
 }
 
-function commandCodeIdentityHeaders(_token: string): Record<string, string> {
-  return {
-    "x-command-code-version": getCommandCodeVersion(),
-    "x-cli-environment": "production",
-    "x-taste-learning": "true",
-    "x-project-slug": "cartethyia",
-    "user-agent": "cli",
-    // Per-request, as the CLI client sends it. The upstream expects a session
-    // id on every generate call and the reference client mints a fresh UUID
-    // for each one; sending a constant correlated requests that had nothing
-    // to do with each other.
-    "x-session-id": randomUUID(),
-  };
-}
-
-function providerApiAdapter(options: CommandCodeAdapterOptions): ProviderAdapter {
-  return createApiKeyAdapter(
-    {
-      provider_id: COMMANDCODE_PROVIDER_ID,
-      // The host, not the `/provider/v1` base: generation is a sibling
-      // surface, so every wire resolves under the host and the path below
-      // supplies the CLI endpoint. Nesting it under `/provider/v1` produced a
-      // URL that is neither surface.
-      base_url: COMMANDCODE_HOST,
-      endpoint_paths_by_wire_family: {
-        // Every wire, not one per family: the reference client sends all
-        // generation to `/alpha/generate` regardless of the row's declared
-        // wire, so dispatch must not fan out across three paths.
-        chat: COMMANDCODE_GENERATE_PATH,
-        responses: COMMANDCODE_GENERATE_PATH,
-        messages: COMMANDCODE_GENERATE_PATH,
-      },
-      buildExtraHeaders: async (context: ProviderDispatchContext) =>
-        commandCodeIdentityHeaders(await readCredentialSecret(context.credential, "Command Code bearer token is required")),
-    },
-    options.fetch,
-  );
-}
 
 class CommandCodeAdapter implements ProviderAdapter {
   readonly provider_id = COMMANDCODE_PROVIDER_ID;
-  private readonly inner: ProviderAdapter;
+  private readonly fetchFn: typeof fetch;
 
   constructor(options: CommandCodeAdapterOptions = {}) {
-    this.inner = providerApiAdapter(options);
+    this.fetchFn = options.fetch ?? globalThis.fetch;
   }
 
-  dispatch(
+  async *dispatch(
     request: CanonicalRequest,
     candidate: ProviderDispatchTarget,
     context: ProviderDispatchContext,
   ): AsyncIterable<CanonicalEvent> {
-    return this.inner.dispatch(request, candidate, context);
+    const token = readCredentialSecret(context.credential, "Command Code bearer token is required");
+    const sessionId = randomUUID();
+    const payload = buildRequest(candidate.model_id, {
+      messages: request.messages,
+      tools: (request.tools ?? []).map(({ name, description, jsonSchema }) => ({ name, description, jsonSchema })),
+      maxOutputTokens: request.generation_controls.max_output_tokens ?? request.generation_controls.max_tokens ?? request.generation_controls.max_completion_tokens ?? null,
+      temperature: request.generation_controls.temperature ?? null,
+      topP: request.generation_controls.top_p ?? null,
+      reasoningEffort: request.reasoning?.effort ?? null,
+    }, sessionId, [request.system, request.instructions].map((parts) => joinTextParts(parts ?? [])).filter(Boolean).join("\n"));
+    const { res, release } = await postUpstreamJson(
+      `${COMMANDCODE_HOST}${COMMANDCODE_GENERATE_PATH}`,
+      await headers(sessionId, token),
+      payload,
+      context,
+      context.outbound_fetch ?? this.fetchFn,
+    );
+    release();
+    try {
+      if (!res.ok) throw await mapUpstreamHttpError(res, COMMANDCODE_PROVIDER_ID);
+      if (!res.body) throw new GatewayError("platform_unavailable", 502, "Command Code returned an empty stream (request {requestId}). The upstream came back empty-handed — retry 🌙", {}, "upstream");
+      // NDJSON carries no model identity; use the selected model, not the provider id.
+      yield* transformNdjson(res.body, context.abort_signal, candidate.model_id);
+    } catch (error: unknown) {
+      throw abortGatewayError({ signal: context.abort_signal, release }, error) ?? error;
+    }
   }
 }
 

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(