@mingxy/ocosay 1.0.0

package/src/index.ts

@@ -0,0 +1,233 @@
+import { handleToolCall } from './tools/tts'
+import { registerProvider, getProvider, listProviders } from './providers/base'
+import { MiniMaxProvider, MiniMaxConfig } from './providers/minimax'
+import { Speaker, SpeakerOptions } from './core/speaker'
+import { TTSError, TTSErrorCode } from './core/types'
+import { StreamReader } from './core/stream-reader'
+import { StreamingSynthesizer } from './core/streaming-synthesizer'
+import { StreamPlayer } from './core/stream-player'
+
+export const pluginInfo = {
+  name: 'ocosay',
+  version: '1.0.0',
+  description: 'OpenCode TTS 播放插件 - 支持 MiniMax TTS',
+  author: '',
+  license: 'MIT'
+}
+
+let speaker: Speaker | undefined
+let streamReader: StreamReader | undefined
+let streamingSynthesizer: StreamingSynthesizer | undefined
+let streamPlayer: StreamPlayer | undefined
+let initialized = false
+let autoReadEnabled = false
+
+export interface InitializeOptions {
+  defaultProvider?: string
+  defaultModel?: 'sync' | 'async' | 'stream'
+  defaultVoice?: string
+  providers?: {
+    minimax?: MiniMaxConfig
+  }
+  autoRead?: boolean
+  streamBufferSize?: number
+  streamBufferTimeout?: number
+}
+
+export async function initialize(config?: InitializeOptions): Promise<void> {
+  if (initialized) {
+    return
+  }
+  
+  if (config?.providers?.minimax) {
+    const minimaxProvider = new MiniMaxProvider(config.providers.minimax)
+    registerProvider('minimax', minimaxProvider)
+    await minimaxProvider.initialize()
+  }
+  
+  const speakerOptions: 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: InitializeOptions): void {
+  const provider = getProvider(config?.defaultProvider || 'minimax')
+  
+  streamReader = new StreamReader(
+    config?.streamBufferSize || 30,
+    config?.streamBufferTimeout || 2000
+  )
+  
+  streamingSynthesizer = new StreamingSynthesizer({
+    provider,
+    voice: config?.defaultVoice,
+    speed: 1.0,
+    volume: 1.0,
+    pitch: 1.0
+  })
+  
+  const playerEvents = {
+    onStart: () => {},
+    onEnd: () => {},
+    onProgress: (bytesWritten: number) => {},
+    onError: (error: Error) => console.error('Stream player error:', error),
+    onStop: () => {}
+  }
+  streamPlayer = new StreamPlayer({ events: playerEvents })
+
+  const synthesisQueue: string[] = []
+  let isSynthesizing = false
+
+  async function processQueue(): Promise<void> {
+    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: string) => {
+    synthesisQueue.push(text)
+    if (!isSynthesizing) {
+      processQueue()
+    }
+  })
+  
+  streamingSynthesizer.on('chunk', (chunk: Buffer) => {
+    if (streamPlayer) {
+      streamPlayer.write(chunk)
+    }
+  })
+  
+  streamingSynthesizer.on('done', () => {
+    if (streamPlayer) {
+      streamPlayer.end()
+    }
+  })
+
+  const TuiEventBus = (global as any).__opencode_tuieventbus__
+  if (TuiEventBus) {
+    const eventBus = new TuiEventBus()
+    let messagePartDeltaHandler: ((event: any) => void) | undefined
+    let messagePartEndHandler: (() => void) | undefined
+    
+    messagePartDeltaHandler = (event: any) => {
+      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)
+  }
+}
+
+export function getSpeaker(): Speaker {
+  if (!speaker) {
+    throw new TTSError(
+      'Plugin not initialized. Call initialize() first.',
+      TTSErrorCode.UNKNOWN,
+      'ocosay'
+    )
+  }
+  return speaker
+}
+
+export function isStreamEnabled(): boolean {
+  return streamReader !== undefined && streamingSynthesizer !== undefined && streamPlayer !== undefined
+}
+
+export function isAutoReadEnabled(): boolean {
+  return autoReadEnabled
+}
+
+export function getStreamStatus(): { isActive: boolean; bytesWritten: number; state: string } {
+  if (!streamReader) {
+    return { isActive: false, bytesWritten: 0, state: 'not_initialized' }
+  }
+  return {
+    isActive: streamReader.isActive(),
+    bytesWritten: streamPlayer?.getBytesWritten() ?? 0,
+    state: streamReader.getState()
+  }
+}
+
+export function getStreamReader(): StreamReader | undefined {
+  return streamReader
+}
+
+export function getStreamingSynthesizer(): StreamingSynthesizer | undefined {
+  return streamingSynthesizer
+}
+
+export function getStreamPlayer(): StreamPlayer | undefined {
+  return streamPlayer
+}
+
+export async function destroy(): Promise<void> {
+  if (streamReader) {
+    streamReader.reset()
+    streamReader = undefined
+  }
+  
+  if (streamingSynthesizer) {
+    streamingSynthesizer.reset()
+    streamingSynthesizer = undefined
+  }
+  
+  if (streamPlayer) {
+    await streamPlayer.stop()
+    streamPlayer = undefined
+  }
+  
+  if (speaker) {
+    await speaker.destroy()
+    speaker = undefined
+  }
+  
+  for (const providerName of listProviders()) {
+    try {
+      getProvider(providerName)?.destroy()
+    } catch (e) {}
+  }
+  
+  initialized = false
+  autoReadEnabled = false
+}
+
+export { handleToolCall }
+export const toolNames = [
+  'tts_speak',
+  'tts_stop',
+  'tts_pause',
+  'tts_resume',
+  'tts_list_voices',
+  'tts_list_providers',
+  'tts_status',
+  'tts_stream_speak',
+  'tts_stream_stop',
+  'tts_stream_status'
+]

