@prometheus-ai/ai 0.5.4 → 0.5.8

package/dist/types/utils/abort.d.ts

@@ -17,3 +17,9 @@ export interface AbortSourceTracker {
  * the UI showing a spinner the user already tried to cancel).
  */
 export declare function createAbortSourceTracker(callerSignal?: AbortSignal): AbortSourceTracker;
+/**
+ * Race a shared promise against a caller's AbortSignal without coupling the
+ * underlying work to that signal. The shared promise keeps running (and caches
+ * its result) even when an individual caller bails out.
+ */
+export declare function raceWithSignal<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T>;

package/dist/types/utils/event-stream.d.ts

@@ -7,6 +7,8 @@ export declare class EventStream<T, R = T> implements AsyncIterable<T> {
         reject: (err: unknown) => void;
     }>;
     done: boolean;
+    /** True once finalResultPromise has been resolved or rejected. */
+    resultSettled: boolean;
     finalResultPromise: Promise<R>;
     resolveFinalResult: (result: R) => void;
     rejectFinalResult: (err: unknown) => void;

package/dist/types/utils/http-inspector.d.ts

@@ -15,7 +15,6 @@ export type CapturedHttpErrorResponse = {
 };
 export declare function appendRawHttpRequestDumpFor400(message: string, error: unknown, dump: RawHttpRequestDump | undefined): Promise<string>;
 export declare function finalizeErrorMessage(error: unknown, rawRequestDump: RawHttpRequestDump | undefined, capturedErrorResponse?: CapturedHttpErrorResponse): Promise<string>;
-export declare function withHttpStatus(error: unknown, status: number): Error;
 /**
  * Rewrite error message for GitHub Copilot request failures.
  * Must run AFTER finalizeErrorMessage since it replaces the message entirely.

package/dist/types/utils/idle-iterator.d.ts

@@ -76,3 +76,38 @@ export interface IdleTimeoutIteratorOptions {
  * before any user-visible content has streamed.
  */
 export declare function iterateWithIdleTimeout<T>(iterable: AsyncIterable<T>, options: IdleTimeoutIteratorOptions): AsyncGenerator<T>;
+export interface TerminalGraceIteratorOptions {
+    /**
+     * Epoch-ms timestamp at which the consumer observed a logically terminal
+     * item (e.g. a chat-completions chunk carrying `finish_reason`), or
+     * `undefined` while the stream is still mid-response. Read before every
+     * pull, so the consumer can flip it between yields.
+     */
+    finishedAtMs: () => number | undefined;
+    /**
+     * Post-terminal budget: how long after `finishedAtMs()` to keep draining
+     * trailing items (e.g. a usage-only chunk or the `[DONE]` sentinel) before
+     * ending the iteration cleanly. The deadline is fixed at
+     * `finishedAtMs() + graceMs`; trailing items do not extend it, so
+     * keepalive-only servers cannot hold the stream open.
+     */
+    graceMs: number;
+    /**
+     * Invoked when the grace window closes with the source still open. Use it
+     * to abort the underlying request: the source generator is typically parked
+     * mid-`next()` (not at a yield), so a queued `.return()` alone cannot reach
+     * the transport until that pending read settles.
+     */
+    onGraceEnd?: () => void;
+}
+/**
+ * Yields items from an async iterable until the consumer marks the stream
+ * logically finished AND the source stays silent past a short grace window.
+ *
+ * Misbehaving OpenAI-compatible servers deliver the terminal chunk but never
+ * send `[DONE]` nor close the connection; without this guard the consumer
+ * hangs on `iterator.next()` until the idle watchdog converts an
+ * already-successful turn into a timeout error. Grace expiry is a clean end
+ * of iteration, never an error.
+ */
+export declare function iterateWithTerminalGrace<T>(iterable: AsyncIterable<T>, options: TerminalGraceIteratorOptions): AsyncGenerator<T>;

package/dist/types/utils/openai-http.d.ts

