cartethyia 2.6.7 → 2.7.1

package/src/providers/operations/account-reset-service.ts

@@ -642,6 +642,7 @@ async function recordResetActivity(
       })
       .where(eq(providerAccounts.id, accountId));
     await db.insert(healthEvents).values({
+      id: randomUUID(),
       entityKind: "account",
       accountId,
       fromStatus: currentStatus,
@@ -655,6 +656,7 @@ async function recordResetActivity(
   }
 
   await db.insert(healthEvents).values({
+    id: randomUUID(),
     entityKind: "account",
     accountId,
     fromStatus: currentStatus,

package/src/providers/provider-contracts.ts

@@ -134,8 +134,6 @@ export interface ProviderDispatchContext {
   readonly outbound_fetch?: ValidatedOutboundFetch | undefined;
   /** Validated image/attachment egress; deliberately excluded from payload capture. */
   readonly outbound_attachment_fetch?: ValidatedOutboundFetch | undefined;
-  /** Validated WSS egress bound to the same selected network pool as HTTP. */
-  readonly outbound_websocket?: ValidatedOutboundWebSocket | undefined;
   /** Validated bidirectional HTTP/2 egress bound to the same selected network pool. */
   readonly outbound_http2?: ValidatedOutboundHttp2Bidi | undefined;
   /** Built-in API-key route-selected fallback User-Agent; custom providers leave this unset. */

package/src/providers/provider-metadata.ts

@@ -15,6 +15,15 @@ export interface CompatibilityProfile {
   }>;
   /** Whether requests to OpenAI/Anthropic-compatible upstream should send official CLI headers. Defaults to true. */
   readonly cli_identity?: boolean;
+  /**
+   * Direct egress for this provider uses the runtime-native fetch instead of
+   * the Node-stack pinned agent. Some upstreams meter per client transport
+   * fingerprint — OpenCode's anonymous free tier refuses the Node agent with
+   * 429 FreeUsageLimitError while accepting the native fetch byte-for-byte
+   * (verified live). The SSRF resolve/validate pass still runs for every hop;
+   * only the socket-level address pin is traded away.
+   */
+  readonly preferNativeFetch?: boolean;
   /**
    * Opts this provider into the gateway identity (`user-agent:
    * `Cartethyia/<version>`) instead of official CLI cloaking. Explicit only:
@@ -322,6 +331,14 @@ const RAW_BUNDLED_PROVIDER_METADATA = [
     hasAdapterUserAgent: true,
   },
   { id: "bai", displayName: "B.AI", baseUrl: "https://api.b.ai/v1", credentialUrl: "https://b.ai" },
+  {
+    id: "inception",
+    displayName: "Inception Labs",
+    // Version-rooted: the chat wire lives below the `/v1` root, so the
+    // declared path is `/chat/completions` (same rule as Groq/DeepInfra).
+    baseUrl: "https://api.inceptionlabs.ai/v1",
+    credentialUrl: "https://platform.inceptionlabs.ai/dashboard/api-keys",
+  },
   {
     id: "larprouter",
     displayName: "LarRouter",
@@ -630,16 +647,20 @@ export function providerBaseUrl(providerId: string): string {
 export const PROVIDER_COMPATIBILITY_PROFILES: Record<string, CompatibilityProfile> = {
   opencode: {
     endpoint_paths_by_wire_family: {
-      chat: "/inference/v1/chat/completions",
-      responses: "/inference/v1/responses",
+      chat: "/inference/openai/v1/chat/completions",
+      responses: "/inference/openai/v1/responses",
     },
+    // Direct egress must use the native fetch: the anonymous free tier refuses
+    // the Node-stack agent with 429 FreeUsageLimitError (verified live).
+    preferNativeFetch: true,
     model_wire_families: [{ pattern: "^muse-spark", wire_family: "responses" }],
   },
   "opencode-zen": {
     endpoint_paths_by_wire_family: {
-      chat: "/inference/v1/chat/completions",
-      responses: "/inference/v1/responses",
+      chat: "/inference/openai/v1/chat/completions",
+      responses: "/inference/openai/v1/responses",
     },
+    preferNativeFetch: true,
     model_wire_families: [{ pattern: "^muse-spark", wire_family: "responses" }],
   },
   "opencode-go": {

package/src/providers/provider-probe.ts

@@ -110,13 +110,13 @@ export async function buildProviderProbeRequest(
       provider_id: providerId,
       model_id: PROBE_MODEL,
       wire_family: "chat",
-      endpoint_path: "/inference/v1/chat/completions",
+      endpoint_path: "/inference/openai/v1/chat/completions",
       capabilities: {},
     } as ProviderDispatchTarget,
   );
   const headers = (await spec.buildExtraHeaders?.(probeContext(providerId), source)) ?? {};
   return {
-    url: `${providerBaseUrl(providerId).replace(/\/+$/, "")}/inference/v1/chat/completions`,
+    url: `${providerBaseUrl(providerId).replace(/\/+$/, "")}/inference/openai/v1/chat/completions`,
     headers: { "content-type": "application/json", ...headers },
     body: payload,
   };

package/src/{console → providers}/quota/cache.ts

@@ -6,7 +6,7 @@
 // Reads the pre-envelope bare result and v2-v4 envelopes during upgrade;
 // writes use v5, which records attempt time, retained-refresh errors, and
 // forces a one-time refresh for required quota accounting metadata.
-import type { ProviderQuotaResult } from "../../providers/quota/quota-contracts";
+import type { ProviderQuotaResult } from "./quota-contracts";
 import type { RedisClient } from "../../persistence/redis";
 import { TtlCache } from "../../persistence/ttl-cache";
 import { log } from "../../observability/logger";

package/src/{console → providers}/quota/refresh.ts

@@ -11,12 +11,12 @@ import type { CartethyiaDatabase } from "../../persistence/db-handle";
 import { providerAccounts } from "../../persistence/schema";
 import type { RedisClient } from "../../persistence/redis";
 import { log } from "../../observability/logger";
-import { fetchProviderQuota } from "../../providers/quota/quota-support";
-import { type FetchLike, type ProviderQuotaResult } from "../../providers/quota/quota-contracts";
-import type { ProviderId } from "../../providers/provider-contracts";
-import type { ProviderRegistry } from "../../providers/provider-registry";
+import { fetchProviderQuota } from "./quota-support";
+import { type FetchLike, type ProviderQuotaResult } from "./quota-contracts";
+import type { ProviderId } from "../provider-contracts";
+import type { ProviderRegistry } from "../provider-registry";
 import { GLOBAL_QUOTA_LENS, setCachedQuota } from "./cache";
-import { record } from "../../providers/authentication/oauth-flow-store";
+import { record } from "../authentication/oauth-flow-store";
 
 /** Why an account quota refresh failed; `null` means the fetch succeeded. */
 export type QuotaRefreshFailureCode = "missing_credential" | "quota_fetch_failed";

package/src/security/abuse.ts

@@ -1,4 +1,6 @@
 import { GatewayError } from "../protocol/gateway-error";
+import { log } from "../observability/logger";
+import { metrics } from "../observability/metrics";
 import { redisEvalTuple, type RedisClient } from "../persistence/redis";
 
 export interface ClientIdentity {
@@ -419,7 +421,21 @@ export class IpAbuseProtectionService {
         banDurationMs: this.banDurationMs,
       });
 
+      // Logged once, at the transition. A ban is the one state here the
+      // operator cannot see from a metric and cannot wait out by guessing:
+      // every request afterwards answers 429 with the same message, whether
+      // the address is banned or merely over the window. Naming the address,
+      // the count that tripped it, and how long it lasts is what turns
+      // "429, sometimes" into something to act on.
+      if (outcome.bannedNow) {
+        log.warn(
+          `ip abuse: banned ${ip} for ${Math.round(this.banDurationMs / 60_000)}min` +
+            ` (route ${input.route}, ceiling ${this.banThreshold})`,
+        );
+      }
+
       if (outcome.banned) {
+        metrics.cartethyia_ip_abuse_refusals_total.inc(1, { reason: "ip-banned" });
         throw new GatewayError("quota_exceeded", 429, "This address is temporarily banned for too many failed requests. Wait for the ban to lift, then slow down.", {
           // Distinguishes this from the rate-limited 429 below and from an API
           // key's own budget. It used to be "admission-unavailable", which is
@@ -437,6 +453,7 @@ export class IpAbuseProtectionService {
       }
 
       if (outcome.count > this.maxRequestsPerWindow) {
+        metrics.cartethyia_ip_abuse_refusals_total.inc(1, { reason: "ip-rate-limited" });
         throw new GatewayError("quota_exceeded", 429, "This address is sending requests faster than the abuse limit allows. Back off and retry after the window rolls over.", {
           reason: "ip-rate-limited",
           ip,

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

@@ -13,7 +13,7 @@ import type { TelemetryBatchBuffer } from "../../observability/telemetry-buffer"
 import type { ProxyRequestOutcome, ProxyRequestState } from "../request/state";
 import type { PayloadCaptureState } from "../../observability/payload-capture";
 import { finalizeRequestTelemetry } from "../guards/error-lifecycle";
-import { debitCachedQuota, quotaLens } from "../../console/quota/cache";
+import { debitCachedQuota, quotaLens } from "../../providers/quota/cache";
 import { BUDDY_PROVIDER_IDS } from "../../providers/provider-metadata";
 import { log } from "../../observability/logger";
 import {
@@ -195,6 +195,43 @@ export function providerRequestMetadataOnly(request: unknown): unknown {
   return Object.keys(metadata).length === 0 ? null : metadata;
 }
 
+/**
+ * Captures one provider request body into the stored provider-request panel.
+ *
+ * Providers send bodies in several shapes: a plain string (the common case), a
+ * `Uint8Array`/Buffer (Qoder's custom cosy encoding), or another BodyInit
+ * type (URLSearchParams, Blob, FormData) that cannot be sliced safely here.
+ * Strings and byte arrays are decoded and stored; anything else is recorded as
+ * present-but-opaque, same as the metadata path.
+ */
+function captureRequestBodyBody(
+  body: BodyInit,
+  maxBytes: number,
+): { body: unknown } | { body_present: true; body_bytes: number } {
+  if (typeof body === "string") {
+    return { body: parseCapturedBody(truncateUtf8(body, maxBytes)) };
+  }
+  if (body instanceof Uint8Array) {
+    return { body: parseCapturedBody(truncateUtf8(new TextDecoder().decode(body), maxBytes)) };
+  }
+  return { body_present: true, body_bytes: capturedBodyByteLength(body) };
+}
+
+/** Byte length of a request body in whatever shape the provider sent it. */
+function capturedBodyByteLength(body: BodyInit): number {
+  if (typeof body === "string") return Buffer.byteLength(body, "utf8");
+  if (body instanceof Uint8Array) return body.byteLength;
+  if (typeof body === "object" && body !== null && "size" in body) {
+    const size = (body as { size?: unknown }).size;
+    if (typeof size === "number" && Number.isFinite(size)) return Math.round(size);
+  }
+  if (typeof body === "object" && body !== null && "byteLength" in body) {
+    const byteLength = (body as { byteLength?: unknown }).byteLength;
+    if (typeof byteLength === "number" && Number.isFinite(byteLength)) return Math.round(byteLength);
+  }
+  return 0;
+}
+
 /**
  * Wraps a validated outbound fetch to tee the provider request/response.
  *
@@ -216,7 +253,7 @@ export function captureProviderExchange(
         : input instanceof URL
           ? input.toString()
           : input.url;
-    const rawBody = typeof init?.body === "string" ? init.body : null;
+    const rawBody = init?.body;
     const headers = selectCapturedHeaders(init);
     sink.request = {
       method: init?.method ?? "GET",
@@ -227,11 +264,11 @@ export function captureProviderExchange(
       // shape sliced up to `maxBytes` of the translated body and ran it through
       // `JSON.parse` for every attempt — content a metadata-mode tenant had
       // explicitly declined to retain, paid on every dispatch.
-      ...(rawBody === null
+      ...(rawBody === null || rawBody === undefined
         ? {}
         : captureBody
-          ? { body: parseCapturedBody(truncateUtf8(rawBody, maxBytes)) }
-          : { body_present: true, body_bytes: Buffer.byteLength(rawBody, "utf8") }),
+          ? captureRequestBodyBody(rawBody, maxBytes)
+          : { body_present: true, body_bytes: capturedBodyByteLength(rawBody) }),
     };
     const response = await inner(input, init);
     sink.response =
@@ -463,6 +500,13 @@ export function estimatedUsage(inputTokens: number, outputTokens: number): Usage
 export interface AttemptCompletion extends ProxyRequestOutcome {
   readonly modelId?: string;
   readonly error?: unknown;
+  /**
+   * The HTTP status the terminal classifier derived for a raw (non-GatewayError)
+   * failure — an upstream socket drop is 502, not the 500 the fallback implied.
+   * Only consulted when the error carries no status of its own and no wire
+   * response named one.
+   */
+  readonly terminalHttpStatus?: number;
   readonly lease?: AdmissionLease;
   /** Usage to reconcile, or undefined when this attempt consumed nothing billable. */
   readonly commitUsage?: UsageRecord;
@@ -538,6 +582,63 @@ export function completionContext(input: {
   };
 }
 
+/**
+ * The terminal-completion base the native routes (generation, responses
+ * compact, system one, web search, token count) all assemble. The proxy and
+ * streaming paths use `completionContext`; these routes previously spelled
+ * the same twelve fields by hand in six places. Callers spread this and add
+ * only what differs: status, response body, error classification.
+ */
+export function nativeCompletionBase(input: {
+  readonly providerId: string;
+  readonly modelId: string;
+  readonly tenantId: string | null;
+  readonly ingressBody: unknown;
+  readonly accountId?: string;
+  readonly accountLabel?: string;
+  readonly networkPoolId?: string;
+  readonly lease?: AdmissionLease;
+  readonly db: CartethyiaDatabase;
+  readonly telemetryBuffer?: TelemetryBatchBuffer;
+  readonly snapshotService?: { invalidate(): unknown };
+  readonly providerCapture?: ProviderExchangeCapture;
+  readonly usage?: AttemptCompletion["usage"];
+  readonly commitUsage?: AttemptCompletion["commitUsage"];
+}): Omit<
+  AttemptCompletion,
+  | "status"
+  | "responseBody"
+  | "httpStatus"
+  | "terminalHttpStatus"
+  | "error"
+  | "clientResponseText"
+  | "firstContentDeltaAtMs"
+  | "lastEventAtMs"
+  | "reportedModel"
+  | "errorCategory"
+  | "errorOrigin"
+  | "ttfbMs"
+  | "tokensPerSec"
+> {
+  return {
+    providerId: input.providerId,
+    modelId: input.modelId,
+    tenantId: input.tenantId,
+    ingressBody: input.ingressBody,
+    terminal: true,
+    ...(input.accountId === undefined ? {} : { accountId: input.accountId }),
+    ...(input.accountLabel === undefined ? {} : { accountLabel: input.accountLabel }),
+    ...(input.networkPoolId === undefined ? {} : { networkPoolId: input.networkPoolId }),
+    ...(input.lease === undefined ? {} : { lease: input.lease }),
+    db: input.db,
+    ...(input.telemetryBuffer === undefined ? {} : { telemetryBuffer: input.telemetryBuffer }),
+    ...(input.snapshotService === undefined ? {} : { snapshotService: input.snapshotService }),
+    ...(input.providerCapture === undefined ? {} : { providerCapture: input.providerCapture }),
+    ...(input.usage === undefined ? {} : { usage: input.usage }),
+    ...(input.commitUsage === undefined ? {} : { commitUsage: input.commitUsage }),
+  };
+}
+
 /**
  * Decides whether a failed attempt proves *the pool* is unusable, and which
  * HTTP status that verdict rests on.
@@ -639,13 +740,14 @@ export async function completeAttempt(
       completion.httpStatus ??
       (completion.error instanceof GatewayError
         ? completion.error.status
-        : completion.status === "completed"
-          ? 200
-          : completion.status === "cancelled"
-            ? 499
-            : completion.status === "truncated"
-              ? 502
-              : 500),
+        : completion.terminalHttpStatus ??
+          (completion.status === "completed"
+            ? 200
+            : completion.status === "cancelled"
+              ? 499
+              : completion.status === "truncated"
+                ? 502
+                : 500)),
     ...(completion.providerId === undefined ? {} : { providerId: completion.providerId }),
     ...(completion.accountId === undefined ? {} : { accountId: completion.accountId }),
     ...(completion.accountLabel === undefined ? {} : { accountLabel: completion.accountLabel }),

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

@@ -288,6 +288,7 @@ export async function runAttemptLoop<TResult, TAdapter>(
             status: terminal.status,
             errorCategory: terminal.errorCategory,
             errorOrigin: terminal.errorOrigin,
+            ...(terminal.httpStatus === undefined ? {} : { terminalHttpStatus: terminal.httpStatus }),
             error: lastError,
             tenantId: input.tenantId,
             terminal: true,
@@ -419,6 +420,7 @@ export async function runAttemptLoop<TResult, TAdapter>(
         status: terminal.status,
         errorCategory: terminal.errorCategory,
         errorOrigin: terminal.errorOrigin,
+        ...(terminal.httpStatus === undefined ? {} : { terminalHttpStatus: terminal.httpStatus }),
         error,
         tenantId: input.tenantId,
         terminal: terminalAttempt,
@@ -539,6 +541,7 @@ export async function runAttemptLoop<TResult, TAdapter>(
       status: terminal.status,
       errorCategory: terminal.errorCategory,
       errorOrigin: terminal.errorOrigin,
+      ...(terminal.httpStatus === undefined ? {} : { terminalHttpStatus: terminal.httpStatus }),
       error: lastError,
       terminal: true,
       tenantId: input.tenantId,