@xopcai/xopc 0.0.241 → 0.0.243

package/dist/src/voice/realtime/runtime.d.ts

@@ -0,0 +1,99 @@
+import type { IncomingMessage } from 'node:http';
+import type { Socket } from 'node:net';
+import { type CreateVoiceSessionRequest, type CreateVoiceSessionResponse, type VoiceProviderRoute } from '@xopcai/realtime-protocol/voice';
+import type { Config } from '../../config/schema.js';
+import type { MediaUnderstandingProvider } from '../../media-understanding/types.js';
+import { type ResolvedSpeechProvider } from '../tts/factory.js';
+import type { TTSConfig } from '../tts/types.js';
+import { type VoiceConversationContext } from './conversation-context.js';
+import { type OmniRoute } from './omniRoute.js';
+import { type OmniTranscript } from './omniEngine.js';
+interface ResolvedStreamingStt {
+    plugin: MediaUnderstandingProvider & Required<Pick<MediaUnderstandingProvider, 'openAudioStream' | 'streamingAudio'>>;
+    model: string;
+    apiKey?: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    language?: string;
+    prompt?: string;
+    route: VoiceProviderRoute;
+}
+export interface VoiceTicketClaim {
+    sessionId: string;
+    principalId: string;
+    request: CreateVoiceSessionRequest;
+    inputMode: 'server_vad';
+    idleTimeoutMs: number;
+    maxSessionMs: number;
+    silenceDurationMs: number;
+    stt?: ResolvedStreamingStt;
+    omni?: OmniRoute;
+    conversationSessionId?: string;
+    tts?: ResolvedStreamingTts;
+    config: Config;
+    createdAt: number;
+    expiresAt: number;
+}
+interface ResolvedStreamingTts {
+    provider: ResolvedSpeechProvider;
+    config: TTSConfig;
+    route: VoiceProviderRoute;
+}
+export type VoiceSessionCreationErrorCode = 'VOICE_DISABLED' | 'SESSION_NOT_FOUND' | 'SESSION_CONFLICT' | 'SESSION_LIMIT' | 'PROVIDER_UNAVAILABLE';
+export declare class VoiceSessionCreationError extends Error {
+    readonly code: VoiceSessionCreationErrorCode;
+    readonly status: 404 | 409 | 429 | 503;
+    constructor(code: VoiceSessionCreationErrorCode, message: string, status: 404 | 409 | 429 | 503);
+}
+interface VoiceAgentEvent {
+    type: string;
+    payload?: {
+        delta?: unknown;
+        message?: unknown;
+        status?: unknown;
+        toolCallId?: unknown;
+        toolName?: unknown;
+        requestId?: unknown;
+        question?: unknown;
+        choices?: unknown;
+    };
+}
+export interface VoiceRealtimeRuntimeOptions {
+    recordOmniTranscript?: (sessionKey: string, callId: string, entry: OmniTranscript, expectedSessionId: string) => Promise<void>;
+    getConversationContext?: (sessionKey: string, expectedSessionId: string) => Promise<VoiceConversationContext>;
+    getSessionIdentity?: (sessionKey: string) => Promise<string | undefined>;
+    getConfig: () => Config;
+    sessionExists: (sessionKey: string) => Promise<boolean>;
+    sessionBusy: (sessionKey: string) => boolean;
+    runAgent: (text: string, sessionKey: string, signal: AbortSignal) => AsyncIterable<VoiceAgentEvent>;
+    recordInterruption: (entry: {
+        sessionKey: string;
+        responseId: string;
+        reason: 'barge_in' | 'client_cancelled';
+        generatedCharacters: number;
+        interruptedDuring: 'thinking' | 'speaking';
+    }) => Promise<void>;
+}
+export declare function resolveStreamingStt(config: Config, language?: string): ResolvedStreamingStt | undefined;
+export declare function resolveStreamingTts(config: Config): ResolvedStreamingTts | undefined;
+export declare class VoiceRealtimeRuntime {
+    private readonly options;
+    private readonly wss;
+    private readonly tickets;
+    private readonly preauthBudget;
+    private readonly socketsByPrincipal;
+    private readonly conversationReservations;
+    private closed;
+    constructor(options: VoiceRealtimeRuntimeOptions);
+    private prepareSession;
+    preflight(request: CreateVoiceSessionRequest): Promise<void>;
+    createSession(request: CreateVoiceSessionRequest, principalId: string, now?: number): Promise<CreateVoiceSessionResponse>;
+    handleUpgrade(req: IncomingMessage, socket: Socket, head: Buffer): boolean;
+    hasConversation(sessionKey: string): boolean;
+    close(): void;
+    private releaseConversationReservation;
+    private consumeTicket;
+    private pruneTickets;
+    private handleConnection;
+}
+export {};