@@ -0,0 +1,58 @@
+/**
+ * JSON-POST → SSE transport for OpenAI-wire streaming endpoints (chat
+ * completions, responses, azure responses). Replaces the `openai` SDK client:
+ *
+ * - Retries: `fetchWithRetry` (Retry-After/quota-hint aware; 5xx/408/429 and
+ *   transient network errors). Default 6 total attempts — parity with the
+ *   SDK's former `maxRetries: 5`.
+ * - SSE decode: `readSseJson` (spec-compliant framing, `[DONE]`-aware).
+ *   `onSseEvent` observers now receive real wire frames instead of events
+ *   re-synthesized from decoded SDK objects.
+ * - Errors: {@link OpenAIHttpError} exposes `status`/`headers`/`code`
+ *   structurally (ProviderHttpError contract — `extractHttpStatusFromError`,
+ *   retry-after extraction, copilot transient classification) and carries the
+ *   captured response body for the strict-tools fallback and the responses
+ *   chain-state detectors, which regex over `error.message`.
+ */
+import { type SseEventObserver } from "@prometheus-ai/utils";
+import { ProviderHttpError } from "../errors";
+import type { FetchImpl } from "../types";
+import type { CapturedHttpErrorResponse } from "./http-inspector";
+/** Non-2xx response from an OpenAI-wire endpoint, with the decoded body attached. */
+export declare class OpenAIHttpError extends ProviderHttpError {
+    readonly captured: CapturedHttpErrorResponse;
+    constructor(message: string, captured: CapturedHttpErrorResponse, code: string | undefined);
+}
+export interface OpenAIStreamRequestInit {
+    url: string;
+    headers: Record<string, string>;
+    /** JSON request body; serialized once per call (retries resend the same bytes). */
+    body: unknown;
+    signal: AbortSignal;
+    fetch?: FetchImpl;
+    /**
+     * Total attempts (initial + retries). Defaults to {@link DEFAULT_MAX_ATTEMPTS}.
+     * Pass `1` when a first-event watchdog is armed so retries cannot silently
+     * extend the caller's deadline (mirrors the old `maxRetries: 0` hint).
+     */
+    maxAttempts?: number;
+    /** Raw wire-frame observer (`onSseEvent` debug pipeline). */
+    onSseEvent?: SseEventObserver;
+}
+export interface OpenAIStreamHandle<TEvent> {
+    /** Decoded `data:` payloads; terminates on `[DONE]` or stream end. */
+    events: AsyncGenerator<TEvent>;
+    response: Response;
+    /** `x-request-id` response header (the SDK's former `request_id`). */
+    requestId: string | null;
+}
+/**
+ * POST a JSON body and stream back decoded SSE events.
+ *
+ * Throws {@link OpenAIHttpError} on a non-2xx terminal response. Aborts on
+ * `signal` propagate from `fetchWithRetry`/`readSseJson`; callers own the
+ * watchdog timers and abort-reason bookkeeping.
+ */
+export declare function postOpenAIStream<TEvent>(init: OpenAIStreamRequestInit): Promise<OpenAIStreamHandle<TEvent>>;
+/** Decode a non-2xx response into an {@link OpenAIHttpError} without consuming it twice. */
+export declare function captureOpenAIHttpError(response: Response): Promise<OpenAIHttpError>;

package/dist/types/utils/request-debug.d.ts

@@ -22,6 +22,9 @@ export interface RequestDebugSession {
     wrapResponse(response: Response): Promise<Response>;
 }
 export declare function isRequestDebugEnabled(): boolean;
