@urun-sh/openai 0.5.4 → 0.5.6

package/dist/server-wmUnMewW.d.cts

@@ -1,206 +0,0 @@
-import { IncomingMessage, Server } 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 local OpenAI-compatible proxy — `npx @urun-sh/openai proxy`.
- *
- * A loopback HTTP server speaking the OpenAI REST surface (`/v1/models`,
- * `/v1/responses`, `/v1/chat/completions`, SSE streaming included), so any
- * OpenAI-env-var tool — coding agents first — integrates with uRun with ZERO
- * code changes: point `OPENAI_BASE_URL` at it and keep making plain, local,
- * "inefficient" HTTP requests. The proxy backhauls each request over the uRun
- * session transport (the `@urun-sh/openai` Responses client → session doc
- * lanes + streams — no public OpenAI-style HTTP leaves the machine), which is
- * also where the delta-sync chat-state doc lane (urun-python
- * `urun/serve/chat_state.py`) plugs in as the transport evolves.
- *
- * Local-trust model: binds 127.0.0.1 by default; `apiKey` (when set) must
- * match the agent's `Authorization: Bearer` — otherwise any local bearer is
- * accepted (the key the agent sends is NEVER forwarded upstream; uRun auth is
- * the session's own).
- */
-
-/** 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;
-    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 below.
- *
- * 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;
-}
-/** The proxy server's own options: a FIXED backhaul (the local CLI lane). */
-interface OpenAIProxyOptions extends ProxyHandlerOptions {
-    clients: ProxyClients;
-}
-/** Build (not listen) the proxy server — the caller owns listen/close. */
-declare function createOpenAIProxy(options: OpenAIProxyOptions): Server;
-
-export { type OpenAIProxyOptions as O, type ProxyClients as P, type ProxyIdentity as a, type ProxyVideoOutLane as b, createOpenAIProxy as c };