cartethyia 2.7.8 → 2.7.9

package/src/console/quota/account-quota-global.ts

@@ -1,6 +1,7 @@
 import { t } from "elysia";
 import type { Elysia } from "elysia";
-import { and, eq, inArray, isNull } from "drizzle-orm";
+import { and, eq, inArray, isNull, sql } from "drizzle-orm";
+import { isSqliteDatabase } from "../../persistence/dialect";
 import { adminAuditLog, providerAccounts } from "../../persistence/schema";
 import { requireGlobalAdmin } from "../shared/errors";
 import {
@@ -26,6 +27,24 @@ import {
   type AccountQuotaRoutesDeps,
   type AccountStatus,
 } from "./account-quota-shared";
+import type { ProviderAccountBulkActionResult } from "../providers/catalog/contracts";
+
+/**
+ * The same live-cooldown predicate as the tenant-scoped store, evaluated in
+ * SQL so one statement covers the whole shared-account set. `status='cooldown'`
+ * counts even when its deadline elapsed; a live `model_cooldowns` entry counts
+ * even while `status` is still `active` (D07).
+ */
+function globalLiveCooldownPredicate(database: unknown): ReturnType<typeof and> {
+  const nowIso = new Date().toISOString();
+  const liveModelCooldown = isSqliteDatabase(database)
+    ? sql`EXISTS (SELECT 1 FROM json_each(${providerAccounts.modelCooldowns}) AS entry WHERE json_valid(${providerAccounts.modelCooldowns}) AND json_type(${providerAccounts.modelCooldowns}) = 'object' AND entry.value > ${nowIso})`
+    : sql`EXISTS (SELECT 1 FROM jsonb_each_text(${providerAccounts.modelCooldowns}) AS entry WHERE jsonb_typeof(${providerAccounts.modelCooldowns}) = 'object' AND entry.value > ${nowIso})`;
+  return and(
+    isNull(providerAccounts.tenantId),
+    sql`${providerAccounts.status} = 'cooldown' OR ${providerAccounts.cooldownUntil} > ${nowIso} OR ${liveModelCooldown}`,
+  )!;
+}
 
 /**
  * Registers the platform-admin account/quota routes onto `app`. Every route here
@@ -38,6 +57,47 @@ export function registerAccountQuotaGlobalRoutes(
   refreshDeps: QuotaRefreshDeps,
 ): void {
   const { db, accessResolver, redis, snapshotInvalidator } = deps;
+  /**
+   * The two bulk actions are one statement each, scoped strictly to shared
+   * rows. Neither action takes a provider filter: the global-admin surface
+   * lists shared accounts across providers, and the same health predicate
+   * defines the target set everywhere.
+   */
+  const runGlobalBulk = async (
+    kind: "disable" | "delete",
+  ): Promise<ProviderAccountBulkActionResult> => {
+    if (kind === "disable") {
+      const updated = await db
+        .update(providerAccounts)
+        .set({ status: "disabled" })
+        .where(globalLiveCooldownPredicate(db))
+        .returning({ id: providerAccounts.id });
+      invalidateCredentialCaches(updated.map((row) => row.id));
+      await snapshotInvalidator?.invalidate();
+      return { ok: true, updated: updated.length, globalSkipped: 0 };
+    }
+    const deleted = await db
+      .delete(providerAccounts)
+      .where(
+        and(
+          isNull(providerAccounts.tenantId),
+          eq(providerAccounts.status, "disabled"),
+          eq(providerAccounts.lastErrorCategory, "policy_blocked_banned"),
+        ),
+      )
+      .returning({ id: providerAccounts.id });
+    const deletedIds = deleted.map((row) => row.id);
+    invalidateCredentialCaches(deletedIds);
+    await invalidateQuotaCaches(GLOBAL_QUOTA_LENS, deletedIds, redis);
+    await snapshotInvalidator?.invalidate();
+    return {
+      ok: true,
+      updated: 0,
+      deleted: deletedIds,
+      missing: [],
+      globalSkipped: 0,
+    };
+  };
   app
     .get("/global/accounts", async ({ request }) => {
       requireGlobalAdmin(accessResolver(request));
@@ -157,6 +217,34 @@ export function registerAccountQuotaGlobalRoutes(
       });
       return { ok: true, deleted: deletedIds, missing };
     })
