@urun-sh/openai 0.5.5 → 0.6.0

package/dist/responses-turn-CdhIre_a.d.ts

@@ -0,0 +1,652 @@
+import { C as CatalogRow } from './models-DUdx_Y6X.js';
+import { IncomingMessage } from 'node:http';
+import { a as AudioBridge, h as VideoFrameLane, j as VideoOutLane } from './video-out-Cawtm7SF.js';
+
+interface ProxyIdentity {
+    app: string;
+    org: string;
+    fn: string;
+    
+    base_url: string;
+    proxy_version: string;
+}
+
+type TurnCatalogIdentity = {
+    kind: 'catalog';
+    model_id: string;
+    variant: string;
+} | {
+    kind: 'not-a-catalog-model';
+    model: string | null;
+} | {
+    kind: 'unresolved';
+    reason: string;
+};
+
+interface DialReport {
+    
+    sessionId: string | null;
+    
+    identity: TurnCatalogIdentity;
+}
+
+type DialObserver = (dial: DialReport) => void;
+
+interface InferenceRecord {
+    readonly event: 'inference_request';
+    readonly ts: string;
+    readonly inference_id: string;
+    readonly method: string;
+    readonly path: string;
+    readonly status: number | null;
+    readonly delivered: boolean;
+    readonly stream_error: boolean;
+    readonly model: string | null;
+    readonly stream: boolean | null;
+    readonly org: string | null;
+    readonly duration_ms: number;
+    readonly ttft_ms: number | null;
+    
+    readonly prompt_tokens: number | null;
+    readonly completion_tokens: number | null;
+    readonly output_units: number | null;
+    
+    readonly session_id: string | null;
+    
+    readonly queue_ms: number | null;
+    readonly prefill_ms: number | null;
+    readonly decode_ms: number | null;
+    readonly total_ms: number | null;
+    
+    readonly catalog: TurnCatalogIdentity;
+}
+
+interface SharedEndpointRow {
+    model_id: string;
+    variant: string;
+    
+    app_slug: string;
+    
+    function: string;
+    
+    gpu_spec?: string | null;
+    
+    warm?: number | null;
+    
+    compat_default?: boolean | null;
+    
+    output_free?: boolean | null;
+    
+    ready?: boolean | null;
+    
+    ready_runtimes?: number | null;
+    
+    ready_since?: string | null;
+}
+
+interface SharedCatalogBlock {
+    shared_org_id: string;
+    endpoints: SharedEndpointRow[];
+    
+    regions?: string[] | null;
+    
+    compliance?: {
+        zdr: boolean;
+        hipaa: boolean;
+    } | null;
+}
+
+interface TokenPricing {
+    input: number;
+    output: number;
+}
+
+type Side = 'input' | 'output';
+
+interface ModelPriceRow {
+    model_id: string;
+    
+    variant: string | null;
+    side: Side;
+    
+    usd: number;
+    
+    effective_at: number;
+    
+    expires_at: number | null;
+}
+
+type OpenRouterProviderDoc = {
+    data: OpenRouterProviderModel[];
+};
+
+interface OpenRouterDatacenter {
+    country_code: string;
+    region?: string;
+}
+
+interface OpenRouterCompliance {
+    zdr: boolean;
+    hipaa: boolean;
+}
+interface OpenRouterProviderModel {
+    schema_version: '2.4';
+    
+    id: string;
+    name: string;
+    created: number;
+    
+    quantization: string | null;
+    
+    tokenizer?: string;
+    description: string;
+    hugging_face_id: string;
+    
+    is_ready: boolean;
+    
+    is_free: boolean;
+    input_modalities: Array<Record<string, unknown>>;
+    output_modalities: Array<Record<string, unknown>>;
+    
+    datacenters?: OpenRouterDatacenter[];
+    
+    compliance?: OpenRouterCompliance;
+}
+
+interface SpeechVoicesResolution {
+    
+    readonly published: readonly string[];
+    
+    readonly defect: string | null;
+}
+
+interface DeployedApp {
+    app_slug: string;
+    
+    function_name?: string | null;
+    
+    serves?: string | null;
+    deployment_status?: string | null;
+}
+
+declare class UnknownModelError extends Error {
+}
+
+declare class SessionGoneError extends Error {
+}
+
+interface RouterModelEntry {
+    id: string;
+    object: 'model';
+    created: number;
+    owned_by: string;
+    
+    name?: string;
+    
+    description?: string;
+    
+    task?: string;
+    
+    engine?: string;
+    
+    gpu_spec?: string;
+    
+    context_length?: number;
+    
+    pricing?: TokenPricing;
+    
+    warm?: number;
+    
+    voices?: string[];
+}
+interface RouterModelList {
+    object: 'list';
+    data: RouterModelEntry[];
+}
+
+interface RouterImageModelEntry extends RouterModelEntry {
+    image_modes: ImageCapabilityMode[];
+}
+interface RouterImageModelList {
+    object: 'list';
+    data: RouterImageModelEntry[];
+}
+
+interface RouteTarget {
+    appSlug: string;
+    
+    fnName?: string;
+    
+    sharedApp?: boolean;
+    
+    modelId?: string;
+    
+    variant?: string;
+    
+    sharedOrgId?: string;
+}
+interface ModelRouterOptions<S> {
+    
+    defaultApp: string | null;
+    
+    fnName: string;
+    
+    openSession: (target: RouteTarget, poolKey: string) => S | Promise<S>;
+    
+    closeSession: (entry: S) => Promise<void>;
+    
+    listApps: (() => Promise<DeployedApp[]>) | null;
+    
+    listCatalog: (() => Promise<CatalogRow[]>) | null;
+    
+    listPrices: (() => Promise<ModelPriceRow[]>) | null;
+    
+    warn?: (line: string) => void;
+    
+    appsTtlMs?: number;
+    
+    sessionKey?: (entry: S) => string;
+    
+    shared?: (() => Promise<SharedCatalogBlock | null>) | null;
+    
+    sharedOnlyListing?: boolean;
+}
+
+type ImageCapabilityMode = 'generation' | 'edit';
+
+declare class ModelRouter<S> {
+    private readonly opts;
+    private readonly pool;
+    private appsCache;
+    private rowsCache;
+    constructor(opts: ModelRouterOptions<S>);
+    
+    seed(appSlug: string, entry: S): void;
+    private deployedApps;
+    
+    private sharedBlock;
+    private sharedCache;
+    
+    private catalogRows;
+    private pricesCache;
+    
+    private priceRows;
+    
+    private pricesForListing;
+    
+    private outputFreeKeys;
+    
+    private warn;
+    
+    private servable;
+    private availableIds;
+    
+    private noDefaultApp;
+    
+    private resolveTarget;
+    
+    catalogIdentityFor(model: string | undefined): Promise<{
+        model_id: string;
+        variant: string;
+    } | null>;
+    
+    servingAppSlugFor(model: string | undefined): Promise<string>;
+    
+    targetFor(model: string | undefined): Promise<RouteTarget>;
+    
+    resolveApp(model: string | undefined): Promise<string>;
+    
+    sessionFor(model: string | undefined): Promise<{
+        app: string;
+        entry: S;
+        identity: TurnCatalogIdentity;
+    }>;
+    
+    speechSessionFor(model: string | undefined): Promise<{
+        app: string;
+        entry: S;
+        identity: TurnCatalogIdentity;
+    }>;
+    
+    private acquire;
+    private keyOf;
+    
+    handleFor(model: string | undefined): Promise<{
+        app: string;
+        handle: string;
+    }>;
+    
+    speechHandleFor(model: string | undefined): Promise<{
+        app: string;
+        handle: string;
+    }>;
+    
+    sessionForHandle(handle: string): Promise<{
+        app: string;
+        entry: S;
+    }>;
+    
+    evict(app: string, entry: S): Promise<void>;
+    
+    modelList(): Promise<RouterModelList>;
+    
+    openRouterModels(): Promise<OpenRouterProviderDoc>;
+    
+    supportsImages(model: string | undefined, mode: ImageCapabilityMode): Promise<boolean>;
+    
+    supportsAudio(model: string | undefined): Promise<boolean>;
+    
+    supportsSpeech(model: string | undefined): Promise<boolean>;
+    
+    speechVoices(model: string | undefined): Promise<SpeechVoicesResolution>;
+    
+    imageModelList(): Promise<RouterImageModelList>;
+    
+    closeAll(): Promise<void>;
+}
+
+interface RuntimePresenceRow {
+    runtime_id: string;
+    
+    address: string;
+    ready: boolean;
+    
+    last_seen: string;
+    status?: string | null;
+}
+
+interface DialTarget {
+    appSlug: string;
+    fnName?: string;
+    sharedApp?: boolean;
+    modelId?: string;
+    variant?: string;
+    sharedOrgId?: string;
+}
+interface StatelessDecisionDialOptions {
+    
+    targetFor: (model: string | undefined) => Promise<DialTarget>;
+    apiUrl: string;
+    apiKey: string;
+    
+    orgId: string;
+    
+    fnName: string;
+    
+    secret: string;
+    
+    shared?: {
+        apiKey: string;
+    };
+    fetchImpl?: typeof fetch;
+    nowMs?: () => number;
+    
+    timeoutMs?: number;
+}
+
+declare class StatelessDecisionDial {
+    private readonly opts;
+    private readonly replicas;
+    private readonly nowMs;
+    
+    private readonly presenceCache;
+    constructor(opts: StatelessDecisionDialOptions);
+    
+    get enabled(): boolean;
+    
+    targetFor(model: string | undefined): Promise<DialTarget | null>;
+    
+    decide(body: Record<string, unknown>, model: string | undefined): Promise<{
+        status: number;
+        body: unknown;
+        completed: unknown;
+        target: DialTarget & {
+            fnName: string;
+        };
+    }>;
+    
+    private ensureRows;
+    private readPresence;
+    
+    pick(rows: RuntimePresenceRow[]): string | null;
+    private post;
+}
+
+interface InferenceUsageRecord {
+    
+    inference_id: string;
+    
+    model_id: string;
+    
+    identity_kind: string;
+    
+    variant: string | null;
+    task: string;
+    http_status: number;
+    started_at: string;
+    completed_at: string;
+    
+    prompt_tokens: number | null;
+    completion_tokens: number | null;
+    output_units: number | null;
+    
+    cost_nano_usd: number | null;
+    price_version: string | null;
+    priced_at: string | null;
+}
+
+interface UsageRowRejection {
+    
+    where: string;
+    
+    reason: string;
+}
+
+type UsageRowReporter = (rejection: UsageRowRejection) => void | Promise<void>;
+
+interface UsageLane {
+    
+    authorize(req: IncomingMessage): string;
+    
+    lookup(credential: string, inferenceIds: readonly string[]): Promise<InferenceUsageRecord[]>;
+}
+
+interface LedgerWrite {
+    
+    inference_id: string;
+    
+    model_id: string;
+    
+    identity_kind: 'catalog_model' | 'caller_org_app';
+    variant: string | null;
+    task: string;
+    http_status: number;
+    started_at: string;
+    completed_at: string;
+    
+    billable_outcome: boolean;
+    
+    session_id: string | null;
+    
+    prompt_tokens: number | null;
+    completion_tokens: number | null;
+    output_units: number | null;
+    
+    queue_ms: number | null;
+    prefill_ms: number | null;
+    decode_ms: number | null;
+    total_ms: number | null;
+    
+    ttft_ms: number | null;
+    
+    e2e_ms: number | null;
+}
+
+interface LedgerRecorded {
+    inference_id: string;
+    
+    cost_nano_usd: number | null;
+    
+    price_version: string | null;
+    
+    unpriced_reason: string | null;
+}
+
+declare const LEDGER_FAILURE_REASONS: readonly ["duplicate", "duplicate_foreign", "auth", "surface", "unknown", "dwell_expired", "dropped_on_exit"];
+type LedgerFailureReason = (typeof LEDGER_FAILURE_REASONS)[number];
+
+interface LedgerFailure {
+    readonly ledgerFailureReason: LedgerFailureReason;
+}
+
+declare const LEDGER_SKIP_REASONS: readonly ["no_response_head", "no_org", "model_unresolved", "no_model_named", "queue_full"];
+type LedgerSkipReason = (typeof LEDGER_SKIP_REASONS)[number];
+
+declare const LEDGER_PRICING_STATES: readonly ["priced", "unpriced"];
+type LedgerPricingState = (typeof LEDGER_PRICING_STATES)[number];
+
+type LedgerOutcome = 
+
+{
+    outcome: 'written';
+    reason: LedgerPricingState;
+}
+
+ | {
+    outcome: 'already_written';
+    reason: LedgerPricingState;
+}
+
+ | {
+    outcome: 'skipped';
+    reason: LedgerSkipReason;
+}
+
+ | {
+    outcome: 'failed';
+    reason: LedgerFailureReason;
+};
+
+interface LedgerLane {
+    
+    write(req: IncomingMessage, entry: LedgerWrite): Promise<LedgerRecorded>;
+    
+    observe(outcome: LedgerOutcome): void;
+    
+    report?(line: string): void;
+}
+
+interface ResponsesCreateParams {
+    model?: string;
+    input: unknown;
+    stream?: boolean;
+    tools?: unknown;
+    tool_choice?: unknown;
+    temperature?: number;
+    max_output_tokens?: number;
+    
+    instructions?: string;
+    top_p?: number;
+    stop?: string[];
+    
+    reasoning_effort?: string;
+    chat_template_kwargs?: Record<string, unknown>;
+    
+    response_format?: unknown;
+    
+    voice?: string;
+}
+
+interface SessionEndInfo {
+    
+    timeLeftMs: number | null;
+    
+    reason: string;
+}
+
+interface ProxyClients {
+    
+    readonly tenant?: string;
+    
+    createResponse(params: ResponsesCreateParams, onDial?: DialObserver): Promise<AsyncIterable<unknown>> | AsyncIterable<unknown>;
+    
+    listModels(): Promise<unknown>;
+    
+    openRouterModels?(): Promise<unknown>;
+    
+    supportsImages?(model: string | undefined, mode: 'generation' | 'edit'): Promise<boolean>;
+    
+    supportsAudio?(model: string | undefined): Promise<boolean>;
+    
+    supportsSpeech?(model: string | undefined): Promise<boolean>;
+    
+    speechVoices?(model: string | undefined): Promise<SpeechVoicesResolution>;
+    
+    listImageModels?(): Promise<unknown>;
+    
+    catalogIdentity(model: string | undefined): Promise<{
+        model_id: string;
+        variant: string;
+    } | null>;
+    
+    servingAppSlug?(model: string | undefined): Promise<string | null>;
+    
+    openAudio?(model: string | undefined, signal?: AbortSignal): Promise<ProxyAudioLane>;
+    
+    openAudioOn?(handle: string): Promise<PinnedAudioLane>;
+    
+    openVideo?(model: string | undefined): Promise<ProxyVideoLane>;
+    
+    openVideoOut?(model: string | undefined): Promise<ProxyVideoOutLane>;
+    
+    sessionHandle(model: string | undefined): Promise<string>;
+    
+    speechSessionHandle?(model: string | undefined): Promise<string>;
+    
+    evictSpeechSession?(handle: string): Promise<void>;
+    
+    createResponseOn(handle: string, params: ResponsesCreateParams): Promise<AsyncIterable<unknown>> | AsyncIterable<unknown>;
+    
+    onSessionEnd(handle: string, cb: (end: SessionEndInfo) => void): Promise<() => void>;
+    
+    readonly stateless?: StatelessDecisionDial;
+}
+
+type ProxyAudioLane = Pick<AudioBridge, 'appendInputAudio' | 'onOutputAudio'> & {
+    sessionId?: string | null;
+};
+
+interface PinnedAudioLane extends ProxyAudioLane {
+    
+    readonly sessionId: string | null;
+}
+
+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;
+    
+    requestLog?: (line: string) => void;
+    
+    usage?: UsageLane;
+    
+    ledger?: LedgerLane;
+    
+    observe?: (record: InferenceRecord) => void;
+}
+
+export { type DialObserver as D, type InferenceRecord as I, type LedgerFailure as L, ModelRouter as M, type ProxyClients as P, SessionGoneError as S, UnknownModelError as U, type DialReport as a, type InferenceUsageRecord as b, type LedgerOutcome as c, type LedgerRecorded as d, type LedgerWrite as e, type ProxyHandlerOptions as f, type ProxyIdentity as g, type ProxyVideoOutLane as h, type UsageRowReporter as i };

