cartethyia 2.7.3 → 2.7.4

package/src/console/providers/detail/routes.ts

@@ -1,4 +1,4 @@
-import { Elysia, t } from "elysia";
+import { Elysia, t, type AnyElysia } from "elysia";
 import { ConsoleDomainError, errorResponse, requireTenantScope } from "../../shared/errors";
 import { literalUnion } from "../../shared/elysia-schema";
 import type { AccessDecision } from "../../../security/access-control";
@@ -160,7 +160,7 @@ const updateRoutingBody = t.Object({
 });
 
 
-export function createProviderDetailRoutes(config: ProviderDetailConfig): Elysia {
+export function createProviderDetailRoutes(config: ProviderDetailConfig): AnyElysia {
   const factory = createProviderDetailOperations(config);
   return new Elysia({ prefix: "/providers" })
     .get("/:providerId/routing", async ({ request, params, set }) => {
@@ -191,5 +191,5 @@ export function createProviderDetailRoutes(config: ProviderDetailConfig): Elysia
           return providerDetailErrorResponse(e, set);
         }
       },
-    ) as unknown as Elysia;
+    )
 }

package/src/console/providers/oauth/routes.ts

@@ -9,7 +9,7 @@ import type { ProviderRegistry } from "../../../providers/provider-registry";
 import { browserAuthorizeRedirectUri } from "../../../config/providers";
 import { log } from "../../../observability/logger";
 import { GatewayError } from "../../../protocol/gateway-error";
-import { Elysia, t } from "elysia";
+import { Elysia, t, type AnyElysia } from "elysia";
 import { ConsoleDomainError, errorResponse, requireScope } from "../../shared/errors";
 import { generateOAuthState, generatePkcePair } from "../../../providers/authentication/oauth-flow-store";
 import type { OAuthFlowStorage } from "../../../providers/authentication/oauth-flow-store";
@@ -639,7 +639,7 @@ const importBody = t.Object({
   accountLabel: t.Optional(t.String()),
 });
 
-export function createOAuthLoginRoutes(config: OAuthLoginConfig): Elysia {
+export function createOAuthLoginRoutes(config: OAuthLoginConfig): AnyElysia {
   const factory = createOAuthLoginOperations(config);
   return new Elysia({ prefix: "/providers" })
     .post(
@@ -721,6 +721,6 @@ export function createOAuthLoginRoutes(config: OAuthLoginConfig): Elysia {
           return oauthErrorResponse(e, set);
         }
       },
-    ) as unknown as Elysia;
+    )
 }
 

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

@@ -54,6 +54,7 @@ import {
   listAccountResetCredits,
 } from "../../providers/operations/account-reset-service";
 import {
+  enqueueBackgroundQuotaRefresh,
   pendingQuotaRefreshes,
   toQuotaAccountHealth,
   toQuotaView,
@@ -369,6 +370,15 @@ export function registerAccountQuotaTenantRoutes(
           icon: providerId,
         }));
       let refreshing = 0;
+      // Cold-cache backfill: the overview renders whatever is cached, and the
+      // periodic sweep owns freshness — but with many accounts (e.g. a large
+      // Qoder roster) the sweep's per-pass cap cannot keep every cache warm,
+      // so a page open would show accounts with no badge for minutes. Enqueue
+      // a bounded background refresh for accounts whose cache entry is missing
+      // (not merely stale), so the badge fills in without waiting for the next
+      // sweep pass and without fanning out to the whole roster at once.
+      const coldCacheCap = 20;
+      let coldCacheEnqueued = 0;
       // The sweep's day markers answer "attempted today" without an upstream
       // request; only check-in-capable accounts can carry one, so only they
       // are read.
