@linxiraos/pi-ai 1.1.26 → 1.2.0

package/dist/types/auth-broker/client.d.ts

@@ -1,8 +1,8 @@
 /**
- * HTTP client for the omp auth-broker server.
+ * HTTP client for the zetacode auth-broker server.
  *
  * Used by {@link RemoteAuthCredentialStore} (snapshot pulls) and by
- * `omp auth-broker status` (liveness checks). All endpoints except
+ * `zetacode auth-broker status` (liveness checks). All endpoints except
  * `/v1/healthz` require a bearer token.
  */
 import type { AuthCredential, DisabledCredentialSummary, OAuthRefreshReason } from "../auth-storage.js";
@@ -85,7 +85,7 @@ export declare class AuthBrokerClient {
     fetchClientUsageSummary(query?: {
         sinceMs?: number;
     }, signal?: AbortSignal): Promise<ClientUsageSummaryResponse>;
-    notifyUsageStale(signal?: AbortSignal): Promise<UsageStaleResponse>;
+    notifyUsageStale(provider?: string, signal?: AbortSignal): Promise<UsageStaleResponse>;
     refreshCredential(id: number, signal?: AbortSignal, reason?: OAuthRefreshReason): Promise<CredentialRefreshResponse>;
     disableCredential(id: number, cause: string, signal?: AbortSignal): Promise<CredentialDisableResponse>;
     /**

package/dist/types/auth-broker/discover.d.ts

@@ -18,7 +18,7 @@ export interface DiscoverAuthStorageOptions {
     accountPolicies?: AuthAccountPolicies;
     authStorageOptions?: Omit<AuthStorageOptions, "accountPolicies" | "configValueResolver" | "sourceLabel">;
 }
-/** Path to the local bearer token file. Created by `omp auth-broker token`. */
+/** Path to the local bearer token file. Created by `zetacode auth-broker token`. */
 export declare function getAuthBrokerTokenFilePath(): string;
 export interface AuthAccountPolicyConfig {
     accountPolicies: AuthAccountPolicies;

package/dist/types/auth-broker/refresher.d.ts

@@ -20,6 +20,11 @@ export declare class AuthBrokerRefresher {
     start(): void;
     stop(): void;
     getSchedule(): AuthBrokerRefresherSchedule;
-    /** Run one sweep. Exposed for tests. */
+    /**
+     * Run one sweep. Exposed for tests.
+     *
+     * Never rejects: callers fire it unawaited from a timer, so a failed sweep
+     * (e.g. an unreadable credential store) is logged and retried next interval.
+     */
     tick(): Promise<void>;
 }

package/dist/types/auth-broker/remote-store.d.ts

@@ -73,6 +73,7 @@ export declare class RemoteAuthCredentialStore implements AuthCredentialStore {
     /** Broker-backed disabled tombstones; empty against brokers predating the endpoint. */
     listDisabledCredentials(provider?: string, signal?: AbortSignal): Promise<DisabledCredentialSummary[]>;
     getCredentialBlock(credentialId: number, providerKey: string, blockScope: string): number | undefined;
+    getCredentialBlockScopes(credentialId: number, providerKey: string): Map<string, number>;
     getCredentialBlockReconcileAfter(credentialId: number, providerKey: string, blockScope: string): number | undefined;
     listCredentialBlocks(credentialIds: readonly number[]): StoredCredentialBlock[];
     upsertCredentialBlock(block: StoredCredentialBlock): void;
@@ -121,7 +122,7 @@ export declare class RemoteAuthCredentialStore implements AuthCredentialStore {
     /** Drop all cache rows whose keys start with the supplied prefix. */
     deleteCachePrefix(prefix: string): void;
     cleanExpiredCache(): void;
-    invalidateUsageCache(signal?: AbortSignal): Promise<void>;
+    invalidateUsageCache(provider?: string, signal?: AbortSignal): Promise<void>;
     /**
      * Store-level hook consumed by `AuthStorage` — routes refresh through the
      * broker so the actual refresh token never leaves the broker host. Returns
@@ -148,9 +149,10 @@ export declare class RemoteAuthCredentialStore implements AuthCredentialStore {
     ingestUsageReport(provider: Provider, credential: OAuthCredential, report: UsageReport): boolean;
     /**
      * Fold locally observed request usage into the pending report and schedule
-     * a flush. One `POST /v1/usage/observed` at most per flush interval; on
-     * failure the batch is retained and retried with the next flush. A 404
-     * (pre-endpoint broker) disables reporting for the life of this store.
+     * a flush. One `POST /v1/usage/observed` at most per flush interval, plus a
+     * final one when the process exits; on failure the batch is retained and
+     * retried with the next flush. A 404 (pre-endpoint broker) disables
+     * reporting for the life of this store.
      *
      * `client` overrides the reporting identity — the auth-gateway attributes
      * each request to the originating install/app instead of the gateway host.

package/dist/types/auth-broker/server.d.ts

@@ -17,6 +17,8 @@ export interface AuthBrokerServerOptions {
     bind?: string;
     /** Accept any of these bearer tokens. Empty disables auth (loopback only). */
     bearerTokens: string[];
+    /** Honor forwarded peer headers only when the connecting proxy is trusted. Default false. */
+    trustProxyHeaders?: boolean;
     /** Broker version string surfaced on `/v1/healthz`. */
     version?: string;
     /** Refresh credentials expiring within this window. Default 5 min. */

package/dist/types/auth-broker/snapshot-cache.d.ts

@@ -15,3 +15,15 @@ export interface WriteAuthBrokerSnapshotCacheOptions {
 }
 export declare function readAuthBrokerSnapshotCache(opts: ReadAuthBrokerSnapshotCacheOptions): Promise<SnapshotResponse | null>;
 export declare function writeAuthBrokerSnapshotCache(opts: WriteAuthBrokerSnapshotCacheOptions): Promise<void>;
+/**
+ * Fire-and-forget cache write for snapshot callbacks. The first snapshot after
+ * a quiet period is written immediately; later ones within
+ * {@link WRITE_COALESCE_MS} collapse into a single trailing write of the
+ * newest. A snapshot whose generation and credential content match the last
+ * write is skipped (see {@link UNCHANGED_REWRITE_MS}). Pending writes are
+ * flushed on process shutdown and by {@link flushAuthBrokerSnapshotCacheWrites};
+ * failures are logged, never thrown.
+ */
+export declare function scheduleAuthBrokerSnapshotCacheWrite(opts: WriteAuthBrokerSnapshotCacheOptions): void;
+/** Write every pending scheduled snapshot now and wait for in-flight writes to settle. */
+export declare function flushAuthBrokerSnapshotCacheWrites(): Promise<void>;

package/dist/types/auth-gateway/dispatch.d.ts

@@ -5,8 +5,9 @@ import type { Api, FetchImpl, Model, Usage } from "../types.js";
 import type { ClientUsageIdentity } from "../usage.js";
 import type { AuthGatewayServerOptions } from "./types.js";
 export type ModelResolver = (modelId: string) => Model<Api> | undefined;
-export interface AuthGatewayBootOptions extends AuthGatewayServerOptions {
-    /** Source of credentials. Caller wires this to a broker-backed AuthStorage. */
+/** What the gateway's routes need, whatever transport carries the requests. */
+export interface AuthGatewayRouteOptions {
+    /** Source of credentials: broker-backed for `serve`, the CLI's own for `stdio`. */
     storage: AuthStorage;
     /**
      * Resolve a client-requested model id to a pi-ai Model. Caller supplies
@@ -16,9 +17,14 @@ export interface AuthGatewayBootOptions extends AuthGatewayServerOptions {
     resolveModel: ModelResolver;
     /** Optional supplier for `/v1/models` listing. Returns the full model array. */
     listModels?: () => Iterable<Model<Api>>;
+    /** Providers the host does not serve; `/v1/usage` and `/v1/credentials/check` leave their accounts out. */
+    excludeProviders?: ReadonlySet<string>;
     /** Upstream transport for every provider call; defaults to global `fetch`. Test seam. */
     fetch?: FetchImpl;
 }
+/** The HTTP server's options: the routes' plus its listener and inbound auth. */
+export interface AuthGatewayBootOptions extends AuthGatewayServerOptions, AuthGatewayRouteOptions {
+}
 /**
  * The client's own session key, or `undefined` when it sent none. A blank key
  * counts as none: honouring it would collapse every caller that sends an empty
@@ -59,9 +65,11 @@ export declare function resolveGatewayApiKey(storage: AuthStorage, model: Model<
  *   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. `onResolvedKey` observes every rotation;
- * routes that retain provider session state use it to re-key the account
- * lease, one-shot routes pass `undefined`.
+ * credential that actually failed; a retry context's `previousKey` wins, since
+ * concurrent operations sharing one resolver (split judgment chunks) each know
+ * the bearer they sent. `onResolvedKey` observes every rotation; routes that
+ * retain provider session state use it to re-key the account lease, one-shot
+ * routes pass `undefined`.
  */
 export declare function buildGatewayApiKeyResolver(storage: AuthStorage, model: Model<Api>, sessionId: string, initialKey: ResolvedApiKey, requestSignal: AbortSignal, format: string, peer: string, onResolvedKey?: (apiKey: string) => void): ApiKeyResolver;
 /**

package/dist/types/auth-gateway/http.d.ts

@@ -16,8 +16,6 @@ export declare function gatewayResponseHeaders(model: Model<Api>, info: {
     costUsd?: number;
     startedAt?: number;
 }): Record<string, string>;
-/** Use the socket peer unless the gateway explicitly trusts its reverse proxy. */
-export declare function resolvePeer(req: Request, socketAddress: string, trustProxyHeaders?: boolean): string;
 /** Keep configured gateway credentials out of URL and forwarded/logged request fields. */
 export declare function hasMisplacedBearer(req: Request, url: URL, tokens: ReadonlySet<string>): boolean;
 /**

package/dist/types/auth-gateway/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./dispatch.js";
 export * from "./http.js";
 export * from "./session-state.js";
+export * from "./stdio.js";
 export * from "./server.js";
 export * from "./types.js";

package/dist/types/auth-gateway/routes/embeddings.d.ts

@@ -1,3 +1,3 @@
-import { type AuthGatewayBootOptions } from "../dispatch.js";
+import { type AuthGatewayRouteOptions } from "../dispatch.js";
 /** OpenAI-compatible `POST /v1/embeddings` gateway handler. */
-export declare function handleEmbeddings(bootOpts: AuthGatewayBootOptions, req: Request, peer: string): Promise<Response>;
+export declare function handleEmbeddings(bootOpts: AuthGatewayRouteOptions, req: Request, peer: string): Promise<Response>;

package/dist/types/auth-gateway/routes/images.d.ts

@@ -1,3 +1,3 @@
-import { type AuthGatewayBootOptions } from "../dispatch.js";
-export declare function handleImageGenerations(bootOpts: AuthGatewayBootOptions, req: Request, peer: string): Promise<Response>;
-export declare function handleImageEdits(bootOpts: AuthGatewayBootOptions, req: Request, peer: string): Promise<Response>;
+import { type AuthGatewayRouteOptions } from "../dispatch.js";
+export declare function handleImageGenerations(bootOpts: AuthGatewayRouteOptions, req: Request, peer: string): Promise<Response>;
+export declare function handleImageEdits(bootOpts: AuthGatewayRouteOptions, req: Request, peer: string): Promise<Response>;

package/dist/types/auth-gateway/routes/rerank.d.ts

@@ -1,3 +1,3 @@
-import { type AuthGatewayBootOptions } from "../dispatch.js";
+import { type AuthGatewayRouteOptions } from "../dispatch.js";
 /** OpenRouter-compatible `POST /v1/rerank` gateway handler. */
-export declare function handleRerank(bootOpts: AuthGatewayBootOptions, req: Request, peer: string): Promise<Response>;
+export declare function handleRerank(bootOpts: AuthGatewayRouteOptions, req: Request, peer: string): Promise<Response>;

package/dist/types/auth-gateway/routes/speech.d.ts

@@ -1,2 +1,2 @@
-import { type AuthGatewayBootOptions } from "../dispatch.js";
-export declare function handleSpeech(bootOpts: AuthGatewayBootOptions, req: Request, peer: string): Promise<Response>;
+import { type AuthGatewayRouteOptions } from "../dispatch.js";
+export declare function handleSpeech(bootOpts: AuthGatewayRouteOptions, req: Request, peer: string): Promise<Response>;

package/dist/types/auth-gateway/routes/systemone.d.ts

@@ -1,2 +1,2 @@
-import { type AuthGatewayBootOptions } from "../dispatch.js";
-export declare function handleSystemOne(bootOpts: AuthGatewayBootOptions, req: Request, peer: string): Promise<Response>;
+import { type AuthGatewayRouteOptions } from "../dispatch.js";
+export declare function handleSystemOne(bootOpts: AuthGatewayRouteOptions, req: Request, peer: string): Promise<Response>;

package/dist/types/auth-gateway/routes/transcriptions.d.ts

@@ -1,3 +1,3 @@
-import { type AuthGatewayBootOptions } from "../dispatch.js";
+import { type AuthGatewayRouteOptions } from "../dispatch.js";
 /** OpenAI-compatible `POST /v1/audio/transcriptions` gateway handler. */
-export declare function handleTranscriptions(bootOpts: AuthGatewayBootOptions, req: Request, peer: string): Promise<Response>;
+export declare function handleTranscriptions(bootOpts: AuthGatewayRouteOptions, req: Request, peer: string): Promise<Response>;

package/dist/types/auth-gateway/routes/video.d.ts

@@ -1,7 +1,7 @@
-import { type AuthGatewayBootOptions } from "../dispatch.js";
+import { type AuthGatewayRouteOptions } from "../dispatch.js";
 /** OpenRouter-compatible `POST /v1/videos` asynchronous video submit handler. */
-export declare function handleVideoSubmit(bootOpts: AuthGatewayBootOptions, req: Request, peer: string): Promise<Response>;
+export declare function handleVideoSubmit(bootOpts: AuthGatewayRouteOptions, req: Request, peer: string): Promise<Response>;
 /** OpenRouter-compatible `GET /v1/videos/:id` asynchronous video poll handler. */
-export declare function handleVideoPoll(bootOpts: AuthGatewayBootOptions, req: Request, peer: string, gatewayId: string): Promise<Response>;
+export declare function handleVideoPoll(bootOpts: AuthGatewayRouteOptions, req: Request, peer: string, gatewayId: string): Promise<Response>;
 /** OpenRouter-compatible `GET /v1/videos/:id/content` streaming video content handler. */
-export declare function handleVideoContent(bootOpts: AuthGatewayBootOptions, req: Request, peer: string, gatewayId: string): Promise<Response>;
+export declare function handleVideoContent(bootOpts: AuthGatewayRouteOptions, req: Request, peer: string, gatewayId: string): Promise<Response>;

package/dist/types/auth-gateway/server.d.ts

@@ -1,12 +1,12 @@
 /**
- * zeta-c auth-gateway HTTP server.
+ * zetacode auth-gateway router and HTTP server.
  *
  * Accepts any provider-format request (OpenAI chat-completions, Anthropic
  * messages, OpenAI Responses) and dispatches through pi-ai's `streamSimple()`
  * — which handles credential injection, anthropic-beta headers, codex
  * websocket transport, and all the per-provider intricacies. The gateway is
- * pure protocol translation: foreign wire → zeta Context → pi-ai stream() →
- * zeta events → foreign wire.
+ * pure protocol translation: foreign wire → omp Context → pi-ai stream() →
+ * omp events → foreign wire.
  *
  * Endpoints:
  *   GET  /healthz                          → unauth; ok + version
@@ -23,8 +23,25 @@
  *   POST /v1/audio/transcriptions          → speech-to-text, multipart or JSON base64 in (routes/transcriptions)
  *
  * Chat routes live in this file; every other modality is a `routes/*` module
- * built on the shared plumbing in `dispatch.ts`.
+ * built on the shared plumbing in `dispatch.ts`. {@link createAuthGatewayRouter}
+ * answers the `/v1/*` routes for any transport: {@link startAuthGateway}
+ * serves them over HTTP behind bearer auth, `stdio.ts` over JSON lines.
  */
-import { type AuthGatewayBootOptions } from "./dispatch.js";
+import { type AuthGatewayBootOptions, type AuthGatewayRouteOptions } from "./dispatch.js";
 import type { AuthGatewayServerHandle } from "./types.js";
+/** The gateway's `/v1/*` routes, for a transport that has already admitted the caller. */
+export interface AuthGatewayRouter {
+    /** Answers one request; `peer` names the caller in logs. Never rejects: a crashed route answers 500. */
+    route(req: Request, peer: string): Promise<Response>;
+    /**
+     * Closes the retained provider session state (Codex WebSockets, GitLab Duo
+     * workflows), whose sockets and timers would otherwise keep the process alive.
+     */
+    close(): void;
+}
+/**
+ * The gateway's routes over `opts`, owning their per-session provider state:
+ * two routers in one process never share (or tear down) each other's.
+ */
+export declare function createAuthGatewayRouter(opts: AuthGatewayRouteOptions): AuthGatewayRouter;
 export declare function startAuthGateway(opts: AuthGatewayBootOptions): AuthGatewayServerHandle;

package/dist/types/auth-gateway/session-state.d.ts

@@ -63,6 +63,12 @@ export interface AuthGatewaySessionStateRequest {
      * continues.
      */
     context: Context;
+    /**
+     * `JSON.stringify(context.tools)` when the caller already serialized it
+     * (the gateway derives its `sessionId` from the same string). Recomputed
+     * from `context` when absent.
+     */
+    toolsJson?: string;
     /**
      * Stable identity of the account this request's credential resolved to.
      * A change means the gateway switched the session to a sibling credential,

package/dist/types/auth-gateway/stdio.d.ts

@@ -0,0 +1,12 @@
+export interface AuthGatewayStdioOptions {
+    /** Request lines. */
+    input: ReadableStream<Uint8Array>;
+    /** Writes one response line, newline included. */
+    write(line: string): void;
+    /** Answers one request; never rejects (the gateway router's `route`, or a wrapper around it). */
+    route(req: Request): Promise<Response>;
+    /** Reported on the ready line. */
+    version?: string;
+}
+/** Serves `opts.input` until it ends and every request it carried is answered. */
+export declare function serveAuthGatewayStdio(opts: AuthGatewayStdioOptions): Promise<void>;

package/dist/types/auth-storage.d.ts

@@ -1,6 +1,6 @@
 import type { AuthCredentialStore } from "./auth/store.js";
 import type { AuthAccountPolicies, AuthApiKeyOptions, AuthStorageOptions, BlocksApi, CredentialsApi, HealthApi, KeysApi, LimitsApi, OAuthApi, ResetsApi, SessionsApi, UsageApi } from "./auth/types.js";
-export { isSqliteBusyError, isSqliteCorruptionError, SqliteAuthCredentialStore } from "./auth/sqlite-credential-store.js";
+export { isSameOAuthAccount, isSqliteBusyError, isSqliteCorruptionError, matchesReplacementCredential, resolveCredentialIdentityKey, SqliteAuthCredentialStore, } from "./auth/sqlite-credential-store.js";
 export * from "./auth/store.js";
 export * from "./auth/types.js";
 /**
@@ -35,8 +35,9 @@ export declare class AuthStorage {
     /**
      * Apply new account routing policy (live `auth.accountPolicies` /
      * `retry.usageReservePct` change). Throws a configuration error, leaving the
-     * active policy untouched, when the policy is malformed or does not match the
-     * stored OAuth accounts.
+     * active policy untouched, when a policy is malformed, a selector matches
+     * several stored OAuth accounts, or two policies claim the same account; a
+     * policy naming an absent account stays inactive and logs a warning.
      */
     setAccountPolicies(config: {
         accountPolicies: AuthAccountPolicies;
@@ -46,9 +47,9 @@ export declare class AuthStorage {
      * Swap the backing credential store in place (live `auth.broker.url` change).
      * Loads `store` into fresh store-bound state — pins, blocks, and usage caches are
      * keyed by the old store's row ids — then closes the previous store. Runtime key
-     * overrides, account policies, usage-provider overrides, and credential event
-     * subscribers carry over. On a load failure `store` is closed and the current
-     * store stays active.
+     * overrides, account policies, session account restrictions, usage-provider
+     * overrides, and credential event subscribers carry over. On a load failure
+     * `store` is closed and the current store stays active.
      */
     replaceStore(store: AuthCredentialStore, options?: {
         sourceLabel?: string;

package/dist/types/dialect/terminator-wait.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Fast path for in-band scanners that sit inside a body waiting for one fixed
+ * terminator (a tool-call close tag) and emit nothing until it arrives.
+ *
+ * Appending each delta to the scanner's string buffer and calling `indexOf` on
+ * it flattens the growing rope on every delta, so a long in-band tool call cost
+ * O(n²) copying and scanning. While armed, deltas are set aside and only the new
+ * text plus the terminator-length overlap with what came before is searched;
+ * the buffer is rebuilt once, when the terminator shows up or the stream ends.
+ */
+export declare class TerminatorWait {
+    #private;
+    /** Start deferring; `buffered` is the scanner's pending body, known not to contain `terminator`. */
+    arm(terminator: string, buffered: string): void;
+    /** Take `text` while the terminator is still absent; false means the caller must {@link release} and scan. */
+    absorb(text: string): boolean;
+    /** Stop deferring and return `buffered` with every absorbed delta appended. */
+    release(buffered: string): string;
+}

package/dist/types/env-api-key.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Get API key for provider from known environment variables, e.g. OPENAI_API_KEY.
+ *
+ * Will not return API keys for providers that require OAuth tokens.
+ * Checks Bun.env, then cwd/.env, then ~/.env.
+ */
+export declare function getEnvApiKey(provider: string): string | undefined;
+/**
+ * Name of the environment variable that backs `getEnvApiKey` for a provider,
+ * when that provider maps to a single named variable (e.g. `github-copilot` →
+ * `COPILOT_GITHUB_TOKEN`). Returns undefined for providers whose env fallback
+ * is computed (multi-var pickers, Vertex ADC / Bedrock probes, …) since no
+ * single variable name describes the source.
+ */
+export declare function getEnvApiKeyName(provider: string): string | undefined;
+/**
+ * Enumerate every provider that has an env-var fallback for `getEnvApiKey`.
+ * Used by `zetacode auth-broker migrate --include-env` to discover env-sourced keys
+ * that should be uploaded to the broker.
+ */
+export declare function listProvidersWithEnvKey(): string[];

package/dist/types/error/auth.d.ts

@@ -10,6 +10,16 @@ export declare class MissingApiKeyError extends Error {
     readonly provider: string | undefined;
     constructor(provider?: string, message?: string);
 }
+/**
+ * Every usable OAuth credential for a provider failed to refresh with a
+ * retryable error (network blip, timeout, 5xx). The stored credentials are
+ * intact, so this is classified transient: retrying the request can succeed,
+ * unlike {@link MissingApiKeyError}. The refresh failure is kept as `cause`.
+ */
+export declare class OAuthRefreshUnavailableError extends Error {
+    readonly provider: string;
+    constructor(provider: string, cause: unknown);
+}
 /** A user-facing login flow required an `onPrompt` callback that was not supplied. */
 export declare class OnPromptRequiredError extends Error {
     constructor(providerLabel: string);

package/dist/types/error/flags.d.ts

@@ -23,6 +23,16 @@ export declare const Flag: {
     readonly FastModeUnsupported: 536870912;
     /** OAuth refresh failed definitively — the stored grant is dead, re-login required. */
     readonly OAuthExpiry: 1073741824;
+    /**
+     * An Anthropic-compatible endpoint rejected the `cache_control` field with a
+     * 400, so prompt-cache breakpoints must be dropped for it.
+     *
+     * Every bit from {@link Flag.Class} up is already taken, so this claims a low
+     * bit instead. Those belong to the raw-status lane — an unclassified id is an
+     * HTTP status (100-599, see `statusFromId`) — and 0x800 is 2048, above every
+     * status value, so no raw status id can set it.
+     */
+    readonly CacheControlUnsupported: 2048;
     /** HTTP 413 byte/media rejection — token compaction cannot shrink bytes or media budgets (#9235). */
     readonly PayloadRejected: 2147483648;
 };
@@ -43,6 +53,21 @@ export declare function isResponsesRequestBodyReadTimeout(message: {
     errorMessage?: string;
     requestBodyReadTimeoutFullReplay?: boolean;
 }): boolean;
+/**
+ * Codex code for the experimental native turn lane refusing a mid-response
+ * `response.steer`; the server then drops the in-flight response and closes
+ * the socket.
+ */
+export declare const CODEX_NATIVE_LANE_STEER_REJECTED_CODE = "unsupported_native_inflight_message";
+/**
+ * A Codex turn the native turn lane dropped because omp steered it. The
+ * rejection answers our own `response.steer`, not the model's health: the
+ * provider stops steering the session, so the same model replays cleanly.
+ */
+export declare function isCodexSteerRejection(message: {
+    api?: Api;
+    errorMessage?: string;
+}): boolean;
 export declare const TRANSIENT_TRANSPORT_PATTERN: RegExp;
 export declare const ANTHROPIC_ACCOUNT_POLICY_PATTERN: RegExp;
 /** Whether an error message represents an Anthropic account-scoped permission/policy denial. */
@@ -98,6 +123,19 @@ export declare function isGrammarError(error: unknown): boolean;
  * Accessor for {@link Flag.FastModeUnsupported}.
  */
 export declare function isFastModeUnsupported(error: unknown): boolean;
+/**
+ * An Anthropic-compatible endpoint returned a 400 rejecting something about
+ * `cache_control`. Whether it refused the field or one nested option is not
+ * decidable here (see {@link CACHE_CONTROL_FIELD_PATTERN}); the caller's retry
+ * ladder settles it by replaying.
+ * Accessor for {@link Flag.CacheControlUnsupported}.
+ *
+ * Unlike the high-bit accessors this also requires a classified id. The flag
+ * sits in the raw-status lane (see {@link Flag.CacheControlUnsupported}), and
+ * while no HTTP status reaches 0x800, `is` is a bare bit test — the extra gate
+ * keeps a stray non-HTTP status out of the retry path.
+ */
+export declare function isCacheControlUnsupported(error: unknown): boolean;
 /**
  * Cline's gateway gates some roster entries (certain free-tier models) to its
  * own product surfaces with a 403. The API key is valid — the restriction is

package/dist/types/images/index.d.ts

@@ -1,4 +1,4 @@
-import type { Api, Model } from "@linxiraos/pi-catalog/types";
+import { type Api, type ImageGenerationApi, type Model } from "@linxiraos/pi-catalog/types";
 import type { ImageGenerationOptions, ImageGenerationRequest, ImageGenerationResult } from "./types.js";
 export * from "./google-antigravity.js";
 export * from "./google-generative-ai.js";
@@ -6,8 +6,7 @@ export * from "./openai-hosted.js";
 export * from "./openai-images.js";
 export * from "./openrouter-images.js";
 export * from "./types.js";
-/** Catalog APIs {@link generateImage} serves; the hosted Responses pair needs an explicit carrier model. */
-export type ImageGenerationApi = "openai-images" | "openrouter-images" | "google-generative-ai" | "google-gemini-cli" | "openai-responses" | "openai-codex-responses";
+export type { ImageGenerationApi } from "@linxiraos/pi-catalog/types";
 /** Whether a catalog API generates images through one of the pi-ai image clients. */
 export declare function isImageGenerationApi(api: Api): api is ImageGenerationApi;
 /** Generate (or edit, when `request.inputImages` is set) images through the transport selected by the model's `api`. */

package/dist/types/images/shared.d.ts

@@ -32,6 +32,12 @@ export declare function decodeImageResponse(value: unknown, fetch: FetchImpl, si
     images: GeneratedImage[];
     usage: Usage;
 }>;
+/**
+ * Mime type of a base64 image, read from its header only. 64 base64 chars
+ * decode to 48 bytes, past every magic number `parseImageMetadata` checks, so
+ * multi-MB payloads are never fully decoded just to be labelled.
+ */
+export declare function sniffBase64ImageMimeType(base64: string): string | undefined;
 export declare function toDataUrl(image: GeneratedImage): string;
 export declare function resolveOpenAIImageSize(aspectRatio?: string, imageSize?: string): string | undefined;
 export {};

package/dist/types/index.d.ts

@@ -1,7 +1,7 @@
 export { type Type, type } from "@linxiraos/pi-omptype";
 export * from "./api-registry.js";
 export type * from "./auth-broker/index.js";
-export type { AuthGatewayBootOptions, ModelResolver } from "./auth-gateway/dispatch.js";
+export type { AuthGatewayBootOptions, AuthGatewayRouteOptions, ModelResolver } from "./auth-gateway/dispatch.js";
 export * from "./auth-gateway/types.js";
 export * from "./auth-retry.js";
 export * from "./auth-storage.js";
@@ -39,6 +39,7 @@ export type * from "./providers/openai-responses.js";
 export type * from "./providers/synthetic.js";
 export * from "./registry/index.js";
 export { resolveCacheRetention } from "./utils.js";
+export * from "./env-api-key.js";
 export * from "./stream.js";
 export * from "./types.js";
 export * from "./usage.js";

package/dist/types/judgment/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./chat.js";
+export * from "./native.js";
+export * from "./question-file.js";
 export * from "./text.js";
 export * from "./types.js";
-export * from "./typesafe.js";

package/dist/types/judgment/native.d.ts

@@ -0,0 +1,80 @@
+import type { Api, FetchImpl } from "@linxiraos/pi-catalog/types";
+import { type ApiKey } from "../auth-retry.js";
+import * as AIError from "../error/index.js";
+import type { Model, Usage } from "../types.js";
+import { type Judge, type JudgeOptions, type JudgmentRequest, type JudgmentResult, type Questions } from "./types.js";
+import type { JudgmentWire } from "./wire.js";
+export declare const TYPESAFE_PROVIDER = "typesafe";
+export declare const TYPESAFE_DEFAULT_MODEL = "jev-latest";
+declare const JUDGMENT_WIRES: {
+    readonly typesafe: JudgmentWire;
+    readonly "openrouter-decisions": JudgmentWire;
+    readonly "workers-ai-systemone": JudgmentWire;
+    readonly "openai-decisions": JudgmentWire;
+};
+/** APIs {@link NativeJudge} can serve. */
+export type JudgmentApi = keyof typeof JUDGMENT_WIRES;
+/** Whether a catalog API answers judgments natively. */
+export declare function isJudgmentApi(api: Api): api is JudgmentApi;
+/** `TYPESAFE_BASE_URL` when set, else the public API root; trailing slashes stripped. */
+export declare function typesafeBaseUrl(): string;
+/** `TYPESAFE_DEFAULT_MODEL` when set, else {@link TYPESAFE_DEFAULT_MODEL}. */
+export declare function typesafeModel(): string;
+/** Credential and transport overrides for a judge; see {@link createNativeJudge}. */
+export interface NativeJudgeConnection {
+    apiKey: ApiKey;
+    /** Static headers attached to judgment requests (e.g. proxy routing, gateway auth). */
+    headers?: Record<string, string>;
+    fetch?: FetchImpl;
+}
+export interface NativeJudgeOptions extends NativeJudgeConnection {
+    /** Wire dialect; defaults to TypeSafe's own API. */
+    api?: JudgmentApi;
+    /** Catalog provider reported on results; defaults to {@link TYPESAFE_PROVIDER}. */
+    provider?: string;
+    /** Defaults to {@link typesafeBaseUrl}. */
+    baseUrl?: string;
+    /** Wire model id; defaults to {@link typesafeModel}. */
+    model?: string;
+    /** Per-attempt timeout; defaults to {@link DEFAULT_TIMEOUT_MS}. */
+    timeoutMs?: number;
+    /**
+     * Most questions per request the endpoint accepts, a positive integer; larger
+     * requests are split. Unset: no cap.
+     */
+    maxQuestions?: number;
+}
+/** Per-call options for {@link NativeJudge.judge}. */
+export interface NativeJudgeCallOptions extends JudgeOptions {
+    /**
+     * Called before a split judgment rejects, with the summed usage of the chunks that had already
+     * succeeded: billed upstream, but their answers are discarded with the failure. Not called when
+     * no chunk succeeded or the request was not split.
+     */
+    onPartialUsage?: (usage: Usage) => void;
+}
+/** Non-2xx response from a native judgment API. */
+export declare class JudgmentApiError extends AIError.ProviderHttpError {
+    readonly name = "JudgmentApiError";
+}
+export declare class NativeJudge implements Judge {
+    #private;
+    readonly label: string;
+    readonly api: JudgmentApi;
+    readonly provider: string;
+    /** Wire model id sent with every request. */
+    readonly model: string;
+    readonly baseUrl: string;
+    constructor(options: NativeJudgeOptions);
+    judge<Q extends Questions>(request: JudgmentRequest<Q>, options?: NativeJudgeCallOptions): Promise<JudgmentResult<Q>>;
+}
+/**
+ * The {@link NativeJudge} for a catalog judge model: its API's dialect, wire id
+ * (`requestModelId ?? id`), base URL, and catalog question cap
+ * (`judgment-questions-max`). Shared by the coding agent's judge chain and the
+ * auth-gateway System One route so both address a model the same way.
+ *
+ * @throws ConfigurationError when the model's API is not a judgment API.
+ */
+export declare function createNativeJudge(model: Model, connection: NativeJudgeConnection): NativeJudge;
+export {};

package/dist/types/judgment/openai-decisions.d.ts

@@ -0,0 +1,3 @@
+import { type JudgmentWire } from "./wire.js";
+/** OpenAI's `/v1/decisions` route. */
+export declare const openaiDecisionsWire: JudgmentWire;