@urun-sh/openai 0.5.6 → 0.6.0

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-BfdBbey8.cjs';
+export { D as DialObserver, a as DialReport, g as ProxyIdentity, h as ProxyVideoOutLane, S as SessionGoneError, U as UnknownModelError } from '../responses-turn-BfdBbey8.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
+ * `openAudio` 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> {
     /**
@@ -291,7 +306,7 @@ interface RealtimeBinding<S = unknown> {
      * 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 +320,15 @@ interface RealtimeBinding<S = unknown> {
         audio: {
             appendInputAudio(base64Pcm16: string): void;
             onOutputAudio(handler: (b64: string) => void): () => void;
+            /**
+             * The pooled uRun session this lane rides (backhaul `openAudio` 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 +364,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
@@ -398,7 +433,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
@@ -531,7 +569,7 @@ declare function realtimeModelOf(req: IncomingMessage): string | undefined;
  *   - A voice verdict with no `openAudio` seam ⇒ 501 (a voice binding cannot
  *     be served without its bridge; a voiceless downgrade is never silent).
  */
-declare function realtimeBindingFor(clients: Pick<ProxyClients, 'createResponse'> & Partial<Pick<ProxyClients, 'supportsAudio' | 'openAudio'>>, model: string | undefined): Promise<RealtimeBinding<ProxyClients>>;
+declare function realtimeBindingFor(clients: Pick<ProxyClients, 'createResponse'> & Partial<Pick<ProxyClients, 'supportsAudio' | 'openAudio'>>, 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 +579,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-CdhIre_a.js';
+export { D as DialObserver, a as DialReport, g as ProxyIdentity, h as ProxyVideoOutLane, S as SessionGoneError, U as UnknownModelError } from '../responses-turn-CdhIre_a.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;
@@ -177,10 +184,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, 'createResponse'> & Partial<Pick<ProxyClients, 'supportsAudio' | 'openAudio'>>, 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-TPH77ZOW.js";import{d as r,e as i}from"../chunk-WCMX5VOF.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};