@urun-sh/openai 0.5.4 → 0.5.6

package/dist/proxy/index.d.ts

@@ -1,5 +1,186 @@
-export { O as OpenAIProxyOptions, P as ProxyClients, a as ProxyIdentity, b as ProxyVideoOutLane, c as createOpenAIProxy } from '../server-DuH_5OD9.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 { 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 { WebSocket } from 'ws';
+import '../models-DUdx_Y6X.js';
+import '../video-out-IGQ4YQ-c.js';
 import '../types-lsVTbNcH.js';
+
+interface OpenAIProxyOptions extends ProxyHandlerOptions {
+    clients: ProxyClients;
+}
+
+declare function createOpenAIProxy(options: OpenAIProxyOptions): Server;
+
+type GeminiLiveClients = Pick<ProxyClients, 'createResponse' | 'openAudio' | 'openVideo' | 'openVideoOut' | 'sessionHandle' | 'onSessionEnd'>;
+interface LiveSnapshot {
+    model: string;
+    
+    proxyHandle: string;
+    
+    transcript: Array<Record<string, unknown>>;
+}
+
+declare class ResumptionRegistry {
+    private readonly snapshots;
+    store(scope: string, handle: string, snapshot: LiveSnapshot): void;
+    get(scope: string, handle: string): LiveSnapshot | undefined;
+}
+
+interface GeminiLiveCall {
+    clients: GeminiLiveClients;
+    
+    scope: string;
+    
+    onBindResumeHandle?: (handle: string) => void;
+    
+    clientsForResume?: (resumeHandle: string) => Promise<GeminiLiveClients>;
+    
+    release?: () => Promise<void>;
+}
+
+type GeminiLiveAuthenticate = (credential: string, req: IncomingMessage) => Promise<GeminiLiveCall>;
+interface GeminiLiveOptions {
+    
+    clients?: GeminiLiveClients;
+    
+    apiKey?: string;
+    
+    authenticate?: GeminiLiveAuthenticate;
+}
+
+declare function attachGeminiLive(server: Server, options: GeminiLiveOptions): () => Promise<void>;
+
+declare function serveGeminiLiveSocket(ws: WebSocket, call: GeminiLiveCall, registry?: ResumptionRegistry): void;
+
+declare const OPENAI_REALTIME_PATH = "/v1/realtime";
+
+type OpenAIRealtimeResolver<S = unknown> = ((req: IncomingMessage) => Promise<RealtimeBinding<S>>) | {
+    resolve(req: IncomingMessage): Promise<RealtimeBinding<S>>;
+};
+interface RealtimeBinding<S = unknown> {
+    
+    session?: S & {
+        sendResponseCreate?(params: unknown, input: unknown[], requestId: string): AsyncIterable<unknown>;
+    };
+    clients?: Pick<ProxyClients, 'createResponse'>;
+    
+    voice: boolean;
+    
+    audioSession?: {
+        audio: {
+            appendInputAudio(base64Pcm16: string): void;
+            onOutputAudio(handler: (b64: string) => void): () => void;
+        };
+        
+        openaiRealtimeClaims?: Set<RealtimeBinding['audioSession']>;
+    };
+    
+    model?: string;
+    
+    resumed?: boolean;
+    
+    turns?: () => AsyncIterable<{
+        kind: 'delta' | 'final' | 'turn_start' | 'turn_end' | 'turn_eager_end' | 'turn_resumed';
+        text?: string;
+        confidence?: number;
+        startMs?: number;
+    }>;
+    
+    release?: () => Promise<void> | void;
+}
+interface OpenAIRealtimeOptions<S = unknown> {
+    resolver: OpenAIRealtimeResolver<S>;
+}
+
+declare function attachOpenAIRealtime<S = unknown>(server: Server, options: OpenAIRealtimeOptions<S>): () => Promise<void>;
+
+declare class OpenAIRealtimeConnection<S = unknown> {
+    readonly id: string;
+    private readonly ws;
+    private readonly binding;
+    private readonly onClosed?;
+    private config;
+    private readonly sessionId;
+    private readonly conversationId;
+    private readonly items;
+    
+    private pendingAudioBytes;
+    private pendingAudioTotalBytes;
+    
+    private frozenAudio;
+    private inFlight;
+    private activeResponseId;
+    
+    private responseFlushed;
+    private cancelled;
+    private voiceClaimed;
+    private audioLaneOwner;
+    private audioUnsubscribe;
+    private outOfTurnAudioWarned;
+    private audioOnlyTranscriptGapWarned;
+    private closed;
+    
+    private turnLaneAbort;
+    
+    private turnTranscript;
+    
+    private lastCommittedTranscript;
+    constructor(opts: {
+        ws: WebSocket;
+        binding: RealtimeBinding<S>;
+        onClosed?: (conn: OpenAIRealtimeConnection<S>) => void;
+    });
+    
+    private startTurnLane;
+    
+    private onTurnEvent;
+    
+    private takeTurnTranscript;
+    private onMessage;
+    private handle;
+    
+    private ensureVoice;
+    
+    private claimVoiceBinding;
+    private releaseVoiceBinding;
+    private warnAudioOnlyTranscriptGap;
+    
+    private upstreamStream;
+    private startResponse;
+    
+    private onOutputAudioFrame;
+    
+    private messageItemAdded;
+    
+    private messageItemOpenForAudio;
+    private beginMessageItem;
+    private beginAudioMessageItem;
+    
+    private closeOpenItems;
+    private responseObject;
+    private failedResponse;
+    
+    private doneResponse;
+    private upstreamErrorBody;
+    private emitUpstreamFault;
+    
+    private cancelResponse;
+    private pushItem;
+    private itemToProtocol;
+    private send;
+    private fail;
+    
+    private teardown;
+}
+
+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 fixedClientsResolver(clients: ProxyClients, apiKey?: string): {
+    resolve(req: IncomingMessage): 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{b as t}from"../chunk-VNM4M4P3.js";import"../chunk-4MSBS7M6.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};
+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};

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

