cartethyia 2.7.2 → 2.7.4

package/src/security/admission/reasons.ts

@@ -19,26 +19,26 @@ const REASON_META: Record<
   }
 > = {
   "rpm-exhausted": {
-    message: "This key has used its requests-per-minute allowance. Wait for the window to roll over, or raise the key's rpm limit.",
-    code: "quota_exceeded",
+    message: "This key has used its requests-per-minute allowance (request {requestId}). Wait for the window to roll over, or raise the key's rpm limit. You've maxed this window — pace yourself ⏳",
+    code: "rate_limited",
     status: 429,
     metricLabel: "rpm_exhausted",
   },
   "daily-token-limit": {
-    message: "This key has used today's token allowance. It resets at the start of the next day, or raise the key's daily limit.",
-    code: "quota_exceeded",
+    message: "This key has used today's token allowance (request {requestId}). It resets at the start of the next day, or raise the key's daily limit. Pace yourself — it resets tomorrow ⏳",
+    code: "rate_limited",
     status: 429,
     metricLabel: "daily",
   },
   "monthly-token-limit": {
-    message: "This key has used this month's token allowance. It resets at the start of the next month, or raise the key's monthly limit.",
-    code: "quota_exceeded",
+    message: "This key has used this month's token allowance (request {requestId}). It resets at the start of the next month, or raise the key's monthly limit. Saving up for next month? It resets then ⏳",
+    code: "rate_limited",
     status: 429,
     metricLabel: "monthly",
   },
   "lifetime-token-budget": {
-    message: "This key has spent its lifetime token budget. Raise the budget, or issue a new key.",
-    code: "quota_exceeded",
+    message: "This key has spent its lifetime token budget (request {requestId}). Raise the budget, or issue a new key. The piggy bank is empty — top it up or mint a new key 🐷",
+    code: "rate_limited",
     status: 429,
     metricLabel: "lifetime",
   },
@@ -47,27 +47,27 @@ const REASON_META: Record<
     // max-inflight. The two used to be indistinguishable and both named the
     // provider, sending operators to the wrong setting after a rejection. The
     // `details` carry the limit so a client can tell which one fired.
-    message: "This API key is already serving its maximum number of concurrent requests. Retry shortly, or raise the key's concurrency limit.",
+    message: "This API key is already serving its maximum number of concurrent requests (request {requestId}). Retry shortly, or raise the key's concurrency limit. It'll free up in a moment 🌊",
     code: "capacity_exhausted",
     status: 429,
     metricLabel: "concurrency",
   },
   "tenant-capacity-exhausted": {
-    message: "This tenant is already serving its maximum number of concurrent requests. Retry shortly, or raise the tenant's concurrency limit.",
+    message: "This tenant is already serving its maximum number of concurrent requests (request {requestId}). Retry shortly, or raise the tenant's concurrency limit. The tenant is maxed out right now — chill 🏠",
     code: "tenant_capacity_exhausted",
     status: 429,
     metricLabel: "tenant_capacity",
   },
   "model-not-allowed": {
-    message: "This key is not allowed to use this model under its allowlist. Add the model to the key, or use one it already allows.",
-    code: "model_not_found",
-    status: 404,
+    message: "This key is not allowed to use this model under its allowlist (request {requestId}). Add the model to the key, or use one it already allows. The door's locked for this one — check the allowlist 🔒",
+    code: "model_not_allowed",
+    status: 403,
     metricLabel: "model_not_allowed",
   },
   "model-denied": {
-    message: "This key's denylist blocks this model. Remove the model from the denylist, or use a different model.",
-    code: "model_not_found",
-    status: 404,
+    message: "This key's denylist blocks this model (request {requestId}). Remove the model from the denylist, or use a different model. This one's on the banned list — pick another 🚫",
+    code: "model_not_allowed",
+    status: 403,
     metricLabel: "model_not_allowed",
   },
   "admission-unavailable": {
@@ -76,7 +76,7 @@ const REASON_META: Record<
     // `invalid_counter`, `unknown_reservation`, `invalid_actual_usage`). The
     // second is not an outage, so the text must not claim one — it names the
     // effect the client can act on, and the diagnostic stays in `details.reason`.
-    message: "The gateway could not admit this request. Retry shortly; if it persists, check the instance's Redis or coordination backend.",
+    message: "The gateway could not admit this request (request {requestId}). Retry shortly; if it persists, check the instance's Redis or coordination backend. The bouncer stepped out — come back shortly 🚪",
     code: "admission_unavailable",
     status: 503,
     metricLabel: "admission_unavailable",

package/src/security/api-key-auth.ts

@@ -6,7 +6,7 @@ import { DrizzleApiKeyStore } from "../persistence/stores/api-key-store";
 import { GatewayError } from "../protocol/gateway-error";
 import { hashSecret } from "./crypto";
 import { AUTH_CACHE_TTL_MS, createApiKeyAuthorizationCache } from "./api-key-auth-cache";
-import type { AccessScope } from "./access-control";
+import type { AccessScope, CallerIdentity } from "./access-control";
 import type { ApiKeyModelAccessMode } from "../persistence/schema";
 
 // ── Authorization cache ──────────────────────────────────────────────────────
@@ -222,6 +222,12 @@ export interface ResolvedApiKey {
   readonly modelPrefix?: string;
   /** Share-template id whose remote CLI mappings are inherited by this child. */
   readonly cliMappingOwnerId?: string;
+  /**
+   * Single "who is speaking" identity derived at auth. Carried through
+   * planning, admission, pool selection, and telemetry so every gate reasons
+   * about the same caller.
+   */
+  readonly caller: CallerIdentity;
 }
 
 /**
@@ -233,7 +239,7 @@ export interface ResolvedApiKey {
  * indistinguishable — distinguishing them would let a caller confirm that a
  * guessed token once existed — so there is no variant carrying a reason.
  */
-const INVALID_KEY_MESSAGE = "Invalid API key. Check the key you are sending, or create a new one in API Keys and send it as: Authorization: Bearer <key>.";
+const INVALID_KEY_MESSAGE = "Invalid API key (request {requestId}). Check the key you are sending, or create a new one in API Keys and send it as: Authorization: Bearer <key>. Wrong key, right door — double-check and come back 🔑";
 
 export function unknownApiKeyError(): GatewayError {
   return new GatewayError("authentication_failed", 401, INVALID_KEY_MESSAGE);
@@ -252,7 +258,7 @@ export function modelsListApiKeyError(): GatewayError {
   return new GatewayError(
     "authentication_failed",
     401,
-    "Invalid API key. Rotate the default Cartethyia API key in API Keys and send the new key as: Authorization: Bearer <key>.",
+    "Invalid API key (request {requestId}). Rotate the default Cartethyia API key in API Keys and send the new key as: Authorization: Bearer <key>. Wrong key, right door — rotate and try again 🔑",
   );
 }
 
@@ -273,12 +279,12 @@ export function requestToken(headers: Headers | Record<string, string>): string
     // *different* credentials stay a conflict — accepting whichever came first
     // would silently decide the request's identity.
     if (bearerMatch?.[1] === apiKey) return apiKey;
-    throw new GatewayError("invalid_request", 400, "The request sends two different credentials. Send exactly one key, either as Authorization: Bearer <key> or as the api-key header.");
+    throw new GatewayError("invalid_request", 400, "The request sends two different credentials (request {requestId}). Send exactly one key, either as Authorization: Bearer <key> or as the api-key header. Pick one key and stick with it 🤝");
   }
   if (hasApiKey) return apiKey;
   const token = bearerMatch?.[1];
   if (token === undefined)
-    throw new GatewayError("invalid_request", 401, "The request carries no usable credential. Send the key as: Authorization: Bearer <key>.");
+    throw new GatewayError("authentication_failed", 401, "The request carries no usable credential (request {requestId}). Send the key as: Authorization: Bearer <key>. We need a key to let you in 🔑");
   return token;
 }
 
