@urun-sh/openai 0.2.60 → 0.3.1

package/dist/proxy/index.d.cts

@@ -1,182 +1,5 @@
-import { Server } from 'node:http';
-import { a as AudioBridge, V as VideoFrameLane } from '../media-DCHTX3Ez.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>;
-    /**
-     * 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>;
-    /**
-     * 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'>;
-interface OpenAIProxyOptions {
-    clients: ProxyClients;
-    /** 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;
-}
-/** Build (not listen) the proxy server — the caller owns listen/close. */
-declare function createOpenAIProxy(options: OpenAIProxyOptions): Server;
-
-/**
- * Gemini Live (BidiGenerateContent) ⇄ uRun Responses translation — PURE
- * functions only, no I/O and no session state. The wire shapes mirror the
- * official WebSocket reference (https://ai.google.dev/api/live): client
- * messages are a union of exactly one of `setup` / `clientContent` /
- * `realtimeInput` / `toolResponse`; server messages are a union of
- * `setupComplete` / `serverContent` / `toolCall` / … with `usageMetadata` as
- * a SIBLING of the union field on `BidiGenerateContentServerMessage`.
- *
- * Scope (this slice): setup + clientContent + realtimeInput TEXT + AUDIO +
- * VIDEO + serverContent streaming + toolCall/toolResponse + sessionResumption
- * (handles over the proxy's pooled-session identity seam) + goAway + MANUAL
- * VAD/activity (setup.realtimeInputConfig.automaticActivityDetection.disabled
- * + realtimeInput.activityStart/activityEnd + serverContent.interrupted
- * barge-in). AUTOMATIC (server-side) activity detection is the DECLARED
- * follow-up slice — requesting it fails loud naming the follow-up, never
- * silently ignored (repo mandate: one canonical path, no silent fallbacks).
- *
- * AUTOMATIC activity detection is deliberately NOT emulated here: server-side
- * VAD is a PLATFORM primitive (urun-python `urun.serve.turn_detection`
- * `detect_turns` — `turn_start`/`turn_end` events on the session's §5 stream
- * lane), never adapter-local DSP in the proxy. Until the Live lane's session
- * shapes emit those events, requesting automatic detection fails loud.
- */
-/** The Live WS endpoint path (v1beta), verbatim from the Google reference. */
-declare const GEMINI_LIVE_PATH = "/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent";
-
-export { GEMINI_LIVE_PATH, type OpenAIProxyOptions, type ProxyClients, type ProxyIdentity, createOpenAIProxy };
+export { O as OpenAIProxyOptions, P as ProxyClients, a as ProxyIdentity, b as ProxyVideoOutLane, c as createOpenAIProxy } from '../server-BfME37pQ.cjs';
+export { h as GEMINI_LIVE_PATH, V as VIDEO_OUT_SETUP_KEY } from '../translator-CcDBEfvm.cjs';
+import 'node:http';
+import '../video-out-D20UuJ8G.cjs';
+import '../types-lsVTbNcH.cjs';

package/dist/proxy/index.d.ts

@@ -1,67 +1,5 @@
-import { Server } from 'node:http';
-import { a as AudioBridge, V as VideoFrameLane } from '../media-DCHTX3Ez.js';
-
-interface ProxyIdentity {
-    app: string;
-    org: string;
-    fn: string;
-    
-    base_url: string;
-    proxy_version: string;
-}
-
-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_effort?: string;
-    chat_template_kwargs?: Record<string, unknown>;
-}
-
-interface SessionEndInfo {
-    
-    timeLeftMs: number | null;
-    
-    reason: string;
-}
-
-interface ProxyClients {
-    
-    createResponse(params: ResponsesCreateParams): Promise<AsyncIterable<unknown>> | AsyncIterable<unknown>;
-    
-    listModels(): Promise<unknown>;
-    
-    openAudio?(model: string | undefined): Promise<ProxyAudioLane>;
-    
-    openVideo?(model: string | undefined): Promise<ProxyVideoLane>;
-    
-    sessionHandle(model: string | undefined): Promise<string>;
-    
-    createResponseOn(handle: string, params: ResponsesCreateParams): Promise<AsyncIterable<unknown>> | AsyncIterable<unknown>;
-    
-    onSessionEnd(handle: string, cb: (end: SessionEndInfo) => void): Promise<() => void>;
-}
-
-type ProxyAudioLane = Pick<AudioBridge, 'appendInputAudio' | 'onOutputAudio'>;
-
-type ProxyVideoLane = Pick<VideoFrameLane, 'sendInputFrame'>;
-interface OpenAIProxyOptions {
-    clients: ProxyClients;
-    
-    apiKey?: string;
-    
-    identity?: ProxyIdentity;
-}
-
-declare function createOpenAIProxy(options: OpenAIProxyOptions): Server;
-
-declare const GEMINI_LIVE_PATH = "/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent";
-
-export { GEMINI_LIVE_PATH, type OpenAIProxyOptions, type ProxyClients, type ProxyIdentity, createOpenAIProxy };
+export { O as OpenAIProxyOptions, P as ProxyClients, a as ProxyIdentity, b as ProxyVideoOutLane, c as createOpenAIProxy } from '../server-l1himPxc.js';
+export { h as GEMINI_LIVE_PATH, V as VIDEO_OUT_SETUP_KEY } from '../translator-C9uPKypK.js';
+import 'node:http';
+import '../video-out-CWesbk12.js';
+import '../types-lsVTbNcH.js';

