cartethyia 2.7.5 → 2.7.6

package/src/providers/integrations/qoder/qoder.ts

@@ -998,8 +998,16 @@ export function buildQoderRequest(
   // When the caller sends no intent but the model needs the push to think
   // (verified live: Sonus/Cantus stream no reasoning without it), use the
   // roster's default effort.
+  //
+  // Only a reasoning-capable model carries the field. A non-reasoning model
+  // (e.g. `lite`) cannot think, so an effort is meaningless there; sending it
+  // would also assert a capability the model does not advertise. The upstream
+  // tolerates it today, but declaring reasoning on a model that has none is a
+  // latent contract violation, so the field is kept off non-reasoning models.
   const reasoningEffort =
-    reasoningEffortFromIntent(request.reasoning) ?? modelConfig.default_reasoning_effort;
+    reasoning
+      ? (reasoningEffortFromIntent(request.reasoning) ?? modelConfig.default_reasoning_effort)
+      : undefined;
   const sessionId = qoderStableHash("qoder-session", auth.userId, modelId);
   const recordId = qoderStableRecordId(modelId, allMessages, maxTokens);
   return {
@@ -1073,6 +1081,17 @@ export function buildQoderRequest(
       const choice = qoderToolChoice(request.tool_choice);
       return choice === undefined ? {} : { tool_choice: choice };
     })(),
+    // Passthrough knobs the IDE surface reads from `parameters` (worker `vyl`):
+    // parallel_tool_calls, tool_choice, top_p, seed, user, response_format, …
+    // Only include what the caller actually set.
+    parameters: (() => {
+      const out: Record<string, unknown> = {};
+      const choice = qoderToolChoice(request.tool_choice);
+      if (choice !== undefined) out["tool_choice"] = choice;
+      const parallel = request.generation_controls.parallel_tool_calls;
+      if (parallel !== undefined) out["parallel_tool_calls"] = parallel;
+      return Object.keys(out).length > 0 ? out : undefined;
+    })(),
   };
 }
 