package/dist/{translator-CcDBEfvm.d.cts → translator-CO8W_hmJ.d.cts}

@@ -1,4 +1,4 @@
-import { k as VideoOutRecord } from './video-out-D20UuJ8G.cjs';
+import { k as VideoOutRecord } from './video-out-BsuLqlID.cjs';
 
 /**
  * Gemini Live (BidiGenerateContent) ⇄ uRun Responses translation — PURE
@@ -90,7 +90,7 @@ interface LiveSessionConfig {
     /**
      * `generationConfig.responseModalities` includes AUDIO — the handler opens
      * the native audio lane (ProxyClients.openAudio → AudioBridge over
-     * rt-audio-in/rt-audio-out) EAGERLY at setup instead of on first audio chunk.
+     * the canonical `audio` lane, transport/media.ts AUDIO_STREAM) EAGERLY at setup instead of on first audio chunk.
      */
     audioModality: boolean;
     /** VAD/activity posture from setup.realtimeInputConfig (manual mode only). */
@@ -209,7 +209,7 @@ declare function serverContentOfDelta(ev: {
     delta?: unknown;
 }): Rec | null;
 /**
- * One native `rt-audio-out` chunk (base64 PCM16 @24 kHz, exactly as the
+ * One native `audio`-lane chunk (base64 PCM16 @24 kHz, exactly as the
  * AudioBridge emits it — no conversion: the Live spec output rate IS the
  * native rate) → a serverContent.modelTurn inlineData message.
  */