@@ -398,6 +404,13 @@ export async function resolveApiKeyAuthorization(
     snapshot,
     ...(policy.modelPrefix ? { modelPrefix: policy.modelPrefix } : {}),
     ...(parent?.keyMode === "share" ? { cliMappingOwnerId: parent.id } : {}),
+    caller: {
+      apiKeyId: row.id,
+      // The admission identity is the family owner for a share child — the
+      // same id every counter/lease in the system keys against.
+      admissionIdentity: snapshot.admission_identity ?? row.id,
+      tenantId: row.tenantId,
+    },
   };
   authorizationCache.rememberPositive(hash, value.id, value, Date.now());
   // Shared copy for peer processes, keyed by the token hash so a lookup can

package/src/shared/coerce.ts

@@ -13,6 +13,25 @@ export function asRecord(value: unknown): Record<string, unknown> | undefined {
     : undefined;
 }
 
+/**
+ * Narrow a stored `auth_state`/JSONB value to a plain object. Postgres'
+ * drizzle `jsonb` arrives as a POJO; SQLite's text-backed column arrives as
+ * a JSON STRING. Parse the string form so both backends hand downstream
+ * readers the same shape — otherwise auth-state-dependent providers (Qoder's
+ * userId/machineId, Trae's region, …) silently lose their identity on the
+ * SQLite backend.
+ */
+export function asJsonbRecord(value: unknown): Record<string, unknown> | undefined {
+  if (typeof value === "string") {
+    try {
+      return asRecord(JSON.parse(value));
+    } catch {
+      return undefined;
+    }
+  }
+  return asRecord(value);
+}
+
 /** Narrow to a finite number, else `undefined`. `NaN`/`Infinity` are not numbers here. */
 export function asNumber(value: unknown): number | undefined {
   return typeof value === "number" && Number.isFinite(value) ? value : undefined;

package/src/transport/dispatch/attempt-finalize.ts

@@ -425,7 +425,7 @@ export function terminalFailure(
     return new GatewayError(
       "transport_unavailable",
       502,
-      "The upstream closed the response without reporting a result. Retry; if it keeps happening, the account or pool is unstable.",
+      "The upstream closed the response without reporting a result (request {requestId}). Retry; if it keeps happening, the account or pool is unstable. The connection ghosted us — come back in a moment 👻",
       {},
       "upstream",
     );
@@ -437,7 +437,7 @@ export function terminalFailure(
     const details: Record<string, unknown> = {};
     if (terminal.provider_stop_reason) details["provider_code"] = terminal.provider_stop_reason;
     if (terminal.stop_details) Object.assign(details, terminal.stop_details);
-    const message = typeof details["message"] === "string" ? details["message"] : "upstream request failed";
+    const message = typeof details["message"] === "string" ? details["message"] : "upstream request failed (request {requestId}). The upstream came back empty-handed — retry 🌙";
    // Preserve the upstream's error code when the provider embedded it in
    // `stop_details` (Cursor writes `quota_exceeded` and `authentication_failed`
    // there). Wrapping every terminal failure as `transport_unavailable` discarded
@@ -460,7 +460,7 @@ export function terminalFailure(
     // reports it as truncation instead.
     return options.truncated === true
       ? undefined
-      : new GatewayError("transport_closed", 499, "request was cancelled");
+      : new GatewayError("transport_closed", 499, "The request was cancelled (request {requestId}). Send it again whenever ready 🙃");
   }
   return undefined;
 }
@@ -823,6 +823,7 @@ export async function completeAttempt(
           (completion.error instanceof ProxyConnectRefusalError ? "network" : undefined);
         await recordPoolDispatchOutcome(completion.db, completion.networkPoolId, {
           succeeded: completion.status === "completed",
+          ...(completion.providerId === undefined ? {} : { providerId: completion.providerId }),
           ...(completion.error === undefined ? {} : { error: completion.error }),
           // A CONNECT refusal is the proxy's own answer, given before any
           // upstream was dialed, so it is a network fault even though the

package/src/transport/dispatch/attempt-loop.ts

@@ -41,7 +41,8 @@ import {
   type ProviderExchangeCapture,
 } from "./attempt-finalize";
 import { repriceUsage } from "../../providers/provider-usage";
-import { isFreeTierIpBlock, isOAuthCredentialInvalidated, shouldCooldownPool } from "./retry-policy";
+import { classifyEgressFailure } from "../../network/rate-limit-verdict";
+import { isOAuthCredentialInvalidated } from "./retry-policy";
 import { drainAbortReason } from "../shutdown-notice";
 
 /**
@@ -316,7 +317,7 @@ export async function runAttemptLoop<TResult, TAdapter>(
     };
     try {
       if (state.abortController.signal.aborted)
-        throw new GatewayError("transport_closed", 499, "request was cancelled");
+        throw new GatewayError("transport_closed", 499, "The request was cancelled (request {requestId}). Send it again whenever ready 🙃");
       const { credential, adapter } = await input.prepare(candidate);
       const host = input.resolveHost?.(candidate);
       // Single attempt-lease manager owns acquisition order (admission →
@@ -353,9 +354,10 @@ export async function runAttemptLoop<TResult, TAdapter>(
       });
     } catch (error) {
       // A drain aborts the controller, so a mid-flight attempt unwinds here as
-      // an abort. Surface the typed shutdown error (503 shutting_down /
-      // restart_for_update) instead of an opaque `transport_closed`, so the
-      // client's JSON error — not just the SSE path — names the real cause.
+      // an abort. Surface the typed shutdown error (503 shutting_down, reason
+      // restart_for_update for an update drain) instead of an opaque
+      // `transport_closed`, so the client's JSON error — not just the SSE path —
+      // names the real cause.
       const drain = drainAbortReason(state.abortController.signal.reason);
       if (drain !== undefined) error = drain;
       lastError = error;
@@ -374,11 +376,12 @@ export async function runAttemptLoop<TResult, TAdapter>(
       // single candidate carrying every pool). Judging it there is what made a
       // refused egress end the request instead of failing over to a healthy
       // one.
-      const rateLimitedPool = !cancelled && shouldCooldownPool(error, candidate.provider_id);
+      const egressVerdict = !cancelled ? classifyEgressFailure(error, candidate.provider_id) : { kind: "none" } as const;
       // A free-tier refusal is only ever this provider's: the guard is gated on
       // `ipScopedRateLimit` in the provider metadata, so a 403 from any other
       // upstream still means what it always did and never retires an egress.
-      const blockedPool = !cancelled && isFreeTierIpBlock(error, candidate.provider_id);
+      const rateLimitedPool = egressVerdict.kind === "cooldown";
+      const blockedPool = egressVerdict.kind === "blocked";
       const poolScopedFailure =
         (rateLimitedPool || blockedPool) &&
         networkPoolId !== undefined &&

package/src/transport/dispatch/empty-stream.ts

@@ -107,7 +107,7 @@ export async function fetchWithEmptyStreamRecovery(
   const sleep = deps.policy?.sleep ?? abortableSleep;
 
   if (endpoints.length === 0) {
-    throw new GatewayError("platform_unavailable", 502, "No endpoints available", {}, "upstream");
+    throw new GatewayError("platform_unavailable", 502, "No endpoints available (request {requestId}). The upstream came back empty-handed — retry 🌙", {}, "upstream");
   }
 
   for (let endpointIndex = 0; endpointIndex < endpoints.length; endpointIndex++) {
@@ -118,7 +118,7 @@ export async function fetchWithEmptyStreamRecovery(
     for (let replay = 0; replay <= replaysAllowed; replay++) {
       // Check abort before each fetch
       if (deps.signal.aborted) {
-        throw new GatewayError("transport_closed", 499, "Aborted");
+        throw new GatewayError("transport_closed", 499, "The request was aborted (request {requestId}). Send it again whenever ready 🙃");
       }
 
       // Check deadline floor
@@ -128,7 +128,7 @@ export async function fetchWithEmptyStreamRecovery(
         throw new GatewayError(
           "platform_unavailable",
           502,
-          "Deadline exhausted before empty-stream replay",
+          "Deadline exhausted before empty-stream replay (request {requestId}). Some things just take longer 🐢",
           {},
           "upstream",
         );
@@ -181,7 +181,7 @@ export async function fetchWithEmptyStreamRecovery(
   throw new GatewayError(
     "platform_unavailable",
     502,
-    "All endpoints returned empty streams",
+    "All endpoints returned empty streams (request {requestId}). The upstream came back empty-handed — retry 🌙",
     {},
     "upstream",
   );
@@ -204,11 +204,11 @@ async function fetchWithTimeout(
       // It must surface as a deadline failure, never as a `transport_closed`
       // 499 — that code is reserved for genuine client cancellations and would
       // otherwise hide a real upstream wait behind "cancelled by client".
-      reject(new GatewayError("deadline_exceeded", 504, "First event timeout", {}, "upstream"));
+      reject(new GatewayError("deadline_exceeded", 504, "First event timeout (request {requestId}). Some things just take longer 🐢", {}, "upstream"));
     }, timeoutMs);
     signal.addEventListener("abort", () => {
       clearTimeout(timer);
-      reject(new GatewayError("transport_closed", 499, "Aborted"));
+      reject(new GatewayError("transport_closed", 499, "The request was aborted (request {requestId}). Send it again whenever ready 🙃"));
     }, { once: true });
   });
 

package/src/transport/dispatch/generation.ts

@@ -163,18 +163,18 @@ export function createNativeSurfaceHandler(
       throw new GatewayError(
         "invalid_request",
         400,
-        `The ${noun} body must be a JSON object. Send one with at least a model and a prompt.`,
+        `The ${noun} body must be a JSON object (request {requestId}). Send one with at least a model and a prompt. Check the shape of what you sent — then resend 🪞`,
       );
     }
     const generation = body as Record<string, unknown>;
     if (typeof generation.model !== "string" || generation.model.trim().length === 0) {
-      throw new GatewayError("invalid_request", 400, `A model is required: it names the ${noun} provider to use.`);
+      throw new GatewayError("invalid_request", 400, `A model is required (request {requestId}): it names the ${noun} provider to use. Check the shape of what you sent — then resend 🪞`);
     }
     if (!authorization.snapshot.scopes?.includes("routing:invoke" as never)) {
       throw new GatewayError(
-        "invalid_request",
+        "policy_rejected",
         403,
-        `${noun} generation not allowed for this key — enable routing:invoke on the API key`,
+        `${noun} generation not allowed for this key (request {requestId}) — enable routing:invoke on the API key. Not allowed by policy — no hard feelings 🫂`,
       );
     }
     // Trust boundary only. Keep accepting `messages` for chat-backed providers
@@ -183,7 +183,7 @@ export function createNativeSurfaceHandler(
       const hasPrompt = typeof generation.prompt === "string" && generation.prompt.trim().length > 0;
       const hasMessages = Array.isArray(generation.messages) && generation.messages.length > 0;
       if (!hasPrompt && !hasMessages) {
-        throw new GatewayError("invalid_request", 400, "prompt is required");
+        throw new GatewayError("invalid_request", 400, "prompt is required (request {requestId}). Check the shape of what you sent — then resend 🪞");
       }
       if (generation.n !== undefined) {
         const n = generation.n;
@@ -191,7 +191,7 @@ export function createNativeSurfaceHandler(
           throw new GatewayError(
             "invalid_request",
             400,
-            `n must be an integer between 1 and ${MAX_ITEMS_PER_REQUEST}`,
+            `n must be an integer between 1 and ${MAX_ITEMS_PER_REQUEST} (request {requestId}). Check the shape of what you sent — then resend 🪞`,
           );
         }
       }
@@ -219,7 +219,7 @@ export function createNativeSurfaceHandler(
       candidates: prepared.candidates,
       tenantId: prepared.authorization.tenantId,
       strictPoolSelection: false,
-      exhaustedError: new GatewayError("admission_unavailable", 503, `no eligible ${noun} generation route`),
+      exhaustedError: new GatewayError("route_unavailable", 503, `no eligible ${noun} generation route (request {requestId}). The bouncer stepped out — come back shortly 🚪`),
       prepare: async (candidate) => {
         const credential = candidate.provider_account_id
           ? await resolveCredentialForAccount(
@@ -239,7 +239,7 @@ export function createNativeSurfaceHandler(
           throw new GatewayError(
             "capability_unsupported",
             400,
-            `${noun} generation is unavailable for this provider`,
+            `${noun} generation is unavailable for this provider (request {requestId}). Know your tools — this one just isn't in the box 🧰`,
           );
         }
         return { credential, adapter };
@@ -344,7 +344,7 @@ export function createNativeSurfaceHandler(
                   new GatewayError(
                     "capability_unsupported",
                     400,
-                    `${noun} generation is unavailable for this provider`,
+                    `${noun} generation is unavailable for this provider (request {requestId}). Know your tools — this one just isn't in the box 🧰`,
                   ),
                 )
               : adapter

package/src/transport/dispatch/leases.ts

@@ -141,7 +141,7 @@ async function acquirePoolSlot(
       throw new GatewayError(
         "proxy_pool_unhealthy",
         503,
-        "Every proxy pool this route requires is unhealthy or disabled. Repair a pool, or relax the route's pool requirement.",
+        "Every proxy pool this route requires is unhealthy or disabled (request {requestId}). Repair a pool, or relax the route's pool requirement. This bridge looks shaky — repair or reroute 🔧",
         { reason: "no_healthy_pool" },
         "network",
       );
@@ -172,7 +172,7 @@ async function acquirePoolSlot(
     throw new GatewayError(
       "proxy_pool_unavailable",
       503,
-      "No active proxy pool is available because coordination is unavailable.",
+      "No active proxy pool is available because coordination is unavailable (request {requestId}). The bouncer stepped out — come back shortly 🚪",
       { reason: "coordination_unavailable" },
       "network",
     );
@@ -219,14 +219,14 @@ async function acquirePoolSlot(
     failure.reason === "at_capacity" || failure.reason === "provider_at_capacity" ? 429 : 503;
   const message =
     failure.reason === "at_capacity"
-      ? "Every proxy pool for this provider is at its concurrency limit. Retry shortly, or add a pool or raise its capacity."
+      ? "Every proxy pool for this provider is at its concurrency limit (request {requestId}). Retry shortly, or add a pool or raise its capacity. The pools are full right now — chill 🌊"
       : failure.reason === "provider_at_capacity"
-        ? "Every proxy pool has reached this provider's per-proxy concurrency limit. Retry shortly, raise the limit in the provider's routing settings, or add a pool."
+        ? "Every proxy pool has reached this provider's per-proxy concurrency limit (request {requestId}). Retry shortly, raise the limit in the provider's routing settings, or add a pool. The proxies are working overtime — hang tight ⚡️"
         : failure.reason === "blocked"
-          ? "All proxy pools are saturated for this provider: the upstream refuses every egress configured for it. Replace a blocked proxy, or add one the upstream has not flagged."
+          ? "All proxy pools are saturated for this provider (request {requestId}): the upstream refuses every egress configured for it. Replace a blocked proxy, or add one the upstream has not flagged. All roads blocked — time to find a new route 🗺️"
           : failure.reason === "cooldown"
-            ? "Every proxy pool for this provider is cooling down after upstream failures. Retry once the cooldown resets."
-            : "No active proxy pool is configured for this tenant and provider. Add one, or route this provider through direct egress.";
+            ? "Every proxy pool for this provider is cooling down after upstream failures (request {requestId}). Retry once the cooldown resets. The proxies are catching their breath — zzz 💤"
+            : "No active proxy pool is configured for this tenant and provider (request {requestId}). Add one, or route this provider through direct egress. No bridge to cross — configure a pool first 🏗️";
   throw new GatewayError(code, status, message, {
     pools: failure.pools,
     // Only measured evidence: a cooldown's real reset instant. The
@@ -279,7 +279,7 @@ export async function acquireAttemptLeases(
       : await acquirePoolSlot(candidate, source, input.poolSelector, input.strictPoolSelection);
     if (slot) partial.proxySlot = slot;
     if (input.strictPoolSelection && input.signal.aborted)
-      throw new GatewayError("transport_closed", 499, "request was cancelled");
+      throw new GatewayError("transport_closed", 499, "The request was cancelled (request {requestId}). Send it again whenever ready 🙃");
     partial.reservation = await source.routingEngine.reserve({
       ...source.plan,
       candidates: [candidate],

package/src/transport/dispatch/proxy-request.ts

@@ -1,6 +1,9 @@
 import { isBundledProviderId } from "../../providers/provider-contracts";
 import type { ProviderDispatchContext, ProviderId, ProviderAdapter } from "../../providers/provider-contracts";
 import { GatewayError } from "../../protocol/gateway-error";
+import { isWrappedInjectionProvider } from "../../console/system-prompt/contracts";
+import { resolveTenantSystemPrompt } from "../request/system-prompt-injection";
+import { readTenantSystemPromptsForDispatch } from "../request/tenant-preferences";
 import type { CanonicalEvent } from "../../protocol/canonical-model";
 import { resolveCredentialForAccount } from "../../providers/operations/provider-credential-service";
 import type { ByokUpstreamHost } from "../../providers/operations/provider-catalog-service";
@@ -113,8 +116,28 @@ export async function handleProviderProxyRequest(
   const state = deps.stateStore.require(request);
   const prepared = state.preparedRequest;
   if (!prepared)
-    throw new GatewayError("admission_unavailable", 503, "The request was not prepared, so no route can be dialed. Resend the request.");
+    throw new GatewayError("route_unavailable", 503, "The request was not prepared, so no route can be dialed (request {requestId}). Resend the request. The bouncer stepped out — resend shortly 🚪");
   const canonicalRequest = await applyTenantPreferences(prepared, deps.db);
+  // Tenant system-prompt injection, resolved once per request. For providers
+  // whose upstream validates the fixed system prompt as a channel identity
+  // (the buddy family), the text cannot ride the canonical `system` array —
+  // the adapter replaces it — so it travels through dispatch context and the
+  // adapter folds it into its fixed turn, wrapped in the gateway's markers.
+  // `override` degrades to wrapped append there: stripping the identity would
+  // have the upstream refuse the request outright.
+  const candidateForPrompt = prepared.candidate;
+  const tenantSystemPromptText = isWrappedInjectionProvider(candidateForPrompt.provider_id)
+    ? resolveTenantSystemPrompt(
+        await readTenantSystemPromptsForDispatch(
+          deps.db,
+          prepared.authorization.snapshot.tenant_id,
+        ),
+        {
+          providerId: candidateForPrompt.provider_id,
+          modelId: candidateForPrompt.model_id,
+        },
+      )?.text
+    : undefined;
   // Per-tenant timeout, applied as soon as the tenant is known. The deadline
   // was armed at admission with the deployment default; this re-arms it.
   await applyTenantDeadlineOverride(
@@ -153,20 +176,25 @@ export async function handleProviderProxyRequest(
       estimatedOutputTokens: prepared.estimatedOutputTokens,
       authorizationSnapshot: prepared.authorization.snapshot,
       // A continuation borrows the held Cursor Run: one upstream turn must not
-      // occupy two account/pool concurrency slots.
-      ...(prepared.continuationAffinity === undefined ? {} : { borrowsHeldSession: true }),
+      // occupy two account/pool concurrency slots. A rebaseable continuation
+      // (complete history, pinned account no longer routable) does NOT borrow —
+      // it starts a fresh Run on a newly selected account, so it leases like a
+      // normal request.
+      ...(prepared.continuationAffinity === undefined || prepared.continuationAffinity.rebaseable
+        ? {}
+        : { borrowsHeldSession: true }),
     },
     candidates: attemptCandidates,
     tenantId: prepared.authorization.tenantId,
     strictPoolSelection: true,
     resolveHost: (candidate) => deps.byokUpstreamHosts?.get(candidate.provider_id),
-    exhaustedError: new GatewayError("admission_unavailable", 503, "No account could be leased for this request. Retry shortly; if it persists, add an account or check that one is healthy."),
+    exhaustedError: new GatewayError("route_unavailable", 503, "No account could be leased for this request (request {requestId}). Retry shortly; if it persists, add an account or check that one is healthy. The bouncer stepped out — come back shortly 🚪"),
     prepare: async (candidate) => {
       if (!candidate.provider_account_id && candidate.requires_account !== false)
         throw new GatewayError(
-          "admission_unavailable",
+          "route_unavailable",
           503,
-          "This route has no usable credential. Save one on the account, or route to a provider whose account is configured.",
+          "This route has no usable credential (request {requestId}). Save one on the account, or route to a provider whose account is configured. Wrong key, right door — check the credential 🔑",
         );
       const credential = candidate.provider_account_id
         ? await resolveCredentialForAccount(
@@ -183,13 +211,13 @@ export async function handleProviderProxyRequest(
           };
       const adapter = await deps.resolveProviderAdapter?.(candidate.provider_id);
       if (!adapter)
-        throw new GatewayError("admission_unavailable", 503, "provider adapter not registered");
+        throw new GatewayError("route_unavailable", 503, "provider adapter not registered (request {requestId}). Even we have bad days — check the registry wiring 🐻");
       if (!isBundledProviderId(candidate.provider_id)) {
         if (!deps.byokUpstreamHosts?.get(candidate.provider_id) || !deps.networkBindingFactory)
           throw new GatewayError(
-            "admission_unavailable",
+            "route_unavailable",
             503,
-            "validated network binding is required for configurable upstreams",
+            "validated network binding is required for configurable upstreams (request {requestId}). No bridge to cross — configure a pool first 🏗️",
           );
       }
       return { credential, adapter };
@@ -231,6 +259,7 @@ export async function handleProviderProxyRequest(
           ? {}
           : { imageClampMaxBytes: state.imageClampMaxBytes }),
         ...(conversationAffinity ? { conversationAffinity } : {}),
+        ...(tenantSystemPromptText === undefined ? {} : { tenantSystemPrompt: tenantSystemPromptText }),
         ...(candidate.user_agent === undefined ? {} : { userAgent: candidate.user_agent }),
         ...(deps.networkBindingFactory
           ? {

package/src/transport/dispatch/responses-compact.ts

@@ -27,10 +27,10 @@ export function createResponsesCompactHandler(deps: ResponsesCompactHandlerDeps)
     const authorization = state.authorization;
     const body = state.ingressBody;
     if (!authorization || body === null || typeof body !== "object" || Array.isArray(body))
-      throw new GatewayError("invalid_request", 400, "compact request body must be a JSON object");
+      throw new GatewayError("invalid_request", 400, "compact request body must be a JSON object (request {requestId}). Check the shape of what you sent — then resend 🪞");
     const compact = body as Record<string, unknown>;
     if (typeof compact.model !== "string" || compact.model.trim().length === 0)
-      throw new GatewayError("invalid_request", 400, "model is required");
+      throw new GatewayError("invalid_request", 400, "model is required (request {requestId}). Check the shape of what you sent — then resend 🪞");
     // A thinking suffix (`model(high)`) is stripped here for the same reason the
     // canonical preparer strips it: this route matches the model name against
     // the allowlist and the route plan, and `(high)` is not part of any
@@ -43,18 +43,18 @@ export function createResponsesCompactHandler(deps: ResponsesCompactHandlerDeps)
     const compactBody: Record<string, unknown> =
       compactModel === compact.model ? compact : { ...compact, model: compactModel };
     if (!(typeof compact.input === "string" || Array.isArray(compact.input)))
-      throw new GatewayError("invalid_request", 400, "input must be a string or array");
+      throw new GatewayError("invalid_request", 400, "input must be a string or array (request {requestId}). Check the shape of what you sent — then resend 🪞");
     if ("instructions" in compact && typeof compact.instructions !== "string")
-      throw new GatewayError("invalid_request", 400, "instructions must be a string");
+      throw new GatewayError("invalid_request", 400, "instructions must be a string (request {requestId}). Check the shape of what you sent — then resend 🪞");
     if (compact.stream === true)
       throw new GatewayError(
         "capability_unsupported",
         400,
-        "Responses compact does not support streaming",
+        "Responses compact does not support streaming (request {requestId}). Know your tools — this one just isn't in the box 🧰",
       );
     const adapter = (await deps.resolveProviderAdapter?.("codex")) as CodexCompactAdapter | undefined;
     if (!adapter || typeof adapter.compact !== "function")
-      throw new GatewayError("admission_unavailable", 503, "Codex compact transport unavailable");
+      throw new GatewayError("admission_unavailable", 503, "Codex compact transport unavailable (request {requestId}). The bouncer stepped out — come back shortly 🚪");
     const prepared = await deps.proxyPreparer.prepareNativeCompact({
       model: compactModel,
       authorization,
@@ -77,16 +77,16 @@ export function createResponsesCompactHandler(deps: ResponsesCompactHandlerDeps)
       // Lenient pool semantics: a missing slot tolerates direct egress.
       strictPoolSelection: false,
       exhaustedError: new GatewayError(
-        "admission_unavailable",
+        "route_unavailable",
         503,
-        "no eligible Codex route",
+        "no eligible Codex route (request {requestId}). The bouncer stepped out — come back shortly 🚪",
       ),
       prepare: async (candidate) => {
         if (!candidate.provider_account_id)
           throw new GatewayError(
-            "admission_unavailable",
+            "route_unavailable",
             503,
-            "Codex compact requires an OAuth account",
+            "Codex compact requires an OAuth account (request {requestId}). Wrong key, right door — check the credential 🔑",
           );
         const credential = await resolveCredentialForAccount(
           deps.db,
@@ -100,7 +100,7 @@ export function createResponsesCompactHandler(deps: ResponsesCompactHandlerDeps)
           throw new GatewayError(
             "capability_unsupported",
             400,
-            "Responses compact requires a Codex ChatGPT OAuth account",
+            "Responses compact requires a Codex ChatGPT OAuth account (request {requestId}). Wrong key, right door — check the credential 🔑",
           );
         return { credential, adapter };
       },