+    /**
+     * Global counterparts of the provider-detail bulk actions (D10): shared
+     * accounts carry `tenant_id IS NULL`, so the tenant-scoped pair can never
+     * match them. Both are one statement, one audit row, one snapshot
+     * invalidation, and authorize through `requireGlobalAdmin`.
+     */
+    .post("/global/accounts/actions/disable-cooldowns", async ({ request }) => {
+      const access = requireGlobalAdmin(accessResolver(request));
+      const { ok, updated, globalSkipped } = await runGlobalBulk("disable");
+      await db.insert(adminAuditLog).values({
+        actor: access.admissionIdentity,
+        action: "provider_account.bulk_disabled_cooldowns",
+        target: "global",
+        detail: { updated, globalSkipped },
+      });
+      return { ok, updated, globalSkipped };
+    })
+    .post("/global/accounts/actions/delete-banned", async ({ request }) => {
+      const access = requireGlobalAdmin(accessResolver(request));
+      const { ok, updated, deleted, missing, globalSkipped } = await runGlobalBulk("delete");
+      await db.insert(adminAuditLog).values({
+        actor: access.admissionIdentity,
+        action: "provider_account.bulk_deleted_banned",
+        target: "global",
+        detail: { deleted: deleted ?? [], missing: missing ?? [], globalSkipped },
+      });
+      return { ok, updated, deleted: deleted ?? [], missing: missing ?? [], globalSkipped };
+    })
     .post("/global/accounts/:id/quota/refresh", async ({ request, params, set }) => {
       const access = requireGlobalAdmin(accessResolver(request));
       const target = await loadQuotaTarget(db, params.id, null);

package/src/console/quota/native-identity.ts

@@ -16,6 +16,7 @@ import {
   DrizzleQoderNativeIdentityStore,
   type QoderNativeIdentityStore,
 } from "../../providers/integrations/qoder/qoder-native-identity-store";
+import { qoderRealmForProvider } from "../../providers/integrations/qoder/qoder-realm";
 import { ConsoleDomainError, requireGlobalAdmin, requireTenantScope } from "../shared/errors";
 import type { ConsoleAccessResolver } from "../auth/access";
 
@@ -38,6 +39,7 @@ export type NativeIdentityAllocator = (args: {
 function defaultAllocator(store: QoderNativeIdentityStore): NativeIdentityAllocator {
   return ({ providerId, accountId, avoidToken }) =>
     allocateQoderNativeIdentity(store, providerId, accountId, {
+      realm: qoderRealmForProvider(providerId),
       ...(avoidToken !== undefined ? { avoidToken } : {}),
     });
 }

package/src/console/settings/contracts.ts

@@ -59,6 +59,15 @@ export interface RuntimeSettingsResponse {
    * used instead.
    */
   readonly visionHandoffModels: readonly string[];
+  /**
+   * Auto-disable provider accounts stuck on upstream rate-limit/quota verdicts.
+   * Default false — the risky direction stays off until an operator flips it.
+   */
+  readonly autoDisableRateLimited: boolean;
+  /** Modelprobe mode; `detail` when unset. */
+  readonly modelProbeMode: ModelProbeMode;
+  /** Fast-probe timeout in seconds; null means the built-in default (10). */
+  readonly modelProbeFastTimeoutSeconds: number | null;
   readonly updatedAt: string;
   /*
    * What each `null` actually resolves to, in the same units the row stores.
@@ -136,6 +145,10 @@ export type PonyTailLevel = (typeof PONYTAIL_LEVELS)[number];
 /** RTK prune strength accepted by the runtime-settings PATCH. */
 export type RtkLevel = (typeof RTK_LEVELS)[number];
 
+export const MODEL_PROBE_MODES = ["fast", "detail"] as const;
+/** Modelprobe mode accepted by the runtime-settings PATCH and the probe route. */
+export type ModelProbeMode = (typeof MODEL_PROBE_MODES)[number];
+
 /** Upper bound on the number of ordered vision-handoff models. */
 export const VISION_HANDOFF_MAX_MODELS = 8;
 
@@ -272,4 +285,9 @@ export const runtimeUpdateBody = t.Object({
     t.Union([t.Null(), t.Number({ minimum: 64 * 1024, maximum: 100 * 1024 * 1024 })]),
   ),
   visionHandoffModels: t.Optional(t.Array(t.String())),
+  autoDisableRateLimited: t.Optional(t.Boolean()),
+  modelProbeMode: t.Optional(literalUnion(MODEL_PROBE_MODES)),
+  modelProbeFastTimeoutSeconds: t.Optional(
+    t.Union([t.Null(), t.Number({ minimum: 1, maximum: 120 })]),
+  ),
 });

package/src/console/settings/store.ts

@@ -10,6 +10,7 @@ import { resolveUpstreamTimeoutMs } from "../../config/timeouts";
 import { payloadRetentionMs } from "../../observability/payload-capture";
 import { IMAGE_CLAMP_MAX_BYTES } from "../../protocol/image-clamp";
 import {
+  MODEL_PROBE_MODES,
   PONYTAIL_LEVELS,
   RESPONSES_REASONING_SUMMARIES,
   RTK_LEVELS,
@@ -23,6 +24,7 @@ import {
   type RuntimeSettingsStore,
   type TelemetryPayloadDepth,
   type TelemetryPayloadMode,
+  type ModelProbeMode,
   type UpdateRuntimeSettingsRequest,
 } from "./contracts";
 
@@ -116,6 +118,23 @@ function normalizeConcurrencyTolerance(value: unknown): number | null {
   return normalizeBoundedNumber(value, 0, 1024);
 }
 
+/** Modelprobe mode: only the two known modes survive; anything else = `detail`. */
+function normalizeModelProbeMode(value: unknown): ModelProbeMode {
+  return typeof value === "string" && (MODEL_PROBE_MODES as readonly string[]).includes(value)
+    ? (value as ModelProbeMode)
+    : "detail";
+}
+
+/**
+ * Fast-probe timeout in seconds: 1–120, `null` = deployment default, and any
+ * other absent/non-finite value reads as the built-in default of 10 (the UI
+ * select's middle choice, and the value probing uses when unset).
+ */
+function normalizeModelProbeFastTimeoutSeconds(value: unknown): number | null {
+  if (value === null) return null;
+  return normalizeBoundedNumber(value, 1, 120) ?? 10;
+}
+
 /** Ordered vision-handoff models: non-empty strings, trimmed, de-duplicated. */
 function normalizeVisionHandoffModels(value: unknown): readonly string[] {
   if (!Array.isArray(value)) return [];
@@ -166,6 +185,11 @@ function mapRuntimeSettingsRow(
     telemetryWindowMinutes: normalizeTelemetryWindowMinutes(prefs.telemetryWindowMinutes),
     imageClampMaxBytes: normalizeImageClampMaxBytes(prefs.imageClampMaxBytes),
     visionHandoffModels: normalizeVisionHandoffModels(prefs.visionHandoffModels),
+    autoDisableRateLimited: prefs.autoDisableRateLimited === true,
+    modelProbeMode: normalizeModelProbeMode(prefs.modelProbeMode),
+    modelProbeFastTimeoutSeconds: normalizeModelProbeFastTimeoutSeconds(
+      prefs.modelProbeFastTimeoutSeconds,
+    ),
     updatedAt,
     /*
      * Resolved at request time, not at module load: all four come from env the
@@ -231,6 +255,14 @@ export class DrizzleRuntimeSettingsStore implements RuntimeSettingsStore {
       patchPrefs.imageClampMaxBytes = normalizeImageClampMaxBytes(patch.imageClampMaxBytes);
     if (patch.visionHandoffModels !== undefined)
       patchPrefs.visionHandoffModels = normalizeVisionHandoffModels(patch.visionHandoffModels);
+    if (patch.autoDisableRateLimited !== undefined)
+      patchPrefs.autoDisableRateLimited = patch.autoDisableRateLimited === true;
+    if (patch.modelProbeMode !== undefined)
+      patchPrefs.modelProbeMode = normalizeModelProbeMode(patch.modelProbeMode);
+    if (patch.modelProbeFastTimeoutSeconds !== undefined)
+      patchPrefs.modelProbeFastTimeoutSeconds = normalizeModelProbeFastTimeoutSeconds(
+        patch.modelProbeFastTimeoutSeconds,
+      );
 
     const rows = await this.db
       .insert(consoleSettings)

package/src/console/system-prompt/contracts.ts

@@ -115,7 +115,6 @@ export const SYSTEM_PROMPT_ALIAS_LIMIT = 512;
 const WRAPPED_INJECTION_PROVIDERS: ReadonlySet<string> = new Set([
   "cb", // CodeBuddy International
   "cbcn", // CodeBuddy CN
-  "workbuddy",
 ]);
 
 /** Whether a provider's tenant text rides wrapped after the fixed identity prompt. */

package/src/main.ts

@@ -84,6 +84,7 @@ const app = boot
         oauthRefreshService: boot.deps.oauthRefreshService,
         admissionService: boot.deps.admissionService,
         readRoutingAccountInflight: boot.deps.readRoutingAccountInflight,
+        ipAbuseStore: boot.deps.ipAbuseStore,
         // The same three writers the shutdown coordinator drains, so a manual
         // flush from the console does exactly what a graceful stop would do
         // for the queues, minus the stop.

package/src/observability/event-query.ts

@@ -41,11 +41,26 @@ export const IS_GATEWAY_ERROR_SQL = gatewayErrorSql(telemetryEvents.status, tele
  * cannot drift; the sum fragments coalesce to 0 so an empty window reads as
  * zero rather than null.
  */
+/**
+ * Cached-token aggregate under the "eligible request" rule.
+ *
+ * A request that carried any cached input (`cached_input_tokens > 0`) is a
+ * cache hit, and the WHOLE prompt is read as cached — the operator's rule is
+ * binary per request, not proportional (see the Usage page's "Cached tokens"
+ * tile and the provider Activity Matrix). So the aggregate is the sum of
+ * `input_tokens` over rows with a positive cached count, not the sum of the
+ * cached counts themselves.
+ *
+ * This reuses the same column the row-level estimator writes
+ * (`cached_input_tokens`), so it stays consistent across SQLite and Postgres.
+ */
+const CACHED_INPUT_TOKENS_SQL = sql<number>`coalesce(sum(case when ${telemetryEvents.cachedInputTokens} > 0 then ${telemetryEvents.inputTokens} else 0 end), 0)`;
+
 const AGGREGATE_SELECT = {
   errors: sql<number>`sum(case when ${IS_GATEWAY_ERROR_SQL} then 1 else 0 end)`,
   inputTokens: sql<number>`coalesce(sum(${telemetryEvents.inputTokens}), 0)`,
   outputTokens: sql<number>`coalesce(sum(${telemetryEvents.outputTokens}), 0)`,
-  cachedInputTokens: sql<number>`coalesce(sum(${telemetryEvents.cachedInputTokens}), 0)`,
+  cachedInputTokens: CACHED_INPUT_TOKENS_SQL,
 } as const;
 
 /** One bounded page of events, newest first. */
@@ -531,7 +546,6 @@ export async function breakdownTelemetry(
       key: column,
       requests: sql<number>`count(*)`,
       ...AGGREGATE_SELECT,
-      cachedInputTokens: sql<number>`coalesce(sum(${telemetryEvents.cachedInputTokens}), 0)`,
       costUsd: sql<number>`coalesce(sum(${telemetryEvents.estimatedCostUsd}), 0)`,
       avgTokensPerSec: sql<number>`coalesce(avg(${telemetryEvents.tokensPerSec}), 0)`,
     })
@@ -620,7 +634,7 @@ export async function providerUsageMatrix(
       model: telemetryEvents.requestedModel,
       requests: sql<number>`count(*)`,
       inputTokens: AGGREGATE_SELECT.inputTokens,
-      cachedInputTokens: sql<number>`coalesce(sum(${telemetryEvents.cachedInputTokens}), 0)`,
+      cachedInputTokens: CACHED_INPUT_TOKENS_SQL,
       outputTokens: AGGREGATE_SELECT.outputTokens,
       costUsd: sql<number>`coalesce(sum(${telemetryEvents.estimatedCostUsd}), 0)`,
     })
@@ -861,7 +875,7 @@ export async function summarizeUsageWithPerformance(
       truncated: sql<number>`sum(case when ${telemetryEvents.status} = 'truncated' then 1 else 0 end)`,
       inputTokens: AGGREGATE_SELECT.inputTokens,
       outputTokens: AGGREGATE_SELECT.outputTokens,
-      cachedInputTokens: sql<number>`coalesce(sum(${telemetryEvents.cachedInputTokens}), 0)`,
+      cachedInputTokens: CACHED_INPUT_TOKENS_SQL,
       reasoningTokens: sql<number>`coalesce(sum(${telemetryEvents.reasoningTokens}), 0)`,
       estimatedCostUsd: sql<number>`coalesce(sum(${telemetryEvents.estimatedCostUsd}), 0)`,
       sampled: sql<number>`count(${telemetryEvents.latencyMs})`,

package/src/persistence/dialect.ts

@@ -55,6 +55,18 @@ function hasSqliteDialect(database: unknown): boolean {
   return (database as { session?: unknown } | undefined)?.session instanceof SQLiteBunSession;
 }
 
+/**
+ * Dialect of a concrete Drizzle handle, rather than of the process's env.
+ *
+ * A test can hold an in-memory SQLite database while `CARTETHYIA_DB_MODE`
+ * names `full` (the backend suite sets that globally). A raw SQL predicate
+ * chosen from the env would emit `jsonb_each_text` into SQLite and fail; the
+ * handle's session is the authority, exactly as `mergeJson` already treats it.
+ */
+export function isSqliteDatabase(database: unknown): boolean {
+  return hasSqliteDialect(database);
+}
+
 /**
  * The per-model cooldown object with every entry whose timestamp has passed
  * removed, or `'{}'` when nothing remains.

package/src/persistence/schema.ts

@@ -219,8 +219,8 @@ export interface NativeIdentityRecord {
   readonly machineCode: string;
   /** The seed-file content this identity was minted from, if captured. */
   readonly seed?: string;
-  /** How this identity was produced: the genuine SG bridge or the fallback. */
-  readonly source?: "runtime-info" | "generated";
+  /** How this identity was produced: the genuine SG bridge, the OS fingerprint, or the fallback. */
+  readonly source?: "runtime-info" | "generated" | "os";
 }
 
 export const providerAccounts = pgTable("provider_accounts", {
@@ -432,6 +432,11 @@ export const models = pgTable(
     reasoning: boolean("reasoning").notNull().default(false),
     toolCall: boolean("tool_call").notNull().default(false),
     cost: jsonb("cost"),
+    // Display-only warning metadata for this row: Postgres `jsonb` (SQLite
+    // `text` carrying the JSON string), nullable, `NULL` = no warnings. Shape:
+    // `{ warnings: [{ kind, message, severity?, updatedAt? }] }`. Part of the
+    // provider-account model-update proposal §3.4 area 06; not read by routing.
+    warningMetadata: jsonb("warning_metadata"),
     source: text("source"),
     sourceUpdatedAt: timestamp("source_updated_at", { withTimezone: true }),
     enabled: boolean("enabled").notNull().default(true),
@@ -1288,6 +1293,19 @@ export interface ConsoleSettingsPreferences {
    * placeholder behavior.
    */
   visionHandoffModels?: readonly string[];
+  /**
+   * Auto-disable provider accounts that keep failing with upstream rate-limit
+   * or quota verdicts. Off by default: without it, those failures land on a
+   * per-model/account cooldown and the account stays rotatable.
+   */
+  autoDisableRateLimited?: boolean;
+  /**
+   * Modelprobe mode: `detail` (full identity probe) or `fast` (minimal
+   * 32-token check). `detail` when unset.
+   */
+  modelProbeMode?: "fast" | "detail";
+  /** Fast-probe timeout in seconds; `null`/absent means the built-in default (10). */
+  modelProbeFastTimeoutSeconds?: number | null;
 }
 
 export const consoleSettings = pgTable("console_settings", {

package/src/protocol/dsml.ts

@@ -5,7 +5,7 @@
  * markup inside the plain-text content stream instead of the structured
  * `tool_calls` field. The gateway sees it from one upstream family:
  *
- * - CodeBuddy/WorkBuddy emit strict blocks (`<｜DSML｜ calls>…</｜DSML｜ calls>`)
+ * - CodeBuddy emits strict blocks (`<｜DSML｜ calls>…</｜DSML｜ calls>`)
  *   that must be parsed exactly, with declared-tool allowlisting.
  */
 export interface DsmlToolCall {

package/src/protocol/gateway-error.ts

@@ -174,6 +174,7 @@ const PUBLIC_ERROR_DETAIL_KEYS = new Set([
   "status",
   "upstreamRequestId",
   "upstreamStatus",
+  "upstreamMessageAsIs",
   "maxInflight",
   "weight",
 ]);

package/src/protocol/reasoning.ts

@@ -34,7 +34,7 @@ export function applyOpenAIReasoning(payload: Record<string, unknown>, request:
   payload["reasoning_effort"] = effort;
 }
 
-/** Applies the DeepSeek chat contract shared by CodeBuddy and WorkBuddy. */
+/** Applies the DeepSeek chat contract shared by CodeBuddy. */
 export function applyDeepSeekReasoning(payload: Record<string, unknown>): void {
   const model = typeof payload["model"] === "string" ? payload["model"].trim().toLowerCase() : "";
   if (!model.startsWith("deepseek")) return;

package/src/protocol/request/chat.ts

@@ -248,7 +248,7 @@ export function canonicalToChatPayload(
       // to be replayed, and the tool-call turn is exactly where a thinking
       // model emits it — dropping it here made the next request fail with
       // "the reasoning content from the previous turn must be passed back in
-      // thinking mode" (WorkBuddy/CodeBuddy 400). Chat Completions has no
+      // thinking mode" (CodeBuddy 400). Chat Completions has no
       // reasoning content part, so it travels in the provider-native
       // `reasoning_content` side channel, same as the branches below.
       const reasoningContent = m.content
@@ -365,7 +365,7 @@ export function canonicalToChatPayload(
         // nothing left to say: emitting it as an empty-content `user` message
         // right after the tool results breaks strict upstreams (a bare `user`
         // turn between a result and the next assistant turn reads as a broken
-        // tool sequence — WorkBuddy/CodeBuddy `11148`). Fold the leftover
+        // tool sequence — CodeBuddy `11148`). Fold the leftover
         // reasoning into the last tool message's side channel when one was
         // just emitted, and skip the turn otherwise; a turn that still
         // carries text or rich parts emits below as usual.
@@ -382,7 +382,7 @@ export function canonicalToChatPayload(
           // or a non-empty serialised payload. Pushing `{content:"",
           // reasoning_content:""}` is the opposite of load-bearing — the
           // upstream reads it as "thinking mode with the reasoning stripped"
-          // and rejects the whole request (`WorkBuddy/CodeBuddy 11151 "history
+          // and rejects the whole request (`CodeBuddy 11151 "history
           // not found"`). The canonical form that reaches this branch with no
           // trace is an input `reasoning` item whose `summary` was absent and
           // whose `payload` was `null` — a signature-less thinking block
@@ -570,7 +570,7 @@ export function canonicalToChatPayload(
   // Resolved unconditionally, not only when the caller sent a value: the bound
   // table now carries a `defaultMaxTokens` for this wire, and an omitted limit
   // must reach the upstream as a real number. Upstreams that require the field
-  // reject a large prompt whose `max_tokens` is absent outright (WorkBuddy
+  // reject a large prompt whose `max_tokens` is absent outright (CodeBuddy
   // `400 model_param_invalid`, reproduced through the gateway).
   const bounded = resolveWireMaxTokens("chat", { max_tokens: requestedMaxTokens }, {
     ...(options.maxOutputTokens === undefined ? {} : { maxOutputTokens: options.maxOutputTokens }),

package/src/protocol/request/messages.ts

@@ -39,7 +39,7 @@ import { claudeResponseToEvents, parseClaudeSseStream } from "../response/messag
  * Gateway default when the caller sent no max_tokens (Anthropic requires
  * the field). Explicit and warned at the call site — never silent.
  */
-const ANTHROPIC_DEFAULT_MAX_TOKENS = WIRE_TOKEN_BOUNDS["messages"]?.defaultMaxTokens ?? 4_096;
+export const ANTHROPIC_DEFAULT_MAX_TOKENS = WIRE_TOKEN_BOUNDS["messages"]?.defaultMaxTokens ?? 4_096;
 
 /** Anthropic Messages' documented base64-image media-type allowlist. */
 const ANTHROPIC_IMAGE_MEDIA_TYPES = new Set([

package/src/protocol/response/gemini.ts

@@ -38,15 +38,20 @@ export function responseParts(parts: readonly Record<string, unknown>[]): {
   readonly text: string;
   readonly calls: readonly { readonly id: string; readonly name: string; readonly args: Record<string, unknown> }[];
   readonly thought: string;
+  readonly thoughtSignature: string;
 } {
   const text: string[] = [];
   const thought: string[] = [];
+  let thoughtSignature = "";
   const calls: Array<{ id: string; name: string; args: Record<string, unknown> }> = [];
   let callIndex = 0;
   for (const part of parts) {
     if (typeof part["text"] === "string") {
       if (part["thought"] === true) {
         thought.push(part["text"] as string);
+        if (thoughtSignature.length === 0 && typeof part["thoughtSignature"] === "string") {
+          thoughtSignature = part["thoughtSignature"] as string;
+        }
       } else text.push(part["text"] as string);
     }
     if (isRecord(part["functionCall"]) && typeof (part["functionCall"] as Record<string, unknown>)["name"] === "string") {
@@ -58,7 +63,7 @@ export function responseParts(parts: readonly Record<string, unknown>[]): {
       });
     }
   }
-  return { text: text.join(""), calls, thought: thought.join("") };
+  return { text: text.join(""), calls, thought: thought.join(""), thoughtSignature };
 }
 
 export function mapGeminiUsage(body: Record<string, unknown>): Record<string, unknown> {

package/src/protocol/sse-decoder.ts

@@ -93,8 +93,19 @@ function isCompleteJsonValue(data: string): boolean {
 // invited a retry of the identical request against a broken upstream. The
 // `upstream` origin keeps the public envelope from prefixing it
 // a gateway-branded message, which blamed the gateway for the provider's bytes.
-function oversized(what: string): GatewayError {
-  return new GatewayError("platform_unavailable", 502, `SSE ${what} exceeds size bound (request {requestId}). The upstream sent more than we can hold — retry 🌙`, {}, "upstream");
+// The message quotes the offending line (bounded) so the client and operator
+// see the actual bytes the upstream sent rather than a generic sentence.
+const MAX_SSE_SNIPPET = 160;
+function snippet(line: string): string {
+  const collapsed = line.replace(/[\r\n]+/g, " ").trim();
+  if (collapsed.length === 0) return "<empty line>";
+  return collapsed.length > MAX_SSE_SNIPPET
+    ? `${collapsed.slice(0, MAX_SSE_SNIPPET)}…`
+    : collapsed;
+}
+function oversized(what: string, line?: string): GatewayError {
+  const quote = line === undefined ? "" : `: ${snippet(line)}`;
+  return new GatewayError("platform_unavailable", 502, `SSE ${what} exceeds size bound${quote} (request {requestId}). The upstream sent more than we can hold — retry 🌙`, {}, "upstream");
 }
 
 export async function* decodeSseEvents(
@@ -161,7 +172,7 @@ export async function* decodeSseEvents(
     const rest = last.subarray(newlineAt + 1);
     if (rest.byteLength > 0) pending.unshift(rest);
     const line = decoder.decode(lineBytes).replace(/\r$/, "");
-    if (line.length > maxLineBytes) throw oversized("line");
+    if (line.length > maxLineBytes) throw oversized("line", line);
     return line;
   }
   function* dispatchEvent(): Iterable<SseEvent> {
@@ -188,7 +199,7 @@ export async function* decodeSseEvents(
       const piece = line.slice(5).trimStart();
       dataLines.push(piece);
       eventBytes += piece.length;
-      if (eventBytes > maxEventBytes) throw oversized("event");
+      if (eventBytes > maxEventBytes) throw oversized("event", line);
       return;
     }
     if (line.startsWith("id:") || line.startsWith("retry:")) return;
@@ -220,10 +231,10 @@ export async function* decodeSseEvents(
     if (dataLines.length > 0) {
       dataLines.push(line);
       eventBytes += line.length;
-      if (eventBytes > maxEventBytes) throw oversized("event");
+      if (eventBytes > maxEventBytes) throw oversized("event", line);
       return;
     }
-    throw new GatewayError("platform_unavailable", 502, "Malformed SSE line (request {requestId}). The upstream sent something we can't read — retry 🌙", {}, "upstream");
+    throw new GatewayError("platform_unavailable", 502, `Malformed SSE line: ${snippet(line)} (request {requestId}). The upstream sent something we can't read — retry 🌙`, {}, "upstream");
   }
 
   try {
@@ -233,7 +244,10 @@ export async function* decodeSseEvents(
       if (chunk.value && chunk.value.byteLength > 0) {
         pending.push(chunk.value);
         pendingBytes += chunk.value.byteLength;
-        if (!hasPendingNewline() && pendingBytes > maxLineBytes) throw oversized("line");
+        if (!hasPendingNewline() && pendingBytes > maxLineBytes) {
+          const partial = decoder.decode(new Uint8Array(pendingBytes)).slice(0, MAX_SSE_SNIPPET);
+          throw oversized("line", partial);
+        }
       }
       let line = takeLine();
       while (line !== undefined) {
@@ -243,7 +257,10 @@ export async function* decodeSseEvents(
       if (chunk.done) break;
     }
     if (pendingBytes > 0) {
-      if (pendingBytes > maxLineBytes) throw oversized("line");
+      if (pendingBytes > maxLineBytes) {
+        const partial = decoder.decode(new Uint8Array(pendingBytes)).slice(0, MAX_SSE_SNIPPET);
+        throw oversized("line", partial);
+      }
       const total = new Uint8Array(pendingBytes);
       let offset = 0;
       for (const chunk of pending.splice(0, pending.length)) {

package/src/protocol/stream-error-frames.ts

@@ -17,7 +17,11 @@
  * which is honest: the upstream failed and we do not know more.
  */
 import { GatewayError } from "./gateway-error";
-import { classifyUpstreamError, extractUpstreamMessage, upstreamErrorIdentifier } from "../transport/failure-policy";
+import {
+  classifyUpstreamError,
+  upstreamErrorIdentifier,
+  extractUpstreamMessageText,
+} from "../transport/failure-policy";
 import { isRecord } from "./codecs";
 
 
@@ -54,19 +58,25 @@ export function gatewayErrorFromStreamError(
   }
   if (!isRecord(error)) return undefined;
 
-  const message = extractUpstreamMessage(error);
   const identifier = upstreamErrorIdentifier(error);
   const explicitStatus = numericStatus(error["status"], error["statusCode"], error["status_code"]);
   const classification = classifyUpstreamError(explicitStatus, identifier);
   const raw = JSON.stringify(error, null, 2).slice(0, 16_384);
+  // Only genuine prose (`message`/`msg`/`error` fields) counts as upstream
+  // passthrough text. A `code`/identifier is a classification key, not prose —
+  // it still serves as the message fallback when no text exists, but it must
+  // not set `upstreamMessageAsIs`.
+  const prose = extractUpstreamMessageText(error);
+  const message = prose.slice(0, 500) || identifier || label;
   return new GatewayError(
     classification.code,
     classification.status,
-    message || label,
+    message,
     {
       ...(explicitStatus === undefined ? {} : { providerStatus: explicitStatus }),
       ...(identifier ? { providerCode: identifier } : {}),
       raw,
+      ...(prose ? { upstreamMessageAsIs: true } : {}),
       ...(classification.credentialEvidence ? { credentialEvidence: true } : {}),
       ...(classification.rateLimitScope
         ? { rateLimitScope: classification.rateLimitScope }

package/src/protocol/translation/quirks.ts

@@ -49,7 +49,7 @@ interface WireTokenBound {
  * The output limit assumed when the caller states none, for wires that need
  * the field present.
  *
- * PROVEN, not assumed: a 3.16M-char prompt to WorkBuddy/CodeBuddy
+ * PROVEN, not assumed: a 3.16M-char prompt to CodeBuddy
  * (`bansos/deepseek-v4.1-flash`) answered `400 model_param_invalid` whenever
  * `max_tokens` was absent, and answered 200 with the *same* body plus any
  * explicit value — `1`, `16`, `1000`, `8000`, `64000`, `384000` all passed.

package/src/protocol/translation/tool-repair.ts

@@ -91,7 +91,7 @@ export function repairMissingToolResponses(
  * fully answered by matching `tool` results is stripped of its calls (kept when
  * it still carries content), and the dangling results go with it.
  *
- * This is the buddy-family policy (WorkBuddy/CodeBuddy code `11148`): a partial
+ * This is the buddy-family policy (CodeBuddy code `11148`): a partial
  * batch `assistant[c1 c2] + tool[c1]` is a broken sequence the upstream rejects,
  * and a synthesized placeholder cannot stand in for a real execution the model
  * never saw. Contrast `repairMissingToolResponses`, which synthesizes an
@@ -188,7 +188,7 @@ export function repairRequestToolCalls(request: CanonicalRequest): CanonicalRequ
  * True when a `toolResult` part is a `tool`-role turn whose `toolCall` is
  * absent from the whole history, or when results for one batch of calls are
  * not contiguous. Upstreams reject both with `tool_call_sequence_broken`
- * (WorkBuddy/CodeBuddy code `11148`), and a broken history stays broken: the
+ * (CodeBuddy code `11148`), and a broken history stays broken: the
  * client replays it on every later turn, so the whole conversation dies.
  */
 function toolCallIdsIn(message: CanonicalMessage): string[] {