cartethyia 2.7.2 → 2.7.4

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

@@ -1,4 +1,4 @@
-import { and, eq, inArray } from "drizzle-orm";
+import { and, eq, sql } from "drizzle-orm";
 import type { CartethyiaDatabase } from "../../persistence/db-handle";
 import type { ApiKeyRecord } from "../../persistence/stores/api-key-store";
 import { CachedPreferencesReader, DrizzlePreferencesReader } from "../../persistence/tenant-preferences";
@@ -9,7 +9,7 @@ import { isGatewayError } from "../../observability/telemetry-status";
 import type { RedisClient } from "../../persistence/redis";
 import { cachedRead } from "../shared/read-through-cache";
 import { SHARE_STATS_CACHE_TTL_SECONDS } from "./share-stats";
-import { telemetryUsageTotals } from "../../persistence/schema";
+import { apiKeys, telemetryUsageTotals } from "../../persistence/schema";
 import { shouldMaskClientIp } from "../shared/ip-privacy";
 import { utcDayStart } from "../shared/day";
 
@@ -66,9 +66,16 @@ export interface SharedKeyActivityDetail {
 
 /** Read-only share-recipient telemetry; payloads and credential material never cross this boundary. */
 export interface ShareActivityPort {
+  /**
+   * `familyTemplateKeyId` is the share template the children were issued from:
+   * the telemetry reads scope to the whole family through it (an `EXISTS`
+   * against `api_keys`, constant-wire) rather than through an id list, so the
+   * read is the same no matter how many keys the template has minted.
+   */
   getSharedKeySummaries(
     tenantId: string,
     children: readonly ApiKeyRecord[],
+    familyTemplateKeyId: string,
   ): Promise<readonly SharedKeySummary[]>;
   getSharedKeyDetail(tenantId: string, childKeyId: string): Promise<SharedKeyActivityDetail>;
 }
@@ -133,15 +140,25 @@ export function createShareUsagePort(deps: ShareUsagePortDeps): ShareActivityPor
   const { db, redis } = deps;
   const preferences = new CachedPreferencesReader(new DrizzlePreferencesReader(db));
   return {
-    async getSharedKeySummaries(tenantId, children) {
+    async getSharedKeySummaries(tenantId, children, familyTemplateKeyId) {
       if (children.length === 0) return [];
-      const childIds = children.map((child) => child.id);
       const todayStart = utcDayStart(new Date());
+      /**
+       * Family membership of the entity the totals/events row is attributed to.
+       * Primary predicate is the denormalized template column (so history
+       * survives key deletion); the `EXISTS` fallback covers rows written
+       * before the column existed.
+       */
+      const familyMembership = (entityId: typeof apiKeys.id | typeof telemetryUsageTotals.entityId) =>
+        sql`(${telemetryUsageTotals.familyTemplateKeyId} = ${familyTemplateKeyId} or (${telemetryUsageTotals.familyTemplateKeyId} is null and exists (select 1 from ${apiKeys} where ${apiKeys.id} = ${entityId} and (${apiKeys.id} = ${familyTemplateKeyId} or ${apiKeys.parentKeyId} = ${familyTemplateKeyId}))))`;
       const [todayEvents, lifetimeRows, hideClientIp] = await Promise.all([
         // Today's per-key totals as one GROUP BY instead of reading every
         // event of the family. `addEventUsage` needs per-event fields, so the
-        // groups are projected into the same shape the loop consumes.
-        querySqlEvents(db, { tenantId, apiKeyIds: childIds, since: todayStart, limit: MAX_SUMMARY_EVENTS }).then(
+        // groups are projected into the same shape the loop consumes. The
+        // family filter is the template key, not an id list: a family with
+        // tens of thousands of minted children must not expand them into bind
+        // parameters on every dashboard poll.
+        querySqlEvents(db, { tenantId, familyApiKeyId: familyTemplateKeyId, since: todayStart, limit: MAX_SUMMARY_EVENTS }).then(
           (page) => page.events,
         ),
         db
@@ -158,7 +175,7 @@ export function createShareUsagePort(deps: ShareUsagePortDeps): ShareActivityPor
             and(
               eq(telemetryUsageTotals.tenantId, tenantId),
               eq(telemetryUsageTotals.identityType, "api_key"),
-              inArray(telemetryUsageTotals.entityId, childIds),
+              familyMembership(telemetryUsageTotals.entityId),
             ),
           ),
         shouldMaskClientIp(preferences, tenantId),

package/src/console/shared/read-through-cache.ts

@@ -63,6 +63,34 @@ export function etagKey(key: string): string {
   return `${key}:etag`;
 }
 
+/**
+ * In-memory fallback store used when no Redis client is configured (the
+ * embedded lite backend). Keyed by the same cache key, storing the value and
+ * its validator with a TTL. Bounded so a busy gateway cannot grow it without
+ * limit.
+ */
+const LOCAL_CACHE_MAX_ENTRIES = 2000;
+const localCache = new Map<string, { at: number; value: string; etag: string }>();
+
+function localGet(key: string): { value: string; etag: string } | undefined {
+  const entry = localCache.get(key);
+  if (entry === undefined) return undefined;
+  if (Date.now() - entry.at >= READ_THROUGH_DEFAULT_TTL_SECONDS * 1000) {
+    localCache.delete(key);
+    return undefined;
+  }
+  return { value: entry.value, etag: entry.etag };
+}
+
+function localSet(key: string, value: string, etag: string): void {
+  if (localCache.size >= LOCAL_CACHE_MAX_ENTRIES) {
+    // Evict the oldest entry (Map iterates in insertion order).
+    const oldest = localCache.keys().next();
+    if (!oldest.done) localCache.delete(oldest.value);
+  }
+  localCache.set(key, { at: Date.now(), value, etag });
+}
+
 /**
  * Reads through the cache and returns a strong validator alongside the value.
  *
@@ -74,7 +102,8 @@ export function etagKey(key: string): string {
  * With no cache configured (`client === undefined`) the value is computed and
  * the validator is still returned, so conditional requests keep working for
  * the length of the client's own polling loop; only the cross-instance sharing
- * is lost.
+ * is lost. A process-local Map serves the same TTL when Redis is absent, so a
+ * poller still gets cache hits.
  */
 export async function cachedReadWithEtag<T>(
   client: ReadThroughCacheClient | undefined,
@@ -83,8 +112,15 @@ export async function cachedReadWithEtag<T>(
   ttlSeconds: number = READ_THROUGH_DEFAULT_TTL_SECONDS,
 ): Promise<CachedResult<T>> {
   if (client === undefined) {
+    const entry = localGet(key);
+    if (entry !== undefined) {
+      return { value: JSON.parse(entry.value) as T, etag: entry.etag };
+    }
     const fresh = await compute();
-    return { value: fresh, etag: etagFor(JSON.stringify(fresh) ?? "null") };
+    const bytes = JSON.stringify(fresh) ?? "null";
+    const etag = etagFor(bytes);
+    localSet(key, bytes, etag);
+    return { value: fresh, etag };
   }
   try {
     const hit = await client.get(key);

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

@@ -0,0 +1,102 @@
+// Tenant system-prompt injection contracts.
+//
+// Shared by the console API, the persistence store, and the dispatch-path
+// transform — all Elysia-free so the dashboard bundle can import the types.
+
+/**
+ * One scope's prompt configuration. `enabled` is the master switch for the
+ * scope; `mode` decides how the text meets existing system content.
+ */
+export interface PromptSetting {
+  readonly enabled: boolean;
+  readonly mode: PromptMode;
+  readonly text: string;
+}
+
+export const PROMPT_MODES = ["append", "override"] as const;
+export type PromptMode = (typeof PROMPT_MODES)[number];
+
+/** Per-provider entry: follow the tenant's global prompt, or carry a custom one. */
+export interface ProviderPromptEntry {
+  readonly followGlobal: boolean;
+  /** Present and used only when `followGlobal` is false. */
+  readonly setting?: PromptSetting;
+}
+
+/** The full per-tenant configuration, one row in `tenant_system_prompts`. */
+export interface TenantSystemPrompts {
+  /** `null` = never configured — distinct from an explicit disabled setting. */
+  readonly global: PromptSetting | null;
+  /** providerId → entry */
+  readonly providers: Readonly<Record<string, ProviderPromptEntry>>;
+  /** `${providerId}::${modelId}` → setting */
+  readonly models: Readonly<Record<string, PromptSetting>>;
+}
+
+/** Empty configuration: nothing configured anywhere. */
+export const EMPTY_TENANT_SYSTEM_PROMPTS: TenantSystemPrompts = {
+  global: null,
+  providers: {},
+  models: {},
+};
+
+/** Maximum stored text per scope (5 MB). Enforced at the console API. */
+export const SYSTEM_PROMPT_TEXT_CAP_BYTES = 5_000_000;
+
+/**
+ * Marker wrapping tenant text injected into a provider wire whose upstream
+ * validates the system prompt as a channel identity (the buddy family). The
+ * fixed identity prompt stays the opener; the tenant text rides after it
+ * inside the same turn, framed so the provider's own parser is not confused.
+ */
+export const SYSTEM_PROMPT_WRAPPER_PREFIX = "<cartethyia:system-prompt>";
+export const SYSTEM_PROMPT_WRAPPER_SUFFIX = "</cartethyia:system-prompt>";
+
+/** Maximum number of per-provider entries stored for one tenant. */
+export const SYSTEM_PROMPT_PROVIDER_LIMIT = 256;
+
+/** Maximum number of per-model entries stored for one tenant. */
+export const SYSTEM_PROMPT_MODEL_LIMIT = 512;
+
+/**
+ * Providers whose upstream validates the fixed system prompt as a channel
+ * identity. Their system turn must keep the fixed prompt as the opener, so
+ * tenant text is appended after it inside the same turn, wrapped in the
+ * gateway's prefix/suffix markers (see `SYSTEM_PROMPT_WRAPPER_PREFIX`).
+ * `override` mode is not honoured for these providers — it would strip the
+ * identity and the upstream would refuse the request.
+ */
+export 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. */
+export function isWrappedInjectionProvider(providerId: string): boolean {
+  return WRAPPED_INJECTION_PROVIDERS.has(providerId);
+}
+
+/** Model-scope key for the `models` map. */
+export function systemPromptModelKey(providerId: string, modelId: string): string {
+  return `${providerId}::${modelId}`;
+}
+
+/** Parses a model-scope key; null when the key is malformed. */
+export function parseSystemPromptModelKey(key: string): { providerId: string; modelId: string } | null {
+  const index = key.indexOf("::");
+  if (index <= 0 || index === key.length - 2) return null;
+  return { providerId: key.slice(0, index), modelId: key.slice(index + 2) };
+}
+
+/** True when the value is a well-formed prompt setting (shape only, not size). */
+export function isPromptSetting(value: unknown): value is PromptSetting {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value as Partial<PromptSetting>;
+  return (
+    typeof candidate.enabled === "boolean" &&
+    typeof candidate.mode === "string" &&
+    (PROMPT_MODES as readonly string[]).includes(candidate.mode) &&
+    typeof candidate.text === "string"
+  );
+}

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

@@ -0,0 +1,165 @@
+// Console API for tenant system-prompt injection.
+//
+// GET    /system-prompt → the stored configuration
+// PUT    /system-prompt → replace the configuration wholesale
+// DELETE /system-prompt → clear it entirely
+//
+// The PUT replaces the row: the modal edits the whole three-scope shape at
+// once, so a PATCH surface would add states the UI never produces. Text is
+// capped at 5 MB per scope and the provider/model maps are bounded, matching
+// the store's own defensive limits.
+import { Elysia, t } from "elysia";
+import type { ConsoleAccessResolver } from "../auth/access";
+import { ConsoleDomainError, consoleErrorHandler, requireTenantScope } from "../shared/errors";
+import type { AuditSink } from "../audit/contracts";
+import type { CartethyiaDatabase } from "../../persistence/db-handle";
+import {
+  clearTenantSystemPrompts,
+  readTenantSystemPrompts,
+  writeTenantSystemPrompts,
+} from "../../persistence/system-prompt-store";
+import {
+  EMPTY_TENANT_SYSTEM_PROMPTS,
+  PROMPT_MODES,
+  SYSTEM_PROMPT_MODEL_LIMIT,
+  SYSTEM_PROMPT_PROVIDER_LIMIT,
+  SYSTEM_PROMPT_TEXT_CAP_BYTES,
+  isPromptSetting,
+  parseSystemPromptModelKey,
+  type PromptSetting,
+  type ProviderPromptEntry,
+  type TenantSystemPrompts,
+} from "./contracts";
+
+/** Route-group context injected by the composition root. */
+export interface SystemPromptRoutesConfig {
+  readonly db: CartethyiaDatabase;
+  readonly accessResolver: ConsoleAccessResolver;
+  readonly auditSink?: AuditSink;
+}
+
+/** Validates one scope setting, including the 5 MB text cap. */
+function validateSetting(value: unknown, scopeLabel: string): PromptSetting {
+  if (!isPromptSetting(value)) {
+    throw new ConsoleDomainError("invalid_request", 400, `${scopeLabel} is not a valid prompt setting`);
+  }
+  const bytes = Buffer.byteLength(value.text, "utf8");
+  if (bytes > SYSTEM_PROMPT_TEXT_CAP_BYTES) {
+    throw new ConsoleDomainError("payload_too_large", 413, `${scopeLabel} exceeds the 5 MB limit`);
+  }
+  if (!(PROMPT_MODES as readonly string[]).includes(value.mode)) {
+    throw new ConsoleDomainError("invalid_request", 400, `${scopeLabel} has an invalid mode`);
+  }
+  return value;
+}
+
+/** Validates the full PUT body into the stored shape. */
+function validateBody(value: unknown): TenantSystemPrompts {
+  if (typeof value !== "object" || value === null) {
+    throw new ConsoleDomainError("invalid_request", 400, "Body must be an object");
+  }
+  const body = value as {
+    global?: unknown;
+    providers?: unknown;
+    models?: unknown;
+  };
+
+  const global =
+    body.global === null || body.global === undefined
+      ? null
+      : validateSetting(body.global, "global");
+
+  if (body.providers !== undefined && typeof body.providers !== "object") {
+    throw new ConsoleDomainError("invalid_request", 400, "providers must be an object");
+  }
+  const rawProviders = (body.providers ?? {}) as Record<string, unknown>;
+  const providerIds = Object.keys(rawProviders);
+  if (providerIds.length > SYSTEM_PROMPT_PROVIDER_LIMIT) {
+    throw new ConsoleDomainError(
+      "invalid_request",
+      400,
+      `providers exceeds the ${SYSTEM_PROMPT_PROVIDER_LIMIT} entry limit`,
+    );
+  }
+  const providers: Record<string, ProviderPromptEntry> = {};
+  for (const providerId of providerIds) {
+    const entry = rawProviders[providerId];
+    if (typeof entry !== "object" || entry === null) {
+      throw new ConsoleDomainError("invalid_request", 400, `provider ${providerId} entry must be an object`);
+    }
+    const candidate = entry as Partial<ProviderPromptEntry>;
+    if (typeof candidate.followGlobal !== "boolean") {
+      throw new ConsoleDomainError("invalid_request", 400, `provider ${providerId} needs followGlobal`);
+    }
+    if (candidate.followGlobal) {
+      providers[providerId] = { followGlobal: true };
+    } else {
+      providers[providerId] = {
+        followGlobal: false,
+        setting: validateSetting(candidate.setting, `provider ${providerId}`),
+      };
+    }
+  }
+
+  if (body.models !== undefined && typeof body.models !== "object") {
+    throw new ConsoleDomainError("invalid_request", 400, "models must be an object");
+  }
+  const rawModels = (body.models ?? {}) as Record<string, unknown>;
+  const modelKeys = Object.keys(rawModels);
+  if (modelKeys.length > SYSTEM_PROMPT_MODEL_LIMIT) {
+    throw new ConsoleDomainError(
+      "invalid_request",
+      400,
+      `models exceeds the ${SYSTEM_PROMPT_MODEL_LIMIT} entry limit`,
+    );
+  }
+  const models: Record<string, PromptSetting> = {};
+  for (const key of modelKeys) {
+    if (parseSystemPromptModelKey(key) === null) {
+      throw new ConsoleDomainError("invalid_request", 400, `model key ${key} is malformed`);
+    }
+    models[key] = validateSetting(rawModels[key], `model ${key}`);
+  }
+
+  return { global, providers, models };
+}
+
+/**
+ * The return type is inferred rather than annotated as `Elysia`: `.error()`
+ * widens the instance type with its handler's response envelope, so the
+ * annotated base type no longer matches the chained result (same reason the
+ * remote-support routes leave it inferred).
+ */
+export function createSystemPromptRoutes(config: SystemPromptRoutesConfig) {
+  return new Elysia()
+    .error(consoleErrorHandler("System prompt settings failed"))
+    .get("/system-prompt", async ({ request }) => {
+      const access = requireTenantScope(config.accessResolver(request), "dashboard:read");
+      return await readTenantSystemPrompts(config.db, access.tenantId);
+    })
+    .put(
+      "/system-prompt",
+      { body: t.Any() },
+      async ({ request, body }) => {
+        const access = requireTenantScope(config.accessResolver(request), "dashboard:write");
+        const next = validateBody(body);
+        await writeTenantSystemPrompts(config.db, access.tenantId, next);
+        await config.auditSink?.record({
+          access,
+          action: "system_prompt.update",
+          target: "tenant_system_prompts",
+          detail: {
+            global: next.global !== null,
+            providers: Object.keys(next.providers).length,
+            models: Object.keys(next.models).length,
+          },
+        });
+        return next;
+      },
+    )
+    .delete("/system-prompt", async ({ request }) => {
+      const access = requireTenantScope(config.accessResolver(request), "dashboard:write");
+      await clearTenantSystemPrompts(config.db, access.tenantId);
+      return EMPTY_TENANT_SYSTEM_PROMPTS;
+    });
+}

package/src/console/updates/routes.ts

@@ -1,4 +1,4 @@
-import { Elysia } from "elysia";
+import { Elysia, type AnyElysia } from "elysia";
 import { spawn } from "node:child_process";
 import { consoleErrorHandler, requireTenantScope } from "../shared/errors";
 import { consoleSseResponse, createConsoleSseStream } from "../observability/sse";
@@ -7,7 +7,10 @@ import type { ConsoleAccessResolver } from "../auth/access";
 import { fetchLatestRelease, type LatestRelease } from "./repository-updates";
 import { isNewerRelease } from "./version-compare";
 
-const MEMORY_SAMPLE_INTERVAL_MS = 10_000;
+// Memory is sampled per visible tab: ten seconds per stream made a console
+// with many open tabs wake up constantly for numbers nobody is reading. 30 s
+// is still responsive for a memory warning while cutting that work by three.
+const MEMORY_SAMPLE_INTERVAL_MS = 30_000;
 const UPDATE_SAMPLE_INTERVAL_MS = 60_000;
 const HIGH_MEMORY_PERCENT = 85;
 const HIGH_MEMORY_CLEAR_PERCENT = 80;
@@ -94,7 +97,7 @@ export function createUpdateRoutes(config: {
   readonly accessResolver: ConsoleAccessResolver;
   readonly observabilityStore: ObservabilityStore;
   readonly fetchRelease?: () => Promise<LatestRelease | null>;
-}): Elysia {
+}): AnyElysia {
   const fetchRelease = config.fetchRelease ?? fetchLatestRelease;
   return new Elysia()
     .error(consoleErrorHandler("Update check failed"))
@@ -199,5 +202,5 @@ export function createUpdateRoutes(config: {
           };
         }),
       );
-    }) as unknown as Elysia;
+    });
 }

package/src/main.ts

@@ -169,6 +169,17 @@ if (boot) {
     globalThis.__cartethyiaSignalsRegistered = true;
     process.on("SIGINT", () => shutdown("SIGINT"));
     process.on("SIGTERM", () => shutdown("SIGTERM"));
+    // A rejected promise nothing awaited (a sweep, a cache warm, a read whose
+    // parameters a bug elsewhere ballooned) must not kill the listener: the
+    // default is fatal exit, which turned one query fault into a systemd
+    // restart loop. Logged and absorbed — the failure stays visible, the
+    // process stays up.
+    process.on("unhandledRejection", (reason) => {
+      log.error(
+        "[process] unhandled rejection (kept alive)",
+        reason instanceof Error ? reason : new Error(String(reason)),
+      );
+    });
     // An in-place update signals SIGUSR2 before swapping the image so the old
     // process drains with the `update` reason and its callers are told the
     // replacement is seconds away instead of seeing a generic shutdown. Not

package/src/network/outbound-fetch.ts

@@ -1,7 +1,7 @@
 // Validated fetch: SSRF-guarded outbound fetch with optional pool-agent support.
 import { GatewayError } from "../protocol/gateway-error";
-import { Agent as HttpAgent } from "node:http";
-import { Agent as HttpsAgent } from "node:https";
+import { request as httpRequest, Agent as HttpAgent } from "node:http";
+import { request as httpsRequest, Agent as HttpsAgent } from "node:https";
 import { Agent as UndiciAgent, fetch as undiciFetch, type UndiciRequestInit } from "undici";
 import { SocksProxyAgent } from "socks-proxy-agent";
 import { resolveAllAddresses, validateResolvedAddresses } from "./ssrf";
@@ -167,6 +167,66 @@ async function dial(
   });
 }
 
+/**
+ * One raw GET/HEAD dial that carries a body.
+ *
+ * The runtime-native fetch (`Bun`/undici) rejects `GET`/`HEAD` requests with a
+ * body — "request with GET/HEAD method cannot have body" — but some upstreams
+ * validate a signature over the body on a GET (Qoder's `/model/list` does).
+ * This is the Node `http`/`https` path for exactly that case. It runs only
+ * after the SSRF resolve/validate pass and only when no pool/relay agent owns
+ * the dial, so the security boundary is unchanged.
+ */
+function nodeDial(url: URL, init: RequestInit): Promise<Response> {
+  return new Promise((resolve, reject) => {
+    const mod = url.protocol === "http:" ? httpRequest : httpsRequest;
+    const headers: Record<string, string> = {};
+    {
+      const h = new Headers(init.headers);
+      h.forEach((value, key) => {
+        headers[key] = value;
+      });
+    }
+    let payload: Buffer | undefined;
+    const body = init.body;
+    if (typeof body === "string") {
+      payload = Buffer.from(body, "utf8");
+    } else if (Buffer.isBuffer(body)) {
+      payload = body;
+    } else if (body instanceof Uint8Array) {
+      payload = Buffer.from(body);
+    } else if (body !== null && body !== undefined) {
+      reject(new TypeError("nodeDial only supports string/Buffer/Uint8Array bodies"));
+      return;
+    }
+    if (payload !== undefined) headers["content-length"] = String(payload.byteLength);
+    const req = mod(
+      url,
+      {
+        method: (init.method ?? "GET").toUpperCase(),
+        headers,
+        ...(init.signal === undefined ? {} : { signal: init.signal as AbortSignal }),
+      },
+      (res) => {
+        const chunks: Buffer[] = [];
+        res.on("data", (c: Buffer) => chunks.push(c));
+        res.on("end", () => {
+          resolve(
+            new Response(Buffer.concat(chunks), {
+              status: res.statusCode ?? 200,
+              ...(res.statusMessage === undefined ? {} : { statusText: res.statusMessage }),
+              headers: res.headers as unknown as HeadersInit,
+            }),
+          );
+        });
+      },
+    );
+    req.on("error", reject);
+    if (payload !== undefined) req.write(payload);
+    req.end();
+  });
+}
+
 export function createValidatedFetch(options: ValidatedFetchOptions = {}): ValidatedFetch {
   const policy = options.policy ?? {};
   const maxRedirects = options.maxRedirects ?? policy.maxRedirects ?? 3;
@@ -242,7 +302,18 @@ export function createValidatedFetch(options: ValidatedFetchOptions = {}): Valid
         // serverless front door refuses (400).
         response = await dial(relay.url, relay.init, fetchFn, undefined);
       } else {
-        response = await dial(url, requestInit, fetchFn, proxyUrl, socksAgent ? socksDispatcherFor(socksAgent) : undefined, socksFetch);
+        const method = (requestInit.method ?? "GET").toUpperCase();
+        const hasBody = requestInit.body !== undefined && requestInit.body !== null;
+        // The runtime fetch cannot carry a body on GET/HEAD, but Qoder's
+        // model-list endpoint requires a signed GET body. When no pool/relay
+        // owns the dial and no injected test fetch is present, dial through the
+        // Node http(s) client (post SSRF validation). Every other case keeps
+        // the existing fetch path.
+        if ((method === "GET" || method === "HEAD") && hasBody && !socksAgent && options.fetchFn === undefined) {
+          response = await nodeDial(url, requestInit);
+        } else {
+          response = await dial(url, requestInit, fetchFn, proxyUrl, socksAgent ? socksDispatcherFor(socksAgent) : undefined, socksFetch);
+        }
       }
       if (response.status < 300 || response.status >= 400) {
         trackNetworkCall(url.hostname, performance.now() - startedAt);
@@ -264,7 +335,7 @@ export function createValidatedFetch(options: ValidatedFetchOptions = {}): Valid
       if (isCrossOriginRedirect && (response.status === 307 || response.status === 308)) {
         const method = (requestInit.method ?? "GET").toUpperCase();
         if (method !== "GET" && method !== "HEAD" && requestInit.body !== undefined) {
-          throw new GatewayError("invalid_request", 400, "cross-origin redirect with body blocked");
+          throw new GatewayError("invalid_request", 400, "cross-origin redirect with body blocked (request {requestId}). Check the shape of what you sent — then resend 🪞");
         }
       }
       url = nextUrl;