@@ -404,6 +414,21 @@ export function registerAccountQuotaTenantRoutes(
         const canRefresh = providerRegistry.hasQuotaCollector(row.providerId);
         const isRefreshing = canRefresh && (pending.has(row.id) || entry === undefined);
         if (isRefreshing) refreshing += 1;
+        // Backfill a missing cache entry on page open (bounded, see above).
+        if (
+          canRefresh &&
+          entry === undefined &&
+          !pending.has(row.id) &&
+          coldCacheEnqueued < coldCacheCap
+        ) {
+          coldCacheEnqueued += 1;
+          enqueueBackgroundQuotaRefresh(refreshDeps, {
+            accountId: row.id,
+            providerId: row.providerId,
+            tenantId: row.tenantId,
+            credentialKind: row.credentialKind,
+          });
+        }
         return {
           id: row.id,
           provider: row.providerId,
@@ -525,7 +550,7 @@ export function registerAccountQuotaTenantRoutes(
         throw new GatewayError(
           "proxy_pool_unavailable",
           503,
-          "Account test cannot select a proxy because proxy routing is not configured.",
+          "Account test cannot select a proxy because proxy routing is not configured (request {requestId}). No bridge to cross — configure a pool first 🏗️",
           { reason: "proxy_routing_unconfigured" },
           "network",
         );

package/src/console/quota/account-test-egress.ts

@@ -138,7 +138,7 @@ export async function selectAccountTestEgress(
     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",
     );
@@ -159,10 +159,10 @@ export async function selectAccountTestEgress(
     const status = failure.reason === "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 === "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,

package/src/console/routing/model/routes.ts

@@ -1,5 +1,5 @@
 // Model routing control-plane HTTP routes. The only module that touches Elysia.
-import { Elysia, t } from "elysia";
+import { Elysia, t, type AnyElysia } from "elysia";
 import { errorResponse } from "../../shared/errors";
 import { literalUnion } from "../../shared/elysia-schema";
 import { modelComboStrategy, type ComboStrategy } from "../../../persistence/schema";
@@ -41,7 +41,7 @@ const updateComboBody = t.Object({
   members: t.Optional(t.Array(t.String(), { minItems: 1 })),
   strategy: t.Optional(comboStrategySchema),
 });
-export function createModelRoutingRoutes(config: ModelRoutingConfig): Elysia {
+export function createModelRoutingRoutes(config: ModelRoutingConfig): AnyElysia {
   const factory = createModelRoutingOperations(config);
   return new Elysia({ prefix: "/routing" })
     .get("/aliases", async ({ request, set }) => {
@@ -132,5 +132,5 @@ export function createModelRoutingRoutes(config: ModelRoutingConfig): Elysia {
       } catch (e) {
         return modelRoutingErrorResponse(e, set);
       }
-    }) as unknown as Elysia;
+    });
 }

package/src/console/routing/pools/contracts.ts

@@ -188,7 +188,7 @@ export function validateTransportConfig(
     case "http":
     case "https":
       if (cfg.timeout !== undefined && typeof cfg.timeout !== "number")
-        throw new ConsoleDomainError("invalid_config", 400, "HTTP timeout must be a number");
+        throw new ConsoleDomainError("invalid_pool", 400, "HTTP timeout must be a number", { field: "timeout" });
       return;
     case "socks5":
       return;
@@ -196,9 +196,10 @@ export function validateTransportConfig(
       // Compile-time exhaustiveness: new TransportKind variants must add a case.
       kind satisfies never;
       throw new ConsoleDomainError(
-        "invalid_config",
+        "invalid_pool",
         400,
         `Unsupported transport kind: ${String(kind)}`,
+        { field: "kind" },
       );
   }
 }
@@ -494,10 +495,10 @@ export function validateEndpoint(
     try {
       u = new URL(candidate);
     } catch {
-      throw new ConsoleDomainError("invalid_endpoint", 400, "Endpoint must be host:port");
+      throw new ConsoleDomainError("invalid_pool", 400, "Endpoint must be host:port", { field: "endpoint" });
     }
     if (!u.hostname || !u.port)
-      throw new ConsoleDomainError("invalid_endpoint", 400, "Endpoint must be host:port");
+      throw new ConsoleDomainError("invalid_pool", 400, "Endpoint must be host:port", { field: "endpoint" });
     if (u.hostname === "localhost" || u.hostname.endsWith(".internal"))
       throw new ConsoleDomainError("ssrf_rejected", 400, "Private endpoint rejected");
     if (isIP(u.hostname) !== 0 && !isAddressAllowed(u.hostname, policy))
@@ -508,10 +509,10 @@ export function validateEndpoint(
   try {
     u = new URL(endpoint);
   } catch {
-    throw new ConsoleDomainError("invalid_endpoint", 400, "Endpoint must be a valid http(s) URL");
+    throw new ConsoleDomainError("invalid_pool", 400, "Endpoint must be a valid http(s) URL", { field: "endpoint" });
   }
   if (!["http:", "https:"].includes(u.protocol)) {
-    throw new ConsoleDomainError("invalid_endpoint", 400, "Endpoint must be a valid http(s) URL");
+    throw new ConsoleDomainError("invalid_pool", 400, "Endpoint must be a valid http(s) URL", { field: "endpoint" });
   }
   if (u.hostname === "localhost" || u.hostname.endsWith(".internal")) {
     throw new ConsoleDomainError("ssrf_rejected", 400, "Private endpoint rejected");
@@ -529,9 +530,10 @@ export function validatePoolLimits(maxInflight?: number, weight?: number): void
     (!Number.isInteger(maxInflight) || maxInflight < 1 || maxInflight > MAX_POOL_INFLIGHT)
   ) {
     throw new ConsoleDomainError(
-      "invalid_pool_limits",
+      "invalid_pool",
       400,
       "maxInflight must be an integer between 1 and 1000000",
+      { field: "maxInflight" },
     );
   }
   if (
@@ -539,9 +541,10 @@ export function validatePoolLimits(maxInflight?: number, weight?: number): void
     (!Number.isInteger(weight) || weight < 1 || weight > MAX_POOL_WEIGHT)
   ) {
     throw new ConsoleDomainError(
-      "invalid_pool_limits",
+      "invalid_pool",
       400,
       "weight must be an integer between 1 and 1000",
+      { field: "weight" },
     );
   }
 }

package/src/console/routing/pools/operations.ts

@@ -141,9 +141,10 @@ export function createNetworkPoolOperations(config: NetworkPoolConfig) {
         const rotateCount = request.rotateCount ?? current.rotateCount;
         if (!Number.isInteger(rotateCount) || rotateCount < 1 || rotateCount > 1000) {
           throw new ConsoleDomainError(
-            "invalid_pool_limits",
+            "invalid_pool",
             400,
             "rotateCount must be an integer between 1 and 1000",
+            { field: "rotateCount" },
           );
         }
         const saved = await config.store.setStrategy(a.tenantId, { strategy, rotateCount });
@@ -447,6 +448,12 @@ export function createNetworkPoolOperations(config: NetworkPoolConfig) {
       const a = requireTenantScope(access, "dashboard:write");
       const recovered = await config.store.recover(a.tenantId, poolId);
       if (!recovered) throw new ConsoleDomainError("pool_not_found", 404, `Pool ${poolId} not found`);
+      // Recover is the operator's "make this pool healthy again": besides
+      // resetting the pool-level state, drop every provider-rate-limit marker
+      // (volatile and durable) so a just-cleared pool is not still excluded
+      // by a stale 429 flag.
+      await config.poolSelector?.clearPoolCooldowns(poolId).catch(() => undefined);
+      await config.store.dropAllProviderCooldownMarkers?.(a.tenantId, poolId);
       await config.poolAgentReleaser?.releasePool(poolId, a.tenantId);
       await config.auditSink?.record({
         access: a,
@@ -482,7 +489,7 @@ export function createNetworkPoolOperations(config: NetworkPoolConfig) {
     ): Promise<PoolSpeedTestResult> {
       const a = requireTenantScope(access, "dashboard:read");
       if (!config.store.speedTest) {
-        throw new ConsoleDomainError("not_supported", 400, "Speed tests are unavailable");
+        throw new ConsoleDomainError("capability_unsupported", 400, "Speed tests are unavailable");
       }
       if (!Number.isInteger(bytes) || bytes < SPEED_TEST_MIN_BYTES || bytes > SPEED_TEST_MAX_BYTES) {
         throw new ConsoleDomainError(
@@ -507,7 +514,7 @@ export function createNetworkPoolOperations(config: NetworkPoolConfig) {
     ): Promise<PoolProviderProbeResult> {
       const a = requireTenantScope(access, "dashboard:read");
       if (!config.store.providerProbe) {
-        throw new ConsoleDomainError("not_supported", 400, "Provider probing is unavailable");
+        throw new ConsoleDomainError("capability_unsupported", 400, "Provider probing is unavailable");
       }
       const result = await config.store.providerProbe(a.tenantId, poolId, providerId);
       if (!config.poolSelector) return result;
@@ -596,7 +603,7 @@ export function createNetworkPoolOperations(config: NetworkPoolConfig) {
         );
       }
       if (!config.store.probeAdHocProvider) {
-        throw new ConsoleDomainError("not_supported", 400, "Provider probing is unavailable");
+        throw new ConsoleDomainError("capability_unsupported", 400, "Provider probing is unavailable");
       }
       const probe = config.store.probeAdHocProvider.bind(config.store);
       const results: PoolBatchProviderProbeResult[] = new Array(requests.length);
@@ -632,7 +639,7 @@ export function createNetworkPoolOperations(config: NetworkPoolConfig) {
       if (config.store.probeAdHoc) {
         return config.store.probeAdHoc(a.tenantId, request);
       }
-      throw new ConsoleDomainError("not_supported", 400, "Ad-hoc pool probing is unavailable");
+      throw new ConsoleDomainError("capability_unsupported", 400, "Ad-hoc pool probing is unavailable");
     },
     /**
      * Probes many unsaved pool definitions in one call.
@@ -656,7 +663,7 @@ export function createNetworkPoolOperations(config: NetworkPoolConfig) {
         );
       }
       if (!config.store.probeAdHoc) {
-        throw new ConsoleDomainError("not_supported", 400, "Ad-hoc pool probing is unavailable");
+        throw new ConsoleDomainError("capability_unsupported", 400, "Ad-hoc pool probing is unavailable");
       }
       const probe = config.store.probeAdHoc.bind(config.store);
       const results: PoolBatchProbeResult[] = new Array(requests.length);
@@ -700,7 +707,7 @@ export function createNetworkPoolOperations(config: NetworkPoolConfig) {
     ): Promise<NetworkPoolResponse & { relayUrl: string }> {
       const a = requireTenantScope(access, "dashboard:write");
       if (!config.relayFetch)
-        throw new ConsoleDomainError("not_supported", 503, "Relay deployment is unavailable");
+        throw new ConsoleDomainError("capability_unsupported", 503, "Relay deployment is unavailable");
       if (!isRelayTarget(request.target))
         throw new ConsoleDomainError("invalid_request", 422, `Unsupported relay target: ${String(request.target)}`);
       const result = await deployRelayWorker(config.relayFetch, request);

package/src/console/routing/pools/probe-verdict.ts

@@ -15,8 +15,16 @@
  * the address works (`allowed`, `throttled`) or says nothing about it
  * (`unreachable`), and treating "says nothing" as "refused" would drop a usable
  * pool for good.
+ *
+ * The 403-free-tier and 429 verdicts are the probe's reading of the same facts
+ * `classifyEgressFailure` (in `network/rate-limit-verdict`) reads on the
+ * dispatch path — for the probe they arrive as an HTTP status + body instead of
+ * a `GatewayError`, so the shared free-tier regex is borrowed from there to
+ * keep the two classifiers' boundaries honest.
  */
 
+import { FREE_TIER_REFUSAL } from "../../../network/rate-limit-verdict";
+
 export type ProbeVerdict = "allowed" | "blocked" | "throttled" | "unreachable";
 
 export interface ProbeAnswer {
@@ -25,9 +33,6 @@ export interface ProbeAnswer {
   readonly reason?: string;
 }
 
-/** The upstream's own wording for "this address is retired". */
-const FREE_TIER_REFUSAL = /freetier|free tier can only be used/i;
-
 /**
  * Classifies one upstream response.
  *

package/src/console/routing/pools/relay-deploy.ts

@@ -151,7 +151,7 @@ async function deployCloudflare(
   request: RelayDeployRequest,
 ): Promise<RelayDeployResult> {
   const accountId = request.accountId?.trim();
-  if (!accountId) throw new GatewayError("invalid_request", 400, "Cloudflare account id is required");
+  if (!accountId) throw new GatewayError("invalid_request", 400, "Cloudflare account id is required (request {requestId}). Check the shape of what you sent — then resend 🪞");
   const projectName = request.projectName?.trim() || generateName("relay");
   const scriptUrl = `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountId)}/workers/scripts/${encodeURIComponent(projectName)}`;
   const form = new FormData();
@@ -174,7 +174,7 @@ async function deployCloudflare(
     body: form,
   });
   if (!upload.ok)
-    throw new GatewayError("platform_unavailable", upload.status, `Cloudflare deploy failed: ${await readError(upload)}`);
+    throw new GatewayError("platform_unavailable", upload.status, `Cloudflare deploy failed (request {requestId}): ${await readError(upload)}. Flip the switch back on when ready 🔌`);
   // Enable the workers.dev route; a failure here is non-fatal because the
   // subdomain lookup below decides the final URL and reports its own error.
   await fetchImpl(`${scriptUrl}/subdomain`, {
@@ -190,7 +190,7 @@ async function deployCloudflare(
     throw new GatewayError(
       "platform_unavailable",
       subdomainRes.status,
-      `Worker uploaded but its workers.dev subdomain could not be read: ${await readError(subdomainRes)}`,
+      `Worker uploaded but its workers.dev subdomain could not be read (request {requestId}): ${await readError(subdomainRes)}. Flip the switch back on when ready 🔌`,
     );
   const subdomainData = (await subdomainRes.json().catch(() => ({}))) as {
     result?: { subdomain?: string };
@@ -200,7 +200,7 @@ async function deployCloudflare(
     throw new GatewayError(
       "platform_unavailable",
       502,
-      "Worker uploaded but no workers.dev subdomain is configured for this Cloudflare account.",
+      "Worker uploaded but no workers.dev subdomain is configured for this Cloudflare account (request {requestId}). Flip the switch back on when ready 🔌",
     );
   return { target: "cloudflare", projectName, relayUrl: `https://${projectName}.${subdomain}.workers.dev` };
 }
@@ -251,7 +251,7 @@ async function deployVercel(
     }),
   });
   if (!deployRes.ok)
-    throw new GatewayError("platform_unavailable", deployRes.status, `Vercel deploy failed: ${await readError(deployRes)}`);
+    throw new GatewayError("platform_unavailable", deployRes.status, `Vercel deploy failed (request {requestId}): ${await readError(deployRes)}. Flip the switch back on when ready 🔌`);
   // Pin the region again after the deploy created the project: the PATCH above
   // is a no-op on first deploy (the project does not exist yet), and a redeploy
   // is what Vercel requires for a region change to take effect anyway. The SSO
@@ -280,7 +280,7 @@ async function deployVercel(
   }).catch(() => undefined);
   const deployment = (await deployRes.json().catch(() => ({}))) as { url?: string };
   if (!deployment.url)
-    throw new GatewayError("platform_unavailable", 502, "Vercel deploy returned no URL");
+    throw new GatewayError("platform_unavailable", 502, "Vercel deploy returned no URL (request {requestId}). Flip the switch back on when ready 🔌");
   return {
     target: "vercel",
     projectName,
@@ -300,11 +300,11 @@ async function deployDeno(
     body: JSON.stringify({ project: projectName, entryPoint: "main.ts", files: { "main.ts": RELAY_DENO_SOURCE } }),
   });
   if (!deployRes.ok)
-    throw new GatewayError("platform_unavailable", deployRes.status, `Deno deploy failed: ${await readError(deployRes)}`);
+    throw new GatewayError("platform_unavailable", deployRes.status, `Deno deploy failed (request {requestId}): ${await readError(deployRes)}. Flip the switch back on when ready 🔌`);
   const deployment = (await deployRes.json().catch(() => ({}))) as { url?: string; domains?: string[] };
   const url = deployment.url ?? deployment.domains?.[0];
   if (!url)
-    throw new GatewayError("platform_unavailable", 502, "Deno deploy returned no URL");
+    throw new GatewayError("platform_unavailable", 502, "Deno deploy returned no URL (request {requestId}). Flip the switch back on when ready 🔌");
   return {
     target: "deno",
     projectName,
@@ -333,6 +333,6 @@ export async function deployRelay(
   request: RelayDeployRequest,
 ): Promise<RelayDeployResult> {
   if (!request.token.trim())
-    throw new GatewayError("invalid_request", 400, `${request.target} API token is required`);
+    throw new GatewayError("invalid_request", 400, `${request.target} API token is required (request {requestId}). Wrong key, right door — check the credential 🔑`);
   return DEPLOYERS[request.target](fetchImpl, request);
 }

package/src/console/routing/pools/routes.ts

@@ -1,5 +1,5 @@
 // Network-pool control-plane HTTP routes. The only module that touches Elysia.
-import { Elysia, t } from "elysia";
+import { Elysia, t, type AnyElysia } from "elysia";
 import { consoleErrorHandler } from "../../shared/errors";
 import { literalUnion } from "../../shared/elysia-schema";
 import { RELAY_TARGETS, type RelayDeployRequest } from "./relay-deploy";
@@ -56,7 +56,7 @@ const importPoolsBody = t.Object({
   family: t.Optional(t.Union([t.String(), t.Null()])),
   labelPrefix: t.Optional(t.String()),
 });
-export function createNetworkPoolRoutes(config: NetworkPoolConfig): Elysia {
+export function createNetworkPoolRoutes(config: NetworkPoolConfig): AnyElysia {
   const factory = createNetworkPoolOperations(config);
   return new Elysia({ prefix: "/network/pools" })
     .error(consoleErrorHandler("Network pool operation failed"))
@@ -207,5 +207,5 @@ export function createNetworkPoolRoutes(config: NetworkPoolConfig): Elysia {
           body as Partial<PoolStrategySetting>,
         );
 },
-    ) as unknown as Elysia;
+    );
 }

package/src/console/routing/pools/store.ts

@@ -1,7 +1,9 @@
 // Drizzle-backed console persistence for network pools.
+import { randomUUID } from "node:crypto";
 import { and, asc, eq, inArray, sql } from "drizzle-orm";
 import type { CartethyiaDatabase } from "../../../persistence/db-handle";
-import { networkPools, poolRoutingSettings } from "../../../persistence/schema";
+import { networkPools, poolRoutingSettings, providerPoolAccounts } from "../../../persistence/schema";
+import { providerRateLimitIsIpScoped } from "../../../providers/provider-metadata";
 import {
   DEFAULT_POOL_STRATEGY,
   type CreateNetworkPoolRequest,
@@ -444,6 +446,24 @@ export class DrizzleNetworkPoolStore implements NetworkPoolStore {
       ...(record.family !== undefined ? { family: record.family } : {}),
     }));
     await this.db.insert(networkPools).values(values);
+
+    // Materialize pool-as-account rows for ip-scoped, credential-less
+    // providers (OpenCode Free today): the operator sees the egress in the
+    // provider's Accounts card, and routing excludes a spent egress like a
+    // cooling account. Every other provider gets no row.
+    if (providerRateLimitIsIpScoped("opencode")) {
+      const now = new Date();
+      const poolAccounts = values.map((value) => ({
+        id: randomUUID(),
+        tenantId: value.tenantId,
+        networkPoolId: value.id,
+        providerId: "opencode",
+        label: `Pool ${value.id.slice(0, 8)}`,
+        createdAt: now,
+        updatedAt: now,
+      }));
+      await this.db.insert(providerPoolAccounts).values(poolAccounts);
+    }
     return values.length;
   }
 

package/src/console/settings/routes.ts

@@ -1,4 +1,4 @@
-import { Elysia } from "elysia";
+import { Elysia, type AnyElysia } from "elysia";
 import {
   createRuntimeSettingsOperations,
   runtimeUpdateBody,
@@ -7,7 +7,7 @@ import {
   type UpdateRuntimeSettingsRequest,
 } from "./contracts";
 
-export function createRuntimeSettingsRoutes(config: RuntimeSettingsConfig): Elysia {
+export function createRuntimeSettingsRoutes(config: RuntimeSettingsConfig): AnyElysia {
   const factory = createRuntimeSettingsOperations(config);
   return new Elysia({ prefix: "/settings/runtime" })
     .get("/", async ({ request, set }) => {
@@ -26,5 +26,5 @@ export function createRuntimeSettingsRoutes(config: RuntimeSettingsConfig): Elys
       } catch (e) {
         return runtimeSettingsErrorResponse(e, set);
       }
-    }) as unknown as Elysia;
+    });
 }

package/src/console/share/share-router.ts

@@ -4,7 +4,7 @@ import { globalOrOwnedBy } from "../../persistence/tenant-scope";
 // Share URLs reveal policy and allow one child key to be created per canonical
 // client IP. The child bearer is returned only by the successful issue call.
 
-import { Elysia } from "elysia";
+import { Elysia, type AnyElysia } from "elysia";
 import { and, eq, sql } from "drizzle-orm";
 import type { CartethyiaDatabase } from "../../persistence/db-handle";
 import { apiKeys, models, providers } from "../../persistence/schema";
@@ -34,12 +34,12 @@ const MIN_TOKEN_LENGTH = 20;
 /**
  * Cadence of the share stats SSE snapshot.
  *
- * Raised with `SHARE_STATS_CACHE_TTL_SECONDS` (10 s). At 2 s the tick was
- * shorter than the rollup's own cache TTL, so every push re-parsed the whole
- * retained telemetry window — the interval was the thing making this read
- * expensive, not the number of viewers. Short enough to still read as live.
+ * Roughly one tenth of the cache TTL (`SHARE_STATS_CACHE_TTL_SECONDS`, 300
+ * s), so nearly every tick is served from the cache and the cold-compute
+ * path runs at most once per five minutes per family. Short enough to still
+ * read as live.
  */
-const SHARE_STATS_STREAM_INTERVAL_MS = 10_000;
+const SHARE_STATS_STREAM_INTERVAL_MS = 30_000;
 
 /**
  * Context and capabilities for one allowed model, sourced from the public
@@ -89,12 +89,12 @@ function json(body: unknown, status = 200): Response {
 function notFound(refusal: ShareLinkRefusal = "not_found"): Response {
   const message =
     refusal === "expired"
-      ? "This share link has expired"
+      ? "This share link has expired (request {requestId}). Time for a fresh one 🌷"
       : refusal === "revoked"
-        ? "This share link's key has been revoked"
+        ? "This share link's key has been revoked (request {requestId}). Ask for a new one 📩"
         : refusal === "disabled"
-          ? "This share link's key is paused"
-          : "Share link is unavailable";
+          ? "This share link's key is paused (request {requestId}). Re-enable it when ready 🌱"
+          : "Share link is unavailable (request {requestId}). This link leads nowhere — check it again 🔗";
   const error = new GatewayError(`link_${refusal}`, 404, message);
   return json(publicGatewayErrorBody(error), error.status);
 }
@@ -261,7 +261,7 @@ async function resolveFamilyStats(
 }
 
 /** Creates the public enrollment page and one-time shared-key issuance route. */
-export function createShareRouter(options: ShareRouterOptions): Elysia {
+export function createShareRouter(options: ShareRouterOptions): AnyElysia {
   const { db, shareStore } = options;
 
   return new Elysia()
@@ -486,5 +486,5 @@ export function createShareRouter(options: ShareRouterOptions): Elysia {
           };
         }),
       );
-    }) as unknown as Elysia;
+    })
 }