@xopcai/xopc 0.0.242 → 0.0.243

package/dist/src/voice/realtime/omniRoute.js

@@ -0,0 +1,31 @@
+import { init_xopc_cloud_config, resolveXopcModelRouterUrl } from "../../providers/xopc-cloud-config.js";
+import { getProviderAuthService, init_provider_auth_service } from "../../providers/provider-auth-service.js";
+//#region src/voice/realtime/omniRoute.ts
+init_provider_auth_service();
+init_xopc_cloud_config();
+async function resolveOmniRoute(config) {
+	const slice = config.voice?.realtime?.omni;
+	if (!slice) throw new Error("Natural conversation is not configured");
+	if (slice.model !== "qwen3-omni-flash-realtime") throw new Error("This Omni model has not been certified");
+	const managed = slice.provider === "xopc-cloud";
+	const url = new URL(managed ? `${resolveXopcModelRouterUrl(slice.baseUrl)}/audio/conversations/realtime` : slice.baseUrl ?? "wss://dashscope.aliyuncs.com/api-ws/v1/realtime");
+	if (managed && url.protocol === "https:") url.protocol = "wss:";
+	if (url.protocol !== "wss:" || url.username || url.password || url.hash || url.port) throw new Error("Omni requires a secure WebSocket endpoint");
+	if (!managed && (!(new Set(["dashscope.aliyuncs.com", "dashscope-intl.aliyuncs.com"]).has(url.hostname) || /^[a-zA-Z0-9-]+\.(cn-beijing|ap-southeast-1)\.maas\.aliyuncs\.com$/.test(url.hostname)) || url.pathname !== "/api-ws/v1/realtime")) throw new Error("Unsupported DashScope realtime endpoint");
+	const apiKey = managed ? await getProviderAuthService().resolveApiKey("xopc-cloud") : slice.apiKey ?? config.tools?.media?.audio?.providers?.alibaba?.apiKey ?? await getProviderAuthService().resolveApiKey("dashscope");
+	if (!apiKey) throw new Error("Omni credentials are unavailable");
+	url.search = new URLSearchParams({ model: slice.model }).toString();
+	return {
+		route: {
+			provider: slice.provider,
+			model: slice.model,
+			managed
+		},
+		url: url.toString(),
+		apiKey,
+		voice: slice.voice,
+		instructions: slice.instructions
+	};
+}
+//#endregion
+export { resolveOmniRoute };

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