@urun-sh/openai 0.5.5 → 0.5.6

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 };