@urun-sh/openai 0.5.6 → 0.6.1

package/dist/proxy/index.d.cts

@@ -1,11 +1,11 @@
 import { Server, IncomingMessage } from 'node:http';
-import { f as ProxyHandlerOptions, P as ProxyClients } from '../responses-turn-tNUHq5b0.cjs';
-export { D as DialObserver, a as DialReport, g as ProxyIdentity, h as ProxyVideoOutLane, S as SessionGoneError, U as UnknownModelError } from '../responses-turn-tNUHq5b0.cjs';
-export { h as GEMINI_LIVE_PATH, V as VIDEO_OUT_SETUP_KEY } from '../translator-Bh0Bp_Ie.cjs';
+import { f as ProxyHandlerOptions, P as ProxyClients } from '../responses-turn-vMefRdgJ.cjs';
+export { D as DialObserver, a as DialReport, g as ProxyIdentity, h as ProxyVideoOutLane, S as SessionGoneError, U as UnknownModelError } from '../responses-turn-vMefRdgJ.cjs';
+export { h as GEMINI_LIVE_PATH, V as VIDEO_OUT_SETUP_KEY } from '../translator-CO8W_hmJ.cjs';
 import { WebSocket } from 'ws';
 import '../models-DUdx_Y6X.cjs';
-import '../video-out-CCksIcj8.cjs';
-import '../types-lsVTbNcH.cjs';
+import '../video-out-BsuLqlID.cjs';
+import '../types-CHPtJx6d.cjs';
 
 /**
  * The local OpenAI-compatible proxy — `npx @urun-sh/openai proxy`.
@@ -253,9 +253,19 @@ declare function serveGeminiLiveSocket(ws: WebSocket, call: GeminiLiveCall, regi
  *     `next()` listener, so sibling lanes (Gemini Live, Responses WS) and the
  *     hosted composition keep their own upgrade hooks.
  *   - Clients are resolved/authenticated ASYNCHRONOUSLY BEFORE the upgrade is
- *     accepted: no 101 is written until `resolver.resolve(req)` settles. A
- *     thrown error maps `err.status` (default 502) to the HTTP reject;
- *     401/403 keep their status.
+ *     accepted: no 101 is written until `resolver.resolve(req, signal)`
+ *     settles. A thrown error maps `err.status` (default 502) to the HTTP
+ *     reject; 401/403 keep their status.
+ *   - THE CLIENT SOCKET'S OWN CLOSE is the cancellation signal for the wait:
+ *     a `close`/`error` on the raw pre-upgrade socket aborts the signal the
+ *     resolver rides. A resolver that settles AFTER the client vanished never
+ *     upgrades — its binding is released through the binding's own `release`
+ *     seam (the native detach; a still-queued admission ticket is cancelled
+ *     underneath it by the backhaul's abort path). A client that closes after
+ *     admission tears down through the connection's own ws-close wiring.
+ *   - ONE structured log line per upgrade lifecycle event (`realtime_upgrade`:
+ *     accept → admit → close, with the binding's session id and the client
+ *     close reason) — the lane was previously invisible in the process log.
  *   - The resolved binding carries a PRIVATE native uRun session (fresh or
  *     explicitly-resumed) and, iff voice, a PRIVATE audio bridge — never the
  *     pooled tenant lane. The connection's cross-caller claim is invariant
@@ -271,11 +281,16 @@ declare const OPENAI_REALTIME_PATH = "/v1/realtime";
  * The resolver seam — the ONLY credential, modality, and session-allocation
  * authority this adapter recognizes. Implemented by Main's composition (and
  * by tests with an injected fake). Accepted in EITHER form: a bare
- * `(req) => Promise<binding>` (the {@link ProxyClientsFor}-style convention)
- * or a `{ resolve(req) }` object.
+ * `(req, signal) => Promise<binding>` (the {@link ProxyClientsFor}-style
+ * convention) or a `{ resolve(req, signal) }` object. `signal` aborts when
+ * the CLIENT SOCKET closes/errors before the upgrade is accepted — the
+ * resolver SHOULD abandon its admission wait on it (the backhaul's
+ * `openAudioOn` rides the same signal into core `whenLive`'s own abort
+ * support); a resolver that ignores it still cannot admit an upgrade to a
+ * vanished client: the settled binding is released, never upgraded.
  */