package/src/plugin.ts

@@ -0,0 +1,166 @@
+import { tool } from '@opencode-ai/plugin'
+import type { Plugin, PluginInput, PluginOptions } from '@opencode-ai/plugin'
+import { handleToolCall } from './index'
+import { initialize, destroy } from './index'
+
+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
+  }
+})
+
+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 ttsPauseTool = tool({
+  description: '暂停当前 TTS 播放',
+  args: {},
+  execute: async () => {
+    const result = await handleToolCall('tts_pause')
+    if (result.success === false) {
+      throw new Error(result.error || 'Unknown error')
+    }
+    return result
+  }
+})
+
+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')
+    }
+    return result
+  }
+})
+
+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')
+    }
+    return result
+  }
+})
+
+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')
+    }
+    return result
+  }
+})
+
+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')
+    }
+    return result
+  }
+})
+
+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')
+    }
+    return result
+  }
+})
+
+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')
+    }
+    return result
+  }
+})
+
+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')
+    }
+    return typeof result === 'string' ? result : JSON.stringify(result)
+  }
+})
+
+const OcosayPlugin: Plugin = async (_input: PluginInput, _options?: PluginOptions) => {
+  console.info(`${pluginName}: initializing...`)
+  
+  await initialize({
+    autoRead: false
+  })
+  
+  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 () => {}
+  }
+}
+
+export default OcosayPlugin

package/src/providers/base.ts

@@ -0,0 +1,150 @@
+/**
+ * TTS Provider Base Class and Registry
+ * Provider 基类和注册机制
+ */
+
+import { TTSProvider, TTSError, TTSErrorCode, Voice, TTSCapabilities, SpeakOptions, AudioResult } from '../core/types'
+
+// Provider 注册表
+const providers = new Map<string, TTSProvider>()
+
+/**
+ * 注册 TTS Provider
+ */
+export function registerProvider(name: string, provider: TTSProvider): void {
+  if (providers.has(name)) {
+    throw new TTSError(
+      `Provider "${name}" is already registered`,
+      TTSErrorCode.UNKNOWN,
+      'system'
+    )
+  }
+  providers.set(name, provider)
+}
+
+/**
+ * 获取 TTS Provider
+ */
+export function getProvider(name: string): TTSProvider {
+  const provider = providers.get(name)
+  if (!provider) {
+    throw new TTSError(
+      `TTS Provider "${name}" not found`,
+      TTSErrorCode.UNKNOWN,
+      'system'
+    )
+  }
+  return provider
+}
+
+/**
+ * 获取所有已注册的 Provider 名称
+ */
+export function listProviders(): string[] {
+  return Array.from(providers.keys())
+}
+
+/**
+ * 检查 Provider 是否已注册
+ */
+export function hasProvider(name: string): boolean {
+  return providers.has(name)
+}
+
+/**
+ * 注销 Provider
+ */
+export function unregisterProvider(name: string): boolean {
+  return providers.delete(name)
+}
+
+/**
+ * Provider 抽象基类，提供通用实现
+ */
+export abstract class BaseTTSProvider implements TTSProvider {
+  abstract name: string
+  abstract capabilities: TTSCapabilities
+  
+  protected apiKey?: string
+  protected defaultVoice?: string
+  protected defaultModel: 'sync' | 'async' | 'stream' = 'stream'
+  
+  async initialize(): Promise<void> {
+    // 子类可override
+  }
+  
+  async destroy(): Promise<void> {
+    // 子类可override
+  }
+  
+  /**
+   * 通用 speak 实现，处理通用逻辑
+   */
+  async speak(text: string, options?: SpeakOptions): Promise<AudioResult> {
+    if (!text || text.trim().length === 0) {
+      throw new TTSError(
+        'Text cannot be empty',
+        TTSErrorCode.INVALID_PARAMS,
+        this.name
+      )
+    }
+    
+    const voice = options?.voice || this.defaultVoice
+    const model = options?.model || this.defaultModel
+    
+    return this.doSpeak(text, voice, model, options)
+  }
+  
+  /**
+   * 子类实现的实际 speak 逻辑
+   */
+  protected abstract doSpeak(
+    text: string, 
+    voice: string | undefined, 
+    model: 'sync' | 'async' | 'stream',
+    options?: SpeakOptions
+  ): Promise<AudioResult>
+  
+  pause(): Promise<void> {
+    throw new TTSError(
+      'Pause is not supported by this provider',
+      TTSErrorCode.UNKNOWN,
+      this.name
+    )
+  }
+  
+  resume(): Promise<void> {
+    throw new TTSError(
+      'Resume is not supported by this provider',
+      TTSErrorCode.UNKNOWN,
+      this.name
+    )
+  }
+  
+  stop(): Promise<void> {
+    // 默认空实现
+    return Promise.resolve()
+  }
+  
+  async listVoices(): Promise<Voice[]> {
+    // 默认返回空数组，子类可override
+    return []
+  }
+  
+  getCapabilities(): TTSCapabilities {
+    return this.capabilities
+  }
+  
+  /**
+   * 验证 API Key
+   */
+  protected validateApiKey(): void {
+    if (!this.apiKey) {
+      throw new TTSError(
+        `API key is required for provider "${this.name}"`,
+        TTSErrorCode.AUTH,
+        this.name
+      )
+    }
+  }
+}