@mingxy/ocosay 1.0.3 → 1.0.5

package/src/index.ts

@@ -1,236 +0,0 @@
-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) {
-    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: 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

@@ -1,178 +0,0 @@
-import { tool } from '@opencode-ai/plugin'
-import type { Plugin, PluginInput, PluginOptions } from '@opencode-ai/plugin'
-import { handleToolCall } from './index'
-import { initialize, destroy } 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
-  }
-})
-
-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...`)
-
-  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
-      }
-    }
-  })
-
-  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
-    }
-  }
-}
-
-export default { server: OcosayPlugin }

package/src/providers/base.ts

@@ -1,150 +0,0 @@
-/**
- * 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
-      )
-    }
-  }
-}