@xiaozhiclaw/provider-core 0.1.0

package/dist/transports/qwen-media.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Qwen (DashScope) Media Transport.
+ *
+ * DashScope async task API pattern:
+ *   Submit: POST /api/v1/services/aigc/<service>/generation  (X-DashScope-Async: enable)
+ *   Poll:   GET  /api/v1/tasks/{taskId}
+ *
+ * Auth: Authorization: Bearer $DASHSCOPE_API_KEY
+ * Docs: https://help.aliyun.com/zh/model-studio/developer-reference/
+ *
+ * Video models: wan2.7-t2v (text-to-video), wan2.7-i2v (image-to-video)
+ * TTS endpoints:
+ *   Qwen3-TTS:  /api/v1/services/aigc/multimodal-generation/generation
+ *   CosyVoice:  /api/v1/services/audio/tts/SpeechSynthesizer
+ * Rerank:       /api/v1/services/rerank/text-rerank/text-rerank
+ * Embedding:    /compatible-mode/v1/embeddings
+ */
+import type { AsyncMediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
+export interface QwenMediaConfig {
+    /** Base URL, e.g. "https://dashscope.aliyuncs.com" */
+    baseUrl: string;
+    timeoutMs?: number;
+}
+export declare class QwenMediaTransport implements AsyncMediaTransport {
+    readonly supportedTypes: readonly MediaType[];
+    private baseUrl;
+    private timeoutMs;
+    constructor(config: QwenMediaConfig);
+    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
+    private generateTTS;
+    private generateQwenTTS;
+    private generateCosyVoiceTTS;
+    private generateEmbedding;
+    private generateRerank;
+    private pollTask;
+    private generateVideo;
+    /**
+     * Query a single task by ID using DashScope unified task endpoint.
+     * GET /api/v1/tasks/{taskId}
+     */
+    getTaskStatus(taskId: string, apiKey: string, signal?: AbortSignal): Promise<{
+        status: string;
+        task: Record<string, unknown>;
+    }>;
+    /**
+     * List tasks 鈥?DashScope has a task list API.
+     * GET /api/v1/tasks?page_no=1&page_size=20&status=RUNNING
+     */
+    listVideoTasks(apiKey: string, options?: {
+        after?: string;
+        limit?: number;
+        status?: string;
+    }, signal?: AbortSignal): Promise<Record<string, unknown>>;
+    /**
+     * Cancel/delete 鈥?DashScope does not have a public task cancellation API.
+     */
+    deleteVideoTask(_taskId: string, _apiKey: string, _signal?: AbortSignal): Promise<void>;
+    private extractMediaUrl;
+}

package/dist/transports/qwen-media.js

@@ -0,0 +1,411 @@
+/**
+ * Qwen (DashScope) Media Transport.
+ *
+ * DashScope async task API pattern:
+ *   Submit: POST /api/v1/services/aigc/<service>/generation  (X-DashScope-Async: enable)
+ *   Poll:   GET  /api/v1/tasks/{taskId}
+ *
+ * Auth: Authorization: Bearer $DASHSCOPE_API_KEY
+ * Docs: https://help.aliyun.com/zh/model-studio/developer-reference/
+ *
+ * Video models: wan2.7-t2v (text-to-video), wan2.7-i2v (image-to-video)
+ * TTS endpoints:
+ *   Qwen3-TTS:  /api/v1/services/aigc/multimodal-generation/generation
+ *   CosyVoice:  /api/v1/services/audio/tts/SpeechSynthesizer
+ * Rerank:       /api/v1/services/rerank/text-rerank/text-rerank
+ * Embedding:    /compatible-mode/v1/embeddings
+ */
+const POLL_INTERVAL_MS = 2_000;
+const MAX_POLL_MS_TTS = 120_000; // 2 min for TTS
+const MAX_POLL_MS_VIDEO = 600_000; // 10 min for video
+const DEFAULT_TIMEOUT_MS = 30_000;
+export class QwenMediaTransport {
+    supportedTypes = ["tts", "video", "embedding", "rerank"];
+    baseUrl;
+    timeoutMs;
+    constructor(config) {
+        // Strip /apps/anthropic suffix 鈥?TTS uses a different path
+        this.baseUrl = config.baseUrl
+            .replace(/\/apps\/anthropic\/?$/, "")
+            .replace(/\/+$/, "");
+        this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    }
+    async generate(request, apiKey, signal) {
+        if (request.mediaType === "video") {
+            return this.generateVideo(request, apiKey, signal);
+        }
+        if (request.mediaType === "embedding") {
+            return this.generateEmbedding(request, apiKey, signal);
+        }
+        if (request.mediaType === "rerank") {
+            return this.generateRerank(request, apiKey, signal);
+        }
+        if (request.mediaType !== "tts") {
+            throw new Error(`QwenMediaTransport: unsupported mediaType "${request.mediaType}"`);
+        }
+        return this.generateTTS(request, apiKey, signal);
+    }
+    async generateTTS(request, apiKey, signal) {
+        const start = Date.now();
+        const text = request.text || request.prompt;
+        if (!text) {
+            throw new Error("QwenMediaTransport: text or prompt is required for TTS");
+        }
+        if ((request.model || "").startsWith("cosyvoice")) {
+            return this.generateCosyVoiceTTS(request, apiKey, signal, start, text);
+        }
+        return this.generateQwenTTS(request, apiKey, signal, start, text);
+    }
+    async generateQwenTTS(request, apiKey, signal, start, text) {
+        const submitUrl = `${this.baseUrl}/api/v1/services/aigc/multimodal-generation/generation`;
+        const body = {
+            model: request.model || "qwen3-tts-flash",
+            input: {
+                text,
+                voice: request.voice ?? "Cherry",
+                language_type: request.metadata?.languageType ?? "English",
+            },
+        };
+        const submitRes = await fetch(submitUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify(body),
+            signal: signal ?? AbortSignal.timeout(this.timeoutMs),
+        });
+        if (!submitRes.ok) {
+            const errText = await submitRes.text().catch(() => "");
+            throw new Error(`DashScope Qwen TTS error ${submitRes.status}: ${errText}`);
+        }
+        const submitData = await submitRes.json();
+        if (submitData.code) {
+            throw new Error(`DashScope Qwen TTS rejected: ${submitData.code}: ${submitData.message ?? ""}`);
+        }
+        const audioUrl = submitData.output?.audio?.url;
+        const characters = submitData.usage?.characters ?? text.length;
+        return {
+            mediaUrls: audioUrl ? [audioUrl] : [],
+            model: request.model || "qwen3-tts-flash",
+            durationMs: Date.now() - start,
+            billingUnit: "per_character",
+            billingQuantity: characters,
+            metadata: {
+                usage: submitData.usage,
+                finishReason: submitData.output?.finish_reason,
+                requestId: submitData.request_id,
+            },
+        };
+    }
+    async generateCosyVoiceTTS(request, apiKey, signal, start, text) {
+        const submitUrl = `${this.baseUrl}/api/v1/services/audio/tts/SpeechSynthesizer`;
+        const body = {
+            model: request.model || "cosyvoice-v2",
+            input: { text },
+            parameters: {
+                voice: request.voice ?? "longxiaochun_v2",
+                format: request.audioFormat ?? "mp3",
+                sample_rate: request.metadata?.sampleRate ?? 24000,
+            },
+        };
+        const submitRes = await fetch(submitUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify(body),
+            signal: signal ?? AbortSignal.timeout(this.timeoutMs),
+        });
+        if (!submitRes.ok) {
+            const errText = await submitRes.text().catch(() => "");
+            throw new Error(`DashScope CosyVoice TTS error ${submitRes.status}: ${errText}`);
+        }
+        const data = await submitRes.json();
+        if (data.code) {
+            throw new Error(`DashScope CosyVoice TTS rejected: ${data.code}: ${data.message ?? ""}`);
+        }
+        const audioUrl = data.output?.audio?.url;
+        const characters = data.usage?.characters ?? text.length;
+        return {
+            mediaUrls: audioUrl ? [audioUrl] : [],
+            model: request.model || "cosyvoice-v2",
+            durationMs: Date.now() - start,
+            billingUnit: "per_character",
+            billingQuantity: characters,
+            metadata: {
+                usage: data.usage,
+                finishReason: data.output?.finish_reason,
+                requestId: data.request_id,
+            },
+        };
+    }
+    async generateEmbedding(request, apiKey, signal) {
+        const start = Date.now();
+        const text = request.text || request.prompt;
+        if (!text)
+            throw new Error("QwenMediaTransport: text or prompt is required for embedding");
+        const url = `${this.baseUrl}/compatible-mode/v1/embeddings`;
+        const body = {
+            model: request.model || "text-embedding-v4",
+            input: text,
+        };
+        if (request.metadata?.dimensions)
+            body.dimensions = request.metadata.dimensions;
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify(body),
+            signal: signal ?? AbortSignal.timeout(this.timeoutMs),
+        });
+        if (!res.ok) {
+            const textBody = await res.text().catch(() => "");
+            throw new Error(`DashScope embedding error ${res.status}: ${textBody}`);
+        }
+        const data = await res.json();
+        const embeddings = (data.data ?? []).map(item => item.embedding).filter((item) => Array.isArray(item));
+        const totalTokens = data.usage?.total_tokens ?? data.usage?.prompt_tokens;
+        return {
+            mediaUrls: [],
+            model: data.model ?? request.model ?? "text-embedding-v4",
+            durationMs: Date.now() - start,
+            billingUnit: totalTokens !== undefined ? "per_token" : undefined,
+            billingQuantity: totalTokens,
+            metadata: {
+                embeddings,
+                dimensions: embeddings[0]?.length ?? 0,
+                usage: data.usage,
+            },
+        };
+    }
+    async generateRerank(request, apiKey, signal) {
+        const start = Date.now();
+        const query = request.prompt;
+        const documents = request.metadata?.documents;
+        if (!query)
+            throw new Error("QwenMediaTransport: prompt (query) is required for rerank");
+        if (!Array.isArray(documents))
+            throw new Error("QwenMediaTransport: metadata.documents is required for rerank");
+        const url = `${this.baseUrl}/api/v1/services/rerank/text-rerank/text-rerank`;
+        const body = {
+            model: request.model || "qwen3-rerank",
+            input: { query, documents },
+            parameters: {},
+        };
+        if (request.metadata?.topN !== undefined) {
+            body.parameters.top_n = request.metadata.topN;
+        }
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify(body),
+            signal: signal ?? AbortSignal.timeout(this.timeoutMs),
+        });
+        if (!res.ok) {
+            const textBody = await res.text().catch(() => "");
+            throw new Error(`DashScope rerank error ${res.status}: ${textBody}`);
+        }
+        const data = await res.json();
+        const totalTokens = data.usage?.total_tokens;
+        return {
+            mediaUrls: [],
+            model: request.model || "qwen3-rerank",
+            durationMs: Date.now() - start,
+            billingUnit: totalTokens !== undefined ? "per_token" : undefined,
+            billingQuantity: totalTokens,
+            metadata: {
+                results: (data.output?.results ?? []).map(r => ({
+                    index: r.index,
+                    relevanceScore: r.relevance_score,
+                    document: r.document,
+                })),
+                usage: data.usage,
+            },
+        };
+    }
+    async pollTask(taskId, apiKey, signal, onProgress, maxPollMs = MAX_POLL_MS_TTS) {
+        const deadline = Date.now() + maxPollMs;
+        const pollUrl = `${this.baseUrl}/api/v1/tasks/${taskId}`;
+        while (Date.now() < deadline) {
+            signal?.throwIfAborted();
+            await sleep(POLL_INTERVAL_MS);
+            const res = await fetch(pollUrl, {
+                method: "GET",
+                headers: { Authorization: `Bearer ${apiKey}` },
+                signal: signal ?? AbortSignal.timeout(this.timeoutMs),
+            });
+            if (!res.ok) {
+                const text = await res.text().catch(() => "");
+                throw new Error(`DashScope TTS poll error ${res.status}: ${text}`);
+            }
+            const data = await res.json();
+            if (data.code) {
+                throw new Error(`DashScope poll rejected: ${data.code} 鈥?${data.message ?? ""}`);
+            }
+            const status = data.output?.task_status;
+            if (status === "SUCCEEDED") {
+                onProgress?.(100, "completed", taskId);
+                const mediaUrl = this.extractMediaUrl(data);
+                return mediaUrl ? [mediaUrl] : [];
+            }
+            if (status === "FAILED") {
+                throw new Error(`DashScope task failed: ${data.message ?? "unknown error"}`);
+            }
+            // PENDING / RUNNING 鈥?report progress and continue polling
+            const elapsed = Date.now() - (deadline - maxPollMs);
+            onProgress?.(Math.min(95, Math.round((elapsed / maxPollMs) * 100)), status ?? "running", taskId);
+        }
+        throw new Error("DashScope task timed out");
+    }
+    // 鈹€鈹€ Video Generation (qwen-ProviderMax 搂19-23) 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
+    // DashScope video uses the same async task pattern as TTS.
+    // Submit: POST /api/v1/services/aigc/generation/generation
+    // Poll:   GET  /api/v1/tasks/{taskId}
+    async generateVideo(request, apiKey, signal) {
+        const start = Date.now();
+        const model = request.model || "wan2.1-t2v-turbo";
+        // DashScope video request body
+        const input = {
+            prompt: request.prompt,
+        };
+        // Image-to-video: pass img_url
+        if (request.imageUrl) {
+            input.img_url = request.imageUrl;
+        }
+        else if (request.referenceImages?.length) {
+            // First-last-frame or reference mode
+            if (request.imageRoles) {
+                const firstIdx = request.imageRoles.indexOf("first_frame");
+                const lastIdx = request.imageRoles.indexOf("last_frame");
+                if (firstIdx >= 0)
+                    input.img_url = request.referenceImages[firstIdx];
+                if (lastIdx >= 0)
+                    input.tail_image_url = request.referenceImages[lastIdx];
+                // Reference images
+                const refIndices = request.imageRoles
+                    .map((role, i) => role === "reference_image" ? i : -1)
+                    .filter(i => i >= 0);
+                if (refIndices.length > 0) {
+                    input.ref_image_url = request.referenceImages[refIndices[0]];
+                }
+            }
+            else {
+                input.img_url = request.referenceImages[0];
+            }
+        }
+        const parameters = {};
+        if (request.duration)
+            parameters.duration = request.duration;
+        if (request.resolution)
+            parameters.resolution = request.resolution;
+        if (request.aspectRatio)
+            parameters.ratio = request.aspectRatio;
+        if (request.metadata?.size)
+            parameters.size = request.metadata.size;
+        const submitUrl = `${this.baseUrl}/api/v1/services/aigc/generation/generation`;
+        const body = { model, input };
+        if (Object.keys(parameters).length > 0)
+            body.parameters = parameters;
+        const submitRes = await fetch(submitUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+                "X-DashScope-Async": "enable",
+            },
+            body: JSON.stringify(body),
+            signal: signal ?? AbortSignal.timeout(this.timeoutMs),
+        });
+        if (!submitRes.ok) {
+            const errText = await submitRes.text().catch(() => "");
+            throw new Error(`DashScope video submit error ${submitRes.status}: ${errText}`);
+        }
+        const submitData = await submitRes.json();
+        if (submitData.code) {
+            throw new Error(`DashScope video submit rejected: ${submitData.code} 鈥?${submitData.message ?? ""}`);
+        }
+        const taskId = submitData.output?.task_id;
+        if (!taskId) {
+            throw new Error("DashScope video submit: no task_id in response");
+        }
+        // Poll for completion with longer timeout for video
+        const videoUrls = await this.pollTask(taskId, apiKey, signal, request.onProgress, MAX_POLL_MS_VIDEO);
+        return {
+            mediaUrls: videoUrls,
+            model,
+            durationMs: Date.now() - start,
+            taskId,
+        };
+    }
+    // 鈹€鈹€ AsyncMediaTransport: Task Management 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
+    /**
+     * Query a single task by ID using DashScope unified task endpoint.
+     * GET /api/v1/tasks/{taskId}
+     */
+    async getTaskStatus(taskId, apiKey, signal) {
+        const url = `${this.baseUrl}/api/v1/tasks/${taskId}`;
+        const res = await fetch(url, {
+            method: "GET",
+            headers: { Authorization: `Bearer ${apiKey}` },
+            signal: signal ?? AbortSignal.timeout(this.timeoutMs),
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            throw new Error(`DashScope task status error ${res.status}: ${text}`);
+        }
+        const data = await res.json();
+        const output = data.output;
+        const rawStatus = output?.task_status ?? "unknown";
+        const normalizedStatus = rawStatus === "SUCCEEDED" ? "succeeded"
+            : rawStatus === "FAILED" ? "failed"
+                : rawStatus.toLowerCase();
+        return { status: normalizedStatus, task: data };
+    }
+    /**
+     * List tasks 鈥?DashScope has a task list API.
+     * GET /api/v1/tasks?page_no=1&page_size=20&status=RUNNING
+     */
+    async listVideoTasks(apiKey, options, signal) {
+        const params = new URLSearchParams();
+        params.set("page_size", String(options?.limit ?? 20));
+        if (options?.status)
+            params.set("status", options.status.toUpperCase());
+        const url = `${this.baseUrl}/api/v1/tasks?${params.toString()}`;
+        const res = await fetch(url, {
+            method: "GET",
+            headers: { Authorization: `Bearer ${apiKey}` },
+            signal: signal ?? AbortSignal.timeout(this.timeoutMs),
+        });
+        if (!res.ok) {
+            // DashScope may not support task list 鈥?return empty gracefully
+            return { data: [] };
+        }
+        return await res.json();
+    }
+    /**
+     * Cancel/delete 鈥?DashScope does not have a public task cancellation API.
+     */
+    async deleteVideoTask(_taskId, _apiKey, _signal) {
+        throw new Error("DashScope does not support task cancellation.");
+    }
+    extractMediaUrl(data) {
+        // DashScope returns different URL fields per media type
+        if (data.output?.video_url)
+            return data.output.video_url;
+        if (data.output?.audio_url)
+            return data.output.audio_url;
+        if (data.output?.results?.[0]?.url)
+            return data.output.results[0].url;
+        return undefined;
+    }
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/dist/transports/realtime-transport.d.ts

@@ -0,0 +1,183 @@
+/**
+ * Realtime WebSocket Transport 鈥?bidirectional audio/voice streaming
+ * via the OpenAI Realtime API protocol (also compatible with GLM Realtime).
+ *
+ * ## Protocol: WebSocket JSON events
+ *
+ * Client 鈫?Server:
+ *   - session.update: configure session (model, voice, tools, etc.)
+ *   - input_audio_buffer.append: send audio chunks (base64 PCM16)
+ *   - input_audio_buffer.commit: signal end of audio input
+ *   - conversation.item.create: inject text/function_result items
+ *   - response.create: request a model response
+ *   - response.cancel: abort in-progress response
+ *
+ * Server 鈫?Client:
+ *   - session.created: session initialized
+ *   - session.updated: config acknowledged
+ *   - input_audio_buffer.speech_started: VAD detected speech
+ *   - input_audio_buffer.speech_stopped: VAD detected silence
+ *   - response.created: response generation started
+ *   - response.output_item.added: new output item (text/audio/function_call)
+ *   - response.audio.delta: audio chunk (base64 PCM16)
+ *   - response.audio_transcript.delta: transcript of generated speech
+ *   - response.text.delta: text generation delta
+ *   - response.function_call_arguments.delta: tool call args delta
+ *   - response.function_call_arguments.done: tool call complete
+ *   - response.output_item.done: output item finished
+ *   - response.done: full response complete
+ *   - error: server error
+ *
+ * ## Architecture
+ *
+ * RealtimeTransport manages a single persistent WebSocket connection per session.
+ * It exposes an event-driven API (AsyncGenerator) that the agent tool-loop
+ * can consume for voice-enabled interactions.
+ *
+ * Docs:
+ *   - OpenAI: https://platform.openai.com/docs/api-reference/realtime
+ *   - GLM:    https://docs.bigmodel.cn/cn/guide/develop/realtime-api
+ */
+export interface RealtimeConfig {
+    /** WebSocket endpoint (e.g. "wss://api.openai.com/v1/realtime") */
+    baseUrl: string;
+    /** Model to use (e.g. "gpt-realtime-2", "glm-realtime") */
+    model: string;
+    /** API key */
+    apiKey: string;
+    /** Voice for TTS output */
+    voice?: string;
+    /** Input modalities: "text", "audio", or both */
+    inputModalities?: Array<"text" | "audio">;
+    /** Output modalities: "text", "audio", or both */
+    outputModalities?: Array<"text" | "audio">;
+    /** Temperature for generation */
+    temperature?: number;
+    /** Tool definitions for function calling */
+    tools?: RealtimeTool[];
+    /** Voice Activity Detection mode */
+    vadMode?: "server_vad" | "none";
+    /** VAD threshold (0.0-1.0) */
+    vadThreshold?: number;
+    /** Auth type: "header" (OpenAI) or "query" (GLM) */
+    authMode?: "header" | "query";
+}
+export interface RealtimeTool {
+    type: "function";
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+}
+export type RealtimeEvent = {
+    type: "session_created";
+    sessionId: string;
+} | {
+    type: "speech_started";
+} | {
+    type: "speech_stopped";
+    audioEndMs: number;
+} | {
+    type: "audio_delta";
+    delta: string;
+} | {
+    type: "audio_transcript_delta";
+    delta: string;
+} | {
+    type: "text_delta";
+    delta: string;
+} | {
+    type: "function_call_start";
+    callId: string;
+    name: string;
+} | {
+    type: "function_call_delta";
+    callId: string;
+    delta: string;
+} | {
+    type: "function_call_done";
+    callId: string;
+    name: string;
+    arguments: string;
+} | {
+    type: "response_done";
+    usage?: RealtimeUsage;
+} | {
+    type: "error";
+    code: string;
+    message: string;
+} | {
+    type: "closed";
+    code: number;
+    reason: string;
+};
+export interface RealtimeUsage {
+    inputTokens: number;
+    outputTokens: number;
+    inputAudioTokens?: number;
+    outputAudioTokens?: number;
+}
+/**
+ * Manages a persistent WebSocket connection for real-time audio/voice
+ * interactions with an LLM provider.
+ *
+ * Usage:
+ * ```ts
+ * const rt = new RealtimeTransport(config);
+ * rt.connect();
+ *
+ * // Send audio
+ * rt.appendAudio(base64Chunk);
+ * rt.commitAudio();
+ *
+ * // Or send text
+ * rt.sendText("Hello!");
+ *
+ * // Submit function results
+ * rt.sendFunctionResult(callId, result);
+ *
+ * // Consume events
+ * for await (const event of rt.events()) {
+ *   switch (event.type) {
+ *     case "audio_delta": playAudio(event.delta); break;
+ *     case "function_call_done": handleToolCall(event); break;
+ *   }
+ * }
+ *
+ * rt.close();
+ * ```
+ */
+export declare class RealtimeTransport {
+    private ws;
+    private config;
+    private eventQueue;
+    private waiters;
+    private closed;
+    constructor(config: RealtimeConfig);
+    /** Open WebSocket connection and configure session. */
+    connect(): Promise<void>;
+    /** Send audio data (base64 PCM16). */
+    appendAudio(base64Chunk: string): void;
+    /** Mark end of audio input and trigger response. */
+    commitAudio(): void;
+    /** Send a text message. */
+    sendText(text: string): void;
+    /** Submit a function call result back to the model. */
+    sendFunctionResult(callId: string, output: string): void;
+    /** Trigger a model response (e.g. after sending text). */
+    requestResponse(): void;
+    /** Cancel an in-progress response. */
+    cancelResponse(): void;
+    /** Async iterator of server events. */
+    events(): AsyncGenerator<RealtimeEvent>;
+    /** Close the WebSocket connection. */
+    close(): void;
+    private buildUrl;
+    private sendSessionUpdate;
+    private send;
+    private push;
+    private drainWaiters;
+    /**
+     * Parse a server-sent JSON event into our typed event(s).
+     */
+    private parseServerEvent;
+}