@mingxy/ocosay 1.0.35 → 1.1.1

package/dist/providers/minimax.js

@@ -98,36 +98,59 @@ export class MiniMaxProvider extends BaseTTSProvider {
             });
             const stream = response.data;
             const audioChunks = [];
+            let lineBuffer = '';
             return new Promise((resolve, reject) => {
                 stream.on('data', (chunk) => {
-                    try {
-                        const lines = chunk.toString().split('\n');
-                        for (const line of lines) {
-                            if (line.startsWith('data:')) {
-                                const data = JSON.parse(line.slice(5));
-                                if (data.data?.audio) {
-                                    audioChunks.push(Buffer.from(data.data.audio, 'hex'));
-                                }
-                                if (data.data?.status === 2) {
-                                    const fullAudio = Buffer.concat(audioChunks);
-                                    resolve({
-                                        audioData: fullAudio,
-                                        format: this.audioFormat,
-                                        isStream: true,
-                                        duration: this.estimateDuration(fullAudio.length)
-                                    });
-                                }
+                    lineBuffer += chunk.toString();
+                    while (true) {
+                        const lineEnd = lineBuffer.indexOf('\n');
+                        if (lineEnd === -1)
+                            break;
+                        const line = lineBuffer.slice(0, lineEnd).trim();
+                        lineBuffer = lineBuffer.slice(lineEnd + 1);
+                        if (!line || !line.startsWith('data:'))
+                            continue;
+                        const jsonStr = line.slice(5).trim();
+                        if (!jsonStr)
+                            continue;
+                        try {
+                            const data = JSON.parse(jsonStr);
+                            if (data.audio) {
+                                audioChunks.push(Buffer.from(data.audio, 'hex'));
+                            }
+                            if (data.is_final === true) {
+                                const fullAudio = Buffer.concat(audioChunks);
+                                resolve({
+                                    audioData: fullAudio,
+                                    format: this.audioFormat,
+                                    isStream: true,
+                                    duration: this.estimateDuration(fullAudio.length)
+                                });
                             }
                         }
-                    }
-                    catch (e) {
-                        audioChunks.push(chunk);
+                        catch (e) {
+                            // ignore
+                        }
                     }
                 });
                 stream.on('error', (err) => {
                     reject(new TTSError('Stream error', TTSErrorCode.NETWORK, this.name, err));
                 });
                 stream.on('end', () => {
+                    if (lineBuffer.trim() && lineBuffer.startsWith('data:')) {
+                        const jsonStr = lineBuffer.slice(5).trim();
+                        if (jsonStr) {
+                            try {
+                                const data = JSON.parse(jsonStr);
+                                if (data.audio) {
+                                    audioChunks.push(Buffer.from(data.audio, 'hex'));
+                                }
+                            }
+                            catch (e) {
+                                // ignore
+                            }
+                        }
+                    }
                     if (audioChunks.length > 0) {
                         const fullAudio = Buffer.concat(audioChunks);
                         resolve({

package/dist/services/notification-service.d.ts

@@ -0,0 +1,17 @@
+export type ToastType = 'success' | 'error' | 'warning' | 'info';
+export declare class NotificationService {
+    private constructor();
+    static getInstance(): NotificationService;
+    initialize(tuiInstance: any): void;
+    isReady(): boolean;
+    showToast(message: string, type?: ToastType): void;
+    success(message: string): void;
+    error(message: string): void;
+    warning(message: string): void;
+    info(message: string): void;
+    private getTitleForType;
+    private fallbackLog;
+}
+export declare function showToast(message: string, type?: ToastType): void;
+export declare function initializeNotificationService(tuiInstance: any): void;
+//# sourceMappingURL=notification-service.d.ts.map

package/dist/services/notification-service.js

@@ -0,0 +1,74 @@
+import { logger } from '../utils/logger.js';
+let instance;
+let tui = null;
+let initialized = false;
+export class NotificationService {
+    constructor() { }
+    static getInstance() {
+        if (!instance) {
+            instance = new NotificationService();
+        }
+        return instance;
+    }
+    initialize(tuiInstance) {
+        if (initialized)
+            return;
+        tui = tuiInstance;
+        initialized = true;
+        logger.debug('NotificationService initialized');
+    }
+    isReady() {
+        return initialized && tui !== null;
+    }
+    showToast(message, type = 'info') {
+        const title = this.getTitleForType(type);
+        if (tui?.showToast) {
+            try {
+                tui.showToast({
+                    title,
+                    message,
+                    variant: type,
+                    duration: type === 'error' ? 8000 : 5000
+                });
+                return;
+            }
+            catch (err) {
+                logger.warn({ err }, 'tui.showToast failed');
+            }
+        }
+        this.fallbackLog(type, title, message);
+    }
+    success(message) { this.showToast(message, 'success'); }
+    error(message) { this.showToast(message, 'error'); }
+    warning(message) { this.showToast(message, 'warning'); }
+    info(message) { this.showToast(message, 'info'); }
+    getTitleForType(type) {
+        const titles = {
+            success: 'Success',
+            error: 'Error',
+            warning: 'Warning',
+            info: 'Info'
+        };
+        return titles[type];
+    }
+    fallbackLog(type, title, message) {
+        const timestamp = new Date().toISOString();
+        switch (type) {
+            case 'error':
+                logger.error({ title, message, timestamp }, 'Toast (fallback)');
+                break;
+            case 'warning':
+                logger.warn({ title, message, timestamp }, 'Toast (fallback)');
+                break;
+            default:
+                logger.info({ title, message, timestamp }, 'Toast (fallback)');
+        }
+    }
+}
+export function showToast(message, type = 'info') {
+    NotificationService.getInstance().showToast(message, type);
+}
+export function initializeNotificationService(tuiInstance) {
+    NotificationService.getInstance().initialize(tuiInstance);
+}
+//# sourceMappingURL=notification-service.js.map

package/dist/services/speaker-service.d.ts

@@ -0,0 +1,34 @@
+import { Voice, SpeakOptions } from '../core/types';
+export interface speakerServiceOptions {
+    defaultProvider?: string;
+    defaultModel?: 'sync' | 'async' | 'stream';
+    defaultVoice?: string;
+}
+export declare class SpeakerService {
+    private options;
+    private speaker;
+    constructor(options?: speakerServiceOptions);
+    speak(text: string, options?: SpeakOptions & {
+        provider?: string;
+    }): Promise<void>;
+    pause(): void;
+    resume(): void;
+    stop(): Promise<void>;
+    listVoices(providerName?: string): Promise<Voice[]>;
+    getCapabilities(providerName?: string): import("../core/types").TTSCapabilities;
+    getProviders(): string[];
+    isPlaying(): boolean;
+    isPausedState(): boolean;
+    destroy(): Promise<void>;
+    private getTimestamp;
+}
+export declare function getDefaultSpeakerService(): SpeakerService;
+export declare function speak(text: string, options?: SpeakOptions & {
+    provider?: string;
+}): Promise<void>;
+export declare function stop(): Promise<void>;
+export declare function pause(): void;
+export declare function resume(): void;
+export declare function listVoices(providerName?: string): Promise<Voice[]>;
+export default SpeakerService;
+//# sourceMappingURL=speaker-service.d.ts.map

package/dist/services/speaker-service.js

@@ -0,0 +1,74 @@
+import { getDefaultSpeaker, speak as coreSpeak, stop as coreStop, pause as corePause, resume as coreResume, listVoices as coreListVoices } from '../core/speaker';
+import { logger } from '../utils/logger';
+export class SpeakerService {
+    options;
+    speaker;
+    constructor(options = {}) {
+        this.options = options;
+        this.speaker = getDefaultSpeaker();
+    }
+    async speak(text, options) {
+        const timestamp = this.getTimestamp();
+        logger.info(`[Ocosay][${timestamp}][INFO][Speaker] 对应事件{播放开始} - 文本长度: ${text.length}`);
+        return this.speaker.speak(text, options);
+    }
+    pause() {
+        this.speaker.pause();
+    }
+    resume() {
+        this.speaker.resume();
+    }
+    async stop() {
+        return this.speaker.stop();
+    }
+    async listVoices(providerName) {
+        return this.speaker.listVoices(providerName);
+    }
+    getCapabilities(providerName) {
+        return this.speaker.getCapabilities(providerName);
+    }
+    getProviders() {
+        return this.speaker.getProviders();
+    }
+    isPlaying() {
+        return this.speaker.isPlaying();
+    }
+    isPausedState() {
+        return this.speaker.isPausedState();
+    }
+    async destroy() {
+        return this.speaker.destroy();
+    }
+    getTimestamp() {
+        const now = new Date();
+        const pad = (n) => n.toString().padStart(2, '0');
+        return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+    }
+}
+let defaultSpeakerService;
+export function getDefaultSpeakerService() {
+    if (!defaultSpeakerService) {
+        defaultSpeakerService = new SpeakerService();
+    }
+    return defaultSpeakerService;
+}
+export async function speak(text, options) {
+    if (options) {
+        return coreSpeak(text, options);
+    }
+    return coreSpeak(text);
+}
+export async function stop() {
+    return coreStop();
+}
+export function pause() {
+    corePause();
+}
+export function resume() {
+    coreResume();
+}
+export async function listVoices(providerName) {
+    return coreListVoices(providerName);
+}
+export default SpeakerService;
+//# sourceMappingURL=speaker-service.js.map

package/dist/services/streaming-service.d.ts

@@ -0,0 +1,109 @@
+/**
+ * StreamingService - 流式TTS服务（Service层）
+ *
+ * 功能：
+ * - 调用Provider层获取流式TTS
+ * - 调用Backend层播放音频
+ * - 支持边接收边播放（豆包模式）
+ *
+ * 数据流：
+ * stream(text) → MiniMaxProvider.speak(stream) → StreamPlayer (边收边播)
+ */
+import { EventEmitter } from 'events';
+import { BackendType } from '../core/backends';
+export interface StreamingServiceOptions {
+    provider?: string;
+    voice?: string;
+    speed?: number;
+    volume?: number;
+    pitch?: number;
+    backendType?: BackendType;
+}
+export interface StreamingServiceStatus {
+    isActive: boolean;
+    bytesWritten: number;
+    state: string;
+}
+export declare class StreamingService extends EventEmitter {
+    private player;
+    private providerName;
+    private voice?;
+    private speed?;
+    private volume?;
+    private pitch?;
+    private backendType;
+    private _isActive;
+    private _bytesWritten;
+    constructor(options?: StreamingServiceOptions);
+    /**
+     * 获取时间戳
+     */
+    private getTimestamp;
+    /**
+     * 初始化播放器
+     */
+    private initPlayer;
+    /**
+     * 流式播放文本
+     * 边接收边播放（豆包模式）
+     */
+    stream(text: string): Promise<void>;
+    /**
+     * 处理音频结果
+     */
+    private processAudioResult;
+    /**
+     * 流式处理音频chunk
+     */
+    private streamAudioChunks;
+    /**
+     * 停止流式播放
+     */
+    stop(): void;
+    /**
+     * 暂停流式播放
+     */
+    pause(): void;
+    /**
+     * 恢复流式播放
+     */
+    resume(): void;
+    /**
+     * 获取流式播放状态
+     */
+    getStatus(): StreamingServiceStatus;
+    /**
+     * 是否处于活跃状态
+     */
+    isActive(): boolean;
+    /**
+     * 销毁服务
+     */
+    destroy(): Promise<void>;
+}
+/**
+ * 获取默认流式服务实例
+ */
+export declare function getDefaultStreamingService(): StreamingService;
+/**
+ * 导出 stream 方法
+ */
+export declare function stream(text: string, options?: StreamingServiceOptions): Promise<void>;
+/**
+ * 导出 stop 方法
+ */
+export declare function streamStop(): void;
+/**
+ * 导出 pause 方法
+ */
+export declare function streamPause(): void;
+/**
+ * 导出 resume 方法
+ */
+export declare function streamResume(): void;
+/**
+ * 导出 getStreamStatus 方法
+ */
+export declare function getStreamStatus(): StreamingServiceStatus;
+export default StreamingService;
+//# sourceMappingURL=streaming-service.d.ts.map

package/dist/services/streaming-service.js

@@ -0,0 +1,281 @@
+/**
+ * StreamingService - 流式TTS服务（Service层）
+ *
+ * 功能：
+ * - 调用Provider层获取流式TTS
+ * - 调用Backend层播放音频
+ * - 支持边接收边播放（豆包模式）
+ *
+ * 数据流：
+ * stream(text) → MiniMaxProvider.speak(stream) → StreamPlayer (边收边播)
+ */
+import { EventEmitter } from 'events';
+import { getProvider } from '../providers/base';
+import { TTSError, TTSErrorCode } from '../core/types';
+import { StreamPlayer } from '../core/stream-player';
+import { BackendType } from '../core/backends';
+import { logger } from '../utils/logger';
+export class StreamingService extends EventEmitter {
+    player = null;
+    providerName;
+    voice;
+    speed;
+    volume;
+    pitch;
+    backendType;
+    _isActive = false;
+    _bytesWritten = 0;
+    constructor(options = {}) {
+        super();
+        this.providerName = options.provider || 'minimax';
+        this.voice = options.voice;
+        this.speed = options.speed;
+        this.volume = options.volume;
+        this.pitch = options.pitch;
+        this.backendType = options.backendType || BackendType.NAUDIODON;
+    }
+    /**
+     * 获取时间戳
+     */
+    getTimestamp() {
+        const now = new Date();
+        const pad = (n) => n.toString().padStart(2, '0');
+        return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+    }
+    /**
+     * 初始化播放器
+     */
+    initPlayer() {
+        if (this.player) {
+            this.player.stop();
+            this.player = null;
+        }
+        const playerOptions = {
+            format: 'mp3',
+            backendType: this.backendType,
+            events: {
+                onStart: () => {
+                    const timestamp = this.getTimestamp();
+                    logger.info(`[Ocosay][${timestamp}][INFO][Streaming] 对应事件{流式播放开始}`);
+                    this.emit('start');
+                },
+                onEnd: () => {
+                    const timestamp = this.getTimestamp();
+                    logger.info(`[Ocosay][${timestamp}][INFO][Streaming] 对应事件{流式播放结束}`);
+                    this._isActive = false;
+                    this.emit('end');
+                },
+                onError: (error) => {
+                    const timestamp = this.getTimestamp();
+                    logger.error(`[Ocosay][${timestamp}][ERROR][Streaming] 对应事件{流式播放错误} - ${error.message}`);
+                    this._isActive = false;
+                    this.emit('error', error);
+                },
+                onProgress: (bytes) => {
+                    this._bytesWritten = bytes;
+                    this.emit('progress', bytes);
+                },
+                onPause: () => {
+                    const timestamp = this.getTimestamp();
+                    logger.info(`[Ocosay][${timestamp}][INFO][Streaming] 对应事件{流式播放暂停}`);
+                    this.emit('pause');
+                },
+                onResume: () => {
+                    const timestamp = this.getTimestamp();
+                    logger.info(`[Ocosay][${timestamp}][INFO][Streaming] 对应事件{流式播放恢复}`);
+                    this.emit('resume');
+                },
+                onStop: () => {
+                    const timestamp = this.getTimestamp();
+                    logger.info(`[Ocosay][${timestamp}][INFO][Streaming] 对应事件{流式播放停止}`);
+                    this._isActive = false;
+                    this._bytesWritten = 0;
+                    this.emit('stop');
+                }
+            }
+        };
+        this.player = new StreamPlayer(playerOptions);
+        return this.player;
+    }
+    /**
+     * 流式播放文本
+     * 边接收边播放（豆包模式）
+     */
+    async stream(text) {
+        if (!text || text.trim().length === 0) {
+            const timestamp = this.getTimestamp();
+            logger.warn(`[Ocosay][${timestamp}][WARNING][Streaming] 对应事件{空文本跳过}`);
+            return;
+        }
+        const timestamp = this.getTimestamp();
+        logger.info(`[Ocosay][${timestamp}][INFO][Streaming] 对应事件{流式播放开始} - 文本长度: ${text.length}`);
+        try {
+            // 获取 Provider
+            const provider = getProvider(this.providerName);
+            if (!provider) {
+                throw new TTSError(`Provider ${this.providerName} not found`, TTSErrorCode.UNKNOWN, this.providerName);
+            }
+            // 初始化播放器
+            const player = this.initPlayer();
+            player.start();
+            this._isActive = true;
+            this._bytesWritten = 0;
+            // 调用 Provider 的流式合成
+            const result = await provider.speak(text, {
+                voice: this.voice,
+                model: 'stream',
+                speed: this.speed,
+                volume: this.volume,
+                pitch: this.pitch
+            });
+            // 处理音频结果
+            await this.processAudioResult(result, player);
+        }
+        catch (error) {
+            const ts = this.getTimestamp();
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            logger.error(`[Ocosay][${ts}][ERROR][Streaming] 对应事件{流式播放错误} - ${errorMsg}`);
+            this._isActive = false;
+            throw error;
+        }
+    }
+    /**
+     * 处理音频结果
+     */
+    async processAudioResult(result, player) {
+        if (result.isStream && result.audioData instanceof ReadableStream) {
+            // 流式数据：边收边播
+            await this.streamAudioChunks(result.audioData, player);
+        }
+        else if (Buffer.isBuffer(result.audioData)) {
+            // 非流式数据：直接写入
+            player.write(result.audioData);
+            player.end();
+        }
+    }
+    /**
+     * 流式处理音频chunk
+     */
+    async streamAudioChunks(stream, player) {
+        const reader = stream.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                if (value) {
+                    const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+                    player.write(chunk);
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+            player.end();
+        }
+    }
+    /**
+     * 停止流式播放
+     */
+    stop() {
+        if (this.player) {
+            this.player.stop();
+        }
+        this._isActive = false;
+        this._bytesWritten = 0;
+    }
+    /**
+     * 暂停流式播放
+     */
+    pause() {
+        if (this.player) {
+            this.player.pause();
+        }
+    }
+    /**
+     * 恢复流式播放
+     */
+    resume() {
+        if (this.player) {
+            this.player.resume();
+        }
+    }
+    /**
+     * 获取流式播放状态
+     */
+    getStatus() {
+        return {
+            isActive: this._isActive,
+            bytesWritten: this._bytesWritten,
+            state: this.player?.isStopped() ? 'stopped' :
+                this.player?.isPaused() ? 'paused' :
+                    this._isActive ? 'playing' : 'idle'
+        };
+    }
+    /**
+     * 是否处于活跃状态
+     */
+    isActive() {
+        return this._isActive;
+    }
+    /**
+     * 销毁服务
+     */
+    async destroy() {
+        if (this.player) {
+            this.player.stop();
+            this.player = null;
+        }
+        this._isActive = false;
+        this._bytesWritten = 0;
+    }
+}
+// 单例实例
+let defaultStreamingService;
+/**
+ * 获取默认流式服务实例
+ */
+export function getDefaultStreamingService() {
+    if (!defaultStreamingService) {
+        defaultStreamingService = new StreamingService();
+    }
+    return defaultStreamingService;
+}
+/**
+ * 导出 stream 方法
+ */
+export async function stream(text, options) {
+    const service = options ? new StreamingService(options) : getDefaultStreamingService();
+    return service.stream(text);
+}
+/**
+ * 导出 stop 方法
+ */
+export function streamStop() {
+    const service = getDefaultStreamingService();
+    service.stop();
+}
+/**
+ * 导出 pause 方法
+ */
+export function streamPause() {
+    const service = getDefaultStreamingService();
+    service.pause();
+}
+/**
+ * 导出 resume 方法
+ */
+export function streamResume() {
+    const service = getDefaultStreamingService();
+    service.resume();
+}
+/**
+ * 导出 getStreamStatus 方法
+ */
+export function getStreamStatus() {
+    const service = getDefaultStreamingService();
+    return service.getStatus();
+}
+export default StreamingService;
+//# sourceMappingURL=streaming-service.js.map