package/dist/{translator-C9uPKypK.d.ts → translator-Ddd65sXR.d.ts}

@@ -1,4 +1,4 @@
-import { k as VideoOutRecord } from './video-out-CWesbk12.js';
+import { k as VideoOutRecord } from './video-out-Cawtm7SF.js';
 
 declare const GEMINI_LIVE_PATH = "/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent";
 

package/dist/{types-lsVTbNcH.d.cts → types-CHPtJx6d.d.cts}

@@ -3,6 +3,19 @@ interface UrunDocLike {
     set(patch: Record<string, unknown>): void;
     get(path?: string, defaultValue?: unknown): unknown;
     on(event: 'change', handler: (snapshot: Record<string, unknown>) => void): () => void;
+    /**
+     * Whether the provider's initial sync has completed (core
+     * `SessionDocumentImpl.synced`) — true also for local-only docs. Absent on
+     * legacy/test doubles that never model a doc plane; the turn path's
+     * first-write gate skips when the surface is absent (it cannot hold a gate
+     * it cannot observe).
+     */
+    synced?: boolean;
+    /**
+     * One-shot first-sync callback (core `SessionDocumentImpl.onSynced`).
+     * Returns an unsubscribe fn. Absent on legacy/test doubles.
+     */
+    onSynced?(handler: () => void): () => void;
 }
 interface UrunStreamLike {
     messages(): AsyncIterable<unknown>;

package/dist/{types-lsVTbNcH.d.ts → types-CHPtJx6d.d.ts}

@@ -3,6 +3,10 @@ interface UrunDocLike {
     set(patch: Record<string, unknown>): void;
     get(path?: string, defaultValue?: unknown): unknown;
     on(event: 'change', handler: (snapshot: Record<string, unknown>) => void): () => void;
+    
+    synced?: boolean;
+    
+    onSynced?(handler: () => void): () => void;
 }
 interface UrunStreamLike {
     messages(): AsyncIterable<unknown>;