@mingxy/ocosay 1.0.2 → 1.0.3

package/dist/plugin.js

@@ -1,162 +1,1931 @@
-import { tool } from '@opencode-ai/plugin';
-import { handleToolCall } from './index';
-import { initialize } from './index';
-import { loadOrCreateConfig } from './config';
-const pluginName = 'ocosay';
-const ttsSpeakTool = tool({
-    description: '将文本转换为语音并播放',
-    args: {
-        text: tool.schema.string().describe('要转换的文本内容'),
-        provider: tool.schema.string().optional().describe('TTS 提供商名称'),
-        voice: tool.schema.string().optional().describe('音色 ID'),
-        model: tool.schema.enum(['sync', 'async', 'stream']).optional().describe('合成模式'),
-        speed: tool.schema.number().optional().describe('语速 0.5-2.0'),
-        volume: tool.schema.number().optional().describe('音量 0-100'),
-        pitch: tool.schema.number().optional().describe('音调 0.5-2.0')
-    },
-    execute: async (args) => {
-        const result = await handleToolCall('tts_speak', args);
-        if (result.success === false) {
-            throw new Error(result.error || 'Unknown error');
-        }
-        return result;
+// src/plugin.ts
+import { tool } from "@opencode-ai/plugin";
+
+// src/core/speaker.ts
+import { EventEmitter as EventEmitter2 } from "events";
+
+// src/core/types.ts
+var TTSError = class extends Error {
+  constructor(message, code, provider, details) {
+    super(message);
+    this.name = "TTSError";
+    this.code = code;
+    this.provider = provider;
+    this.details = details;
+  }
+  code;
+  provider;
+  details;
+};
+
+// src/providers/base.ts
+var providers = /* @__PURE__ */ new Map();
+function registerProvider(name, provider) {
+  if (providers.has(name)) {
+    throw new TTSError(
+      `Provider "${name}" is already registered`,
+      "UNKNOWN" /* UNKNOWN */,
+      "system"
+    );
+  }
+  providers.set(name, provider);
+}
+function getProvider(name) {
+  const provider = providers.get(name);
+  if (!provider) {
+    throw new TTSError(
+      `TTS Provider "${name}" not found`,
+      "UNKNOWN" /* UNKNOWN */,
+      "system"
+    );
+  }
+  return provider;
+}
+function listProviders() {
+  return Array.from(providers.keys());
+}
+function hasProvider(name) {
+  return providers.has(name);
+}
+var BaseTTSProvider = class {
+  apiKey;
+  defaultVoice;
+  defaultModel = "stream";
+  async initialize() {
+  }
+  async destroy() {
+  }
+  /**
+   * 通用 speak 实现，处理通用逻辑
+   */
+  async speak(text, options) {
+    if (!text || text.trim().length === 0) {
+      throw new TTSError(
+        "Text cannot be empty",
+        "INVALID_PARAMS" /* INVALID_PARAMS */,
+        this.name
+      );
     }
-});
-const ttsStopTool = tool({
-    description: '停止当前 TTS 播放',
-    args: {},
-    execute: async () => {
-        const result = await handleToolCall('tts_stop');
-        if (result.success === false) {
-            throw new Error(result.error || 'Unknown error');
-        }
-        return result;
+    const voice = options?.voice || this.defaultVoice;
+    const model = options?.model || this.defaultModel;
+    return this.doSpeak(text, voice, model, options);
+  }
+  pause() {
+    throw new TTSError(
+      "Pause is not supported by this provider",
+      "UNKNOWN" /* UNKNOWN */,
+      this.name
+    );
+  }
+  resume() {
+    throw new TTSError(
+      "Resume is not supported by this provider",
+      "UNKNOWN" /* UNKNOWN */,
+      this.name
+    );
+  }
+  stop() {
+    return Promise.resolve();
+  }
+  async listVoices() {
+    return [];
+  }
+  getCapabilities() {
+    return this.capabilities;
+  }
+  /**
+   * 验证 API Key
+   */
+  validateApiKey() {
+    if (!this.apiKey) {
+      throw new TTSError(
+        `API key is required for provider "${this.name}"`,
+        "AUTH" /* AUTH */,
+        this.name
+      );
     }
-});
-const ttsPauseTool = tool({
-    description: '暂停当前 TTS 播放',
-    args: {},
-    execute: async () => {
-        const result = await handleToolCall('tts_pause');
-        if (result.success === false) {
-            throw new Error(result.error || 'Unknown error');
+  }
+};
+
+// src/core/player.ts
+import { EventEmitter } from "events";
+import { spawn } from "child_process";
+import fs from "fs";
+import { createWriteStream } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+var AudioPlayer = class extends EventEmitter {
+  constructor(events) {
+    super();
+    this.events = events;
+  }
+  events;
+  _playing = false;
+  _paused = false;
+  currentProcess;
+  currentFile;
+  /**
+   * 播放音频
+   * @param audioData 音频数据 (Buffer 或 ReadableStream)
+   * @param format 音频格式 (mp3, wav, etc.)
+   */
+  async play(audioData, format) {
+    if (this._playing) {
+      await this.stop();
+    }
+    this._playing = true;
+    this._paused = false;
+    try {
+      const tempFile = join(tmpdir(), `ocosay-${Date.now()}.${format}`);
+      this.currentFile = tempFile;
+      if (Buffer.isBuffer(audioData)) {
+        fs.writeFileSync(tempFile, audioData);
+      } else {
+        const writeStream = createWriteStream(tempFile);
+        const reader = audioData.getReader();
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            if (value instanceof Uint8Array) {
+              writeStream.write(Buffer.from(value));
+            }
+          }
+          writeStream.end();
+        } finally {
+          reader.releaseLock();
         }
-        return result;
+        await new Promise((resolve, reject) => {
+          writeStream.on("finish", resolve);
+          writeStream.on("error", reject);
+        });
+      }
+      this.events?.onStart?.();
+      this.emit("start");
+      await this.playFile(tempFile, format);
+      this._playing = false;
+      this.events?.onEnd?.();
+      this.emit("end");
+      this.cleanup();
+    } catch (error) {
+      this._playing = false;
+      const ttsError = new TTSError(
+        error.message || "Playback failed",
+        "PLAYER_ERROR" /* PLAYER_ERROR */,
+        "player"
+      );
+      this.events?.onError?.(ttsError);
+      this.emit("error", ttsError);
+      throw ttsError;
     }
-});
-const ttsResumeTool = tool({
-    description: '恢复暂停的 TTS 播放',
-    args: {},
-    execute: async () => {
-        const result = await handleToolCall('tts_resume');
-        if (result.success === false) {
-            throw new Error(result.error || 'Unknown error');
+  }
+  /**
+   * 播放音频文件
+   * 优先使用 afplay (macOS), aplay (Linux), 否则用 PowerShell (Windows)
+   */
+  playFile(filePath, format) {
+    const platform = process.platform;
+    return new Promise((resolve, reject) => {
+      let command;
+      let args;
+      if (platform === "darwin") {
+        command = "afplay";
+        args = [filePath];
+      } else if (platform === "linux") {
+        command = "aplay";
+        args = [filePath];
+      } else {
+        command = "powershell";
+        args = ["-c", `(New-Object System.Media.SoundPlayer('${filePath.replace(/\\/g, "\\\\")}')).PlaySync()`];
+      }
+      this.currentProcess = spawn(command, args, {
+        stdio: "ignore",
+        detached: false
+      });
+      this.currentProcess.on("exit", (code, signal) => {
+        if (signal === "SIGTERM" || signal === "SIGINT") {
+          resolve();
+        } else if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`Player exited with code ${code}`));
         }
-        return result;
+      });
+      this.currentProcess.on("error", (error) => {
+        reject(error);
+      });
+    });
+  }
+  /**
+   * 暂停播放
+   * 注意: 目前通过 SIGSTOP 实现，真正的 pause 需要支持暂停的音频库
+   */
+  pause() {
+    if (!this._playing || this._paused) return;
+    if (this.currentProcess) {
+      try {
+        this.currentProcess.kill("SIGSTOP");
+        this._paused = true;
+        this.events?.onPause?.();
+        this.emit("pause");
+      } catch (e) {
+      }
     }
-});
-const ttsListVoicesTool = tool({
-    description: '列出可用的音色',
-    args: {
-        provider: tool.schema.string().optional().describe('TTS 提供商名称')
-    },
-    execute: async (args) => {
-        const result = await handleToolCall('tts_list_voices', args);
-        if (result.success === false) {
-            throw new Error(result.error || 'Unknown error');
+  }
+  /**
+   * 恢复播放
+   */
+  resume() {
+    if (!this._playing || !this._paused) return;
+    if (this.currentProcess) {
+      try {
+        this.currentProcess.kill("SIGCONT");
+        this._paused = false;
+        this.events?.onResume?.();
+        this.emit("resume");
+      } catch (e) {
+      }
+    }
+  }
+  /**
+   * 停止播放
+   */
+  async stop() {
+    this._playing = false;
+    this._paused = false;
+    if (this.currentProcess) {
+      try {
+        this.currentProcess.kill("SIGTERM");
+      } catch (e) {
+      }
+      this.currentProcess = void 0;
+    }
+    this.cleanup();
+    this.events?.onStop?.();
+    this.emit("stop");
+  }
+  /**
+   * 是否正在播放
+   */
+  isPlaying() {
+    return this._playing;
+  }
+  /**
+   * 是否暂停
+   */
+  isPaused() {
+    return this._paused;
+  }
+  /**
+   * 清理临时文件
+   */
+  cleanup() {
+    if (this.currentFile) {
+      try {
+        if (fs.existsSync(this.currentFile)) {
+          fs.unlinkSync(this.currentFile);
         }
-        return result;
+      } catch (e) {
+      }
+      this.currentFile = void 0;
     }
-});
-const ttsListProvidersTool = tool({
-    description: '列出所有已注册的 TTS 提供商',
-    args: {},
-    execute: async () => {
-        const result = await handleToolCall('tts_list_providers');
-        if (result.success === false) {
-            throw new Error(result.error || 'Unknown error');
+  }
+};
+
+// src/core/speaker.ts
+var Speaker = class extends EventEmitter2 {
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    const playerEvents = {
+      onStart: () => this.emit("start", this.currentText),
+      onEnd: () => {
+        this.isSpeaking = false;
+        this.emit("end", this.currentText);
+      },
+      onError: (error) => this.emit("error", error),
+      onPause: () => {
+        this.isPaused = true;
+        this.emit("pause");
+      },
+      onResume: () => {
+        this.isPaused = false;
+        this.emit("resume");
+      },
+      onStop: () => {
+        this.isSpeaking = false;
+        this.isPaused = false;
+        this.emit("stop");
+      }
+    };
+    this.player = new AudioPlayer(playerEvents);
+  }
+  options;
+  currentProvider;
+  player;
+  currentText;
+  isSpeaking = false;
+  isPaused = false;
+  /**
+   * 说话 - 核心方法
+   * @param text 要说的文本
+   * @param options 可选参数
+   */
+  async speak(text, options = {}) {
+    if (!text || text.trim().length === 0) {
+      throw new TTSError(
+        "Text cannot be empty",
+        "INVALID_PARAMS" /* INVALID_PARAMS */,
+        "speaker"
+      );
+    }
+    if (this.isSpeaking) {
+      await this.stop();
+    }
+    this.isSpeaking = true;
+    this.currentText = text;
+    try {
+      const providerName = options.provider || this.options.defaultProvider || "minimax";
+      if (!hasProvider(providerName)) {
+        throw new TTSError(
+          `Provider "${providerName}" not found`,
+          "UNKNOWN" /* UNKNOWN */,
+          "speaker"
+        );
+      }
+      this.currentProvider = getProvider(providerName);
+      const result = await this.currentProvider.speak(text, {
+        model: options.model || this.options.defaultModel || "stream",
+        voice: options.voice || this.options.defaultVoice,
+        speed: options.speed,
+        volume: options.volume,
+        pitch: options.pitch,
+        sourceVoice: options.sourceVoice
+      });
+      if (this.player) {
+        await this.player.play(result.audioData, result.format);
+      }
+    } catch (error) {
+      this.isSpeaking = false;
+      if (error instanceof TTSError) {
+        this.emit("error", error);
+        throw error;
+      }
+      const ttsError = new TTSError(
+        "Speak failed",
+        "UNKNOWN" /* UNKNOWN */,
+        "speaker",
+        error
+      );
+      this.emit("error", ttsError);
+      throw ttsError;
+    }
+  }
+  /**
+   * 暂停播放
+   */
+  pause() {
+    if (this.player && this.isSpeaking && !this.isPaused) {
+      this.player.pause();
+    }
+  }
+  /**
+   * 恢复播放
+   */
+  resume() {
+    if (this.player && this.isPaused) {
+      this.player.resume();
+    }
+  }
+  /**
+   * 停止播放
+   */
+  async stop() {
+    this.isSpeaking = false;
+    this.isPaused = false;
+    if (this.player) {
+      await this.player.stop();
+    }
+  }
+  /**
+   * 销毁 Speaker，释放资源
+   */
+  async destroy() {
+    this.isSpeaking = false;
+    this.isPaused = false;
+    if (this.player) {
+      await this.player.stop();
+      this.player = void 0;
+    }
+    this.currentProvider = void 0;
+    this.currentText = void 0;
+  }
+  /**
+   * 列出可用音色
+   */
+  async listVoices(providerName) {
+    const name = providerName || this.options.defaultProvider || "minimax";
+    const provider = getProvider(name);
+    return provider.listVoices();
+  }
+  /**
+   * 获取 Provider 能力
+   */
+  getCapabilities(providerName) {
+    const name = providerName || this.options.defaultProvider || "minimax";
+    const provider = getProvider(name);
+    return provider.getCapabilities();
+  }
+  /**
+   * 获取所有已注册的 Provider
+   */
+  getProviders() {
+    return listProviders();
+  }
+  /**
+   * 是否正在播放
+   */
+  isPlaying() {
+    return this.isSpeaking && !this.isPaused;
+  }
+  /**
+   * 是否暂停
+   */
+  isPausedState() {
+    return this.isPaused;
+  }
+};
+var defaultSpeaker;
+function getDefaultSpeaker() {
+  if (!defaultSpeaker) {
+    defaultSpeaker = new Speaker();
+  }
+  return defaultSpeaker;
+}
+async function speak(text, options) {
+  const speaker2 = getDefaultSpeaker();
+  return speaker2.speak(text, options);
+}
+async function stop() {
+  const speaker2 = getDefaultSpeaker();
+  return speaker2.stop();
+}
+function pause() {
+  const speaker2 = getDefaultSpeaker();
+  speaker2.pause();
+}
+function resume() {
+  const speaker2 = getDefaultSpeaker();
+  speaker2.resume();
+}
+async function listVoices(providerName) {
+  const speaker2 = getDefaultSpeaker();
+  return speaker2.listVoices(providerName);
+}
+
+// src/tools/tts.ts
+async function handleToolCall(toolName, args) {
+  try {
+    switch (toolName) {
+      case "tts_speak":
+        await speak(args?.text, {
+          provider: args?.provider,
+          voice: args?.voice,
+          model: args?.model,
+          speed: args?.speed,
+          volume: args?.volume,
+          pitch: args?.pitch
+        });
+        return { success: true, message: "Speech completed" };
+      case "tts_stop":
+        await stop();
+        return { success: true, message: "Stopped" };
+      case "tts_pause":
+        pause();
+        return { success: true, message: "Paused" };
+      case "tts_resume":
+        resume();
+        return { success: true, message: "Resumed" };
+      case "tts_list_voices":
+        const voices = await listVoices(args?.provider);
+        return { success: true, voices };
+      case "tts_list_providers":
+        const speaker2 = getDefaultSpeaker();
+        const providers2 = speaker2.getProviders();
+        return { success: true, providers: providers2 };
+      case "tts_status":
+        const s = getDefaultSpeaker();
+        return {
+          success: true,
+          isPlaying: s.isPlaying(),
+          isPaused: s.isPausedState()
+        };
+      case "tts_stream_speak":
+        if (!isAutoReadEnabled()) {
+          throw new TTSError(
+            "Stream mode is not enabled. autoRead must be enabled in configuration to use tts_stream_speak.",
+            "UNKNOWN" /* UNKNOWN */,
+            "tts_stream"
+          );
+        }
+        if (!isStreamEnabled()) {
+          throw new TTSError(
+            "Stream components not initialized. Please initialize with autoRead enabled.",
+            "UNKNOWN" /* UNKNOWN */,
+            "tts_stream"
+          );
         }
-        return result;
+        const streamReader2 = getStreamReader();
+        const synthesizer = getStreamingSynthesizer();
+        if (streamReader2 && synthesizer) {
+          streamReader2.start();
+          if (args?.text) {
+            synthesizer.synthesize(args.text);
+          }
+          return { success: true, message: "Stream speak started" };
+        }
+        throw new TTSError(
+          "Stream components not available",
+          "UNKNOWN" /* UNKNOWN */,
+          "tts_stream"
+        );
+      case "tts_stream_stop":
+        if (!isStreamEnabled()) {
+          throw new TTSError(
+            "Stream mode is not enabled. Please enable autoRead in configuration.",
+            "UNKNOWN" /* UNKNOWN */,
+            "tts_stream"
+          );
+        }
+        const player = getStreamPlayer();
+        if (player) {
+          player.stop();
+          return { success: true, message: "Stream stopped" };
+        }
+        throw new TTSError(
+          "Stream player not available",
+          "UNKNOWN" /* UNKNOWN */,
+          "tts_stream"
+        );
+      case "tts_stream_status":
+        if (!isStreamEnabled()) {
+          return {
+            success: true,
+            isActive: false,
+            bytesWritten: 0,
+            state: "not_initialized"
+          };
+        }
+        return {
+          success: true,
+          ...getStreamStatus()
+        };
+      default:
+        throw new TTSError(
+          `Unknown tool: ${toolName}`,
+          "UNKNOWN" /* UNKNOWN */,
+          "tools"
+        );
     }
-});
-const ttsStatusTool = tool({
-    description: '获取当前 TTS 播放状态',
-    args: {},
-    execute: async () => {
-        const result = await handleToolCall('tts_status');
-        if (result.success === false) {
-            throw new Error(result.error || 'Unknown error');
+  } catch (error) {
+    if (error instanceof TTSError) {
+      return {
+        success: false,
+        error: error.message,
+        code: error.code,
+        provider: error.provider
+      };
+    }
+    return {
+      success: false,
+      error: String(error)
+    };
+  }
+}
+
+// src/providers/minimax.ts
+import axios from "axios";
+var MiniMaxProvider = class extends BaseTTSProvider {
+  name = "minimax";
+  capabilities = {
+    speak: true,
+    stream: true,
+    sync: true,
+    async: true,
+    voiceList: true,
+    voiceClone: true
+  };
+  config;
+  httpClient;
+  wsConnection;
+  currentAudioData = [];
+  audioFormat = "mp3";
+  constructor(config) {
+    super();
+    this.config = config;
+    this.apiKey = config.apiKey;
+    this.defaultVoice = config.voiceId;
+    this.defaultModel = config.model || "stream";
+    this.audioFormat = config.audioFormat || "mp3";
+    this.httpClient = axios.create({
+      baseURL: this.config.baseURL || "https://api.minimaxi.com",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      timeout: 3e4
+    });
+  }
+  async initialize() {
+    this.validateApiKey();
+  }
+  async destroy() {
+    if (this.wsConnection) {
+      this.wsConnection.close();
+      this.wsConnection = void 0;
+    }
+  }
+  async doSpeak(text, voice, model, options) {
+    this.validateApiKey();
+    switch (model) {
+      case "stream":
+        return this.streamingSpeak(text, voice, options);
+      case "sync":
+        return this.syncSpeak(text, voice, options);
+      case "async":
+        return this.asyncSpeak(text, voice, options);
+      default:
+        return this.streamingSpeak(text, voice, options);
+    }
+  }
+  /**
+   * 流式合成 (HTTP) - T2A v2 with stream: true
+   */
+  async streamingSpeak(text, voice, options) {
+    try {
+      const voiceId = voice || this.defaultVoice || "male-qn-qingse";
+      const speed = options?.speed || this.config.speed || 1;
+      const vol = options?.volume !== void 0 ? options.volume / 10 : this.config.volume !== void 0 ? this.config.volume / 10 : 1;
+      const pitch = options?.pitch !== void 0 ? Math.round((options.pitch - 1) * 12) : this.config.pitch !== void 0 ? Math.round((this.config.pitch - 1) * 12) : 0;
+      const response = await this.httpClient.post("/v1/t2a_v2", {
+        model: this.config.ttsModel || "speech-2.8-hd",
+        text,
+        stream: true,
+        voice_setting: {
+          voice_id: voiceId,
+          speed,
+          vol,
+          pitch
+        },
+        audio_setting: {
+          sample_rate: 32e3,
+          bitrate: 128e3,
+          format: this.audioFormat,
+          channel: 1
         }
-        return result;
+      }, {
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        responseType: "stream"
+      });
+      const stream = response.data;
+      const audioChunks = [];
+      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)
+                  });
+                }
+              }
+            }
+          } catch (e) {
+            audioChunks.push(chunk);
+          }
+        });
+        stream.on("error", (err) => {
+          reject(new TTSError(
+            "Stream error",
+            "NETWORK" /* NETWORK */,
+            this.name,
+            err
+          ));
+        });
+        stream.on("end", () => {
+          if (audioChunks.length > 0) {
+            const fullAudio = Buffer.concat(audioChunks);
+            resolve({
+              audioData: fullAudio,
+              format: this.audioFormat,
+              isStream: true,
+              duration: this.estimateDuration(fullAudio.length)
+            });
+          }
+        });
+      });
+    } catch (error) {
+      if (error instanceof TTSError) throw error;
+      throw this.mapError(error);
     }