package/dist/proxy/index.js

@@ -1 +1 @@
-import{a as r,b as e}from"../chunk-4FUBGLFN.js";import"../chunk-VFHQZ4OM.js";import"../chunk-VXTNG2TP.js";export{r as GEMINI_LIVE_PATH,e as createOpenAIProxy};
+import{b as t}from"../chunk-M6ICU4F5.js";import"../chunk-XHIIEA6Z.js";import{a as r,h as o}from"../chunk-5NXM4IO3.js";import"../chunk-CWJRDBDC.js";import{c as e}from"../chunk-YSFSRI3D.js";e();export{r as GEMINI_LIVE_PATH,o as VIDEO_OUT_SETUP_KEY,t as createOpenAIProxy};

package/dist/server-BfME37pQ.d.cts

@@ -0,0 +1,200 @@
+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>;
+    /**
+     * 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 };

package/dist/server-l1himPxc.d.ts

@@ -0,0 +1,82 @@
+import { IncomingMessage, Server } from 'node:http';
+import { a as AudioBridge, h as VideoFrameLane, j as VideoOutLane } from './video-out-CWesbk12.js';
+
+interface ProxyIdentity {
+    app: string;
+    org: string;
+    fn: string;
+    
+    base_url: string;
+    proxy_version: string;
+}
+
+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_effort?: string;
+    chat_template_kwargs?: Record<string, unknown>;
+}
+
+interface SessionEndInfo {
+    
+    timeLeftMs: number | null;
+    
+    reason: string;
+}
+
+interface ProxyClients {
+    
+    createResponse(params: ResponsesCreateParams): Promise<AsyncIterable<unknown>> | AsyncIterable<unknown>;
+    
+    listModels(): Promise<unknown>;
+    
+    openAudio?(model: string | undefined): Promise<ProxyAudioLane>;
+    
+    openVideo?(model: string | undefined): Promise<ProxyVideoLane>;
+    
+    openVideoOut?(model: string | undefined): Promise<ProxyVideoOutLane>;
+    
+    sessionHandle(model: string | undefined): Promise<string>;
+    
+    createResponseOn(handle: string, params: ResponsesCreateParams): Promise<AsyncIterable<unknown>> | AsyncIterable<unknown>;
+    
+    onSessionEnd(handle: string, cb: (end: SessionEndInfo) => void): Promise<() => void>;
+}
+
+type ProxyAudioLane = Pick<AudioBridge, 'appendInputAudio' | 'onOutputAudio'>;
+
+type ProxyVideoLane = Pick<VideoFrameLane, 'sendInputFrame'>;
+
+type ProxyVideoOutLane = Pick<VideoOutLane, 'codec' | 'onOutputFrame' | 'onLaneError'>;
+
+type ProxyClientsFor = (req: IncomingMessage) => ProxyClients | Promise<ProxyClients>;
+interface ProxyHandlerOptions {
+    
+    clients: ProxyClients | ProxyClientsFor;
+    
+    apiKey?: string;
+    
+    identity?: ProxyIdentity;
+    
+    statusOf?: (err: unknown) => {
+        status: number;
+        openaiType: string;
+        anthropicType: string;
+    } | null;
+}
+
+interface OpenAIProxyOptions extends ProxyHandlerOptions {
+    clients: ProxyClients;
+}
+
+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 };

package/dist/translator-C9uPKypK.d.ts

@@ -0,0 +1,130 @@
+import { k as VideoOutRecord } from './video-out-CWesbk12.js';
+
+declare const GEMINI_LIVE_PATH = "/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent";
+
+declare const CLOSE_PROTOCOL = 1007;
+
+declare const CLOSE_UNKNOWN_MODEL = 1008;
+
+declare const CLOSE_UPSTREAM = 1011;
+
+declare const CLOSE_SESSION_GONE = 1008;
+
+declare class GeminiLiveError extends Error {
+    readonly closeCode: number;
+    constructor(message: string, closeCode?: number);
+}
+type Rec = Record<string, unknown>;
+
+type ClientMessage = {
+    kind: 'setup';
+    setup: Rec;
+} | {
+    kind: 'clientContent';
+    clientContent: Rec;
+} | {
+    kind: 'realtimeInput';
+    realtimeInput: Rec;
+} | {
+    kind: 'toolResponse';
+    toolResponse: Rec;
+};
+
+declare function parseClientMessage(raw: string): ClientMessage;
+
+type ActivityHandling = 'START_OF_ACTIVITY_INTERRUPTS' | 'NO_INTERRUPTION';
+
+interface ActivityConfig {
+    
+    manualActivity: boolean;
+    
+    activityHandling: ActivityHandling;
+}
+
+interface LiveSessionConfig {
+    
+    model: string;
+    
+    systemItems: Rec[];
+    
+    tools: Rec[] | undefined;
+    temperature: number | undefined;
+    maxOutputTokens: number | undefined;
+    
+    audioModality: boolean;
+    
+    activity: ActivityConfig;
+    
+    sessionResumption: {
+        enabled: boolean;
+        handle: string | null;
+    };
+    
+    videoOut: boolean;
+}
+
+declare const VIDEO_OUT_SETUP_KEY = "urun.videoOut";
+
+declare function videoOutAck(codec: string): Rec;
+
+declare function videoOutChunkMsg(record: VideoOutRecord): Rec;
+
+declare function translateSetup(setup: Rec): LiveSessionConfig;
+
+declare function sessionResumptionUpdateMsg(newHandle: string): Rec;
+
+declare function goAwayMsg(timeLeftMs: number | null): Rec;
+
+declare function translateClientContent(cc: Rec): {
+    items: Rec[];
+    turnComplete: boolean;
+};
+
+declare const GEMINI_AUDIO_IN_RATE = 16000;
+
+declare const GEMINI_AUDIO_OUT_RATE = 24000;
+
+declare const GEMINI_AUDIO_OUT_MIME = "audio/pcm;rate=24000";
+
+declare const OUTBOUND_AUDIO_FLUSH_B64: string;
+
+declare function resamplePcm16(samples: Int16Array, from: number, to: number): Int16Array;
+
+type RealtimeInputAction = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'audio';
+    base64Pcm24k: string;
+} | {
+    kind: 'audioStreamEnd';
+} | {
+    kind: 'activityStart';
+} | {
+    kind: 'activityEnd';
+} | {
+    kind: 'video';
+    jpegFrame: Uint8Array;
+};
+
+declare function translateRealtimeInput(ri: Rec): RealtimeInputAction;
+
+declare function translateToolResponse(tr: Rec): Rec[];
+
+declare function serverContentOfDelta(ev: {
+    type?: unknown;
+    delta?: unknown;
+}): Rec | null;
+
+declare function serverContentOfAudio(base64Pcm24k: string): Rec;
+
+interface TurnEnd {
+    
+    messages: Rec[];
+    
+    assistantItems: Rec[];
+}
+
+declare function turnEndOfCompleted(completed: unknown): TurnEnd;
+
+export { type ActivityConfig as A, CLOSE_PROTOCOL as C, GEMINI_AUDIO_IN_RATE as G, type LiveSessionConfig as L, OUTBOUND_AUDIO_FLUSH_B64 as O, type RealtimeInputAction as R, type TurnEnd as T, VIDEO_OUT_SETUP_KEY as V, type ActivityHandling as a, CLOSE_SESSION_GONE as b, CLOSE_UNKNOWN_MODEL as c, CLOSE_UPSTREAM as d, type ClientMessage as e, GEMINI_AUDIO_OUT_MIME as f, GEMINI_AUDIO_OUT_RATE as g, GEMINI_LIVE_PATH as h, GeminiLiveError as i, goAwayMsg as j, serverContentOfDelta as k, sessionResumptionUpdateMsg as l, translateRealtimeInput as m, translateSetup as n, translateToolResponse as o, parseClientMessage as p, turnEndOfCompleted as q, resamplePcm16 as r, serverContentOfAudio as s, translateClientContent as t, videoOutChunkMsg as u, videoOutAck as v };