@@ -0,0 +1,486 @@
+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-IGQ4YQ-c.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;
+}
+
+interface SharedCatalogBlock {
+    shared_org_id: string;
+    endpoints: SharedEndpointRow[];
+}
+
+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 OpenRouterProviderModel {
+    schema_version: '2.4';
+    
+    id: string;
+    name: string;
+    created: number;
+    
+    quantization: string | null;
+    description: string;
+    hugging_face_id: string;
+    input_modalities: Array<Record<string, unknown>>;
+    output_modalities: Array<Record<string, unknown>>;
+}
+
+interface DeployedApp {
+    app_slug: string;
+    function_name?: string | null;
+    deployment_status?: string | null;
+    [k: string]: unknown;
+}
+
+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;
+}
+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;
+}
+interface ModelRouterOptions<S> {
+    
+    defaultApp: string | null;
+    
+    fnName: string;
+    
+    openSession: (target: RouteTarget) => 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;
+}
+
+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 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>;
+    
+    resolveApp(model: string | undefined): Promise<string>;
+    
+    sessionFor(model: string | undefined): Promise<{
+        app: string;
+        entry: S;
+        identity: TurnCatalogIdentity;
+    }>;
+    private keyOf;
+    
+    handleFor(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>;
+    
+    imageModelList(): Promise<RouterImageModelList>;
+    
+    closeAll(): Promise<void>;
+}
+
+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;
+}
+
+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];
+
+type LedgerOutcome = 
+
+{
+    outcome: 'written';
+    reason: 'priced' | 'unpriced';
+}
+
+ | {
+    outcome: 'already_written';
+    reason: 'priced' | 'unpriced';
+}
+
+ | {
+    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;
+}
+
+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>;
+    
+    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): 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;
+    
+    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 };