-});
-const ttsStreamSpeakTool = tool({
-    description: '启动流式朗读（豆包模式），订阅AI回复并边生成边朗读',
-    args: {
-        text: tool.schema.string().optional().describe('初始文本（可选）'),
-        voice: tool.schema.string().optional().describe('音色ID'),
-        model: tool.schema.enum(['sync', 'async', 'stream']).optional().describe('合成模式')
-    },
-    execute: async (args) => {
-        const result = await handleToolCall('tts_stream_speak', args);
-        if (result.success === false) {
-            throw new Error(result.error || 'Unknown error');
+  }
+  /**
+   * 同步合成 (HTTP) - T2A v2
+   * API: POST https://api.minimax.io/v1/t2a_v2
+   */
+  async syncSpeak(text, voice, options) {
+    try {
+      const voiceId = voice || this.defaultVoice || "male-qn-qingse";
+      const speed = options?.speed || this.config.speed || 1;
+      const vol = options?.volume !== void 0 ? options.volume / 10 : this.config.volume !== void 0 ? this.config.volume / 10 : 1;
+      const pitch = options?.pitch !== void 0 ? Math.round((options.pitch - 1) * 12) : this.config.pitch !== void 0 ? Math.round((this.config.pitch - 1) * 12) : 0;
+      const response = await this.httpClient.post("/v1/t2a_v2", {
+        model: this.config.ttsModel || "speech-2.8-hd",
+        text,
+        stream: false,
+        output_format: "hex",
+        voice_setting: {
+          voice_id: voiceId,
+          speed,
+          vol,
+          pitch
+        },
+        audio_setting: {
+          sample_rate: 32e3,
+          bitrate: 128e3,
+          format: this.audioFormat,
+          channel: 1
         }
-        return result;
+      }, {
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json"
+        }
+      });
+      if (response.data.base_resp?.status_code !== 0) {
+        throw new TTSError(
+          response.data.base_resp?.status_msg || "API request failed",
+          "UNKNOWN" /* UNKNOWN */,
+          this.name,
+          response.data.base_resp
+        );
+      }
+      const audioHex = response.data.data?.audio;
+      if (!audioHex) {
+        throw new TTSError(
+          "No audio data in response",
+          "UNKNOWN" /* UNKNOWN */,
+          this.name
+        );
+      }
+      const audioBuffer = Buffer.from(audioHex, "hex");
+      return {
+        audioData: audioBuffer,
+        format: this.audioFormat,
+        isStream: false,
+        duration: response.data.extra_info?.audio_length ? response.data.extra_info.audio_length / 1e3 : this.estimateDuration(audioBuffer.length)
+      };
+    } catch (error) {
+      if (error instanceof TTSError) throw error;
+      throw this.mapError(error);
     }
-});
-const ttsStreamStopTool = tool({
-    description: '停止当前流式朗读',
-    args: {},
-    execute: async () => {
-        const result = await handleToolCall('tts_stream_stop');
-        if (result.success === false) {
-            throw new Error(result.error || 'Unknown error');
+  }
+  /**
+   * 异步合成 (轮询) - T2A Async v2
+   */
+  async asyncSpeak(text, voice, options) {
+    try {
+      const voiceId = voice || this.defaultVoice || "male-qn-qingse";
+      const speed = options?.speed || this.config.speed || 1;
+      const vol = options?.volume !== void 0 ? options.volume / 10 : this.config.volume !== void 0 ? this.config.volume / 10 : 1;
+      const pitch = options?.pitch !== void 0 ? Math.round((options.pitch - 1) * 12) : this.config.pitch !== void 0 ? Math.round((this.config.pitch - 1) * 12) : 0;
+      const createResponse = await this.httpClient.post("/v1/t2a_async_v2", {
+        model: this.config.ttsModel || "speech-2.8-hd",
+        text,
+        voice_setting: {
+          voice_id: voiceId,
+          speed,
+          vol,
+          pitch
+        },
+        audio_setting: {
+          sample_rate: 32e3,
+          bitrate: 128e3,
+          format: this.audioFormat,
+          channel: 1
         }
-        return result;
+      }, {
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json"
+        }
+      });
+      const taskId = createResponse.data.task_id;
+      if (!taskId) {
+        throw new TTSError(
+          "No task_id in async response",
+          "UNKNOWN" /* UNKNOWN */,
+          this.name,
+          createResponse.data
+        );
+      }
+      let attempts = 0;
+      const maxAttempts = 60;
+      while (attempts < maxAttempts) {
+        await this.delay(2e3);
+        const statusResponse = await this.httpClient.get(
+          `/v1/query/t2a_async_query_v2?task_id=${taskId}`,
+          {
+            headers: {
+              "Authorization": `Bearer ${this.apiKey}`
+            }
+          }
+        );
+        if (statusResponse.data.status === "success") {
+          const fileId = statusResponse.data.file_id;
+          if (!fileId) {
+            throw new TTSError(
+              "No file_id in async response",
+              "UNKNOWN" /* UNKNOWN */,
+              this.name,
+              statusResponse.data
+            );
+          }
+          const downloadResponse = await this.httpClient.get(
+            `/v1/files/retrieve_content?file_id=${fileId}`,
+            {
+              headers: {
+                "Authorization": `Bearer ${this.apiKey}`
+              },
+              responseType: "arraybuffer"
+            }
+          );
+          return {
+            audioData: Buffer.from(downloadResponse.data),
+            format: this.audioFormat,
+            isStream: false,
+            duration: 0
+          };
+        }
+        if (statusResponse.data.status === "failed") {
+          throw new TTSError(
+            "Async TTS task failed",
+            "UNKNOWN" /* UNKNOWN */,
+            this.name,
+            statusResponse.data
+          );
+        }
+        attempts++;
+      }
+      throw new TTSError(
+        "Async TTS task timeout",
+        "NETWORK" /* NETWORK */,
+        this.name
+      );
+    } catch (error) {
+      if (error instanceof TTSError) throw error;
+      throw this.mapError(error);
     }
-});
-const ttsStreamStatusTool = tool({
-    description: '获取当前流式朗读状态',
-    args: {},
-    execute: async () => {
-        const result = await handleToolCall('tts_stream_status');
-        if (result.success === false) {
-            throw new Error(result.error || 'Unknown error');
+  }
+  /**
+   * 音色克隆 - 使用参考音频克隆声音
+   */
+  async voiceClone(audioUrl, text, voice) {
+    this.validateApiKey();
+    try {
+      const response = await this.httpClient.post("/v1/t2a_v2/voice_clone", {
+        audio_url: audioUrl,
+        text,
+        voice_id: voice || "custom_clone"
+      }, {
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        responseType: "arraybuffer"
+      });
+      return {
+        audioData: Buffer.from(response.data),
+        format: this.audioFormat,
+        isStream: false,
+        duration: this.estimateDuration(response.data.length)
+      };
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  /**
+   * 获取音色列表
+   */
+  async listVoices() {
+    this.validateApiKey();
+    try {
+      const response = await this.httpClient.get("/v1/t2a/voices", {
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`
         }
-        return typeof result === 'string' ? result : JSON.stringify(result);
+      });
+      return response.data.voices.map((v) => ({
+        id: v.voice_id,
+        name: v.name,
+        language: v.language,
+        gender: v.gender
+      }));
+    } catch (error) {
+      return MINIMAX_VOICES;
     }
-});
-const OcosayPlugin = async (_input, _options) => {
-    console.info(`${pluginName}: initializing...`);
-    const config = loadOrCreateConfig();
-    await initialize({
-        autoRead: config.autoRead,
-        providers: {
-            minimax: {
-                apiKey: config.providers.minimax.apiKey,
-                baseURL: config.providers.minimax.baseURL || undefined,
-                voiceId: config.providers.minimax.voiceId || undefined
-            }
+  }
+  /**
+   * 错误映射
+   */
+  mapError(error) {
+    if (error.response) {
+      const status = error.response.status;
+      const code = status === 401 ? "AUTH" /* AUTH */ : status === 429 ? "QUOTA" /* QUOTA */ : status >= 500 ? "NETWORK" /* NETWORK */ : "UNKNOWN" /* UNKNOWN */;
+      return new TTSError(
+        error.response.data?.message || "API request failed",
+        code,
+        this.name,
+        error.response.data
+      );
+    }
+    if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND") {
+      return new TTSError(
+        "Network error: Unable to connect to MiniMax API",
+        "NETWORK" /* NETWORK */,
+        this.name,
+        error.message
+      );
+    }
+    return new TTSError(
+      error.message || "Unknown error",
+      "UNKNOWN" /* UNKNOWN */,
+      this.name,
+      error
+    );
+  }
+  /**
+   * 延迟辅助函数
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * 估算音频时长
+   * 基于 32kbps MP3 估算
+   */
+  estimateDuration(bytes) {
+    return bytes * 8 / (32e3 * 60);
+  }
+};
+var MINIMAX_VOICES = [
+  { id: "male-qn-qingse", name: "\u9752\u5E74\u6E05\u6F88", language: "zh-CN", gender: "male" },
+  { id: "male-qn-qingse_2", name: "\u9752\u5E74\u6E05\u6F88v2", language: "zh-CN", gender: "male" },
+  { id: "female-shaonv", name: "\u5C11\u5973", language: "zh-CN", gender: "female" },
+  { id: "male-baiming", name: "\u6210\u719F\u7537\u58F0", language: "zh-CN", gender: "male" },
+  { id: "female-tianmei", name: "\u751C\u7F8E\u5973\u58F0", language: "zh-CN", gender: "female" },
+  { id: "male-zhongnan", name: "\u4E2D\u5E74\u7537\u58F0", language: "zh-CN", gender: "male" },
+  { id: "female-yujie", name: "\u5FA1\u59D0\u97F3", language: "zh-CN", gender: "female" },
+  { id: "male-qn-xiaoao", name: "\u9752\u5E74\u8C6A\u723D", language: "zh-CN", gender: "male" },
+  { id: "female-shandian", name: "\u751C\u5FC3\u5C0F\u5A18", language: "zh-CN", gender: "female" },
+  { id: "male-qn-buke", name: "\u9752\u5E74\u4F4E\u6C89", language: "zh-CN", gender: "male" },
+  { id: "male-qn-wenlv", name: "\u6587\u7EFF\u9752\u5E74", language: "zh-CN", gender: "male" },
+  { id: "female-tianmei-2", name: "\u751C\u7F8E\u5973\u58F0v2", language: "zh-CN", gender: "female" },
+  { id: "female-yujie-2", name: "\u5FA1\u59D0\u97F3v2", language: "zh-CN", gender: "female" },
+  { id: "male-shaonian", name: "\u5C11\u5E74\u97F3", language: "zh-CN", gender: "male" },
+  { id: "female-yunv", name: "\u6E29\u67D4\u5973\u58F0", language: "zh-CN", gender: "female" },
+  { id: "male-qn-jingdian", name: "\u7ECF\u5178\u7537\u58F0", language: "zh-CN", gender: "male" },
+  { id: "male-qn-kuang\u91CE", name: "\u72C2\u91CE\u9752\u5E74", language: "zh-CN", gender: "male" },
+  { id: "female-yujie-old", name: "\u4F18\u96C5\u4F4E\u6C89", language: "zh-CN", gender: "female" },
+  { id: "female-tianmei-old", name: "\u751C\u7F8E\u5973\u5B69", language: "zh-CN", gender: "female" },
+  { id: "male-qn-taohua", name: "\u6843\u82B1\u9752\u5E74", language: "zh-CN", gender: "male" }
+];
+
+// src/core/stream-reader.ts
+import { EventEmitter as EventEmitter3 } from "events";
+var StreamReader = class extends EventEmitter3 {
+  constructor(bufferSize = 30, bufferTimeout = 2e3) {
+    super();
+    this.bufferSize = bufferSize;
+    this.bufferTimeout = bufferTimeout;
+  }
+  bufferSize;
+  bufferTimeout;
+  state = "idle" /* IDLE */;
+  buffer = "";
+  sessionID;
+  messageID;
+  partID;
+  timeoutHandle;
+  /**
+   * 启动流式监听
+   * 将状态从 IDLE 切换到 BUFFERING，开始监听事件
+   */
+  start() {
+    if (this.state === "idle" /* IDLE */) {
+      this.state = "buffering" /* BUFFERING */;
+      this.emit("streamStart");
+    }
+  }
+  /**
+   * 处理 message.part.delta 事件
+   */
+  handleDelta(sessionID, messageID, partID, delta) {
+    if (this.state === "idle" /* IDLE */) {
+      this.state = "buffering" /* BUFFERING */;
+      this.sessionID = sessionID;
+      this.messageID = messageID;
+      this.partID = partID;
+      this.emit("streamStart");
+    }
+    this.buffer += delta;
+    this.resetTimeout();
+    if (this.shouldFlush()) {
+      this.flushBuffer();
+    }
+  }
+  /**
+   * 处理流结束
+   */
+  handleEnd() {
+    if (this.state === "ended" /* ENDED */) {
+      return;
+    }
+    if (this.buffer.length > 0) {
+      this.flushBuffer();
+    }
+    this.state = "ended" /* ENDED */;
+    this.clearTimeout();
+    this.emit("streamEnd");
+  }
+  /**
+   * 处理错误
+   */
+  handleError(error) {
+    this.clearTimeout();
+    this.state = "idle" /* IDLE */;
+    this.buffer = "";
+    this.emit("streamError", error);
+  }
+  /**
+   * 重置缓冲器
+   */
+  reset() {
+    this.state = "idle" /* IDLE */;
+    this.buffer = "";
+    this.sessionID = void 0;
+    this.messageID = void 0;
+    this.partID = void 0;
+    this.clearTimeout();
+  }
+  /**
+   * 判断是否应该刷新缓冲区
+   * 条件：
+   * 1. 包含句子结束符（任何长度）
+   * 2. 缓冲区长度 >= bufferSize
+   */
+  shouldFlush() {
+    const sentenceEnd = /[。！？.!?]|……/;
+    if (sentenceEnd.test(this.buffer)) {
+      return true;
+    }
+    if (this.buffer.length >= this.bufferSize) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 刷新缓冲区，发送textReady事件
+   */
+  flushBuffer() {
+    const text = this.buffer.trim();
+    if (text.length > 0) {
+      this.emit("textReady", text);
+    }
+    this.buffer = "";
+    this.resetTimeout();
+  }
+  /**
+   * 重置超时计时器
+   */
+  resetTimeout() {
+    this.clearTimeout();
+    this.timeoutHandle = setTimeout(() => {
+      if (this.buffer.length > 0) {
+        this.flushBuffer();
+      }
+    }, this.bufferTimeout);
+  }
+  /**
+   * 清除超时计时器
+   */
+  clearTimeout() {
+    if (this.timeoutHandle) {
+      clearTimeout(this.timeoutHandle);
+      this.timeoutHandle = void 0;
+    }
+  }
+  /**
+   * 获取当前状态
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * 检查流是否处于活跃状态
+   */
+  isActive() {
+    return this.state === "buffering" /* BUFFERING */;
+  }
+  /**
+   * 获取当前缓冲区内容
+   */
+  getBuffer() {
+    return this.buffer;
+  }
+  /**
+   * 获取当前会话ID
+   */
+  getSessionID() {
+    return this.sessionID;
+  }
+  /**
+   * 获取当前消息ID
+   */
+  getMessageID() {
+    return this.messageID;
+  }
+  /**
+   * 获取当前分块ID
+   */
+  getPartID() {
+    return this.partID;
+  }
+};
+
+// src/core/streaming-synthesizer.ts
+import { EventEmitter as EventEmitter4 } from "events";
+var StreamingSynthesizer = class extends EventEmitter4 {
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  options;
+  audioChunks = [];
+  /**
+   * 发送文本片段进行合成
+   * 调用 provider.speak() 并处理返回的音频流
+   */
+  async synthesize(text) {
+    if (!text || text.trim().length === 0) {
+      return;
+    }
+    try {
+      const result = await this.options.provider.speak(text, {
+        model: "stream",
+        voice: this.options.voice,
+        speed: this.options.speed,
+        volume: this.options.volume,
+        pitch: this.options.pitch
+      });
+      await this.processAudioResult(result);
+      this.emit("done");
+    } catch (error) {
+      const ttsError = error instanceof TTSError ? error : new TTSError(
+        error instanceof Error ? error.message : "Synthesis failed",
+        "UNKNOWN",
+        this.options.provider.name,
+        error
+      );
+      this.emit("error", ttsError);
+    }
+  }
+  /**
+   * 处理 AudioResult，根据 audioData 类型进行相应处理
+   */
+  async processAudioResult(result) {
+    if (result.isStream && result.audioData instanceof ReadableStream) {
+      await this.processReadableStream(result.audioData);
+    } else if (Buffer.isBuffer(result.audioData)) {
+      this.emitChunk(result.audioData);
+    }
+  }
+  /**
+   * 处理 ReadableStream，逐chunk emit
+   */
+  async processReadableStream(stream) {
+    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);
+          this.emitChunk(chunk);
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  /**
+   * emit chunk 并累积
+   */
+  emitChunk(chunk) {
+    this.audioChunks.push(chunk);
+    this.emit("chunk", chunk);
+  }
+  /**
+   * 重置状态
+   * 清空累积的音频数据
+   */
+  reset() {
+    this.audioChunks = [];
+  }
+  /**
+   * 获取累积的音频数据
+   * 返回所有已接收的 chunk
+   */
+  getAudioChunks() {
+    return [...this.audioChunks];
+  }
+};
+
+// src/core/stream-player.ts
+import { EventEmitter as EventEmitter5 } from "events";
+import { spawn as spawn2 } from "child_process";
+import fs2 from "fs";
+import { createWriteStream as createWriteStream2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join2 } from "path";
+var StreamPlayer = class extends EventEmitter5 {
+  tempFile = "";
+  writeStream;
+  playerProcess;
+  _bytesWritten = 0;
+  _started = false;
+  _paused = false;
+  _stopped = false;
+  format = "mp3";
+  events;
+  constructor(options = {}) {
+    super();
+    this.format = options.format || "mp3";
+    this.events = options.events;
+  }
+  /**
+   * 开始播放
+   * 创建临时文件，创建写入流，启动播放器进程
+   */
+  start() {
+    if (this._started) {
+      return;
+    }
+    this.tempFile = join2(tmpdir2(), `ocosay-stream-${Date.now()}.${this.format}`);
+    this.writeStream = createWriteStream2(this.tempFile, { highWaterMark: 64 * 1024 });
+    this.writeStream.on("error", (error) => {
+      this.handleError(error);
+    });
+    this.writeStream.on("finish", () => {
+    });
+    this.startPlayer();
+    this._started = true;
+    this._stopped = false;
+    this.events?.onStart?.();
+    this.emit("start");
+  }
+  /**
+   * 启动播放器进程
+   */
+  startPlayer() {
+    const platform = process.platform;
+    let command;
+    let args;
+    if (platform === "darwin") {
+      command = "afplay";
+      args = [this.tempFile];
+    } else if (platform === "linux") {
+      command = "aplay";
+      args = [this.tempFile];
+    } else {
+      this.handleError(new Error("Windows platform is not supported for stream playback. PlaySync() blocks the Node.js event loop."));
+      return;
+    }
+    this.playerProcess = spawn2(command, args, {
+      stdio: "ignore",
+      detached: false
+    });
+    this.playerProcess.on("exit", (code, signal) => {
+      if (this._stopped) {
+        return;
+      }
+      if (signal === "SIGTERM" || signal === "SIGINT") {
+        return;
+      }
+      if (code === 0 || code === null) {
+        this.events?.onEnd?.();
+        this.emit("end");
+      } else {
+        this.handleError(new Error(`Player exited with code ${code}`));
+      }
+    });
+    this.playerProcess.on("error", (error) => {
+      this.handleError(error);
     });
+  }
+  /**
+   * 写入音频数据块（边收边写）
+   * 如果尚未 start()，会自动调用
+   */
+  write(chunk) {
+    if (this._stopped) {
+      return;
+    }
+    if (!this._started) {
+      this.start();
+    }
+    if (this.writeStream) {
+      const canContinue = this.writeStream.write(chunk);
+      if (!canContinue) {
+        this.writeStream.once("drain", () => {
+        });
+      }
+      this._bytesWritten += chunk.length;
+      this.events?.onProgress?.(this._bytesWritten);
+      this.emit("progress", this._bytesWritten);
+    }
+  }
+  /**
+   * 结束写入
+   * 关闭写入流，但不杀播放器进程，让它播完
+   */
+  end() {
+    if (this.writeStream) {
+      this.writeStream.end();
+      this.writeStream = void 0;
+    }
+  }
+  /**
+   * 停止播放
+   * 杀死播放器进程，删除临时文件
+   */
+  stop() {
+    this._stopped = true;
+    this._started = false;
+    this._paused = false;
+    if (this.playerProcess) {
+      try {
+        this.playerProcess.kill("SIGTERM");
+      } catch (e) {
+      }
+      this.playerProcess = void 0;
+    }
+    if (this.writeStream) {
+      try {
+        this.writeStream.destroy();
+      } catch (e) {
+      }
+      this.writeStream = void 0;
+    }
+    this.deleteTempFile();
+    this.events?.onStop?.();
+    this.emit("stop");
+  }
+  /**
+   * 暂停播放
+   * 使用 SIGSTOP 暂停播放器进程
+   */
+  pause() {
+    if (!this._started || this._paused || this._stopped) {
+      return;
+    }
+    if (this.playerProcess) {
+      try {
+        this.playerProcess.kill("SIGSTOP");
+        this._paused = true;
+        this.events?.onPause?.();
+        this.emit("pause");
+      } catch (e) {
+      }
+    }
+  }
+  /**
+   * 恢复播放
+   */
+  resume() {
+    if (!this._paused || this._stopped) {
+      return;
+    }
+    if (this.playerProcess) {
+      try {
+        this.playerProcess.kill("SIGCONT");
+        this._paused = false;
+        this.events?.onResume?.();
+        this.emit("resume");
+      } catch (e) {
+      }
+    }
+  }
+  /**
+   * 是否已启动
+   */
+  isStarted() {
+    return this._started;
+  }
+  /**
+   * 是否暂停
+   */
+  isPaused() {
+    return this._paused;
+  }
+  /**
+   * 是否已停止
+   */
+  isStopped() {
+    return this._stopped;
+  }
+  /**
+   * 获取已写入的字节数
+   */
+  getBytesWritten() {
+    return this._bytesWritten;
+  }
+  /**
+   * 获取临时文件路径
+   */
+  getTempFile() {
+    return this.tempFile;
+  }
+  /**
+   * 处理错误
+   */
+  handleError(error) {
+    this.events?.onError?.(error);
+    this.emit("error", error);
+  }
+  /**
+   * 删除临时文件
+   */
+  deleteTempFile() {
+    if (this.tempFile) {
+      try {
+        if (fs2.existsSync(this.tempFile)) {
+          fs2.unlinkSync(this.tempFile);
+        }
+      } catch (e) {
+      }
+      this.tempFile = "";
+    }
+  }
+};
+
+// src/index.ts
+var speaker;
+var streamReader;
+var streamingSynthesizer;
+var streamPlayer;
+var initialized = false;
+var autoReadEnabled = false;
+async function initialize(config) {
+  if (initialized) {
+    return;
+  }
+  if (config?.providers?.minimax) {
+    if (!config.providers.minimax.apiKey) {
+      throw new Error("[ocosay] API Key is required. Please set minimax.apiKey in ~/.config/opencode/ocosay.jsonc");
+    }
+    const minimaxProvider = new MiniMaxProvider(config.providers.minimax);
+    registerProvider("minimax", minimaxProvider);
+    await minimaxProvider.initialize();
+  }
+  const speakerOptions = {
+    defaultProvider: config?.defaultProvider || "minimax",
+    defaultModel: config?.defaultModel || "stream",
+    defaultVoice: config?.defaultVoice
+  };
+  speaker = new Speaker(speakerOptions);
+  if (config?.autoRead) {
+    autoReadEnabled = true;
+    initializeStreamComponents(config);
+  }
+  initialized = true;
+}
+function initializeStreamComponents(config) {
+  const provider = getProvider(config?.defaultProvider || "minimax");
+  streamReader = new StreamReader(
+    config?.streamBufferSize || 30,
+    config?.streamBufferTimeout || 2e3
+  );
+  streamingSynthesizer = new StreamingSynthesizer({
+    provider,
+    voice: config?.defaultVoice,
+    speed: 1,
+    volume: 1,
+    pitch: 1
+  });
+  const playerEvents = {
+    onStart: () => {
+    },
+    onEnd: () => {
+    },
+    onProgress: (bytesWritten) => {
+    },
+    onError: (error) => console.error("Stream player error:", error),
+    onStop: () => {
+    }
+  };
+  streamPlayer = new StreamPlayer({ events: playerEvents });
+  const synthesisQueue = [];
+  let isSynthesizing = false;
+  async function processQueue() {
+    while (synthesisQueue.length > 0) {
+      const text = synthesisQueue.shift();
+      isSynthesizing = true;
+      try {
+        await streamingSynthesizer?.synthesize(text);
+      } catch (error) {
+        console.error("Synthesize error:", error);
+      }
+    }
+    isSynthesizing = false;
+  }
+  streamReader.on("textReady", (text) => {
+    synthesisQueue.push(text);
+    if (!isSynthesizing) {
+      processQueue();
+    }
+  });
+  streamingSynthesizer.on("chunk", (chunk) => {
+    if (streamPlayer) {
+      streamPlayer.write(chunk);
+    }
+  });
+  streamingSynthesizer.on("done", () => {
+    if (streamPlayer) {
+      streamPlayer.end();
+    }
+  });
+  const TuiEventBus = global.__opencode_tuieventbus__;
+  if (TuiEventBus) {
+    const eventBus = new TuiEventBus();
+    let messagePartDeltaHandler;
+    let messagePartEndHandler;
+    messagePartDeltaHandler = (event) => {
+      if (event?.properties) {
+        streamReader?.handleDelta(
+          event.sessionId || "",
+          event.messageId || "",
+          event.partId || "",
+          event.properties.delta || ""
+        );
+      }
+    };
+    messagePartEndHandler = () => {
+      streamReader?.handleEnd();
+    };
+    eventBus.on("message.part.delta", messagePartDeltaHandler);
+    eventBus.on("message.part.end", messagePartEndHandler);
+  }
+}
+function isStreamEnabled() {
+  return streamReader !== void 0 && streamingSynthesizer !== void 0 && streamPlayer !== void 0;
+}
+function isAutoReadEnabled() {
+  return autoReadEnabled;
+}
+function getStreamStatus() {
+  if (!streamReader) {
+    return { isActive: false, bytesWritten: 0, state: "not_initialized" };
+  }
+  return {
+    isActive: streamReader.isActive(),
+    bytesWritten: streamPlayer?.getBytesWritten() ?? 0,
+    state: streamReader.getState()
+  };
+}
+function getStreamReader() {
+  return streamReader;
+}
+function getStreamingSynthesizer() {
+  return streamingSynthesizer;
+}
+function getStreamPlayer() {
+  return streamPlayer;
+}
+
+// src/config.ts
+import * as fs3 from "fs";
+import * as path from "path";
+import * as os from "os";
+var DEFAULT_CONFIG = {
+  enabled: true,
+  autoPlay: false,
+  autoRead: false,
+  streamMode: true,
+  streamBufferSize: 30,
+  streamBufferTimeout: 2e3,
+  speed: 1,
+  volume: 80,
+  pitch: 1
+};
+var CONFIG_PATH = path.join(os.homedir(), ".config", "opencode", "ocosay.jsonc");
+function generateDefaultConfig() {
+  return {
+    ...DEFAULT_CONFIG,
+    providers: {
+      minimax: {
+        apiKey: "",
+        baseURL: "",
+        voiceId: "",
+        model: "stream",
+        ttsModel: "speech-2.8-hd",
+        audioFormat: "mp3"
+      }
+    }
+  };
+}
+function stripComments(jsonc) {
+  let result = "";
+  let inString = false;
+  let stringChar = "";
+  let i = 0;
+  while (i < jsonc.length) {
+    const char = jsonc[i];
+    if (!inString && (char === '"' || char === "'" || char === "`")) {
+      inString = true;
+      stringChar = char;
+      result += char;
+      i++;
+      continue;
+    }
+    if (inString && char === stringChar && jsonc[i - 1] !== "\\") {
+      inString = false;
+      result += char;
+      i++;
+      continue;
+    }
+    if (inString) {
+      result += char;
+      i++;
+      continue;
+    }
+    if (char === "/" && jsonc[i + 1] === "/") {
+      while (i < jsonc.length && jsonc[i] !== "\n") {
+        i++;
+      }
+      continue;
+    }
+    if (char === "/" && jsonc[i + 1] === "*") {
+      i += 2;
+      while (i < jsonc.length - 1 && !(jsonc[i] === "*" && jsonc[i + 1] === "/")) {
+        i++;
+      }
+      i += 2;
+      continue;
+    }
+    result += char;
+    i++;
+  }
+  return result;
+}
+function mergeWithDefaults(loaded, defaults) {
+  return {
+    enabled: loaded.enabled ?? defaults.enabled,
+    autoPlay: loaded.autoPlay ?? defaults.autoPlay,
+    autoRead: loaded.autoRead ?? defaults.autoRead,
+    streamMode: loaded.streamMode ?? defaults.streamMode,
+    streamBufferSize: loaded.streamBufferSize ?? defaults.streamBufferSize,
+    streamBufferTimeout: loaded.streamBufferTimeout ?? defaults.streamBufferTimeout,
+    speed: loaded.speed ?? defaults.speed,
+    volume: loaded.volume ?? defaults.volume,
+    pitch: loaded.pitch ?? defaults.pitch
+  };
+}
+function loadOrCreateConfig() {
+  const configDir = path.dirname(CONFIG_PATH);
+  if (!fs3.existsSync(configDir)) {
+    try {
+      fs3.mkdirSync(configDir, { recursive: true });
+    } catch (err) {
+      throw new Error(`[ocosay] \u65E0\u6CD5\u521B\u5EFA\u914D\u7F6E\u76EE\u5F55 ${configDir}: ${err}`);
+    }
+  }
+  if (!fs3.existsSync(CONFIG_PATH)) {
+    console.info("[ocosay] \u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728\uFF0C\u6B63\u5728\u521B\u5EFA\u9ED8\u8BA4\u914D\u7F6E...");
+    const defaultConfig = generateDefaultConfig();
+    const configContent = JSON.stringify(defaultConfig, null, 2);
+    try {
+      fs3.writeFileSync(CONFIG_PATH, configContent, "utf-8");
+      try {
+        fs3.chmodSync(CONFIG_PATH, 384);
+      } catch (err) {
+        console.warn(`[ocosay] \u65E0\u6CD5\u8BBE\u7F6E\u914D\u7F6E\u6587\u4EF6\u6743\u9650: ${err}`);
+      }
+    } catch (err) {
+      throw new Error(`[ocosay] \u65E0\u6CD5\u5199\u5165\u914D\u7F6E\u6587\u4EF6 ${CONFIG_PATH}: ${err}`);
+    }
+    console.info(`[ocosay] \u914D\u7F6E\u6587\u4EF6\u5DF2\u521B\u5EFA: ${CONFIG_PATH}`);
+    console.info("[ocosay] \u8BF7\u7F16\u8F91\u914D\u7F6E\u6587\u4EF6\u586B\u5165 API Key \u548C Base URL");
+    return defaultConfig;
+  }
+  try {
+    const content = fs3.readFileSync(CONFIG_PATH, "utf-8");
+    const stripped = stripComments(content);
+    const loaded = JSON.parse(stripped);
+    const merged = mergeWithDefaults(loaded, DEFAULT_CONFIG);
     return {
-        tool: {
-            tts_speak: ttsSpeakTool,
-            tts_stop: ttsStopTool,
-            tts_pause: ttsPauseTool,
-            tts_resume: ttsResumeTool,
-            tts_list_voices: ttsListVoicesTool,
-            tts_list_providers: ttsListProvidersTool,
-            tts_status: ttsStatusTool,
-            tts_stream_speak: ttsStreamSpeakTool,
-            tts_stream_stop: ttsStreamStopTool,
-            tts_stream_status: ttsStreamStatusTool
-        },
-        config: async () => {
-            return;
+      ...merged,
+      providers: {
+        minimax: {
+          apiKey: loaded.providers?.minimax?.apiKey ?? "",
+          baseURL: loaded.providers?.minimax?.baseURL ?? "",
+          voiceId: loaded.providers?.minimax?.voiceId ?? "",
+          model: loaded.providers?.minimax?.model ?? "stream",
+          ttsModel: loaded.providers?.minimax?.ttsModel ?? "speech-2.8-hd",
+          audioFormat: loaded.providers?.minimax?.audioFormat ?? "mp3"
         }
+      }
     };
+  } catch (error) {
+    console.error("[ocosay] \u914D\u7F6E\u6587\u4EF6\u8BFB\u53D6\u5931\u8D25\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u914D\u7F6E:", error);
+    return generateDefaultConfig();
+  }
+}
+
+// src/plugin.ts
+var pluginName = "ocosay";
+var ttsSpeakTool = tool({
+  description: "\u5C06\u6587\u672C\u8F6C\u6362\u4E3A\u8BED\u97F3\u5E76\u64AD\u653E",
+  args: {
+    text: tool.schema.string().describe("\u8981\u8F6C\u6362\u7684\u6587\u672C\u5185\u5BB9"),
+    provider: tool.schema.string().optional().describe("TTS \u63D0\u4F9B\u5546\u540D\u79F0"),
+    voice: tool.schema.string().optional().describe("\u97F3\u8272 ID"),
+    model: tool.schema.enum(["sync", "async", "stream"]).optional().describe("\u5408\u6210\u6A21\u5F0F"),
+    speed: tool.schema.number().optional().describe("\u8BED\u901F 0.5-2.0"),
+    volume: tool.schema.number().optional().describe("\u97F3\u91CF 0-100"),
+    pitch: tool.schema.number().optional().describe("\u97F3\u8C03 0.5-2.0")
+  },
+  execute: async (args) => {
+    const result = await handleToolCall("tts_speak", args);
+    if (result.success === false) {
+      throw new Error(result.error || "Unknown error");
+    }
+    return result;
+  }
+});
+var ttsStopTool = tool({
+  description: "\u505C\u6B62\u5F53\u524D TTS \u64AD\u653E",
+  args: {},
+  execute: async () => {
+    const result = await handleToolCall("tts_stop");
+    if (result.success === false) {
+      throw new Error(result.error || "Unknown error");
+    }
+    return result;
+  }
+});
+var ttsPauseTool = tool({
+  description: "\u6682\u505C\u5F53\u524D TTS \u64AD\u653E",
+  args: {},
+  execute: async () => {
+    const result = await handleToolCall("tts_pause");
+    if (result.success === false) {
+      throw new Error(result.error || "Unknown error");
+    }
+    return result;
+  }
+});
+var ttsResumeTool = tool({
+  description: "\u6062\u590D\u6682\u505C\u7684 TTS \u64AD\u653E",
+  args: {},
+  execute: async () => {
+    const result = await handleToolCall("tts_resume");
+    if (result.success === false) {
+      throw new Error(result.error || "Unknown error");
+    }
+    return result;
+  }
+});
+var ttsListVoicesTool = tool({
+  description: "\u5217\u51FA\u53EF\u7528\u7684\u97F3\u8272",
+  args: {
+    provider: tool.schema.string().optional().describe("TTS \u63D0\u4F9B\u5546\u540D\u79F0")
+  },
+  execute: async (args) => {
+    const result = await handleToolCall("tts_list_voices", args);
+    if (result.success === false) {
+      throw new Error(result.error || "Unknown error");
+    }
+    return result;
+  }
+});
+var ttsListProvidersTool = tool({
+  description: "\u5217\u51FA\u6240\u6709\u5DF2\u6CE8\u518C\u7684 TTS \u63D0\u4F9B\u5546",
+  args: {},
+  execute: async () => {
+    const result = await handleToolCall("tts_list_providers");
+    if (result.success === false) {
+      throw new Error(result.error || "Unknown error");
+    }
+    return result;
+  }
+});
+var ttsStatusTool = tool({
+  description: "\u83B7\u53D6\u5F53\u524D TTS \u64AD\u653E\u72B6\u6001",
+  args: {},
+  execute: async () => {
+    const result = await handleToolCall("tts_status");
+    if (result.success === false) {
+      throw new Error(result.error || "Unknown error");
+    }
+    return result;
+  }
+});
+var ttsStreamSpeakTool = tool({
+  description: "\u542F\u52A8\u6D41\u5F0F\u6717\u8BFB\uFF08\u8C46\u5305\u6A21\u5F0F\uFF09\uFF0C\u8BA2\u9605AI\u56DE\u590D\u5E76\u8FB9\u751F\u6210\u8FB9\u6717\u8BFB",
+  args: {
+    text: tool.schema.string().optional().describe("\u521D\u59CB\u6587\u672C\uFF08\u53EF\u9009\uFF09"),
+    voice: tool.schema.string().optional().describe("\u97F3\u8272ID"),
+    model: tool.schema.enum(["sync", "async", "stream"]).optional().describe("\u5408\u6210\u6A21\u5F0F")
+  },
+  execute: async (args) => {
+    const result = await handleToolCall("tts_stream_speak", args);
+    if (result.success === false) {
+      throw new Error(result.error || "Unknown error");
+    }
+    return result;
+  }
+});
+var ttsStreamStopTool = tool({
+  description: "\u505C\u6B62\u5F53\u524D\u6D41\u5F0F\u6717\u8BFB",
+  args: {},
+  execute: async () => {
+    const result = await handleToolCall("tts_stream_stop");
+    if (result.success === false) {
+      throw new Error(result.error || "Unknown error");
+    }
+    return result;
+  }
+});
+var ttsStreamStatusTool = tool({
+  description: "\u83B7\u53D6\u5F53\u524D\u6D41\u5F0F\u6717\u8BFB\u72B6\u6001",
+  args: {},
+  execute: async () => {
+    const result = await handleToolCall("tts_stream_status");
+    if (result.success === false) {
+      throw new Error(result.error || "Unknown error");
+    }
+    return typeof result === "string" ? result : JSON.stringify(result);
+  }
+});
+var OcosayPlugin = async (_input, _options) => {
+  console.info(`${pluginName}: initializing...`);
+  const config = loadOrCreateConfig();
+  await initialize({
+    autoRead: config.autoRead,
+    providers: {
+      minimax: {
+        apiKey: config.providers.minimax.apiKey,
+        baseURL: config.providers.minimax.baseURL || void 0,
+        voiceId: config.providers.minimax.voiceId || void 0
+      }
+    }
+  });
+  return {
+    tool: {
+      tts_speak: ttsSpeakTool,
+      tts_stop: ttsStopTool,
+      tts_pause: ttsPauseTool,
+      tts_resume: ttsResumeTool,
+      tts_list_voices: ttsListVoicesTool,
+      tts_list_providers: ttsListProvidersTool,
+      tts_status: ttsStatusTool,
+      tts_stream_speak: ttsStreamSpeakTool,
+      tts_stream_stop: ttsStreamStopTool,
+      tts_stream_status: ttsStreamStatusTool
+    },
+    config: async () => {
+      return;
+    }
+  };
+};
+var plugin_default = { server: OcosayPlugin };
+export {
+  plugin_default as default
 };
-export default { server: OcosayPlugin };
-//# sourceMappingURL=plugin.js.map
+//# sourceMappingURL=plugin.js.map