@@ -1096,11 +1115,21 @@ export function buildQoderIdeRequest(
 ): Record<string, unknown> {
   const legacy = buildQoderRequest(modelId, request, modelConfig, auth, realm);
   const messages = legacy.messages as Array<Record<string, unknown>>;
+  // The IDE surface (`model/v1/chat/completions`) must ship the same tool
+  // declaration as the legacy builder. The unpacked desktop client (worker
+  // `PFn`) injects `tools` directly when present — without it the upstream
+  // sees no toolset and answers with a DSML text block (or claims no tool
+  // exists) instead of a structured `tool_calls`. The remaining knobs
+  // (`parallel_tool_calls`, `tool_choice`, …) ride the `parameters`
+  // passthrough (worker `vyl`), matching the reference exactly.
+  const tools = legacy.tools as Array<Record<string, unknown>> | undefined;
   return {
     model: modelId,
     messages,
     stream: true,
     stream_options: { include_usage: true },
+    ...(tools !== undefined && tools.length > 0 ? { tools } : {}),
+    ...(legacy.parameters === undefined ? {} : { parameters: legacy.parameters }),
     // The same reasoning-effort field the legacy surface uses; without it the
     // IDE surface streams no thinking for models that need the push (Sonus,
     // Cantus). Undefined when the caller asked for none and the roster has no
@@ -1197,93 +1226,90 @@ function qoderIdeEntitlementRefused(response: Response): boolean {
  * normal stop with reasoning only and no output text/tool calls (observed ~1
  * in 4 runs with Sonus). That is not a valid completion — the lab would show a
  * thought with "No text came back". Replay such a stream before committing to
- * it. Buffering the body is required: the decision is only knowable after the
- * stream ends, and the bytes are replayed to the canonical parser.
+ * it. `sniffQoderStream` below inspects just enough of the body to make that
+ * call without buffering the whole (possibly long) stream.
  */
-interface QoderStreamDrain {
-  readonly bytes: Uint8Array;
-  readonly meaningful: boolean;
-  readonly thoughtOnly: boolean;
-}
 
-async function drainQoderResponse(
+/**
+ * Reads the upstream body just far enough to decide whether it carries real
+ * output, then returns a replay stream that re-emits the already-read bytes
+ * followed by the rest of the original body. If the body ends before any
+ * meaningful output is seen, `meaningful` is false and the caller replays the
+ * whole request (empty / thought-only recovery) without ever buffering a large
+ * response: the original `drainQoderResponse` read the entire stream before
+ * forwarding, which made every stream appear to complete in one burst at the
+ * end.
+ */
+async function sniffQoderStream(
   response: Response,
   signal: AbortSignal,
-): Promise<QoderStreamDrain> {
-  const chunks: Uint8Array[] = [];
-  let total = 0;
-  const reader = response.body!.getReader();
-  try {
-    for (;;) {
-      if (signal.aborted) break;
-      const { done, value } = await reader.read();
-      if (done) break;
-      if (value) {
-        chunks.push(value);
-        total += value.byteLength;
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  const bytes = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-
-  let dataEvents = 0;
-  let meaningful = false;
-  let thoughtOnly = false;
+): Promise<{ meaningful: boolean; response: Response }> {
+  const body = response.body;
+  if (body === null) return { meaningful: true, response };
+  const reader = body.getReader();
   const decoder = new TextDecoder();
-  const text = decoder.decode(bytes);
-  for (const frame of text.split(/\r?\n\r?\n/)) {
-    if (frame.trim().length === 0) continue;
-    const dataLines: string[] = [];
-    for (const line of frame.split(/\r?\n/)) {
-      if (line.startsWith("data:")) dataLines.push(line.slice(5).trimStart());
-    }
-    const data = dataLines.join("\n").trim();
-    if (data.length === 0 || data === "[DONE]") continue;
-    dataEvents++;
-    for (const { data: frameData } of qoderEnvelopeToFrames(data)) {
-      if (frameData === "[DONE]") continue;
-      let json: Record<string, unknown>;
-      try {
-        json = JSON.parse(frameData) as Record<string, unknown>;
-      } catch {
-        continue;
-      }
-      const choices = json["choices"];
-      if (!Array.isArray(choices)) continue;
-      for (const choice of choices as Array<Record<string, unknown>>) {
-        const delta = choice["delta"] as Record<string, unknown> | undefined;
-        if (delta === undefined) continue;
-        if (typeof delta["content"] === "string" && (delta["content"] as string).length > 0) {
-          meaningful = true;
-          return { bytes, meaningful, thoughtOnly };
-        }
-        if (Array.isArray(delta["tool_calls"]) && (delta["tool_calls"] as unknown[]).length > 0) {
+  const pending: Uint8Array[] = [];
+  let inspected = "";
+  let meaningful = false;
+  for (let i = 0; i < 32 && !meaningful; i += 1) {
+    const { done, value } = await reader.read();
+    if (signal.aborted) break;
+    if (done) break;
+    pending.push(value);
+    inspected += decoder.decode(value, { stream: true });
+    // Peek at completed SSE frames only: a content delta or a tool-call
+    // fragment means real output is coming. Reasoning-only streams are NOT
+    // meaningful (they are exactly what empty-stream recovery replays), and a
+    // finish reason alone is not output either.
+    if (/data:/.test(inspected)) {
+      for (const frame of inspected.split(/\r?\n\r?\n/)) {
+        if (!frame.includes("data:")) continue;
+        if (frame.includes('"content":"') || frame.includes('"tool_calls"')) {
           meaningful = true;
-          return { bytes, meaningful, thoughtOnly };
-        }
-        if (
-          typeof delta["reasoning_content"] === "string" &&
-          (delta["reasoning_content"] as string).length > 0
-        ) {
-          thoughtOnly = true;
+          break;
         }
       }
     }
+    if (inspected.length > 65536) {
+      meaningful = true;
+      break;
+    }
   }
-  return { bytes, meaningful, thoughtOnly };
+  // Replay: previously-read bytes first, then continue the original body.
+  let offset = 0;
+  const replay = new ReadableStream<Uint8Array>({
+    start(controller) {
+      for (; offset < pending.length; offset += 1) controller.enqueue(pending[offset]);
+    },
+    async pull(controller) {
+      if (offset < pending.length) {
+        controller.enqueue(pending[offset]);
+        offset += 1;
+        return;
+      }
+      const { done, value } = await reader.read();
+      if (signal.aborted) {
+        controller.close();
+        return;
+      }
+      if (done) {
+        controller.close();
+        return;
+      }
+      controller.enqueue(value);
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    },
+  });
+  return { meaningful, response: new Response(replay, response) };
 }
 
 /**
  * Runs the IDE request up to `1 + maxReplays` times, returning the first
  * response whose stream carried real output (text or tool calls). A 200 with
- * no output (empty or thought-only) is replayed rather than surfaced.
+ * no output (empty or thought-only) is replayed rather than surfaced. The
+ * stream is forwarded progressively (not buffered to completion).
  */
 async function fetchQoderIdeWithEmptyRecovery(
   requestOnce: () => Promise<Response>,
@@ -1294,12 +1320,9 @@ async function fetchQoderIdeWithEmptyRecovery(
   for (let attempt = 0; attempt <= maxReplays; attempt += 1) {
     const res = await requestOnce();
     if (!res.ok || !res.body) return res;
-    const drain = await drainQoderResponse(res, signal);
-    last = new Response(drain.bytes as BodyInit, {
-      status: 200,
-      headers: { "content-type": "text/event-stream", "cache-control": "no-cache" },
-    });
-    if (drain.meaningful) return last;
+    const sniff = await sniffQoderStream(res, signal);
+    last = sniff.response;
+    if (sniff.meaningful) return last;
   }
   return last!;
 }
@@ -1336,6 +1359,9 @@ export async function* qoderBodyToCanonicalEvents(
   // (recovered) or ordinary prose (released).
   let leakBuf = "";
   let leakFrames = 0;
+  // Tool-call argument fragments, keyed by call id, reconciled at end of
+  // stream (see the tool_calls handling in the loop).
+  const toolCallBuffer = new Map<string, { index: number; name: string | undefined; arguments: string }>();
 
   for await (const sse of decodeQoderSseEvents(body, signal)) {
     const sseData = sse.data;
@@ -1492,7 +1518,14 @@ export async function* qoderBodyToCanonicalEvents(
             for (const tc of toolCalls) {
               const fn = tc["function"] as Record<string, unknown> | undefined;
               const index = typeof tc["index"] === "number" ? (tc["index"] as number) : undefined;
-              const declaredId = typeof tc["id"] === "string" ? (tc["id"] as string) : undefined;
+              // `id` is only meaningful when non-empty: some Qoder slots echo
+              // `id: ""` on continuation chunks, and treating that as a fresh
+              // call id would orphan every argument fragment (the real call
+              // keeps its first-seen id, the fragments pile up under "").
+              const declaredId =
+                typeof tc["id"] === "string" && (tc["id"] as string).length > 0
+                  ? (tc["id"] as string)
+                  : undefined;
               const fragName = typeof fn?.["name"] === "string" ? (fn["name"] as string) : undefined;
               // OpenAI continuation chunks re-identify their call by wire
               // `index` alone — the `id` appears only once, in the first chunk.
@@ -1520,14 +1553,27 @@ export async function* qoderBodyToCanonicalEvents(
               } else {
                 callId = `call_${String(index ?? 0)}`;
               }
-              yield {
-                type: "tool_call_delta",
-                sequence_number: seq++,
-                call_id: callId,
-                ...(index !== undefined ? { index } : {}),
-                ...(fragName === undefined ? {} : { name: fragName }),
-                arguments_delta: (fn?.["arguments"] as string) ?? "",
-              } as CanonicalEvent;
+              // Buffer tool-call argument fragments per call id until the end of
+              // stream. Upstream streaming fragments occasionally drop or mangle
+              // a byte mid-arguments; forwarding each fragment as an
+              // `arguments_delta` would hand the client a malformed JSON blob to
+              // stitch. Holding and reconciling here yields one complete,
+              // parseable arguments string per call — flush happens at end of
+              // stream (or when a terminal frame arrives).
+              const existing = toolCallBuffer.get(callId);
+              if (existing) {
+                existing.index = index ?? existing.index;
+                if (fragName !== undefined) existing.name = fragName;
+                if (typeof fn?.["arguments"] === "string") {
+                  existing.arguments += (fn["arguments"] as string);
+                }
+              } else {
+                toolCallBuffer.set(callId, {
+                  index: index ?? 0,
+                  name: fragName,
+                  arguments: typeof fn?.["arguments"] === "string" ? (fn["arguments"] as string) : "",
+                });
+              }
             }
           }
         }
@@ -1588,6 +1634,19 @@ export async function* qoderBodyToCanonicalEvents(
   const stopReason = mapQoderFinishReason(finishReason);
   const _providerStop = typeof finishReason === "string" ? finishReason : undefined;
   void hasTerminal;
+  // Flush buffered tool-call fragments as complete, stitched calls — one
+  // `arguments_delta` per call with the full JSON string, so the client never
+  // has to repair upstream frame-loss.
+  for (const [callId, buffered] of toolCallBuffer) {
+    yield {
+      type: "tool_call_delta",
+      sequence_number: seq++,
+      call_id: callId,
+      index: buffered.index,
+      name: buffered.name,
+      arguments_delta: buffered.arguments,
+    } as CanonicalEvent;
+  }
   yield {
     type: "terminal",
     sequence_number: seq++,

package/src/providers/integrations/trae/trae.ts

@@ -7,7 +7,7 @@
 import { GatewayError } from "../../../protocol/gateway-error";
 import type { CanonicalEvent, CanonicalMessage, CanonicalRequest, CanonicalStopReason } from "../../../protocol/canonical-model";
 import type { UsageRecord } from "../../../protocol/canonical-model";
-import { applyCacheMode, usageFromProvider } from "../../provider-usage";
+import { usageFromProvider } from "../../provider-usage";
 import {
   readCredentialSecret,
   assertWireFamily,
@@ -482,7 +482,7 @@ class TraeAdapter implements ProviderAdapter {
     // prefixes we estimate them locally (see trae-cache.ts). Then the
     // operator's cache mode decides whether a hit makes the whole input count
     // as cached.
-    return applyCacheMode(estimateTraeSessionCache(record, sessionId, messages));
+    return estimateTraeSessionCache(record, sessionId, messages);
   }
 
 }

package/src/providers/operations/account-error-classification.ts

@@ -458,6 +458,26 @@ function banWording(lower: string): boolean {
   );
 }
 
+/**
+ * Whether GitHub Copilot stated the account lacks a license — a ban-shaped
+ * verdict on the account, not a refreshable auth rejection.
+ *
+ * Observed live (2026-11-03): the health log showed
+ * `unauthorized: not licensed to use Copilot` and `forbidden` on
+ * `gpt-6-luna`. Copilot answers 401 for a bad credential and 403 for a
+ * license/entitlement refusal, so `forbidden`/`unauthorized` on this surface
+ * is the same verdict. No amount of waiting or refreshing changes it — the
+ * subscription cannot serve this credential.
+ */
+function copilotNotLicensed(lower: string): boolean {
+  return (
+    lower.includes("not licensed") ||
+    lower.includes("forbidden") ||
+    lower.includes("unauthorized") ||
+    lower.includes("license")
+  );
+}
+
 /**
  * Bounded to a day, matching `MAX_COOLDOWN_MS` in the failure policy: a stated
  * window longer than that is a monthly or plan-level limit, and parking an
@@ -1263,6 +1283,33 @@ const ACCOUNT_ERROR_RULES: readonly AccountErrorRule[] = [
         true,
       ),
   },
+  {
+    // GitHub Copilot answers a license/entitlement refusal with 403 and
+    // "not licensed to use Copilot" / "forbidden" / "unauthorized". That is a
+    // verdict on the account: the subscription cannot serve this credential,
+    // and no amount of waiting or refreshing changes it. Cooldown cycling
+    // (auth_invalidated + 5m backoff) kept a dead account in rotation where a
+    // client's retry budget burned sibling accounts — the same failure the
+    // buddy ban exists to prevent. Disable immediately. Must run before
+    // `credential-rejected`, which would claim the bare 403 as a refreshable
+    // auth rejection.
+    name: "github-copilot-not-licensed",
+    match: (s) =>
+      s.origin === "upstream" &&
+      s.providerId === "github" &&
+      copilotNotLicensed(s.lower),
+    decide: (s) =>
+      s.result(
+        "policy_blocked_banned",
+        "disabled",
+        0,
+        null,
+        s.reason("GitHub Copilot account not licensed"),
+        // A license refusal is evidence about the account even at provider
+        // scope, for the same reason a named revocation or a buddy ban is.
+        true,
+      ),
+  },
   {
     name: "credential-rejected",
     match: (s) =>
@@ -1471,7 +1518,7 @@ const ACCOUNT_ERROR_RULES: readonly AccountErrorRule[] = [
   },
   {
     name: "quota-exhausted",
-    match: (s) => s.quotaSignal,
+    match: (s) => s.origin === "upstream" && s.quotaSignal,
     decide: (s) => {
       // xAI Grok Build's free tier resets on a rolling window. Use a duration
       // stated by the provider when present; otherwise park for the conservative
@@ -1525,6 +1572,7 @@ const ACCOUNT_ERROR_RULES: readonly AccountErrorRule[] = [
     // moves to the next account and the flagged one returns almost at once.
     name: "inception-per-minute-limit",
     match: (s) =>
+      s.origin === "upstream" &&
       s.providerId === "inception" &&
       (s.statusCode === 429 ||
         s.providerCode === "rate_limit_reached" ||
@@ -1549,15 +1597,16 @@ const ACCOUNT_ERROR_RULES: readonly AccountErrorRule[] = [
   {
     name: "rate-limit",
     match: (s) =>
-      s.statusCode === 429 ||
-      s.providerCode === "rate_limit_exceeded" ||
-      s.lower.includes("rate_limit") ||
-      s.lower.includes("rate limit") ||
-      s.lower.includes("too many requests") ||
-      s.lower.includes("requests per minute") ||
-      s.lower.includes("tokens per minute") ||
-      s.lower.includes("tpm limit") ||
-      s.lower.includes("rpm limit"),
+      s.origin === "upstream" &&
+      (s.statusCode === 429 ||
+        s.providerCode === "rate_limit_exceeded" ||
+        s.lower.includes("rate_limit") ||
+        s.lower.includes("rate limit") ||
+        s.lower.includes("too many requests") ||
+        s.lower.includes("requests per minute") ||
+        s.lower.includes("tokens per minute") ||
+        s.lower.includes("tpm limit") ||
+        s.lower.includes("rpm limit")),
     decide: (s) => {
       const cooldownMs = s.statedCooldownMs ?? DEFAULT_RATE_LIMIT_COOLDOWN_MS();
       // Same per-account reasoning as quota above: the failing account (or
@@ -1576,13 +1625,14 @@ const ACCOUNT_ERROR_RULES: readonly AccountErrorRule[] = [
   {
     name: "model-capacity",
     match: (s) =>
-      s.statusCode === 503 ||
-      s.statusCode === 529 ||
-      s.providerCode === "model_capacity" ||
-      s.queuedUpstream ||
-      s.lower.includes("model overloaded") ||
-      s.lower.includes("capacity exceeded") ||
-      s.lower.includes("temporarily unavailable"),
+      s.origin === "upstream" &&
+      (s.statusCode === 503 ||
+        s.statusCode === 529 ||
+        s.providerCode === "model_capacity" ||
+        s.queuedUpstream ||
+        s.lower.includes("model overloaded") ||
+        s.lower.includes("capacity exceeded") ||
+        s.lower.includes("temporarily unavailable")),
     decide: (s) => {
       const cooldownMs = s.statedCooldownMs ?? MODEL_CAPACITY_COOLDOWN_MS();
       const modelScopedMutation = s.origin === "upstream" && s.modelId !== undefined;

package/src/providers/operations/byok-wire-profile.ts

@@ -92,12 +92,11 @@ const ENDPOINT_TAIL = /\/(?:v\d+\/)?(?:messages|chat\/completions|responses|comp
  * The root an operator's pasted URL really meant, plus the endpoint tail that
  * was removed.
  *
- * The suggestion is the bare **origin**, not the path left behind. For
- * `https://api.deepseek.com/anthropic/v1/messages` the tail `/v1/messages` is
- * only the last segment; `/anthropic` is part of that same endpoint, and
- * suggesting `https://api.deepseek.com/anthropic` would still derive the model
- * list at `…/anthropic/models` and 404 — the very failure this corrects. A URL
- * that is already a root comes back with an empty `stripped`.
+ * Only the **tail** is stripped. Any path before it belongs to the gateway
+ * root and survives, so `https://api.longcat.ai/anthropic/v1/messages`
+ * resolves to `https://api.longcat.ai/anthropic` (not the bare origin) — the
+ * `/anthropic` prefix is where LongCat actually serves the API. A URL that is
+ * already a root comes back with an empty `stripped`.
  */
 export function splitEndpointBaseUrl(baseUrl: string): { readonly baseUrl: string; readonly stripped: string } {
   const trimmed = baseUrl.replace(/\/+$/, "");
@@ -110,20 +109,22 @@ export function splitEndpointBaseUrl(baseUrl: string): { readonly baseUrl: strin
   const basePath = parsed.pathname.replace(/\/+$/, "");
   const match = ENDPOINT_TAIL.exec(basePath);
   if (match === null) return { baseUrl: trimmed, stripped: "" };
-  return { baseUrl: parsed.origin, stripped: basePath };
+  const keptPath = basePath.slice(0, match.index);
+  return { baseUrl: `${parsed.origin}${keptPath}`, stripped: basePath };
 }
 
 /**
  * Base URL an operator's model list lives under (`<base>/models`). A bare host
  * has no version segment, so it gets the `/v1` prefix; a base that already
  * carries a path (conventionally `/v1`) is used as-is. A pasted endpoint path
- * is stripped first, so `…/anthropic/v1/messages` discovers at `<host>/v1/models`
- * rather than one level below a per-request path.
+ * is stripped first, so `…/anthropic/v1/messages` discovers at
+ * `<origin>/anthropic/v1/models` — the gateway prefix before the endpoint tail
+ * belongs to the root and is preserved.
  */
 export function modelDiscoveryBaseUrl(baseUrl: string): string {
-  // A pasted endpoint is not a base at all, so its whole path is discarded and
-  // the list is looked for at `<origin>/v1`. A base that already IS a root —
-  // bare host, or a version/gateway prefix — keeps that path, because
+  // A pasted endpoint has its tail removed; whatever path came before it is a
+  // real gateway prefix and stays. A base that already IS a root — bare host,
+  // or a version/gateway prefix — keeps that path, because
   // `https://gateway.example/api/v1` legitimately serves its list there.
   const trimmed = baseUrl.replace(/\/+$/, "");
   let parsed: URL;
@@ -133,9 +134,12 @@ export function modelDiscoveryBaseUrl(baseUrl: string): string {
     return `${trimmed}/v1`;
   }
   const basePath = parsed.pathname.replace(/\/+$/, "");
-  const isPastedEndpoint = ENDPOINT_TAIL.test(basePath);
-  const listBase = isPastedEndpoint ? parsed.origin : `${parsed.origin}${basePath}`;
-  if (isPastedEndpoint || basePath === "" || basePath === "/") return `${listBase}/v1`;
+  const match = ENDPOINT_TAIL.exec(basePath);
+  const listBase =
+    match === null
+      ? `${parsed.origin}${basePath}`
+      : `${parsed.origin}${basePath.slice(0, match.index)}`;
+  if (match !== null || basePath === "" || basePath === "/") return `${listBase}/v1`;
   return listBase;
 }
 

package/src/providers/provider-usage.ts

@@ -1,4 +1,5 @@
 import type { UsageRecord } from "../protocol/canonical-model";
+import { resolveUsageInputMode } from "../config/usage";
 export interface OpenAiUsage {
   prompt_tokens: number;
   completion_tokens: number;
@@ -11,7 +12,6 @@ export interface OpenAiUsage {
   };
 }
 import { modelsDevCatalog } from "./discovery/models-dev-catalog";
-import { resolveCacheMode } from "../config/providers";
 
 /**
  * Extract cost multipliers from catalog model cost JSONB.
@@ -126,36 +126,6 @@ export function repriceUsage(
     : { ...usage, estimated_cost: estimatedCost };
 }
 
-/**
- * Simplified cache accounting: when the provider reported a cache hit, the
- * whole prompt counts as cached — request input ber-cache = cache-eligible →
- * input = cache. The cache-write volume is already inside the all-in input
- * total on cache-aware shapes, so it stays separate and is not double-counted
- * as a hit. A reported `0` or an absent report stay a cache miss. In `real`
- * mode the provider's reported split is kept as-is.
- *
- * Exported so the hand-built record producers (Cursor, Kiro) apply the same
- * rule as `normalizeUsage`.
- */
-export function applyCacheMode(usage: UsageRecord): UsageRecord {
-  if (resolveCacheMode() !== "simplified") return usage;
-  if (
-    typeof usage.cached_input_tokens === "number" &&
-    usage.cached_input_tokens > 0 &&
-    usage.input_tokens > 0
-  ) {
-    const writes =
-      typeof usage.cache_write_tokens === "number" ? Math.max(0, usage.cache_write_tokens) : 0;
-    const cached = Math.min(usage.input_tokens, Math.max(0, usage.input_tokens - writes));
-    return {
-      ...usage,
-      cached_input_tokens: cached,
-      uncached_input_tokens: 0,
-    };
-  }
-  return usage;
-}
-
 /**
  * Normalize provider-specific usage data into canonical UsageRecord.
  * Handles Anthropic (cache_read_input_tokens, cache_creation_input_tokens, output_tokens_details.thinking_tokens)
@@ -266,10 +236,21 @@ export function normalizeUsage(input: Record<string, unknown>): UsageRecord {
   const reportedTotal = typeof input.total_tokens === "number" ? input.total_tokens : null;
   const inputAlreadyIncludesCache =
     reportedTotal !== null && reportedTotal === input_tokens + output_tokens;
-  const hasAnthropicCacheShape = anthropic_cache_read !== null && !inputAlreadyIncludesCache;
+  // `inclusive` (default) folds cache into input so every provider reads alike:
+  // IN is always the whole prompt and CACHED its subset. Anthropic's raw shape
+  // is fresh-only with cache separate — and its `total_tokens` equals
+  // input+output by contract, so the `inputAlreadyIncludesCache` heuristic
+  // would otherwise mistake it for already-inclusive and never add the cache,
+  // under-reporting prompt by the entire cached span. `as-is` keeps the raw
+  // upstream semantics (and the legacy heuristic for already-inclusive bridges).
+  const accountInputInclusive = resolveUsageInputMode() === "inclusive";
+  const cacheIsSeparate = anthropic_cache_read !== null;
+  const shouldFoldCache = accountInputInclusive
+    ? cacheIsSeparate
+    : cacheIsSeparate && !inputAlreadyIncludesCache;
   let uncached_input_tokens: number | "unavailable" = "unavailable";
   if (typeof cached_input_tokens === "number") {
-    if (hasAnthropicCacheShape) {
+    if (shouldFoldCache) {
       uncached_input_tokens = input_tokens;
       input_tokens +=
         cached_input_tokens + (typeof cache_write_tokens === "number" ? cache_write_tokens : 0);
@@ -277,25 +258,10 @@ export function normalizeUsage(input: Record<string, unknown>): UsageRecord {
       uncached_input_tokens = Math.max(0, input_tokens - Math.min(input_tokens, cached_input_tokens));
       cached_input_tokens = Math.min(input_tokens, cached_input_tokens);
     }
-  } else if (hasAnthropicCacheShape && typeof cache_write_tokens === "number") {
+  } else if (shouldFoldCache && typeof cache_write_tokens === "number") {
     input_tokens += cache_write_tokens;
   }
 
-  // Simplified cache accounting: a reported hit makes the whole prompt count as
-  // cached — request input ber-cache = cache-eligible → input = cache. The
-  // cache-write volume is already inside the all-in input total on cache-aware
-  // shapes, so it stays separate and is not double-counted as a hit. Applied
-  // before pricing so the estimated cost reads the same simplified split as the
-  // record.
-  if (typeof cached_input_tokens === "number" && cached_input_tokens > 0 && input_tokens > 0) {
-    if (resolveCacheMode() === "simplified") {
-      const writes =
-        typeof cache_write_tokens === "number" ? Math.max(0, cache_write_tokens) : 0;
-      cached_input_tokens = Math.min(input_tokens, Math.max(0, input_tokens - writes));
-      uncached_input_tokens = 0;
-    }
-  }
-
   // Handle reasoning tokens: Anthropic and OpenAI both use output_tokens_details
   let reasoning_tokens: number | "unavailable" = "unavailable";
   const details: NonNullable<UsageRecord["details"]> = {};

package/src/security/admission/service.ts

@@ -164,13 +164,20 @@ export class ApiKeyAdmissionService {
         const actual = usageTokens(usage);
         await this.store.reconcile(apiKeyId, estimatedTokens, actual, reservationId);
         finalized = true;
-        // Persist against the authenticating key (`snapshot.api_key_id`), not
-        // the admission identity. Share children share the parent's counter
-        // namespace for enforcement, but attribution must still land on the
-        // child row so recipient usage and sumChildrenConsumed stay correct.
+        // Persist the spend against BOTH the authenticating key and the family
+        // owner. The authenticating key (`snapshot.api_key_id`, the child for
+        // a share recipient) carries attribution so `sumChildrenConsumed` and
+        // recipient rows stay correct. The family owner (`admission_identity`,
+        // the template itself for a share child) is the live accumulator the
+        // console reads for total usage — without it the template column never
+        // moved and every figure depended on telemetry rows alone.
         if (this.persistLifetimeUsage) {
+          const ownerId = snapshot.admission_identity ?? snapshot.api_key_id;
           try {
             await this.persistLifetimeUsage({ apiKeyId: snapshot.api_key_id, delta: actual });
+            if (ownerId !== snapshot.api_key_id) {
+              await this.persistLifetimeUsage({ apiKeyId: ownerId, delta: actual });
+            }
           } catch {
             // Non-fatal: the transient counter already reflects reality; a
             // subsequent request will overwrite the row with the fresh count.