@urun-sh/openai 0.5.5 → 0.6.0

package/dist/responses-turn-OrO4euEN.d.cts

@@ -1,513 +0,0 @@
-import { C as CatalogRow } from './models-NYMZrklp.cjs';
-import { IncomingMessage } from 'node:http';
-import { a as AudioBridge, h as VideoFrameLane, j as VideoOutLane } from './video-out-D20UuJ8G.cjs';
-
-/**
- * WHAT a proxy serves — the `identity` block on `GET /stats`. Reuse of a
- * running proxy is allowed iff every field matches the launching invocation
- * EXACTLY: a partial match (same app, different fn; same everything, older
- * proxy_version) silently routes the agent at the wrong backend, which is
- * worse than any error.
- */
-interface ProxyIdentity {
-    app: string;
-    org: string;
-    fn: string;
-    /**
-     * The control-plane URL the proxy's backhaul session opens against
-     * (URUN_BASE_URL verbatim — same org/app/fn on staging vs prod are
-     * DIFFERENT backends; review finding, #285). Compared exactly: a cosmetic
-     * difference (trailing slash) merely refuses reuse and spawns an ephemeral
-     * proxy — the safe direction.
-     */
-    base_url: string;
-    proxy_version: string;
-}
-
-/**
- * THE OPENROUTER PROVIDER DOCUMENT — `GET /v1/models?format=openrouter`.
- *
- * OpenRouter's provider monitor polls this document (schema 2.4, per
- * openrouter.ai/docs/guides/community/for-providers) to list a provider's
- * models on the marketplace. The `id` field is the EXACT model identifier
- * OpenRouter sends back as `model` on chat completions — which here is the
- * app slug, the same id the OpenAI surface lists. One id space, two views.
- *
- * MODALITY GATING: only rows whose catalog `task` names a chat-completions
- * shape (chat | code | agent | vl) are declared. A voice/video/image app
- * behind a chat surface would stream garbage into OpenRouter's baseline
- * tests; models the catalog cannot vouch for are OMITTED, never guessed.
- * With no catalog oracle configured the document is `{"data": []}` — honest
- * emptiness, not invented capability (the chart turns the oracle on).
- *
- * PRICING is deliberately omitted entirely: the schema's rule is "a modality
- * with no pricing array is simply unpriced", OpenRouter configures pricing
- * during provider onboarding, and the per-model price surface is
- * urun-infra U3 (model_prices) — when that lands, this module grows a
- * `prices` input and emits the input/output pricing arrays.
- *
- * The full closed-value-domain schema ships as OpenAPI 3.1 at
- * openrouter.ai/docs/assets/provider-monitor-schema-v2.openapi.json.
- */
-
-type OpenRouterProviderDoc = {
-    data: OpenRouterProviderModel[];
-};
-interface OpenRouterProviderModel {
-    schema_version: '2.4';
-    /** The EXACT id OpenRouter sends back as `model` — the app slug. */
-    id: string;
-    name: string;
-    created: number;
-    /** Valid enum: int4|int8|fp4|mxfp4|nvfp4|fp6|fp8|mxfp8|fp16|bf16|fp32|null. */
-    quantization: string | null;
-    description: string;
-    hugging_face_id: string;
-    input_modalities: Array<Record<string, unknown>>;
-    output_modalities: Array<Record<string, unknown>>;
-}
-
-/**
- * Per-model → per-app routing for the compat proxy (owner directive
- * 2026-08-07): swapping the model in a coding harness routes the request to
- * the org's DEPLOYED app for that model. v1 is deployed-only — a uRun model
- * that is not deployed gets a loud 404 naming `urun serve <id>`; a later
- * phase (explicitly out of scope here; urun-infra#1490 shared-endpoints)
- * auto-creates from the model catalog on first request.
- *
- * MODEL-ID SURFACE (the documented mapping): a model may be named by
- *   - the app slug itself        ("qwen3-6-27b-bf16"), or
- *   - the catalog id             ("qwen3.6-27b"), or
- *   - the catalog id:variant     ("qwen3.6-27b:bf16"),
- * where slugification mirrors urun-cli `serve.py _default_app_name` exactly:
- * lowercase, every non-alphanumeric-non-dash character becomes "-", leading/
- * trailing dashes stripped (catalog id "qwen3.6-27b" + variant "bf16" → app
- * "qwen3-6-27b-bf16"). COLLISION RULE: an exact slug match always wins over
- * the catalog-id (prefix) interpretation.
- *
- * RESOLUTION ORDER (one canonical path, documented end to end):
- *   1. model absent / "urun" / an alias of the startup app  → DEFAULT app.
- *   2. exact slug match on a deployed serve app             → that app.
- *   3. catalog-id form matching exactly one deployed app    → that app
- *      (two or more candidates → loud ambiguity error naming them).
- *   4. the name maps to an org app that is NOT an active app exposing the
- *      proxy's serve function                               → loud 404
- *      naming `urun serve <model>` and the available models.
- *   5. the name matches a catalog row but no deployed app   → loud 404
- *      naming `urun serve <id>` (deployed-only v1).
- *   6. anything else — a model name outside the uRun namespace entirely
- *      (e.g. the harness's own upstream default, "claude-*"/"gpt-*") →
- *      DEFAULT app. This IS today's single-app contract, kept deliberately
- *      so `urun compat <agent>` with the agent's stock model keeps working
- *      with zero new env; the per-model /stats table records every such
- *      mapping so it is visible, never silent. Models the proxy ADVERTISES
- *      on /v1/models can never land here — they resolve (2/3) or fail loud
- *      (4/5) above.
- *
- * NO-DEFAULT MODE (`defaultApp: null`) — the HOSTED multi-tenant lane
- * (`src/hosted/`): a shared endpoint serving every org has no "the app this
- * proxy was started for", so rules 1 and 6 have nothing to fall back TO.
- * Rather than inventing one (picking "some" app for a caller would be the
- * worst kind of silent divergence), both rules become the SAME loud
- * {@link UnknownModelError} that rules 4/5 already raise: name a deployed
- * model, here is the list. Rules 2–5 are byte-for-byte the local behavior —
- * one router, one resolution order, two configurations.
- */
-
-/** One org app row from `GET {orgApi}/apps` (urun-cli `ApiClient.list_apps`). */
-interface DeployedApp {
-    app_slug: string;
-    function_name?: string | null;
-    deployment_status?: string | null;
-    [k: string]: unknown;
-}
-/**
- * A model that does not resolve to a deployed app the proxy may serve.
- * Rendered by the server in each lane's NATIVE error format as a 404 — never
- * silently served by the default app.
- */
-declare class UnknownModelError extends Error {
-}
-/**
- * A session handle names a pooled session that no longer exists (closed,
- * evicted after its pod died, replaced by a re-home, or the proxy restarted).
- * The caller asked to REATTACH that exact session — opening a fresh one and
- * calling it "resumed" would be a silent lie, so this is always loud.
- */
-declare class SessionGoneError extends Error {
-}
-/**
- * OpenAI-shaped model list (same shape as models.ts listModels). When the
- * catalog oracle is configured, each entry ALSO carries the catalog
- * enrichment fields (additive JSON — OpenAI clients ignore unknown fields;
- * the OpenRouter + Vercel AI Gateway provider listings need them). Entries
- * whose slug matches no catalog row stay at the bare four fields.
- */
-interface RouterModelEntry {
-    id: string;
-    object: 'model';
-    created: number;
-    owned_by: string;
-    /** Display name — the canonical `<model_id>:<variant>` catalog ref. */
-    name?: string;
-    /** User-facing description from the catalog (console Endpoints copy). */
-    description?: string;
-    /** Catalog modality (chat | code | agent | vl | audio | image | ...). */
-    task?: string;
-    /** Serving engine (vllm | sglang | llamacpp | ...). */
-    engine?: string;
-    /** The catalog lane this app deploys, e.g. 'rtx6000:1'. */
-    gpu_spec?: string;
-    /** Context window in tokens (chat rows carry it in engine_args). */
-    context_length?: number;
-}
-interface RouterModelList {
-    object: 'list';
-    data: RouterModelEntry[];
-}
-interface ModelRouterOptions<S> {
-    /**
-     * The startup app slug (URUN_APP) — the DEFAULT model — or `null` for the
-     * hosted multi-tenant lane, which has no per-proxy default app: there,
-     * every request must NAME a deployed model and an unnamed/unknown one
-     * fails loud instead of silently landing somewhere (see the module header,
-     * "NO-DEFAULT MODE").
-     */
-    defaultApp: string | null;
-    /** The serve function name every routed app must expose (URUN_FUNCTION). */
-    fnName: string;
-    /** Open a backhaul session for an app slug (called at most once per app). */
-    openSession: (appSlug: string) => S | Promise<S>;
-    /** Terminal release for one pool entry (Session.end() underneath). */
-    closeSession: (entry: S) => Promise<void>;
-    /**
-     * List the org's deployed apps, or null when the credentials cannot
-     * (URUN_JWT lane: the pre-vended token is scoped to the default app, so
-     * there is no org listing AND no cross-app session — routing degrades to
-     * the default-app-only contract, which is exactly today's behavior).
-     */
-    listApps: (() => Promise<DeployedApp[]>) | null;
-    /**
-     * Catalog rows (models.ts fetchCatalogRows) as the uRun-namespace oracle
-     * for rule 5 AND the /v1/models enrichment + OpenRouter provider-doc
-     * source, or null when catalog access is not configured. Optional fields
-     * beyond model_id/variant are tolerated (thin rows still typecheck).
-     */
-    listCatalog: (() => Promise<CatalogRow[]>) | null;
-    /** Deployed-apps cache TTL (the list changes on deploys, not per request). */
-    appsTtlMs?: number;
-    /**
-     * The stable NATIVE identity of one pooled entry (the uRun session id in
-     * the proxy wiring — the same identity the serve-side session-affinity tag
-     * rides, urun-python#1556). Powers the session-identity seam
-     * ({@link ModelRouter.handleFor} / {@link ModelRouter.sessionForHandle});
-     * a router without it fails LOUD on those calls, never approximates.
-     */
-    sessionKey?: (entry: S) => string;
-}
-/**
- * The image-capability modes the Images lane gates on (images.ts's
- * ImageCapabilityMode — declared here because the router is the LOWER layer:
- * the lane's gate type stays structurally satisfied by
- * {@link ModelRouter.supportsImages} with no router→lane import).
- */
-type ImageCapabilityMode = 'generation' | 'edit';
-/**
- * The session pool: one backhaul session per deployed app, keyed by app slug,
- * opened lazily on the first request that routes to it and reused for every
- * subsequent one. The startup app is seeded eagerly by the CLI. Sessions
- * close on proxy shutdown via {@link closeAll}; there is NO idle-close policy
- * (deliberate v1 simplification — noted as a follow-up in the PR).
- */
-declare class ModelRouter<S> {
-    private readonly opts;
-    private readonly pool;
-    private appsCache;
-    private rowsCache;
-    constructor(opts: ModelRouterOptions<S>);
-    /** Seed an already-open session (the CLI's eagerly-opened startup app). */
-    seed(appSlug: string, entry: S): void;
-    private deployedApps;
-    /**
-     * Catalog rows with the same TTL discipline as {@link deployedApps} (the
-     * catalog changes on reseed migrations, not per request). Null when no
-     * oracle is configured — callers degrade to the bare four-field entries.
-     */
-    private catalogRows;
-    /** Apps this proxy may serve: active AND exposing the serve function. */
-    private servable;
-    private availableIds;
-    /**
-     * NO-DEFAULT MODE's terminal for rules 1 and 6: there is no app to fall
-     * back to, so say so loudly and list what the CALLER'S org actually has.
-     * Never returns.
-     */
-    private noDefaultApp;
-    /**
-     * Resolve a request's `model` to an app slug — the documented resolution
-     * order from the module header. Throws {@link UnknownModelError} for a uRun
-     * model that is not deployed (rules 4/5).
-     */
-    resolveApp(model: string | undefined): Promise<string>;
-    /** The pooled session for a model — opened lazily, reused afterwards. */
-    sessionFor(model: string | undefined): Promise<{
-        app: string;
-        entry: S;
-    }>;
-    private keyOf;
-    /**
-     * SESSION-IDENTITY SEAM (a): the opaque stable handle for the pooled
-     * session currently serving `model`'s turns. Rides the SAME acquisition
-     * path as every request ({@link sessionFor}) — the session opens lazily if
-     * this model has none yet — and derives the handle from native identity
-     * (app slug + uRun session id), zero bespoke bookkeeping.
-     */
-    handleFor(model: string | undefined): Promise<{
-        app: string;
-        handle: string;
-    }>;
-    /**
-     * SESSION-IDENTITY SEAM (b): the exact pooled session a handle names.
-     * NEVER opens a fresh session — a handle whose session is gone (closed,
-     * evicted, re-homed to a replacement, proxy restarted) or malformed throws
-     * {@link SessionGoneError} loudly. Resume is reattach-or-fail, not
-     * reattach-or-quietly-restart.
-     */
-    sessionForHandle(handle: string): Promise<{
-        app: string;
-        entry: S;
-    }>;
-    /**
-     * Drop ONE pooled session whose backhaul died (its pod was restarted /
-     * drained / deleted) and release it — the next {@link sessionFor} opens a
-     * fresh one, i.e. asks the control plane for a new assignment. Used by the
-     * one-shot re-home (rehome.ts, urun-sh/urun-python#1592).
-     *
-     * IDENTITY-GUARDED (the same rule the pi lane's SessionPool follows): a
-     * concurrent request that already re-homed this app has put a NEWER entry
-     * under the key, and evicting that would close a healthy session out from
-     * under it.
-     */
-    evict(app: string, entry: S): Promise<void>;
-    /**
-     * `GET /v1/models`: the org's deployed serve apps as model entries, the
-     * default app FIRST. On the JWT lane (no org listing) this is the default
-     * app plus any app already in the pool — the gap is called out loudly in
-     * the PR, not papered over here.
-     */
-    modelList(): Promise<RouterModelList>;
-    /**
-     * The OpenRouter PROVIDER document (`GET /v1/models?format=openrouter`):
-     * schema 2.4 per openrouter.ai/docs/guides/community/for-providers. Only
-     * chat-completions-shaped models are declared (task chat | code | agent |
-     * vl — a voice or video app behind a chat surface would stream garbage);
-     * models the catalog cannot vouch for are OMITTED, never guessed. Pricing
-     * is deliberately omitted entirely (schema rule: "A modality with no
-     * pricing array is simply unpriced" — OpenRouter configures pricing during
-     * provider onboarding; the per-model price surface is urun-infra U3).
-     */
-    openRouterModels(): Promise<OpenRouterProviderDoc>;
-    /**
-     * IMAGE CAPABILITY GATE (the Images lane's `imageModels` oracle, images.ts):
-     * is `model`'s deployed app a native destination for `mode`? Authorized
-     * resolution ({@link resolveApp} — undeployed uRun models throw
-     * {@link UnknownModelError}, which the lane renders as a 404) then the
-     * SAME catalog join as the /v1/models enrichment (PR421's rowForSlug):
-     * exact `<model_id>-<variant>` slug across ALL its GPU-placement rows, a
-     * bare model_id only when one variant owns it.
-     *
-     * Capability is read ONLY from catalog modality metadata, never from the
-     * serve function name: every row must carry task 'image' INVARIANTLY across
-     * the placements, and the mode comes from engine_args.expects_image —
-     * false ⇒ pure text-to-image ('generation'; diffusers v0.38.0
-     * pipeline_qwenimage_edit_plus raises torch.cat on an EMPTY image list, so
-     * an edit destination is never generation-capable); true or ABSENT (the
-     * native default) ⇒ 'edit'. The consensus rule is per-placement:
-     * capability must agree across every placement — a CONFLICTING flag (mixed
-     * true/false/absent) or a non-boolean one is a refused capability, never
-     * silently defaulted to edit.
-     *
-     * A CONFIGURED catalog oracle that FAILS propagates its rejection — the
-     * gate never fabricates a `false` (which would render as a misleading 404)
-     * out of an infrastructure outage. No oracle configured, no matching row,
-     * or a slug the catalog cannot vouch for ⇒ false (loud 404 upstream).
-     */
-    supportsImages(model: string | undefined, mode: ImageCapabilityMode): Promise<boolean>;
-    /** Close every pooled session (Session.end() underneath) — proxy shutdown. */
-    closeAll(): Promise<void>;
-}
-
-/**
- * The shared Responses execution/store seam — the ONE execution + event-
- * envelope path and the authorized tenant store, imported by BOTH the HTTP
- * SSE lane (server.ts) and the `/v1/responses` WebSocket lane
- * (responses-ws.ts). This module deliberately imports NO transport acceptor
- * and NO HTTP lane module: its only imports are type-only, so the module
- * graph server.ts → responses-ws.ts → responses-turn.ts is acyclic and no
- * Vitest/Bun/Node module-evaluation order can observe an uninitialized
- * binding (the constructor-failure class of bug this extraction removes).
- */
-
-/** The request envelope every Responses-shaped upstream call carries. */
-interface ResponsesCreateParams {
-    model?: string;
-    input: unknown;
-    stream?: boolean;
-    tools?: unknown;
-    tool_choice?: unknown;
-    temperature?: number;
-    max_output_tokens?: number;
-    /**
-     * System/developer instructions, forwarded to the serve envelope — where
-     * they become ONE prepended `system`-role message (the protocol's native
-     * per-request system input; there is NO envelope-level instructions field).
-     * Typed `string` end to end (transport/encode.ts) so no cast bridges the seam.
-     */
-    instructions?: string;
-    top_p?: number;
-    stop?: string[];
-    /**
-     * Reasoning controls (urun-python #1667): forwarded VERBATIM to the serve
-     * envelope — `chat_template_kwargs.enable_thinking:false` is the think-off
-     * switch. Absent -> absent (no default injection; server-side validation).
-     */
-    reasoning_effort?: string;
-    chat_template_kwargs?: Record<string, unknown>;
-}
-/** How one pinned session ended (the native phase machinery's terminal step). */
-interface SessionEndInfo {
-    /**
-     * Milliseconds until the session's native deadline (`endsAt`), or null when
-     * the app declared no maximum session length. NOTE (missing primitive,
-     * called out in the PR): core exposes no PRE-expiry notice event — this
-     * callback fires AT terminal loss, so timeLeftMs is ~0 on expiry.
-     */
-    timeLeftMs: number | null;
-    /** The terminal reason (expired / ended / error), for the loud close. */
-    reason: string;
-}
-/** The upstream calls the proxy makes — injectable (tests; alt transports). */
-interface ProxyClients {
-    /** `UrunResponses(session).responses.create` — an async iterable of Responses stream events. */
-    createResponse(params: ResponsesCreateParams): Promise<AsyncIterable<unknown>> | AsyncIterable<unknown>;
-    /** `listModels(...)` result (an OpenAI model list object). */
-    listModels(): Promise<unknown>;
-    /**
-     * The OpenRouter provider document (`GET /v1/models?format=openrouter`).
-     * Optional at the seam: hand-built test clients may omit it, in which case
-     * the format=openrouter branch answers 501 — loud, never a silent empty.
-     */
-    openRouterModels?(): Promise<unknown>;
-    /**
-     * Open (or reuse) the NATIVE audio lanes on the pooled session `model` routes
-     * to — the same first-party machinery as RealtimeClient.enableAudio
-     * (transport/media.ts `enableSessionAudio`: AudioBridge over the session's
-     * `rt-audio-in`/`rt-audio-out` stream lanes at 24 kHz). One lane per pooled
-     * session; repeat calls return the same lane. Optional at the seam because
-     * text-only embeddings exist — but a surface that RECEIVES audio while the
-     * embedder wired no `openAudio` must fail LOUD, never drop chunks.
-     */
-    openAudio?(model: string | undefined): Promise<ProxyAudioLane>;
-    /**
-     * Open (or reuse) the NATIVE video FRAME lane on the pooled session `model`
-     * routes to (transport/media.ts `enableSessionVideo`: discrete JPEG frames →
-     * `stream('rt-video-in').emit`, the §5 named-DATA image-bytes path — NOT the
-     * RTP media plane, which requires an already-H.264-encoded track). One lane
-     * per pooled session; repeat calls return the same lane. Optional at the seam
-     * because text-only embeddings exist — but a surface that RECEIVES video
-     * frames while the embedder wired no `openVideo` must fail LOUD, never drop
-     * frames.
-     */
-    openVideo?(model: string | undefined): Promise<ProxyVideoLane>;
-    /**
-     * Open (or reuse) the NATIVE video OUTPUT lane on the pooled session
-     * `model` routes to (transport/video-out.ts `openSessionVideoOutLane`):
-     * decoded spec-v1 records consumed from the session's named §5
-     * `rt-video-out` downstream. The Live adapter fans each record onto the
-     * SAME Bidi WS as an extension server message (spec v2, WS-inline) — no
-     * side-channel transport. Optional at the seam; an ABSENT seam means the
-     * `urun.videoOut` capability is refused by omission in setupComplete
-     * (vanilla parity), while a wired seam that cannot open the lane must
-     * throw LOUD — never a quiet downgrade.
-     */
-    openVideoOut?(model: string | undefined): Promise<ProxyVideoOutLane>;
-    /**
-     * SESSION-IDENTITY SEAM (ModelRouter.handleFor): the opaque stable handle
-     * for the pooled session currently serving `model`'s turns. Derived from
-     * native identity (app slug + uRun session id) — the same identity the
-     * serve-side session-affinity tag rides (urun-python#1556/#1582).
-     */
-    sessionHandle(model: string | undefined): Promise<string>;
-    /**
-     * createResponse PINNED to the exact session a handle names
-     * (ModelRouter.sessionForHandle). Throws SessionGoneError LOUDLY when that
-     * session is gone or was replaced — never silently opens a fresh session
-     * while claiming resume. Deliberately NO re-home on this path: re-homing
-     * would swap the pinned session out from under the caller.
-     */
-    createResponseOn(handle: string, params: ResponsesCreateParams): Promise<AsyncIterable<unknown>> | AsyncIterable<unknown>;
-    /**
-     * Subscribe to the pinned session's terminal end via core's NATIVE phase
-     * machinery (Session.onPhase → terminal 'expired'/'ended'/'error'). Fires
-     * `cb` once. Throws SessionGoneError if the handle's session is already
-     * gone — which doubles as the loud reattach check at resume time. Returns
-     * the unsubscribe.
-     */
-    onSessionEnd(handle: string, cb: (end: SessionEndInfo) => void): Promise<() => void>;
-}
-/**
- * The audio lane handle `openAudio` returns — structurally the transport
- * AudioBridge (media.ts): base64 PCM16 @24 kHz mono in both directions.
- */
-type ProxyAudioLane = Pick<AudioBridge, 'appendInputAudio' | 'onOutputAudio'>;
-/**
- * The video frame-lane handle `openVideo` returns — structurally the
- * transport VideoFrameLane (media.ts): one raw encoded JPEG frame per call,
- * input-only (Live-style protocols have no video OUT modality).
- */
-type ProxyVideoLane = Pick<VideoFrameLane, 'sendInputFrame'>;
-/**
- * The video-OUT lane handle `openVideoOut` returns — structurally the
- * transport VideoOutLane (video-out.ts): the codec plus frame/error fan-out
- * the WS-inline delivery subscribes.
- */
-type ProxyVideoOutLane = Pick<VideoOutLane, 'codec' | 'onOutputFrame' | 'onLaneError'>;
-/**
- * Per-request `ProxyClients` resolution — the seam the HOSTED multi-tenant
- * server (`src/hosted/`) plugs into so ONE handler implementation serves
- * every org: the hosted server resolves the caller's org from its Bearer API
- * key and returns THAT org's backhaul. The local CLI passes a fixed
- * `ProxyClients` instead; both go through the identical handler body.
- *
- * Throwing from here is the loud path: the thrown error surfaces in the
- * lane's native error envelope (see {@link ProxyHandlerOptions.statusOf}).
- */
-type ProxyClientsFor = (req: IncomingMessage) => ProxyClients | Promise<ProxyClients>;
-interface ProxyHandlerOptions {
-    /** A fixed backhaul (local CLI) or a per-request resolver (hosted server). */
-    clients: ProxyClients | ProxyClientsFor;
-    /** Optional bearer the local agent must present (never forwarded upstream). */
-    apiKey?: string;
-    /**
-     * WHAT this proxy serves (app/org/fn/base_url + proxy_version), surfaced as
-     * the `identity` block on `GET /stats` so a second `urun compat` invocation
-     * can reuse this proxy iff the identity matches its own exactly. Only the
-     * standalone `urun compat proxy` command sets it — a launch-mode proxy is
-     * child-owned (it dies with its child) and an embedder that omits it is
-     * simply never reused.
-     */
-    identity?: ProxyIdentity;
-    /**
-     * Map a thrown error onto an HTTP status + error `type` before the generic
-     * 500. The hosted server uses it to turn its auth/tenancy failures into a
-     * 401 in the OpenAI envelope. Returning null means "not mine" — the error
-     * takes the ordinary loud 500 path.
-     */
-    statusOf?: (err: unknown) => {
-        status: number;
-        openaiType: string;
-        anthropicType: string;
-    } | null;
-}
-
-export { ModelRouter as M, type ProxyClients as P, SessionGoneError as S, UnknownModelError as U, type ProxyHandlerOptions as a, type ProxyIdentity as b, type ProxyVideoOutLane as c };