@urun-sh/openai 0.6.16 → 0.6.18

package/dist/proxy/index.d.cts

@@ -1,6 +1,6 @@
 import { Server, IncomingMessage } from 'node:http';
-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';
+import { f as ProxyHandlerOptions, P as ProxyClients } from '../responses-turn-B91w2YKn.cjs';
+export { D as DialObserver, a as DialReport, g as ProxyIdentity, h as ProxyVideoOutLane, S as SessionGoneError, U as UnknownModelError } from '../responses-turn-B91w2YKn.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';
@@ -339,6 +339,17 @@ interface RealtimeBinding<S = unknown> {
     };
     /** `model` the binding names for this conversation (overrides session config default). */
     model?: string;
+    /**
+     * The GA transcription-session intent (`?intent=transcription`): this
+     * connection is a TRANSCRIPTION session — transcription events flow
+     * without the client opting in, and `response.create` answers the loud
+     * `unsupported` error (the connection stays open) because there are no
+     * model turns to create. Set by the shared binding composition (binding.ts)
+     * only when the resolver's URL carried the intent AND the model's catalog
+     * row vouches stt (the binding carries `turns`). Absent = the realtime
+     * (voice) session, today's behaviour.
+     */
+    intent?: 'transcription';
     /** True when `session` is a resumed authorized session (vs a fresh private one). */
     resumed?: boolean;
     /**
@@ -350,8 +361,14 @@ interface RealtimeBinding<S = unknown> {
      * `turn_start` IS the native barge-in — the adapter drives server-VAD
      * emulation, real transcription events, and model-visible committed audio
      * from it. Absent = the backend wired no turn lane: manual mode only.
+     *
+     * The CONSUMER passes its own lifecycle `signal` (the realtime connection's
+     * turn-lane controller): the lane must END its stream subscription when it
+     * aborts — the transport races its pulls against it — so the subscription
+     * never outlives the consumer. A consumer that passes none gets an
+     * un-raced lane (its own teardown is then its own problem).
      */