+export declare function setNextRequestDebugPath(requestPath: string): void;
+export declare function clearNextRequestDebugPath(): void;
+export declare function getNextRequestDebugPath(): string | undefined;
 export declare function wrapFetchForRequestDebug(fetchImpl: FetchImpl): FetchImpl;
 export declare function withRequestDebugFetch<T extends {
     fetch?: FetchImpl;

package/dist/types/utils/retry-after.d.ts

@@ -1,3 +1,4 @@
 export type HeadersLike = Headers | Record<string, string | undefined> | undefined | null;
 export declare function formatErrorMessageWithRetryAfter(error: unknown, headers?: HeadersLike): string;
 export declare function getRetryAfterMsFromHeaders(headers: HeadersLike): number | undefined;
+export declare function getHeadersFromError(error: unknown): HeadersLike;

package/dist/types/utils/schema/fields.d.ts

@@ -30,6 +30,11 @@ export declare const NON_STRUCTURAL_SCHEMA_KEYS: Record<string, true>;
  * Used when collapsing mixed-type combiner variants for CCA Claude.
  */
 export declare const CLOUD_CODE_ASSIST_TYPE_SPECIFIC_KEYS: Record<string, Record<string, true>>;
+/**
+ * Flat set of every type-specific key across all CCA types.
+ * Used to identify sibling keys that need filtering during mixed-type collapse.
+ */
+export declare const ALL_CCA_TYPE_SPECIFIC_KEYS: Record<string, true>;
 /**
  * Cloud Code Assist shared schema keys allowed on any type.
  * Used alongside CLOUD_CODE_ASSIST_TYPE_SPECIFIC_KEYS for CCA combiner collapsing.

package/dist/types/utils/schema/json-schema-validator.d.ts

@@ -3,6 +3,14 @@ export interface JsonSchemaValidationIssue {
     message: string;
     expectedTypes?: string[];
     keyword?: string;
+    /**
+     * Marks issues that originate inside a failed `anyOf` / `oneOf` branch.
+     * Consumers such as the tool-argument coercion layer use this to avoid
+     * applying type repairs (e.g. singleton-array wrapping) that would be
+     * authoritative outside of a combinator but are only one candidate
+     * branch's expectation here.
+     */
+    fromUnionBranch?: boolean;
 }
 export interface JsonSchemaValidationResult {
     success: boolean;

package/dist/types/utils/schema/stamps.d.ts

@@ -1,17 +1,3 @@
-/**
- * Symbol-keyed lazy memoization stamped directly onto the host object.
- *
- * Faster than a module-level `WeakMap` in V8/JSC because the symbol slot is
- * resolved through the object's hidden class instead of a side-table hash
- * lookup. The slot is defined as a non-enumerable property so the stamp
- * does not leak through `{...spread}`, `Object.keys`, `JSON.stringify`, or
- * `toEqual`-style deep equality.
- *
- * Caveats: the stamp lives as long as the host object, even after callers
- * release their references to the cached value — only use this for caches
- * whose lifetime should match the host. Frozen hosts will throw on write in
- * strict mode; callers that may receive frozen input must handle that.
- */
 export declare function stamp<T extends object, V>(target: T, key: symbol, compute: (target: T) => V): V;
 export declare function epochNext(): number;
 /**
@@ -20,6 +6,12 @@ export declare function epochNext(): number;
  * subsequent call within the same epoch.
  */
 export declare function once<T extends object>(target: T, epoch: number): boolean;
-/** Returns `true` on first entry, `false` if `target` is already on the current path. */
+/**
+ * Returns `true` on first entry, `false` if `target` is already on the
+ * current path. A `false` return does NOT deepen the counter — callers pair
+ * `exit` only with successful enters (`if (!enter(n)) bail; try {…} finally
+ * { exit(n); }`), so incrementing on the cycle branch would leak depth and
+ * make every later top-level walk of the same object misreport a cycle.
+ */
 export declare function enter<T extends object>(target: T): boolean;
 export declare function exit<T extends object>(target: T): void;

package/dist/types/utils/sse-debug.d.ts

@@ -1,10 +1,5 @@
 import type { ServerSentEvent } from "@prometheus-ai/utils";
 import type { RawSseEvent } from "../types";
-type FetchFunction = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
-type FetchWithPreconnect = FetchFunction & {
-    preconnect?: typeof fetch.preconnect;
-};
 type RawSseObserver = (event: RawSseEvent) => void;
 export declare function notifyRawSseEvent(observer: RawSseObserver | undefined, event: ServerSentEvent | RawSseEvent): void;
-export declare function wrapFetchForSseDebug(fetchImpl: FetchWithPreconnect, observer: RawSseObserver | undefined): FetchWithPreconnect;
 export {};

package/dist/types/utils/stream-markup-healing.d.ts

@@ -75,6 +75,8 @@ export declare class StreamMarkupHealing {
 export declare function modelMayLeakKimiToolCalls(provider: string, modelId: string): boolean;
 /** Cheap model/provider gate for DeepSeek DSML envelope leaks. */
 export declare function modelMayLeakDsmlToolCalls(provider: string, modelId: string): boolean;
+/** Cheap model/provider gate for MiniMax plain thinking tag leaks. */
+export declare function modelMayLeakThinkingTags(provider: string, modelId: string): boolean;
 export declare function getStreamMarkupHealingPattern(provider: string, modelId: string, options?: {
     readonly parseThinkingTags?: boolean;
 }): StreamMarkupHealingPattern | undefined;

package/dist/types/utils.d.ts

@@ -1,10 +1,7 @@
-import type { ResponseInput } from "openai/resources/responses/responses";
+import type { ResponseInput } from "./providers/openai-responses-wire";
 import type { CacheRetention, OpenAIResponsesHistoryPayload, ProviderPayload } from "./types";
 export { isRecord } from "@prometheus-ai/utils";
 export declare function normalizeSystemPrompts(systemPrompt: readonly string[] | string | undefined | null): string[];
-export declare function toNumber(value: unknown): number | undefined;
-export declare function toPositiveNumber(value: unknown, fallback: number): number;
-export declare function toBoolean(value: unknown): boolean | undefined;
 export declare function normalizeToolCallId(id: string): string;
 type ResponsesToolItemIdPrefix = "fc" | "ctc";
 export declare function normalizeResponsesToolCallId(id: string, itemPrefix?: ResponsesToolItemIdPrefix): {
@@ -25,4 +22,3 @@ export declare function getOpenAIResponsesHistoryItems(providerPayload: Provider
  * Defaults to "short" and uses PROMETHEUS_CACHE_RETENTION for backward compatibility.
  */
 export declare function resolveCacheRetention(cacheRetention?: CacheRetention): CacheRetention;
-export declare function isAnthropicOAuthToken(key: string): boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@prometheus-ai/ai",
-	"version": "0.5.4",
+	"version": "0.5.8",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://prometheus.trivlab.com",
 	"author": "Uttam Trivedi",
@@ -31,15 +31,15 @@
 		"lint": "biome lint .",
 		"test": "bun test --parallel --timeout=15000",
 		"fix": "biome check --write --unsafe .",
-		"fmt": "biome format --write .",
-		"generate-models": "bun scripts/generate-models.ts"
+		"fmt": "biome format --write ."
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@prometheus-ai/utils": "0.5.4",
+		"@prometheus-ai/catalog": "0.5.8",
+		"@prometheus-ai/utils": "0.5.8",
 		"openai": "^6.39.0",
 		"partial-json": "^0.1.7",
-		"zod": "4.4.3"
+		"zod": "^4"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"
@@ -78,18 +78,6 @@
 			"types": "./dist/types/auth-gateway/*.d.ts",
 			"import": "./src/auth-gateway/*.ts"
 		},
-		"./models.json": {
-			"types": "./dist/types/models.json.d.d.ts",
-			"import": "./src/models.json"
-		},
-		"./provider-models": {
-			"types": "./dist/types/provider-models/index.d.ts",
-			"import": "./src/provider-models/index.ts"
-		},
-		"./provider-models/*": {
-			"types": "./dist/types/provider-models/*.d.ts",
-			"import": "./src/provider-models/*.ts"
-		},
 		"./providers/*": {
 			"types": "./dist/types/providers/*.d.ts",
 			"import": "./src/providers/*.ts"
@@ -110,21 +98,21 @@
 			"types": "./dist/types/utils/*.d.ts",
 			"import": "./src/utils/*.ts"
 		},
-		"./utils/discovery": {
-			"types": "./dist/types/utils/discovery/index.d.ts",
-			"import": "./src/utils/discovery/index.ts"
+		"./oauth": {
+			"types": "./dist/types/registry/oauth/index.d.ts",
+			"import": "./src/registry/oauth/index.ts"
 		},
-		"./utils/discovery/*": {
-			"types": "./dist/types/utils/discovery/*.d.ts",
-			"import": "./src/utils/discovery/*.ts"
+		"./oauth/*": {
+			"types": "./dist/types/registry/oauth/*.d.ts",
+			"import": "./src/registry/oauth/*.ts"
 		},
-		"./utils/oauth": {
-			"types": "./dist/types/utils/oauth/index.d.ts",
-			"import": "./src/utils/oauth/index.ts"
+		"./registry": {
+			"types": "./dist/types/registry/index.d.ts",
+			"import": "./src/registry/index.ts"
 		},
-		"./utils/oauth/*": {
-			"types": "./dist/types/utils/oauth/*.d.ts",
-			"import": "./src/utils/oauth/*.ts"
+		"./registry/oauth": {
+			"types": "./dist/types/registry/oauth/index.d.ts",
+			"import": "./src/registry/oauth/index.ts"
 		},
 		"./utils/schema": {
 			"types": "./dist/types/utils/schema/index.d.ts",

package/src/auth-broker/remote-store.ts

@@ -17,9 +17,9 @@ import {
 	REMOTE_REFRESH_SENTINEL,
 	type StoredAuthCredential,
 } from "../auth-storage";
+import type { OAuthCredentials } from "../registry/oauth/types";
 import type { Provider } from "../types";
 import type { UsageReport } from "../usage";
-import type { OAuthCredentials } from "../utils/oauth/types";
 import { type AuthBrokerClient, AuthBrokerStreamUnsupportedError } from "./client";
 import type { RefresherSchedule, SnapshotEntry, SnapshotResponse, SnapshotStreamEvent } from "./types";
 
@@ -275,6 +275,15 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
 		});
 	}
 
+	async deleteAuthCredentialRemote(id: number, disabledCause: string): Promise<boolean> {
+		const found = this.#snapshot.credentials.some(entry => entry.id === id);
+		if (!found) return false;
+		await this.#client.disableCredential(id, disabledCause);
+		this.#removeCredentialById(id);
+		this.#maybeRefreshSnapshot("delete credential");
+		return true;
+	}
+
 	tryDisableAuthCredentialIfMatches(id: number, _expectedData: string, disabledCause: string): boolean {
 		const found = this.#snapshot.credentials.find(entry => entry.id === id);
 		if (!found) return false;

package/src/auth-broker/snapshot-cache.ts

@@ -12,7 +12,7 @@ import { isEnoent, logger } from "@prometheus-ai/utils";
 import type { SnapshotResponse } from "./types";
 import { snapshotResponseSchema } from "./wire-schemas";
 
-const MAGIC = new Uint8Array([0x50, 0x52, 0x4d, 0x53]); // "PRMS"
+const MAGIC = new Uint8Array([0x4f, 0x4d, 0x50, 0x53]); // "OMPS"
 const VERSION = 1;
 const VERSION_OFFSET = MAGIC.byteLength;
 const IV_OFFSET = VERSION_OFFSET + 1;

package/src/auth-broker/wire-schemas.ts

@@ -10,7 +10,7 @@
  * keys are rejected — the previous implementation used a hand-rolled
  * `hasOnlyFields` allowlist for the same effect.
  */
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import { REMOTE_REFRESH_SENTINEL } from "../auth-storage";
 import { usageReportSchema } from "../usage";
 

package/src/auth-gateway/http.ts

@@ -74,7 +74,7 @@ const PASSTHROUGH_HEADER_NAMES: Record<string, true> = {
 	"openai-organization": true,
 	"openai-project": true,
 	"openai-beta": true,
-	// Codex / ChatGPT-OAuth backend headers (see openai-codex/constants.ts).
+	// Codex / ChatGPT-OAuth backend headers (see @prometheus-ai/catalog/wire/codex).
 	// `session_id` and `conversation_id` thread the upstream session so prompt
 	// caching and per-conversation rate limiting work; `chatgpt-account-id` and
 	// `originator` identify the calling account and client surface.

package/src/auth-gateway/server.ts

@@ -17,9 +17,11 @@
  *   POST /v1/messages                      → Anthropic messages in/out
  *   POST /v1/responses                     → OpenAI Responses in/out
  */
+
+import { Effort } from "@prometheus-ai/catalog/effort";
 import { extractRetryHint, logger } from "@prometheus-ai/utils";
+import type { ApiKeyResolver } from "../auth-retry";
 import type { AuthStorage } from "../auth-storage";
-import { Effort } from "../model-thinking";
 import * as anthropicMessages from "../providers/anthropic-messages-server";
 import * as openaiChat from "../providers/openai-chat-server";
 import * as openaiResponses from "../providers/openai-responses-server";
@@ -314,9 +316,10 @@ async function refreshGatewayApiKeyAfterAuthError(
 	const message = error instanceof Error ? error.message : String(error);
 	if (isUsageLimitError(message)) {
 		const retryAfterMs = extractRetryHint(undefined, message);
-		const switched = await storage.markUsageLimitReached(provider, sessionId, {
+		const { switched, retryAtMs } = await storage.markUsageLimitReached(provider, sessionId, {
 			retryAfterMs,
 			baseUrl: model.baseUrl,
+			modelId: model.id,
 			signal,
 		});
 		logger.debug("auth-gateway retrying provider request after usage-limit block", {
@@ -325,6 +328,7 @@ async function refreshGatewayApiKeyAfterAuthError(
 			peer,
 			switched,
 			retryAfterMs,
+			retryAtMs,
 			error: message,
 		});
 		if (!switched) return undefined;
@@ -340,6 +344,60 @@ async function refreshGatewayApiKeyAfterAuthError(
 	return storage.getApiKey(provider, sessionId, { modelId: model.id, signal });
 }
 
+/**
+ * Build the {@link ApiKeyResolver} handed to `streamSimple` for a gateway
+ * request. Drives the central a/b/c auth-retry policy server-side:
+ *
+ * - initial resolve → the credential already resolved for this request.
+ * - step (b) `!lastChance` → force-refresh the SAME session-sticky credential
+ *   (a peer/broker may have rotated its token out from under our cached copy).
+ * - step (c) `lastChance` → {@link refreshGatewayApiKeyAfterAuthError} switches
+ *   to a sibling (usage-limit block vs credential invalidation by error class).
+ *
+ * `lastKey` tracks the most recent bearer so the switch step invalidates the
+ * credential that actually failed.
+ */
+function buildGatewayApiKeyResolver(
+	storage: AuthStorage,
+	model: Model<Api>,
+	sessionId: string,
+	initialKey: string,
+	requestSignal: AbortSignal,
+	format: string,
+	peer: string,
+): ApiKeyResolver {
+	let lastKey = initialKey;
+	return async ({ lastChance, error, signal }) => {
+		const sig = signal ?? requestSignal;
+		if (error === undefined) {
+			lastKey = initialKey;
+			return initialKey;
+		}
+		if (!lastChance) {
+			const refreshed = await storage.getApiKey(model.provider, sessionId, {
+				modelId: model.id,
+				signal: sig,
+				forceRefresh: true,
+			});
+			lastKey = refreshed ?? lastKey;
+			return refreshed;
+		}
+		const next = await refreshGatewayApiKeyAfterAuthError(
+			storage,
+			model,
+			sessionId,
+			model.provider,
+			lastKey,
+			error,
+			sig,
+			format,
+			peer,
+		);
+		lastKey = next ?? lastKey;
+		return next;
+	};
+}
+
 function clientClosedResponse(route: { module: FormatModule }): Response {
 	return route.module.formatError(499, "request_aborted", "client closed request");
 }
@@ -447,19 +505,15 @@ async function handleFormatEndpoint(
 	}
 
 	const streamOpts = buildStreamOptions(parsed, model.api, controller.signal);
-	streamOpts.apiKey = apiKey;
-	streamOpts.onAuthError = (provider, oldKey, error) =>
-		refreshGatewayApiKeyAfterAuthError(
-			bootOpts.storage,
-			model,
-			sessionId,
-			provider,
-			oldKey,
-			error,
-			controller.signal,
-			route.label,
-			peer,
-		);
+	streamOpts.apiKey = buildGatewayApiKeyResolver(
+		bootOpts.storage,
+		model,
+		sessionId,
+		apiKey,
+		controller.signal,
+		route.label,
+		peer,
+	);
 
 	logger.info("auth-gateway request", {
 		format: route.label,
@@ -514,7 +568,14 @@ async function handleFormatEndpoint(
 	}
 	if (controller.signal.aborted) return clientClosedResponse(route);
 
-	const sseStream = route.module.encodeStream(events, parsed.modelId, parsed.options);
+	const sseStream = route.module.encodeStream(events, parsed.modelId, parsed.options, {
+		signal: controller.signal,
+		onCancel: reason => {
+			if (!controller.signal.aborted) {
+				controller.abort(reason instanceof Error ? reason : new Error("client closed request"));
+			}
+		},
+	});
 	return new Response(sseStream, {
 		status: 200,
 		headers: {
@@ -532,7 +593,7 @@ async function handleFormatEndpoint(
 /**
  * Prometheus-native fast path: `POST /v1/prometheus/stream`. Accepts the canonical Prometheus AI
  * `Context` directly (no wire-format round-trip) and emits a bandwidth-shrunk
- * event stream matching `Prometheus agent`'s `streamProxy`. Skips the OpenAI /
+ * event stream matching Prometheus' `streamProxy`. Skips the OpenAI /
  * Anthropic / Responses translation layers — those exist to bridge foreign
  * SDKs (llm-git, anthropic-sdk, openai-sdk), and bridging back to prometheus-native
  * just to bridge forward again is wasted work.
@@ -604,18 +665,15 @@ async function handlePrometheusNative(bootOpts: AuthGatewayBootOptions, req: Req
 	// only inject server-controlled fields. The codex temperature/topP strip
 	// matches `buildStreamOptions` — Codex rejects them with a 400.
 	const streamOpts: SimpleStreamOptions = { ...parsed.options, apiKey, signal: controller.signal };
-	streamOpts.onAuthError = (provider, oldKey, error) =>
-		refreshGatewayApiKeyAfterAuthError(
-			bootOpts.storage,
-			model,
-			sessionId,
-			provider,
-			oldKey,
-			error,
-			controller.signal,
-			"prometheus-native",
-			peer,
-		);
+	streamOpts.apiKey = buildGatewayApiKeyResolver(
+		bootOpts.storage,
+		model,
+		sessionId,
+		apiKey,
+		controller.signal,
+		"prometheus-native",
+		peer,
+	);
 	if (model.api === "openai-codex-responses") {
 		delete streamOpts.temperature;
 		delete streamOpts.topP;
@@ -679,7 +737,14 @@ async function handlePrometheusNative(bootOpts: AuthGatewayBootOptions, req: Req
 	}
 	if (controller.signal.aborted) return aborted();
 
-	const sseStream = prometheusNative.encodeStream(events);
+	const sseStream = prometheusNative.encodeStream(events, parsed.modelId, parsed.options, {
+		signal: controller.signal,
+		onCancel: reason => {
+			if (!controller.signal.aborted) {
+				controller.abort(reason instanceof Error ? reason : new Error("client closed request"));
+			}
+		},
+	});
 	return new Response(sseStream, {
 		status: 200,
 		headers: {

package/src/auth-gateway/types.ts

@@ -1,4 +1,4 @@
-import type { Effort } from "../model-thinking";
+import type { Effort } from "@prometheus-ai/catalog/effort";
 import type {
 	AssistantMessage,
 	AssistantMessageEventStream,
@@ -14,7 +14,7 @@ import type {
  * The gateway sits between unauthenticated clients (containerized prometheus,
  * llm-git, …) and the broker. It accepts provider-format HTTP requests
  * (OpenAI chat-completions / Anthropic messages / OpenAI Responses),
- * dispatches them through @prometheus-ai/ai's `streamSimple()`, and translates the
+ * dispatches them through Prometheus AI's `streamSimple()`, and translates the
  * canonical event stream back to the matching wire format. The gateway
  * injects `Authorization` server-side so clients never see access tokens.
  */
@@ -110,6 +110,13 @@ export interface AuthGatewayParsedRequest {
 	options: AuthGatewayParsedRequestOptions;
 }
 
+export interface AuthGatewayStreamControl {
+	/** Gateway request signal. Encoders stop producing frames when it aborts. */
+	signal?: AbortSignal;
+	/** Called when the HTTP response body is cancelled by the client. */
+	onCancel?: (reason?: unknown) => void;
+}
+
 export interface AuthGatewayFormatModule {
 	parseRequest(body: unknown, headers?: Headers): AuthGatewayParsedRequest;
 	encodeResponse(message: AssistantMessage, requestedModelId: string): Record<string, unknown>;
@@ -117,6 +124,7 @@ export interface AuthGatewayFormatModule {
 		events: AssistantMessageEventStream,
 		requestedModelId: string,
 		options?: AuthGatewayParsedRequestOptions,
+		control?: AuthGatewayStreamControl,
 	): ReadableStream<Uint8Array>;
 	/**
 	 * Emit a protocol-specific error envelope. OpenAI returns