@xiaozhiclaw/provider-core 0.1.0

package/dist/transports/minimax-media.js

@@ -0,0 +1,433 @@
+/**
+ * MiniMax Media Transport 鈥?Music + Video + TTS Generation.
+ *
+ * Music: POST /v1/music_generation (sync or async poll)
+ * Video: POST /v1/video_generation (4 modes: text, image, first-last-frame, subject-ref)
+ * Video Query: GET /v1/query/video_generation?task_id=XXX
+ * File Retrieve: GET /v1/files/retrieve?file_id=XXX (get download_url)
+ *
+ * Auth: Authorization: Bearer $MINIMAX_API_KEY
+ * Docs: minimax-ProviderMax.md 搂13-18 (video), 搂21 (music), 搂24-28 (files)
+ */
+const DEFAULT_TIMEOUT_MS = 60_000;
+const POLL_INTERVAL_MS = 3_000;
+const MAX_POLL_MS = 600_000; // 10 min
+export class MiniMaxMediaTransport {
+    supportedTypes = ["music", "video", "tts"];
+    baseUrl;
+    timeoutMs;
+    constructor(config) {
+        // MiniMax music API lives at api.minimaxi.com, not the /anthropic subpath
+        this.baseUrl = config.baseUrl
+            .replace(/\/anthropic\/?$/, "")
+            .replace(/\/+$/, "");
+        this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    }
+    async generate(request, apiKey, signal) {
+        switch (request.mediaType) {
+            case "music":
+                return this.generateMusic(request, apiKey, signal);
+            case "video":
+                return this.generateVideo(request, apiKey, signal);
+            case "tts":
+                return this.generateTTS(request, apiKey, signal);
+            default:
+                throw new Error(`MiniMaxMediaTransport: unsupported mediaType "${request.mediaType}"`);
+        }
+    }
+    async generateTTS(request, apiKey, signal) {
+        const start = Date.now();
+        const text = request.text ?? request.prompt;
+        if (!text) {
+            throw new Error("MiniMaxMediaTransport: text or prompt is required for TTS");
+        }
+        const format = request.audioFormat ?? "mp3";
+        const url = `${this.baseUrl}/v1/t2a_v2`;
+        const body = {
+            model: request.model || "speech-2.8-turbo",
+            text,
+            stream: false,
+            output_format: "url",
+            voice_setting: {
+                voice_id: request.voice ?? "male-qn-qingse",
+                speed: request.speed ?? 1,
+                vol: request.metadata?.volume ?? 1,
+                pitch: request.metadata?.pitch ?? 0,
+            },
+            audio_setting: {
+                sample_rate: request.metadata?.sampleRate ?? 32000,
+                bitrate: request.metadata?.bitrate ?? 128000,
+                format,
+                channel: request.metadata?.channel ?? 1,
+            },
+        };
+        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(`MiniMax TTS error ${res.status}: ${textBody}`);
+        }
+        const data = await res.json();
+        if (data.base_resp?.status_code && data.base_resp.status_code !== 0) {
+            throw new Error(`MiniMax TTS rejected: ${data.base_resp.status_msg ?? "unknown"}`);
+        }
+        const audioUrl = data.data?.audio;
+        if (!audioUrl) {
+            throw new Error("MiniMax TTS: no audio in response");
+        }
+        const characters = data.extra_info?.usage_characters ?? text.length;
+        return {
+            mediaUrls: [audioUrl],
+            model: request.model,
+            durationMs: Date.now() - start,
+            billingUnit: "per_character",
+            billingQuantity: characters,
+            metadata: {
+                traceId: data.trace_id,
+                status: data.data?.status,
+                extraInfo: data.extra_info,
+                billableUnits: {
+                    characters,
+                },
+            },
+        };
+    }
+    // 鈹€鈹€ Music Generation 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
+    async generateMusic(request, apiKey, signal) {
+        const start = Date.now();
+        // MiniMax music API is synchronous 鈥?single POST returns audio directly.
+        // Music generation can take 60-300s, so use MAX_POLL_MS as timeout.
+        const url = `${this.baseUrl}/v1/music_generation`;
+        const body = {
+            model: request.model,
+            prompt: request.prompt,
+            output_format: "url",
+        };
+        if (request.lyrics)
+            body.lyrics = request.lyrics;
+        if (request.duration)
+            body.duration = request.duration;
+        // MiniMax music-2.6 requires either lyrics or is_instrumental:true
+        if (request.isInstrumental || !request.lyrics)
+            body.is_instrumental = true;
+        if (request.audioUrl)
+            body.audio_url = request.audioUrl;
+        if (request.lyricsOptimizer)
+            body.lyrics_optimizer = true;
+        if (request.audioFormat || request.voice) {
+            body.audio_setting = {
+                sample_rate: 44100,
+                bitrate: 256000,
+                format: request.audioFormat ?? "mp3",
+            };
+        }
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify(body),
+            signal: signal ?? AbortSignal.timeout(MAX_POLL_MS),
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            throw new Error(`MiniMax music error ${res.status}: ${text}`);
+        }
+        const data = await res.json();
+        if (data.base_resp?.status_code && data.base_resp.status_code !== 0) {
+            throw new Error(`MiniMax music rejected: ${data.base_resp.status_msg ?? "unknown"}`);
+        }
+        // Sync response: data.audio (primary) or audio_file (legacy)
+        const audioUrl = data.data?.audio ?? data.audio_file;
+        if (audioUrl) {
+            return {
+                mediaUrls: [audioUrl],
+                model: request.model,
+                durationMs: Date.now() - start,
+                billingUnit: "per_second",
+                billingQuantity: request.duration ?? 0,
+                metadata: {
+                    billableUnits: {
+                        seconds: request.duration ?? 0,
+                    },
+                },
+            };
+        }
+        // Async fallback: poll by task_id
+        const taskId = data.task_id;
+        if (!taskId) {
+            throw new Error("MiniMax music: no audio_file or task_id in response");
+        }
+        const pollUrl = `${this.baseUrl}/v1/music_generation/${taskId}`;
+        const result = await this.pollTask(pollUrl, apiKey, signal, request.onProgress, taskId);
+        return {
+            mediaUrls: result.audioUrls,
+            model: request.model,
+            durationMs: Date.now() - start,
+            billingUnit: "per_second",
+            billingQuantity: request.duration ?? 0,
+            metadata: {
+                billableUnits: {
+                    seconds: request.duration ?? 0,
+                },
+            },
+        };
+    }
+    async pollTask(url, apiKey, signal, onProgress, taskId) {
+        const deadline = Date.now() + MAX_POLL_MS;
+        while (Date.now() < deadline) {
+            signal?.throwIfAborted();
+            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(`MiniMax music poll error ${res.status}: ${text}`);
+            }
+            const data = await res.json();
+            const status = data.status;
+            if (status === "Success" || status === "Finished") {
+                onProgress?.(100, "completed", taskId);
+                const audioUrls = [];
+                if (data.audio_file)
+                    audioUrls.push(data.audio_file);
+                return { audioUrls };
+            }
+            if (status === "Failed" || status === "Cancelled") {
+                throw new Error(`MiniMax music task failed: ${data.base_resp?.status_msg ?? "unknown"}`);
+            }
+            // Report progress estimate
+            const elapsed = Date.now() - (deadline - MAX_POLL_MS);
+            onProgress?.(Math.min(95, Math.round((elapsed / MAX_POLL_MS) * 100)), status ?? "running", taskId);
+            await new Promise(r => setTimeout(r, POLL_INTERVAL_MS));
+        }
+        throw new Error("MiniMax music task timed out after polling");
+    }
+    /**
+     * Generate lyrics from a text prompt via MiniMax Lyrics Generation API.
+     * POST /v1/lyrics_generation 鈥?returns structured lyrics with tags.
+     */
+    async generateLyrics(prompt, apiKey, signal) {
+        const url = `${this.baseUrl}/v1/lyrics_generation`;
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({ prompt }),
+            signal: signal ?? AbortSignal.timeout(this.timeoutMs),
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            throw new Error(`MiniMax lyrics API error ${res.status}: ${text}`);
+        }
+        const data = await res.json();
+        if (data.base_resp?.status_code && data.base_resp.status_code !== 0) {
+            throw new Error(`MiniMax lyrics error: ${data.base_resp.status_msg ?? "unknown"}`);
+        }
+        return data.data?.lyrics ?? "";
+    }
+    // 鈹€鈹€ Video Generation (minimax-ProviderMax 搂13-16) 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
+    // 4 modes: text-to-video, image-to-video, first-last-frame, subject-reference
+    // All submit to POST /v1/video_generation 鈫?async task 鈫?poll 鈫?file_id 鈫?download
+    async generateVideo(request, apiKey, signal) {
+        const start = Date.now();
+        const url = `${this.baseUrl}/v1/video_generation`;
+        const body = {
+            model: request.model || "S2V-01",
+            prompt: request.prompt,
+        };
+        // Route to correct video mode based on available inputs
+        if (request.referenceImages?.length && request.imageRoles) {
+            // Subject reference mode (搂16) or first-last-frame mode (搂15)
+            const hasFirstFrame = request.imageRoles.includes("first_frame");
+            const hasLastFrame = request.imageRoles.includes("last_frame");
+            if (hasFirstFrame && hasLastFrame) {
+                // First-last-frame mode (搂15)
+                const firstIdx = request.imageRoles.indexOf("first_frame");
+                const lastIdx = request.imageRoles.indexOf("last_frame");
+                body.first_frame_image = request.referenceImages[firstIdx];
+                body.last_frame_image = request.referenceImages[lastIdx];
+            }
+            else if (hasFirstFrame) {
+                // Image-to-video mode (搂14): single image as first frame
+                const idx = request.imageRoles.indexOf("first_frame");
+                body.first_frame_image = request.referenceImages[idx];
+            }
+            else {
+                // Subject reference mode (搂16)
+                body.subject_reference = request.referenceImages.map((imgUrl, i) => ({
+                    type: "character",
+                    image: imgUrl,
+                }));
+            }
+        }
+        else if (request.imageUrl) {
+            // Image-to-video mode (搂14): imageUrl as first frame
+            body.first_frame_image = request.imageUrl;
+        }
+        // Otherwise: text-to-video mode (搂13), just prompt
+        if (request.callbackUrl)
+            body.callback_url = request.callbackUrl;
+        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 text = await res.text().catch(() => "");
+            throw new Error(`MiniMax video submit error ${res.status}: ${text}`);
+        }
+        const data = await res.json();
+        if (data.base_resp?.status_code && data.base_resp.status_code !== 0) {
+            throw new Error(`MiniMax video rejected: ${data.base_resp.status_msg ?? "unknown"}`);
+        }
+        const taskId = data.task_id;
+        if (!taskId) {
+            throw new Error("MiniMax video: no task_id in response");
+        }
+        // Poll for completion
+        const result = await this.pollVideoTask(taskId, apiKey, signal, request.onProgress);
+        return {
+            mediaUrls: result.downloadUrl ? [result.downloadUrl] : [],
+            model: request.model || "S2V-01",
+            durationMs: Date.now() - start,
+            taskId,
+            billingUnit: "per_second",
+            billingQuantity: request.duration ?? 0,
+            metadata: {
+                billableUnits: {
+                    videos: 1,
+                    seconds: request.duration ?? 0,
+                },
+                fileId: result.fileId,
+                width: result.width,
+                height: result.height,
+            },
+        };
+    }
+    async pollVideoTask(taskId, apiKey, signal, onProgress) {
+        const deadline = Date.now() + MAX_POLL_MS;
+        while (Date.now() < deadline) {
+            signal?.throwIfAborted();
+            const queryUrl = `${this.baseUrl}/v1/query/video_generation?task_id=${encodeURIComponent(taskId)}`;
+            const res = await fetch(queryUrl, {
+                method: "GET",
+                headers: { Authorization: `Bearer ${apiKey}` },
+                signal: signal ?? AbortSignal.timeout(this.timeoutMs),
+            });
+            if (!res.ok) {
+                const text = await res.text().catch(() => "");
+                throw new Error(`MiniMax video poll error ${res.status}: ${text}`);
+            }
+            const data = await res.json();
+            if (data.base_resp?.status_code && data.base_resp.status_code !== 0) {
+                // 1026=input sensitive content, 1027=output sensitive content
+                throw new Error(`MiniMax video task error ${data.base_resp.status_code}: ${data.base_resp.status_msg ?? ""}`);
+            }
+            const status = data.status;
+            if (status === "Success") {
+                onProgress?.(100, "completed", taskId);
+                // Get download URL via file retrieve endpoint
+                let downloadUrl;
+                if (data.file_id) {
+                    try {
+                        downloadUrl = await this.getFileDownloadUrl(data.file_id, apiKey, signal);
+                    }
+                    catch {
+                        // Non-fatal: file_id is still usable
+                    }
+                }
+                return {
+                    fileId: data.file_id,
+                    downloadUrl,
+                    width: data.video_width,
+                    height: data.video_height,
+                };
+            }
+            if (status === "Fail") {
+                throw new Error(`MiniMax video task failed: ${data.base_resp?.status_msg ?? "unknown"}`);
+            }
+            // Preparing / Queueing / Processing 鈥?report progress
+            const statusLabel = status ?? "running";
+            const elapsed = Date.now() - (deadline - MAX_POLL_MS);
+            const estimatedPercent = Math.min(95, Math.round((elapsed / MAX_POLL_MS) * 100));
+            onProgress?.(estimatedPercent, statusLabel, taskId);
+            await new Promise(r => setTimeout(r, POLL_INTERVAL_MS));
+        }
+        throw new Error("MiniMax video task timed out after polling");
+    }
+    // 鈹€鈹€ File Retrieve (minimax-ProviderMax 搂26) 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
+    // GET /v1/files/retrieve?file_id=XXX 鈫?{ download_url, bytes, filename, ... }
+    async getFileDownloadUrl(fileId, apiKey, signal) {
+        const url = `${this.baseUrl}/v1/files/retrieve?file_id=${encodeURIComponent(fileId)}`;
+        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(`MiniMax file retrieve error ${res.status}: ${text}`);
+        }
+        const data = await res.json();
+        const downloadUrl = data.file?.download_url;
+        if (!downloadUrl) {
+            throw new Error("MiniMax file retrieve: no download_url in response");
+        }
+        return downloadUrl;
+    }
+    // 鈹€鈹€ AsyncMediaTransport: Task Management 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
+    /**
+     * Query a single video task by ID.
+     * GET /v1/query/video_generation?task_id=XXX
+     */
+    async getTaskStatus(taskId, apiKey, signal) {
+        const url = `${this.baseUrl}/v1/query/video_generation?task_id=${encodeURIComponent(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(`MiniMax task status error ${res.status}: ${text}`);
+        }
+        const data = await res.json();
+        const rawStatus = data.status ?? "unknown";
+        // Normalize MiniMax statuses to lower-case
+        const normalizedStatus = rawStatus === "Success" ? "succeeded"
+            : rawStatus === "Fail" ? "failed"
+                : rawStatus.toLowerCase();
+        return { status: normalizedStatus, task: data };
+    }
+    /**
+     * List tasks 鈥?MiniMax does not have a bulk list endpoint.
+     * Each task must be queried individually with getTaskStatus().
+     */
+    async listVideoTasks(_apiKey, _options, _signal) {
+        // MiniMax has no list endpoint; callers should use getTaskStatus() for direct lookup
+        return { data: [] };
+    }
+    /**
+     * Cancel/delete is not natively supported by MiniMax video API.
+     */
+    async deleteVideoTask(_taskId, _apiKey, _signal) {
+        throw new Error("MiniMax does not support video task cancellation.");
+    }
+}

package/dist/transports/openai-chat.d.ts

@@ -0,0 +1,81 @@
+/**
+ * OpenAI Chat Completions TransportSSE streaming implementation.
+ *
+ * Covers all OpenAI-compatible providers:
+ *   DeepSeek, Qwen, Minimax, Moonshot, OpenRouter, etc.
+ *
+ * POST {baseUrl}/v1/chat/completions with stream: true
+ * Auth: Authorization: Bearer {apiKey}
+ *
+ * SSE format: lines prefixed with "data: ", JSON parsing per event.
+ *
+ * Adapted from admin-infer-proxy-client.ts SSE logic + Hermes openai_chat.py transport.
+ */
+import type { LLMChunk, LLMRequest, LLMTransport, FIMRequest, FIMChunk } from "../transport.js";
+import type { ProviderQuirks } from "../provider-def.js";
+import type { FileUploadAdapter } from "../file-upload-service.js";
+export interface OpenAIChatTransportConfig {
+    baseUrl: string;
+    /** Additional headers (e.g. for specific providers) */
+    extraHeaders?: Record<string, string>;
+    /** Timeout in ms (default 180_000) */
+    timeoutMs?: number;
+    /** Whether to include stream_options (default true). Set false for providers that reject it. */
+    supportsStreamOptions?: boolean;
+    /** Whether to omit temperature when it equals 0 (e.g. Moonshot rejects 0) */
+    omitZeroTemperature?: boolean;
+    /** Provider-specific quirks (CC/altcode parity) */
+    quirks?: ProviderQuirks;
+    /** File upload adapter for resolving local media URLs via upload instead of base64. */
+    fileUploadAdapter?: FileUploadAdapter;
+}
+export declare class OpenAIChatTransport implements LLMTransport {
+    private baseUrl;
+    private extraHeaders;
+    private timeoutMs;
+    private supportsStreamOptions;
+    private omitZeroTemperature;
+    private quirks;
+    private fileUploadAdapter?;
+    private cumulativeReasoningLen;
+    private cumulativeContentLen;
+    constructor(config: OpenAIChatTransportConfig);
+    stream(request: LLMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<LLMChunk>;
+    private fetchAndStream;
+    /**
+     * Handle non-streaming JSON response from providers that ignore stream:true.
+     * Synthesize the same LLMChunk events a streaming response would produce.
+     */
+    private handleNonStreamingResponse;
+    /**
+     * Parse SSE stream with 90s idle watchdog (CC parity).
+     * If no data arrives within STREAM_IDLE_TIMEOUT_MS, throw to trigger retry.
+     */
+    private parseSSEStreamWithWatchdog;
+    private processChunk;
+    /**
+     * FIM completion via /beta/v1/completions.
+     * Only works with DeepSeek (requires supportsPrefixCompletion quirk).
+     * Non-thinking mode only; max completion 4K tokens.
+     */
+    complete(request: FIMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<FIMChunk>;
+    /**
+     * Upload a file for use in conversations (Kimi File API).
+     * Returns a file_id that can be referenced in user messages.
+     * POST /v1/files with multipart/form-data.
+     */
+    uploadFile(fileBlob: Blob, filename: string, purpose: string, apiKey: string, signal?: AbortSignal): Promise<{
+        fileId: string;
+        filename: string;
+        bytes: number;
+    }>;
+    /**
+     * Get file content/statusGET /v1/files/{file_id}
+     */
+    getFileInfo(fileId: string, apiKey: string, signal?: AbortSignal): Promise<{
+        id: string;
+        filename: string;
+        bytes: number;
+        status: string;
+    }>;
+}