-    turns?: () => AsyncIterable<{
+    turns?: (signal?: AbortSignal) => AsyncIterable<{
         kind: 'delta' | 'final' | 'turn_start' | 'turn_end' | 'turn_eager_end' | 'turn_resumed';
         text?: string;
         confidence?: number;
@@ -446,10 +463,39 @@ declare class OpenAIRealtimeConnection<S = unknown> {
     private closed;
     /** The backend's turn/transcript lane consumer (binding.turns), if wired. */
     private turnLaneAbort;
-    /** Accumulated transcript of the OPEN user turn (delta/final events). */
+    /**
+     * The CONSUMER-SIDE turn-lane iterator — held so teardown can end the lane
+     * subscription through the async-iterator return() protocol when it is
+     * parked at a YIELD (no pending pull for the abort to unwind; a plain
+     * for-await has no handle to close). Null once the consumer loop exits.
+     */
+    private turnLaneIterator;
+    /** Accumulated transcript of the OPEN user turn (delta/final events). The
+     * `final` flag says the engine finalized the accumulated text (its last
+     * transcript event was a `final`) — a manual commit may complete on it. */
     private turnTranscript;
     /** Transcript of the LAST committed turn (the model-visible commit). */
     private lastCommittedTranscript;
+    /**
+     * A manual transcription-session commit whose item is still awaiting the
+     * lane's final text (the item id of the committed item): interim deltas
+     * meanwhile carry THIS id, and the lane's next `final`/`turn_end`
+     * discharges exactly one `…transcription.completed` for it. No timers.
+     */
+    private pendingTranscriptItemId;
+    /**
+     * The engine turn a manual transcription-session commit ALREADY discharged
+     * (the discharged item's id): the lane's `final` completed the committed
+     * item (or the commit completed it on the lane's already-final text) while
+     * the engine's `turn_end` for THAT utterance is still to come. That
+     * `turn_end` is the boundary signal only — the server-side commit it
+     * would otherwise open mints a SECOND item for the same utterance and
+     * clears audio the client already appended for the next one. Consumed by
+     * that `turn_end` itself (one-shot); invalidated by the next `turn_start`
+     * (a new engine utterance opened — its boundary was not the discharged
+     * one).
+     */
+    private manuallyDischargedTurnItem;
     constructor(opts: {
         ws: WebSocket;
         binding: RealtimeBinding<S>;
@@ -464,8 +510,33 @@ declare class OpenAIRealtimeConnection<S = unknown> {
      * is the native barge-in, turn_end is the native commit, deltas/finals are
      * the REAL input transcription. This is the server-VAD primitive, not an
      * emulation gap: the voice engine itself decides turn boundaries.
+     *
+     * TEARDOWN ENDS THE SUBSCRIPTION FROM EVERY PARKING STATE, which a plain
+     * `for await` cannot do (its `break` only runs after the next event — a
+     * quiet engine parks the pull forever, and a `return()` enqueued behind a
+     * pending `next()` waits for it to settle):
+     *   - the `abort` threaded into `turns()` unwinds a PENDING pull (the
+     *     transport races its `messages()` pulls against it);
+     *   - the HELD consumer iterator's `return()` (teardown) closes a lane
+     *     parked at a YIELD with no pending pull.
      */
     private startTurnLane;
+    /** True when this connection IS a transcription session (the GA verdict:
+     * the binding's `?intent=transcription`, or the client's own
+     * `session.type: "transcription"` — the latter only accepted behind a
+     * turns lane, so a transcription session always has a transcript source). */
+    private isTranscriptionSession;
+    /** True when input-transcription events flow: the client opted in on a
+     * voice session, or ALWAYS on a transcription session (no opt-in needed). */
+    private transcriptionEventsOn;
+    /**
+     * Discharge a pending manual transcription commit: the ONE
+     * `…transcription.completed` for the committed item, carrying the text the
+     * lane delivered for its audio, and a reset shared accumulator (the
+     * utterance is client-delivered; the next utterance starts clean). The
+     * lane's own boundary events drive this — no timers anywhere.
+     */
+    private completePendingTranscription;
     /** One backend turn/transcript event → REAL GA protocol events. */
     private onTurnEvent;
     /** The committed turn's transcript, consumed once (null = none). */
@@ -647,8 +718,21 @@ declare function realtimeModelOf(req: IncomingMessage): string | undefined;
  *     (`sessionHandle` once → `openAudioOn(handle, signal)` +
  *     `createResponseOn(handle, …)`), so no turn on this connection can ever
  *     resolve a different pooled session than the bridge.
+ *   - An stt verdict (the catalog `task` gate `supportsTranscription`, the
+ *     SAME router-backed oracle the /v1/audio/transcriptions lane rides) with
+ *     no `openTurnsOn` seam ⇒ 501 — a transcription-capable binding without
+ *     its transcript source is never wired silently. A row that OVERRIDES
+ *     the platform's default transcript stream (`engine_args.transcript_stream`,
+ *     resolved through `transcriptStreamFor` when the seam is wired) is the
+ *     same-shape 501 — the lane never listens on a stream the engine does
+ *     not write.
+ *   - `?intent=transcription` on anything but an stt row ⇒ 400 naming the
+ *     model; any other intent value ⇒ 400 naming the accepted values. Every
+ *     refusal lands BEFORE the pooled session is resolved (`sessionHandle`)
+ *     and the bridge opens — a refused upgrade admits nothing. On an stt row
+ *     the intent is recorded on the binding (a transcription session).
  */
-declare function realtimeBindingFor(clients: Pick<ProxyClients, 'sessionHandle' | 'createResponseOn'> & Partial<Pick<ProxyClients, 'supportsAudio' | 'openAudioOn'>>, model: string | undefined, signal?: AbortSignal): Promise<RealtimeBinding<ProxyClients>>;
+declare function realtimeBindingFor(clients: Pick<ProxyClients, 'sessionHandle' | 'createResponseOn'> & Partial<Pick<ProxyClients, 'supportsAudio' | 'openAudioOn' | 'supportsTranscription' | 'openTurnsOn' | 'transcriptStreamFor'>>, model: string | undefined, signal?: AbortSignal, intent?: string): 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

package/dist/proxy/index.d.ts

@@ -1,6 +1,6 @@
 import { Server, IncomingMessage } from 'node:http';
-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';
+import { f as ProxyHandlerOptions, P as ProxyClients } from '../responses-turn-FcEDaymF.js';
+export { D as DialObserver, a as DialReport, g as ProxyIdentity, h as ProxyVideoOutLane, S as SessionGoneError, U as UnknownModelError } from '../responses-turn-FcEDaymF.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';
@@ -81,9 +81,11 @@ interface RealtimeBinding<S = unknown> {
     
     model?: string;
     
+    intent?: 'transcription';
+    
     resumed?: boolean;
     
-    turns?: () => AsyncIterable<{
+    turns?: (signal?: AbortSignal) => AsyncIterable<{
         kind: 'delta' | 'final' | 'turn_start' | 'turn_end' | 'turn_eager_end' | 'turn_resumed';
         text?: string;
         confidence?: number;
@@ -128,9 +130,15 @@ declare class OpenAIRealtimeConnection<S = unknown> {
     
     private turnLaneAbort;
     
+    private turnLaneIterator;
+    
     private turnTranscript;
     
     private lastCommittedTranscript;
+    
+    private pendingTranscriptItemId;
+    
+    private manuallyDischargedTurnItem;
     constructor(opts: {
         ws: WebSocket;
         binding: RealtimeBinding<S>;
@@ -142,6 +150,12 @@ declare class OpenAIRealtimeConnection<S = unknown> {
     
     private startTurnLane;
     
+    private isTranscriptionSession;
+    
+    private transcriptionEventsOn;
+    
+    private completePendingTranscription;
+    
     private onTurnEvent;
     
     private takeTurnTranscript;
@@ -188,7 +202,7 @@ declare class OpenAIRealtimeConnection<S = unknown> {
 
 declare function realtimeModelOf(req: IncomingMessage): string | undefined;
 
-declare function realtimeBindingFor(clients: Pick<ProxyClients, 'sessionHandle' | 'createResponseOn'> & Partial<Pick<ProxyClients, 'supportsAudio' | 'openAudioOn'>>, model: string | undefined, signal?: AbortSignal): Promise<RealtimeBinding<ProxyClients>>;
+declare function realtimeBindingFor(clients: Pick<ProxyClients, 'sessionHandle' | 'createResponseOn'> & Partial<Pick<ProxyClients, 'supportsAudio' | 'openAudioOn' | 'supportsTranscription' | 'openTurnsOn' | 'transcriptStreamFor'>>, model: string | undefined, signal?: AbortSignal, intent?: string): Promise<RealtimeBinding<ProxyClients>>;
 
 declare function fixedClientsResolver(clients: ProxyClients, apiKey?: string): {
     resolve(req: IncomingMessage, signal?: AbortSignal): Promise<RealtimeBinding<ProxyClients>>;

package/dist/proxy/index.js

@@ -1 +1 @@
-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-2PIYH7O7.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};
+import{B as l,C as a,D as x,E as s,G as O,H as f,T as I,a as n,b as p,c as m}from"../chunk-3U7YQ7LE.js";import{f as r,g as i}from"../chunk-NYSZ3RGB.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};

package/dist/{responses-turn-vMefRdgJ.d.cts → responses-turn-B91w2YKn.d.cts}

@@ -151,6 +151,8 @@ interface InferenceRecord {
     readonly prompt_tokens: number | null;
     readonly completion_tokens: number | null;
     readonly output_units: number | null;
+    /** THE OUTPUT-MINUTE QUANTITY — see {@link InferenceTurn.outputMinutes}. */
+    readonly output_minutes: number | null;
     /**
      * THE INSTANCE that served this request — see
      * {@link InferenceTurn.sessionId}. On the log line as well as the ledger,
@@ -379,7 +381,8 @@ interface ModelPriceRow {
 }
 
 /**
- * THE OPENROUTER PROVIDER DOCUMENT — `GET /v1/models?format=openrouter`.
+ * THE OPENROUTER PROVIDER DOCUMENT — `GET /partners/openrouter/models`
+ * (`GET /v1/models?format=openrouter` answers 308 here for one release).
  *
  * OpenRouter's provider monitor polls this document (schema 2.4, per
  * openrouter.ai/docs/guides/community/for-providers §1) to list a provider's
@@ -608,28 +611,30 @@ declare class UnknownModelError extends Error {
 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.
+ * One `/v1/models` row — a CLOSED allow-list of externally contracted keys
+ * (owner ruling, ENG-472: publish what an external contract names, never the
+ * implementation). The four OpenAI `Model` fields, plus — only when known —
+ * the Hugging Face pair (`context_length`, `pricing`), the TTS `voices` and
+ * the `capabilities` object. `name`, `description`, `task`, `engine`,
+ * `gpu_spec` and `warm` are GONE from the type so they cannot be set; every
+ * row builder goes through `publicModelEntry` (openrouter-doc.ts), which
+ * copies exactly these keys.
  */
 interface RouterModelEntry {
+    /** OpenAI `Model`: the model identifier callers reference in the API. */
     id: string;
+    /** OpenAI `Model`: always "model". */
     object: 'model';
+    /** OpenAI `Model`: the Unix time the model id first appeared in the uRun catalog (0 until the catalog carries it). */
     created: number;
+    /** OpenAI `Model`: the organization that owns the model. */
     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). */
+    /**
+     * Hugging Face provider comparison table — its top-level `context_length`
+     * read (HF also gates `:fastest`/`:cheapest` on it). Only when the catalog
+     * states it and the placements agree (openrouter-doc.ts
+     * `placementsContextLength`).
+     */
     context_length?: number;
     /**
      * Per-token price, USD per MILLION tokens — the exact shape Hugging Face
@@ -639,8 +644,6 @@ interface RouterModelEntry {
      * a zero or an estimate here would be a silent lie on a public table.
      */
     pricing?: TokenPricing;
-    /** Idle-floor replica count for a shared-lane model (U6 reconciler). */
-    warm?: number;
     /**
      * The voices a `tts`-task model synthesizes under (ENG-331 — OpenAI's
      * speech API names a voice per request, so a caller needs the list).
@@ -662,7 +665,7 @@ interface RouterModelEntry {
      * whose placements disagree, a malformed value, or a slug with no catalog
      * row omit the object entirely — unknown, never guessed
      * (openrouter-doc.ts `placementsReasoning`, applied by both listing
-     * lanes).
+     * lanes). The conformance kit's voice_profile check reads it.
      */
     capabilities?: {
         reasoning: boolean;
@@ -672,10 +675,11 @@ interface RouterModelList {
     object: 'list';
     data: RouterModelEntry[];
 }
-/** One `/v1/images/models` entry: the OpenAI model object plus the image
+/** One `/v1/images/models` entry: the allow-listed model row plus the image
  * modes the catalog rows vouch for (the SAME per-placement consensus
  * {@link ModelRouter.supportsImages} applies — a row set that vouches
- * nothing is NOT listed). */
+ * nothing is NOT listed). `image_modes` is allow-listed for THIS listing
+ * only (publicModelEntry's image overload). */
 interface RouterImageModelEntry extends RouterModelEntry {
     image_modes: ImageCapabilityMode[];
 }
@@ -1100,7 +1104,8 @@ declare class ModelRouter<S> {
      */
     modelList(): Promise<RouterModelList>;
     /**
-     * The OpenRouter PROVIDER document (`GET /v1/models?format=openrouter`):
+     * The OpenRouter PROVIDER document (`GET /partners/openrouter/models`;
+     * `GET /v1/models?format=openrouter` 308-redirects there for one release):
      * schema 2.4 per openrouter.ai/docs/guides/community/for-providers §1 —
      * "an endpoint that returns all models that should be served by
      * OpenRouter". That is the SHARED block's sellable endpoints (the models
@@ -1216,6 +1221,25 @@ declare class ModelRouter<S> {
      * an infrastructure outage.
      */
     supportsTranscription(model: string | undefined): Promise<boolean>;
+    /**
+     * THE REALTIME TRANSCRIPTION LANE'S STREAM-NAME RESOLUTION (openai-realtime
+     * binding.ts, ENG-461): the §5 stream the model's engine emits its own
+     * transcript events on — `engine_args.transcript_stream`, defaulting to
+     * the platform's {@link STT_TRANSCRIPT_STREAM} when no row carries the
+     * field, over the SAME catalog join {@link supportsTranscription} uses
+     * (exact `(model_id, variant)` for a shared-lane hit,
+     * {@link catalogRowsForSlug} for a caller-org app). Deliberately NOT
+     * task-gated: the binding consults it only behind a `transcribes` verdict,
+     * and the resolution itself is a pure field consensus. The lane's consume
+     * side reads the PLATFORM DEFAULT only — a row that OVERRIDES the default
+     * is the binding's loud 501 naming the field, never a silent listen on a
+     * stream the engine does not write; a catalog that cannot vow ONE name
+     * (disagreeing placements, a non-string or empty value) is the loud
+     * defect, never a guess. Undeployed uRun-namespace models throw
+     * {@link UnknownModelError}, and a CONFIGURED catalog oracle that FAILS
+     * propagates — never a fabricated default.
+     */
+    transcriptStreamFor(model: string | undefined): Promise<string>;
     /**
      * THE SPEECH LANE'S VOICE-SET RESOLUTION (proxy/speech.ts): the voice set
      * `/v1/models` publishes for `model` — resolved by the SAME resolver the
@@ -1266,6 +1290,43 @@ declare class ModelRouter<S> {
     closeAll(): Promise<void>;
 }
 
+/**
+ * THE TURN/TRANSCRIPT LANE over the named §5 `stt` data stream — the
+ * engine's OWN transcript source for the OpenAI Realtime transcription
+ * intent (ENG-461).
+ *
+ * The delivery path is the platform's existing one (urun-python
+ * `urun.serve.transcribe_bridge`): the streaming STT engine emits its own
+ * transcript events on the session-scoped named stream {@link
+ * STT_TRANSCRIPT_STREAM} — the SAME §5 named-DATA mechanism the text-lane
+ * token deltas ride, in the text lane's own wire shape (`{"t": kind,
+ * "delta": text, "start_ms": int}`). Nothing here invents a framing: the
+ * lane is `session.stream('stt').messages()` (core `SessionStream.messages`,
+ * contract §5 — the downstream twin of the `emit` produce seam), and this
+ * module only DECODES each payload onto the `RealtimeBinding.turns` event
+ * shape the realtime adapter already consumes.
+ *
+ * `confidence` in the wire payload is SEMANTIC END-OF-TURN confidence (the
+ * engine's own VAD verdict that the user finished speaking), NOT
+ * transcription confidence — carrying it onto the GA surface would
+ * misrepresent it, so the decoder DROPS it by design (the adapter reads the
+ * boundary from `turn_end`, which is the same verdict as an event).
+ */
+
+/** The turn kinds the transcribe bridge emits (TranscriptEvent kinds). */
+type SessionTurnKind = 'delta' | 'final' | 'turn_start' | 'turn_end' | 'turn_eager_end' | 'turn_resumed';
+/**
+ * One decoded transcript-lane event — the `RealtimeBinding.turns` event
+ * shape. `text` is the wire `delta` field (a transcript PIECE — the adapter
+ * accumulates), `startMs` the additive `start_ms` clock. The wire
+ * `confidence` (semantic end-of-turn confidence) is deliberately absent.
+ */
+interface SessionTurnLaneEvent {
+    kind: SessionTurnKind;
+    text?: string;
+    startMs?: number;
+}
+
 /** One ready replica row from the presence read. */
 interface RuntimePresenceRow {
     runtime_id: string;
@@ -1485,6 +1546,13 @@ interface InferenceUsageRecord {
     prompt_tokens: number | null;
     completion_tokens: number | null;
     output_units: number | null;
+    /**
+     * THE OUTPUT-MINUTE QUANTITY — a text-to-speech row's delivered audio
+     * duration in minutes, the quantity its `per_output_minute` price reads.
+     * null = this modality has no such quantity (a token lane, an unmeasured
+     * TTS answer) — never "zero of it".
+     */
+    output_minutes: number | null;
     /** NULL = NOT YET PRICED (ENG-317). Never "free". */
     cost_nano_usd: number | null;
     price_version: string | null;
@@ -1661,6 +1729,17 @@ interface LedgerWrite {
     prompt_tokens: number | null;
     completion_tokens: number | null;
     output_units: number | null;
+    /**
+     * THE OUTPUT-MINUTE QUANTITY — the delivered audio duration of a
+     * text-to-speech answer, in minutes, carried from the record
+     * ({@link InferenceRecord.output_minutes}). The control plane prices a
+     * `per_output_minute` task from THIS field; `output_units` stays the
+     * per-image/per-clip quantity. NULL = the request has no such quantity —
+     * a discarded answer, or a lane that never measured one. NEVER zero of it,
+     * and never coerced: an unmeasured TTS row is written unpriced
+     * (`output_minutes_absent`), not at a billed zero.
+     */
+    output_minutes: number | null;
     /**
      * THE WEIGHT (ENG-417) — the serve runtime's own residency in whole
      * milliseconds. An allocation input, never GPU time and never a cost. NULL
@@ -1736,7 +1815,8 @@ interface LedgerRecorded {
      * Why the row carries no price, or null when it is priced. One of
      * `not_a_catalog_model` | `outcome_not_billable` | `http_status_not_success`
      * | `task_unit_undeclared` | `task_not_token_billed` | `token_counts_absent`
-     * | `no_active_price` | `no_active_input_price` | `no_active_output_price`.
+     * | `output_minutes_absent` | `no_active_price` | `no_active_input_price` |
+     * `no_active_output_price`.
      * It is a NORMAL answer, not an error: no PER-TOKEN rate has been seeded
      * yet, so this lane has nothing to price with. (Not "the price book is
      * empty" — `model_prices` has carried live `per_minute` rows since
@@ -2085,9 +2165,10 @@ interface ProxyClients {
     /** `listModels(...)` result (an OpenAI model list object). */
     listModels(): Promise<unknown>;
     /**
-     * The OpenRouter provider document (`GET /v1/models?format=openrouter`).
+     * The OpenRouter provider document (`GET /partners/openrouter/models`; the
+     * old `GET /v1/models?format=openrouter` spelling 308-redirects there).
      * 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.
+     * that route answers 501 — loud, never a silent empty.
      */
     openRouterModels?(): Promise<unknown>;
     /**
@@ -2265,6 +2346,46 @@ interface ProxyClients {
       * queued admission going back only at the LAST waiter's abort.
       */
     openAudioOn?(handle: string, signal?: AbortSignal): Promise<PinnedAudioLane>;
+    /**
+     * THE TURN/TRANSCRIPT LANE OPEN (the realtime transcription intent,
+     * ENG-461): the STT engine's OWN transcript events — the §5 `stt` named
+     * data stream (urun.serve.transcribe_bridge's wire shape: `t` =
+     * delta/final/turn_start/turn_end/turn_eager_end/turn_resumed, `delta`
+     * text pieces, additive `start_ms`), consumed off the EXACT pooled session
+     * the handle names (ModelRouter.sessionForHandle — a gone or replaced
+     * session throws {@link SessionGoneError} LOUDLY, never a fresh session
+     * opened behind the handle's back) and decoded onto the
+     * `RealtimeBinding.turns` event shape (the wire's semantic-VAD
+     * `confidence` is end-of-turn confidence, NOT transcription confidence —
+     * the lane deliberately does not carry it). One lane per call; the
+     * realtime binding calls it once per connection. The returned iterable is
+     * lazy. `signal` is the CONSUMER's own lifecycle (the realtime
+     * connection's turn-lane controller, aborted at its teardown): the
+     * transport races every `messages()` pull against it and ends the stream
+     * subscription on every exit path, so the lane never outlives its
+     * consumer — a quiet engine cannot pin it open behind a never-settling
+     * pull. Optional at the seam exactly like
+     * {@link openAudioOn}: the binding's stt verdict answers its absence with
+     * the loud 501 — never a transcription-capable binding with no transcript
+     * source. An already-aborted signal rejects on the first pull — never
+     * opens a lane for a vanished consumer.
+     */
+    openTurnsOn?(handle: string, signal?: AbortSignal): AsyncIterable<SessionTurnLaneEvent>;
+    /**
+     * THE REALTIME TRANSCRIPTION LANE'S STREAM-NAME RESOLUTION (openai-realtime
+     * binding.ts): the §5 transcript stream the model's catalog rows vow
+     * (ModelRouter.transcriptStreamFor — `engine_args.transcript_stream`,
+     * defaulting to the platform's `stt`). The lane's consume side reads the
+     * platform DEFAULT stream name only, so the binding answers a row that
+     * OVERRIDES the default with the loud 501 naming the field — never a
+     * silent listen on a stream the engine does not write, and never a
+     * transcript-less transcription session. Optional at the seam exactly
+     * like {@link supportsTranscription}: hand-built clients own their own
+     * lane (their `openTurnsOn` decides what to read — no catalog row exists
+     * to check), so its absence skips the catalog check; every router-backed
+     * backhaul wires it.
+     */
+    transcriptStreamFor?(model: string | undefined): Promise<string>;
     /**
      * Open (or reuse) the NATIVE video FRAME lane on the pooled session `model`
      * routes to (transport/media.ts `enableSessionVideo`: discrete JPEG frames →

package/dist/{responses-turn-EwxfRJJg.d.ts → responses-turn-FcEDaymF.d.ts}

@@ -51,6 +51,8 @@ interface InferenceRecord {
     readonly completion_tokens: number | null;
     readonly output_units: number | null;
     
+    readonly output_minutes: number | null;
+    
     readonly session_id: string | null;
     
     readonly queue_ms: number | null;
@@ -176,27 +178,19 @@ declare class SessionGoneError extends Error {
 }
 
 interface RouterModelEntry {
-    id: string;
-    object: 'model';
-    created: number;
-    owned_by: string;
     
-    name?: string;
-    
-    description?: string;
+    id: string;
     
-    task?: string;
+    object: 'model';
     
-    engine?: string;
+    created: number;
     
-    gpu_spec?: string;
+    owned_by: string;
     
     context_length?: number;
     
     pricing?: TokenPricing;
     
-    warm?: number;
-    
     voices?: string[];
     
     capabilities?: {
@@ -344,6 +338,8 @@ declare class ModelRouter<S> {
     
     supportsTranscription(model: string | undefined): Promise<boolean>;
     
+    transcriptStreamFor(model: string | undefined): Promise<string>;
+    
     speechVoices(model: string | undefined): Promise<SpeechVoicesResolution>;
     
     imageModelList(): Promise<RouterImageModelList>;
@@ -353,6 +349,14 @@ declare class ModelRouter<S> {
     closeAll(): Promise<void>;
 }
 
+type SessionTurnKind = 'delta' | 'final' | 'turn_start' | 'turn_end' | 'turn_eager_end' | 'turn_resumed';
+
+interface SessionTurnLaneEvent {
+    kind: SessionTurnKind;
+    text?: string;
+    startMs?: number;
+}
+
 interface RuntimePresenceRow {
     runtime_id: string;
     
@@ -438,6 +442,8 @@ interface InferenceUsageRecord {
     completion_tokens: number | null;
     output_units: number | null;
     
+    output_minutes: number | null;
+    
     cost_nano_usd: number | null;
     price_version: string | null;
     priced_at: string | null;
@@ -480,6 +486,8 @@ interface LedgerWrite {
     completion_tokens: number | null;
     output_units: number | null;
     
+    output_minutes: number | null;
+    
     queue_ms: number | null;
     prefill_ms: number | null;
     decode_ms: number | null;
@@ -609,6 +617,10 @@ interface ProxyClients {
     
     openAudioOn?(handle: string, signal?: AbortSignal): Promise<PinnedAudioLane>;
     
+    openTurnsOn?(handle: string, signal?: AbortSignal): AsyncIterable<SessionTurnLaneEvent>;
+    
+    transcriptStreamFor?(model: string | undefined): Promise<string>;
+    
     openVideo?(model: string | undefined): Promise<ProxyVideoLane>;
     
     openVideoOut?(model: string | undefined): Promise<ProxyVideoOutLane>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@urun-sh/openai",
-  "version": "0.6.16",
+  "version": "0.6.18",
   "description": "OpenAI-compatible Realtime + Responses SDK over uRun session primitives (not websockets).",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -70,7 +70,7 @@
     "build:bin": "bun build --compile --external @roamhq/wrtc src/proxy/bin.ts --outfile dist/bin/urun-openai && node scripts/assert-bin-transport.mjs"
   },
   "peerDependencies": {
-    "@urun-sh/core": "^0.6.16"
+    "@urun-sh/core": "^0.6.18"
   },
   "dependencies": {
     "@prometheus-io/client": "^0.16.1",