-type OpenAIRealtimeResolver<S = unknown> = ((req: IncomingMessage) => Promise<RealtimeBinding<S>>) | {
-    resolve(req: IncomingMessage): Promise<RealtimeBinding<S>>;
+type OpenAIRealtimeResolver<S = unknown> = ((req: IncomingMessage, signal?: AbortSignal) => Promise<RealtimeBinding<S>>) | {
+    resolve(req: IncomingMessage, signal?: AbortSignal): Promise<RealtimeBinding<S>>;
 };
 interface RealtimeBinding<S = unknown> {
     /**
@@ -287,11 +302,15 @@ interface RealtimeBinding<S = unknown> {
      *   - `session.sendResponseCreate(params, input, requestId)` (the direct
      *     SdkTransport-style seam), or
      *   - `clients.createResponse(params)` — the canonical ProxyClients seam
-     *     the conversation factory hands out (`input` rides inside `params`).
+     *     shape (`input` rides inside `params`). The shared binding composition
+     *     (binding.ts, ENG-446) hands out a PINNED view of it: the call dials
+     *     `createResponseOn(handle, …)` on the ONE pooled session the binding
+     *     resolved with the audio bridge, so no turn on the connection can
+     *     reach a second pooled session behind the bridge's back.
      * A binding with neither is rejected at upgrade time, LOUD.
      */
     session?: S & {
-        sendResponseCreate?(params: unknown, input: unknown[], requestId: string): AsyncIterable<unknown>;
+        sendResponseCreate?(params: unknown, input: unknown[], requestId: string): Promise<AsyncIterable<unknown>>;
     };
     clients?: Pick<ProxyClients, 'createResponse'>;
     /**
@@ -305,6 +324,15 @@ interface RealtimeBinding<S = unknown> {
         audio: {
             appendInputAudio(base64Pcm16: string): void;
             onOutputAudio(handler: (b64: string) => void): () => void;
+            /**
+             * The pooled uRun session this lane rides (backhaul `openAudioOn`
+             * reports core `Session.id`), when the backhaul knows it — the field the
+             * `realtime_upgrade` log line puts on every lifecycle event so an
+             * orphaned session is traceable from the proxy log alone. Null is the
+             * honest absence (an id-less session reports no id); sessionIdOf
+             * normalizes it to the omitted field below.
+             */
+            sessionId?: string | null;
         };
         /** Cross-caller reuse registry (invariant validation; see connection.ts). */
         openaiRealtimeClaims?: Set<RealtimeBinding['audioSession']>;
@@ -340,6 +368,17 @@ interface RealtimeBinding<S = unknown> {
 }
 interface OpenAIRealtimeOptions<S = unknown> {
     resolver: OpenAIRealtimeResolver<S>;
+    /**
+     * Where the per-upgrade structured `realtime_upgrade` lines go (ONE
+     * newline-terminated JSON object per lifecycle event: accept → admit →
+     * close). Absent, the line goes to this process's stdout through the repo's
+     * canonical guarded write — the hosted container's collected log stream.
+     * Emitted unconditionally, never behind a verbosity flag: this lane's
+     * lifecycle was previously invisible in the process log, which is exactly
+     * why an orphaned queued admission could only be diagnosed from the
+     * session-server side.
+     */
+    log?: (line: string) => void;
 }
 /**
  * Attach the OpenAI Realtime WS endpoint to `server`. Upgrades on any other
@@ -360,6 +399,22 @@ declare function attachOpenAIRealtime<S = unknown>(server: Server, options: Open
  * Multi-attach on the SAME authorized session (explicit resume) is the one
  * sanctioned shared form: one bridge owner at a time, validated by claim.
  *
+ * ONE SESSION IDENTITY PER CONNECTION (ENG-446): the shared binding
+ * composition resolves the connection's pooled session ONCE and pins BOTH the
+ * audio bridge (`openAudioOn(handle)`) and every turn (`createResponseOn
+ * (handle, …)`, threaded through the binding's `clients` view) to that one
+ * handle. This adapter therefore treats a turn seam failure that means THE
+ * SESSION (not the request) is dead — a {@link SessionGoneError} (the pool
+ * replaced or dropped the pinned entry), or a dial that dies before any
+ * client-visible content — as the LOUD `session_gone` CLOSE of the whole
+ * connection: an `error` event naming the cause, then the 1011 close. The
+ * bridge stays bound to the dead session and NEVER rebinds, and the turn is
+ * never retried on a replacement behind the bridge's back (the two-session
+ * race the speech lane's #500 pin fixed for its lane). The ONE exception is
+ * core's own BOUNDED ADMISSION VERDICT (`SessionFailedError` never-live /
+ * create-failed — the platform's answer about this assignment, not a death):
+ * it stays the per-turn `response.failed`, exactly as before.
+ *
  * NO-OP POLICY: every unsupported client event or backend gap renders as a
  * LOUD `error` server event (or a close) — never a silently ignored frame.
  */
@@ -398,7 +453,10 @@ declare class OpenAIRealtimeConnection<S = unknown> {
     constructor(opts: {
         ws: WebSocket;
         binding: RealtimeBinding<S>;
-        onClosed?: (conn: OpenAIRealtimeConnection<S>) => void;
+        /** Fired once at teardown, with the reason (the surface's structured close log rides it). */
+        onClosed?: (conn: OpenAIRealtimeConnection<S>, info: {
+            reason: string;
+        }) => void;
     });
     /**
      * Consume the backend's OWN turn/transcript lane (§5 stt stream): the
@@ -428,7 +486,9 @@ declare class OpenAIRealtimeConnection<S = unknown> {
      * The upstream turn seam, normalized: a binding carries EITHER
      * `session.sendResponseCreate(params, input, requestId)` (direct
      * SdkTransport-style) OR `clients.createResponse(params)` (the canonical
-     * ProxyClients seam the shared conversation factory hands out). A binding
+     * ProxyClients seam SHAPE — the shared binding composition hands out a
+     * PINNED view whose call dials `createResponseOn(handle, …)` on the ONE
+     * pooled session the audio bridge rides, ENG-446). A binding
      * with neither was already rejected at upgrade time; this is the loud
      * backstop. The ProxyClients seam is PROMISE-VALUED
      * (`rehomingCreateResponse` dials inside an async function — its
@@ -474,6 +534,45 @@ declare class OpenAIRealtimeConnection<S = unknown> {
      */
     private doneResponse;
     private upstreamErrorBody;
+    /**
+     * THE SESSION-GONE LOUD CLOSE (ENG-446): an `error` event naming the cause
+     * (`session_gone`), then the abnormal close and teardown. The connection's
+     * audio bridge is bound to the dead/replaced session and NEVER rebinds, and
+     * the turn is never retried on another session behind the bridge's back —
+     * the only honest moves are to say why and close.
+     */
+    private failSessionGone;
+    /**
+     * Classify ONE upstream turn failure (the dial throwing, or the stream
+     * throwing mid-read) — the two outcomes are the LOUD `session_gone` close
+     * and the per-turn fault the lane always had:
+     *
+     *   - a {@link SessionGoneError} (the pool no longer holds the handle's
+     *     session, or a replacement serves under it now) closes the connection
+     *     LOUDLY, pre- or post-content alike — and post-CANCEL alike: the
+     *     bridge is orphaned either way, and a cancelled turn must never mute
+     *     a dead pinned session (round-1 review, CodeRabbit + Greptile);
+     *   - a CANCELLED turn suppresses every OTHER late fault (round-1 review):
+     *     `response.cancel` does not abort a pending dial, and the dial's
+     *     rejection settles AFTER `cancelled` was set — the lane's pre-#511
+     *     behaviour stands (`response.cancelled` from `inFlight.finally`, the
+     *     connection stays open), so a generic late fault from the settling
+     *     dial/read is swallowed here rather than closing the connection as
+     *     `session_gone`;
+     *   - a dial that dies BEFORE any client-visible content (nothing flushed)
+     *     closes the connection LOUDLY too — under the pin there is no re-home,
+     *     and keeping the connection open would leave the bridge attached to a
+     *     session that cannot serve a turn, silently mute on the next
+     *     response.create. The ONE exception is core's own BOUNDED ADMISSION
+     *     VERDICT (`SessionFailedError` never-live / create-failed — the
+     *     platform's answer about this assignment, not a death), which keeps
+     *     the per-turn failure exactly as before;
+     *   - everything else (content already flowed; the upstream answered with
+     *     an `error` EVENT, handled elsewhere) is the per-turn fault — the
+     *     connection stays open, and a later turn on the same pinned handle
+     *     decides the connection's fate.
+     */
+    private upstreamTurnFault;
     private emitUpstreamFault;
     /**
      * Cancel the in-flight response. The upstream iterator is stopped through
@@ -502,11 +601,24 @@ declare class OpenAIRealtimeConnection<S = unknown> {
  * placements) through the SAME router-backed gate seam the Images lane uses
  * (`ProxyClients.supportsAudio` — `ModelRouter.supportsAudio`). A non-audio
  * model is refused LOUDLY with a 404 before anything is opened; a voice
- * binding acquires its PRIVATE audio bridge from `ProxyClients.openAudio`
- * (the pooled session's native `audio` lane at 24 kHz — the ONE canonical
- * session-audio wiring, `transport/media.ts` AUDIO_STREAM). There is no env-var
- * switch and no chat-default fall-through: an absent model resolves through
- * the router exactly like every other lane, and a chat default is refused
+ * binding rides ONE pooled-session identity for BOTH of its legs (ENG-446,
+ * the speech lane's #500 pin applied to the realtime lane): the connection
+ * resolves its pooled session ONCE (`ProxyClients.sessionHandle` — the same
+ * handle seam the speech lane pins its collector and turn with, here naming
+ * the INTERACTIVE pooled slot), opens its PRIVATE audio bridge on that exact
+ * handle (`openAudioOn(handle, signal)` — the pinned open), and drives every
+ * turn on the SAME handle (`createResponseOn(handle, …)`, threaded through
+ * the binding's `clients` view). The unpinned shape — the bridge via
+ * `openAudio(model)`, turns via the re-homing `createResponse` — let each leg
+ * resolve its OWN pooled session, so a dial that died before client-visible
+ * content re-homed the turn onto a REPLACEMENT session while the bridge
+ * stayed attached to the evicted one: the turn's audio was delivered to a
+ * session the client was not attached to, or a concurrent bridge on the
+ * replacement received another caller's audio. Behind the pin, a dead or
+ * replaced session is the connection's LOUD `session_gone` close
+ * (connection.ts), never a retry across sessions. There is no env-var switch
+ * and no chat-default fall-through: an absent model resolves through the
+ * router exactly like every other lane, and a chat default is refused
  * exactly like an explicitly named chat model.
  *
  * Used by BOTH compositions — the local `urun compat proxy` (fixed clients,
@@ -528,10 +640,15 @@ declare function realtimeModelOf(req: IncomingMessage): string | undefined;
  *   - {@link UnknownModelError} ⇒ 404 with the router's own loud message.
  *   - A non-audio verdict ⇒ 404 — the realtime lane never falls through to
  *     the chat lane, in either direction.
- *   - A voice verdict with no `openAudio` seam ⇒ 501 (a voice binding cannot
- *     be served without its bridge; a voiceless downgrade is never silent).
+ *   - A voice verdict with no `openAudioOn` seam ⇒ 501 (a voice binding cannot
+ *     be served without its pinned bridge; a voiceless downgrade is never
+ *     silent).
+ *   - ONE pooled-session identity for the bridge AND every turn
+ *     (`sessionHandle` once → `openAudioOn(handle, signal)` +
+ *     `createResponseOn(handle, …)`), so no turn on this connection can ever
+ *     resolve a different pooled session than the bridge.
  */
-declare function realtimeBindingFor(clients: Pick<ProxyClients, 'createResponse'> & Partial<Pick<ProxyClients, 'supportsAudio' | 'openAudio'>>, model: string | undefined): Promise<RealtimeBinding<ProxyClients>>;
+declare function realtimeBindingFor(clients: Pick<ProxyClients, 'sessionHandle' | 'createResponseOn'> & Partial<Pick<ProxyClients, 'supportsAudio' | 'openAudioOn'>>, model: string | undefined, signal?: AbortSignal): Promise<RealtimeBinding<ProxyClients>>;
 /**
  * The LOCAL lane resolver: fixed pooled clients, optional fixed apiKey (the
  * same shared-secret rule the local Gemini Live lane applies — a mismatched
@@ -541,7 +658,7 @@ declare function realtimeBindingFor(clients: Pick<ProxyClients, 'createResponse'
  * {@link realtimeBindingFor} for the binding itself.
  */
 declare function fixedClientsResolver(clients: ProxyClients, apiKey?: string): {
-    resolve(req: IncomingMessage): Promise<RealtimeBinding<ProxyClients>>;
+    resolve(req: IncomingMessage, signal?: AbortSignal): Promise<RealtimeBinding<ProxyClients>>;
 };
 
 export { type GeminiLiveCall, type GeminiLiveClients, OPENAI_REALTIME_PATH, type OpenAIProxyOptions, OpenAIRealtimeConnection, type OpenAIRealtimeOptions, type OpenAIRealtimeResolver, ProxyClients, type RealtimeBinding, ResumptionRegistry, attachGeminiLive, attachOpenAIRealtime, createOpenAIProxy, fixedClientsResolver, realtimeBindingFor, realtimeModelOf, serveGeminiLiveSocket };

package/dist/proxy/index.d.ts

@@ -1,11 +1,11 @@
 import { Server, IncomingMessage } from 'node:http';
-import { f as ProxyHandlerOptions, P as ProxyClients } from '../responses-turn-Dr37N3kH.js';
-export { D as DialObserver, a as DialReport, g as ProxyIdentity, h as ProxyVideoOutLane, S as SessionGoneError, U as UnknownModelError } from '../responses-turn-Dr37N3kH.js';
-export { h as GEMINI_LIVE_PATH, V as VIDEO_OUT_SETUP_KEY } from '../translator-BCoRFaTs.js';
+import { f as ProxyHandlerOptions, P as ProxyClients } from '../responses-turn-EwxfRJJg.js';
+export { D as DialObserver, a as DialReport, g as ProxyIdentity, h as ProxyVideoOutLane, S as SessionGoneError, U as UnknownModelError } from '../responses-turn-EwxfRJJg.js';
+export { h as GEMINI_LIVE_PATH, V as VIDEO_OUT_SETUP_KEY } from '../translator-Ddd65sXR.js';
 import { WebSocket } from 'ws';
 import '../models-DUdx_Y6X.js';
-import '../video-out-IGQ4YQ-c.js';
-import '../types-lsVTbNcH.js';
+import '../video-out-Cawtm7SF.js';
+import '../types-CHPtJx6d.js';
 
 interface OpenAIProxyOptions extends ProxyHandlerOptions {
     clients: ProxyClients;
@@ -56,13 +56,13 @@ declare function serveGeminiLiveSocket(ws: WebSocket, call: GeminiLiveCall, regi
 
 declare const OPENAI_REALTIME_PATH = "/v1/realtime";
 
-type OpenAIRealtimeResolver<S = unknown> = ((req: IncomingMessage) => Promise<RealtimeBinding<S>>) | {
-    resolve(req: IncomingMessage): Promise<RealtimeBinding<S>>;
+type OpenAIRealtimeResolver<S = unknown> = ((req: IncomingMessage, signal?: AbortSignal) => Promise<RealtimeBinding<S>>) | {
+    resolve(req: IncomingMessage, signal?: AbortSignal): Promise<RealtimeBinding<S>>;
 };
 interface RealtimeBinding<S = unknown> {
     
     session?: S & {
-        sendResponseCreate?(params: unknown, input: unknown[], requestId: string): AsyncIterable<unknown>;
+        sendResponseCreate?(params: unknown, input: unknown[], requestId: string): Promise<AsyncIterable<unknown>>;
     };
     clients?: Pick<ProxyClients, 'createResponse'>;
     
@@ -72,6 +72,8 @@ interface RealtimeBinding<S = unknown> {
         audio: {
             appendInputAudio(base64Pcm16: string): void;
             onOutputAudio(handler: (b64: string) => void): () => void;
+            
+            sessionId?: string | null;
         };
         
         openaiRealtimeClaims?: Set<RealtimeBinding['audioSession']>;
@@ -92,6 +94,8 @@ interface RealtimeBinding<S = unknown> {
 }
 interface OpenAIRealtimeOptions<S = unknown> {
     resolver: OpenAIRealtimeResolver<S>;
+    
+    log?: (line: string) => void;
 }
 
 declare function attachOpenAIRealtime<S = unknown>(server: Server, options: OpenAIRealtimeOptions<S>): () => Promise<void>;
@@ -130,7 +134,10 @@ declare class OpenAIRealtimeConnection<S = unknown> {
     constructor(opts: {
         ws: WebSocket;
         binding: RealtimeBinding<S>;
-        onClosed?: (conn: OpenAIRealtimeConnection<S>) => void;
+        
+        onClosed?: (conn: OpenAIRealtimeConnection<S>, info: {
+            reason: string;
+        }) => void;
     });
     
     private startTurnLane;
@@ -164,6 +171,10 @@ declare class OpenAIRealtimeConnection<S = unknown> {
     
     private doneResponse;
     private upstreamErrorBody;
+    
+    private failSessionGone;
+    
+    private upstreamTurnFault;
     private emitUpstreamFault;
     
     private cancelResponse;
@@ -177,10 +188,10 @@ declare class OpenAIRealtimeConnection<S = unknown> {
 
 declare function realtimeModelOf(req: IncomingMessage): string | undefined;
 
-declare function realtimeBindingFor(clients: Pick<ProxyClients, 'createResponse'> & Partial<Pick<ProxyClients, 'supportsAudio' | 'openAudio'>>, model: string | undefined): Promise<RealtimeBinding<ProxyClients>>;
+declare function realtimeBindingFor(clients: Pick<ProxyClients, 'sessionHandle' | 'createResponseOn'> & Partial<Pick<ProxyClients, 'supportsAudio' | 'openAudioOn'>>, model: string | undefined, signal?: AbortSignal): Promise<RealtimeBinding<ProxyClients>>;
 
 declare function fixedClientsResolver(clients: ProxyClients, apiKey?: string): {
-    resolve(req: IncomingMessage): Promise<RealtimeBinding<ProxyClients>>;
+    resolve(req: IncomingMessage, signal?: AbortSignal): Promise<RealtimeBinding<ProxyClients>>;
 };
 
 export { type GeminiLiveCall, type GeminiLiveClients, OPENAI_REALTIME_PATH, type OpenAIProxyOptions, OpenAIRealtimeConnection, type OpenAIRealtimeOptions, type OpenAIRealtimeResolver, ProxyClients, type RealtimeBinding, ResumptionRegistry, attachGeminiLive, attachOpenAIRealtime, createOpenAIProxy, fixedClientsResolver, realtimeBindingFor, realtimeModelOf, serveGeminiLiveSocket };

package/dist/proxy/index.js

@@ -1 +1 @@
-import{Q as I,a as n,b as p,c as m,f as l,g as a,h as x,i as s,j as O,k as f}from"../chunk-NY23USZF.js";import{d as r,e as i}from"../chunk-3WAJD62J.js";import{a as o,h as t}from"../chunk-7M6LY6DR.js";import"../chunk-BSHT6RZZ.js";import{c as e}from"../chunk-5CCJUNH7.js";e();export{o as GEMINI_LIVE_PATH,a as OPENAI_REALTIME_PATH,l as OpenAIRealtimeConnection,n as ResumptionRegistry,i as SessionGoneError,r as UnknownModelError,t as VIDEO_OUT_SETUP_KEY,p as attachGeminiLive,x as attachOpenAIRealtime,I as createOpenAIProxy,f as fixedClientsResolver,O as realtimeBindingFor,s as realtimeModelOf,m as serveGeminiLiveSocket};
+import{B as l,C as a,D as x,E as s,F as O,G as f,S as I,a as n,b as p,c as m}from"../chunk-WEBOBE7Z.js";import{d as r,e as i}from"../chunk-TMQJY56F.js";import{a as o,h as t}from"../chunk-3JWYIKHM.js";import"../chunk-6M5JK4YC.js";import{c as e}from"../chunk-YSFSRI3D.js";e();export{o as GEMINI_LIVE_PATH,a as OPENAI_REALTIME_PATH,l as OpenAIRealtimeConnection,n as ResumptionRegistry,i as SessionGoneError,r as UnknownModelError,t as VIDEO_OUT_SETUP_KEY,p as attachGeminiLive,x as attachOpenAIRealtime,I as createOpenAIProxy,f as fixedClientsResolver,O as realtimeBindingFor,s as realtimeModelOf,m as serveGeminiLiveSocket};