cactus-react-native 0.2.11 → 1.0.2

package/src/tts.ts

@@ -1,236 +0,0 @@
-import {
-  LlamaContext,
-  initVocoder,
-  getFormattedAudioCompletion,
-  decodeAudioTokens,
-  releaseVocoder,
-  getTTSType,
-  isVocoderEnabled,
-} from './index'
-import type { NativeAudioDecodeResult, NativeTTSType } from './index'
-
-export interface TTSOptions {
-  voiceId?: string
-  speed?: number
-  pitch?: number
-  volume?: number
-  format?: 'wav' | 'mp3' | 'ogg'
-  sampleRate?: number
-}
-
-export interface TTSGenerationResult extends NativeAudioDecodeResult {
-  metadata?: {
-    duration?: number
-    sampleRate?: number
-    channels?: number
-    format?: string
-  }
-}
-
-export interface TTSSpeaker {
-  id: string
-  name?: string
-  language?: string
-  gender?: 'male' | 'female' | 'neutral'
-  config: Record<string, any>
-}
-
-export class TTSError extends Error {
-  constructor(
-    message: string,
-    public code?: string,
-    public contextId?: number
-  ) {
-    super(message)
-    this.name = 'TTSError'
-  }
-}
-
-export class CactusTTS {
-  private context: LlamaContext
-  private isInitialized: boolean = false
-  private isReleased: boolean = false
-  private vocoderPath?: string
-  private ttsType?: NativeTTSType
-
-  private constructor(context: LlamaContext, vocoderPath: string) {
-    this.context = context
-    this.vocoderPath = vocoderPath
-  }
-
-  static async init(
-    context: LlamaContext,
-    vocoderModelPath: string,
-  ): Promise<CactusTTS> {
-    if (!context) {
-      throw new TTSError('LlamaContext is required', 'INVALID_CONTEXT')
-    }
-    
-    if (!vocoderModelPath || typeof vocoderModelPath !== 'string') {
-      throw new TTSError('Valid vocoder model path is required', 'INVALID_VOCODER_PATH')
-    }
-
-    try {
-      await initVocoder(context.id, vocoderModelPath)
-      const instance = new CactusTTS(context, vocoderModelPath)
-      instance.isInitialized = true
-      instance.ttsType = await getTTSType(context.id)
-      return instance
-    } catch (error) {
-      throw new TTSError(
-        `Failed to initialize TTS: ${error instanceof Error ? error.message : 'Unknown error'}`,
-        'INITIALIZATION_FAILED',
-        context.id
-      )
-    }
-  }
-
- 
-  async generate(
-    textToSpeak: string,
-    speaker: TTSSpeaker | string,
-    options?: TTSOptions
-  ): Promise<TTSGenerationResult> {
-    this.validateState()
-    this.validateInputs(textToSpeak, speaker)
-
-    const speakerConfig = typeof speaker === 'string' ? speaker : JSON.stringify(speaker.config)
-    const startTime = Date.now()
-
-    try {
-      const { formatted_prompt } = await getFormattedAudioCompletion(
-        this.context.id,
-        speakerConfig,
-        textToSpeak,
-      )
-      
-      if (!formatted_prompt) {
-        throw new TTSError('Failed to format audio prompt', 'FORMATTING_FAILED', this.context.id)
-      }
-
-      const tokenizeResult = await this.context.tokenize(formatted_prompt)
-      if (!tokenizeResult?.tokens || tokenizeResult.tokens.length === 0) {
-        throw new TTSError('Failed to tokenize prompt', 'TOKENIZATION_FAILED', this.context.id)
-      }
-
-      const audioResult = await decodeAudioTokens(this.context.id, tokenizeResult.tokens)
-      const endTime = Date.now()
-
-      return {
-        ...audioResult,
-        metadata: {
-          duration: endTime - startTime,
-          sampleRate: options?.sampleRate,
-          format: options?.format || 'wav',
-          channels: 1, // Assuming mono output
-        }
-      }
-    } catch (error) {
-      if (error instanceof TTSError) {
-        throw error
-      }
-      throw new TTSError(
-        `Audio generation failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
-        'GENERATION_FAILED',
-        this.context.id
-      )
-    }
-  }
-
- 
-  async isVocoderReady(): Promise<boolean> {
-    if (!this.isInitialized || this.isReleased) {
-      return false
-    }
-    
-    try {
-      return await isVocoderEnabled(this.context.id)
-    } catch {
-      return false
-    }
-  }
-
-
-  getTTSType(): NativeTTSType | undefined {
-    return this.ttsType
-  }
-
- 
-  getContextId(): number {
-    return this.context.id
-  }
-
-  getVocoderPath(): string | undefined {
-    return this.vocoderPath
-  }
-
-
-  isReady(): boolean {
-    return this.isInitialized && !this.isReleased
-  }
-
-  static createSpeaker(
-    id: string,
-    config: Record<string, any>,
-    metadata?: {
-      name?: string
-      language?: string
-      gender?: 'male' | 'female' | 'neutral'
-    }
-  ): TTSSpeaker {
-    return {
-      id,
-      config,
-      ...metadata
-    }
-  }
-
- 
-  private validateState(): void {
-    if (this.isReleased) {
-      throw new TTSError('TTS instance has been released', 'INSTANCE_RELEASED', this.context.id)
-    }
-    
-    if (!this.isInitialized) {
-      throw new TTSError('TTS instance not initialized', 'NOT_INITIALIZED', this.context.id)
-    }
-  }
-
-  
-  private validateInputs(textToSpeak: string, speaker: TTSSpeaker | string): void {
-    if (!textToSpeak || typeof textToSpeak !== 'string' || textToSpeak.trim().length === 0) {
-      throw new TTSError('Valid text input is required', 'INVALID_TEXT_INPUT')
-    }
-
-    if (textToSpeak.length > 10000) { // Reasonable limit
-      throw new TTSError('Text input too long (max 10000 characters)', 'TEXT_TOO_LONG')
-    }
-
-    if (!speaker) {
-      throw new TTSError('Speaker configuration is required', 'INVALID_SPEAKER')
-    }
-
-    if (typeof speaker === 'object' && (!speaker.id || !speaker.config)) {
-      throw new TTSError('Speaker must have id and config properties', 'INVALID_SPEAKER_FORMAT')
-    }
-  }
-
-  
-  async release(): Promise<void> {
-    if (this.isReleased) {
-      return // Already released, no-op
-    }
-
-    try {
-      await releaseVocoder(this.context.id)
-      this.isReleased = true
-      this.isInitialized = false
-    } catch (error) {
-      throw new TTSError(
-        `Failed to release TTS resources: ${error instanceof Error ? error.message : 'Unknown error'}`,
-        'RELEASE_FAILED',
-        this.context.id
-      )
-    }
-  }
-} 

package/src/vlm.ts

@@ -1,276 +0,0 @@
-import {
-  initLlama,
-  initMultimodal,
-  multimodalCompletion,
-  LlamaContext,
-  type ContextParams,
-  type CompletionParams,
-  type CactusOAICompatibleMessage,
-  type NativeCompletionResult,
-} from './index'
-
-import { Telemetry } from './telemetry'
-import { setCactusToken, getTextCompletion, getVisionCompletion } from './remote'
-import { ConversationHistoryManager } from './chat'
-
-interface CactusVLMReturn {
-  vlm: CactusVLM | null
-  error: Error | null
-}
-
-export type VLMContextParams = ContextParams & {
-  mmproj: string
-}
-
-export type VLMCompletionParams = Omit<CompletionParams, 'prompt'> & {
-  images?: string[]
-  mode?: string
-}
-
-export class CactusVLM {
-  private context: LlamaContext
-  protected conversationHistoryManager: ConversationHistoryManager
-
-  private static _initCache: Map<string, Promise<CactusVLMReturn>> = new Map();
-
-  private static getCacheKey(params: VLMContextParams, cactusToken?: string, retryOptions?: { maxRetries?: number; delayMs?: number }): string {
-    return JSON.stringify({ params, cactusToken, retryOptions });
-  }
-
-  private constructor(context: LlamaContext) {
-    this.context = context
-    this.conversationHistoryManager = new ConversationHistoryManager()
-  }
-
-  static async init(
-    params: VLMContextParams,
-    onProgress?: (progress: number) => void,
-    cactusToken?: string,
-    retryOptions?: { maxRetries?: number; delayMs?: number },
-  ): Promise<CactusVLMReturn> {
-    if (cactusToken) {
-      setCactusToken(cactusToken);
-    }
-
-    const key = CactusVLM.getCacheKey(params, cactusToken, retryOptions);
-    if (CactusVLM._initCache.has(key)) {
-      return CactusVLM._initCache.get(key)!;
-    }
-
-    const initPromise = (async () => {
-      const maxRetries = retryOptions?.maxRetries ?? 3;
-      const delayMs = retryOptions?.delayMs ?? 1000;
-
-      const configs = [
-        params,
-        { ...params, n_gpu_layers: 0 } 
-      ];
-
-      const sleep = (ms: number): Promise<void> => {
-        return new Promise(resolve => {
-          const start = Date.now();
-          const wait = () => {
-            if (Date.now() - start >= ms) {
-              resolve();
-            } else {
-              Promise.resolve().then(wait);
-            }
-          };
-          wait();
-        });
-      };
-
-      for (const config of configs) {
-        let lastError: Error | null = null;
-
-        for (let attempt = 1; attempt <= maxRetries; attempt++) {
-          try {
-            const context = await initLlama(config, onProgress)
-            await initMultimodal(context.id, params.mmproj, false)
-            return {vlm: new CactusVLM(context), error: null}
-          } catch (e) {
-            lastError = e as Error;
-            const isLastConfig = configs.indexOf(config) === configs.length - 1;
-            const isLastAttempt = attempt === maxRetries;
-
-            Telemetry.error(e as Error, {
-              n_gpu_layers: config.n_gpu_layers ?? null,
-              n_ctx: config.n_ctx ?? null,
-              model: config.model ?? null,
-            });
-
-            if (!isLastAttempt) {
-              const delay = delayMs * Math.pow(2, attempt - 1);
-              await sleep(delay);
-            } else if (!isLastConfig) {
-              break;
-            }
-          }
-        }
-
-        if (configs.indexOf(config) === configs.length - 1 && lastError) {
-          return {vlm: null, error: lastError}
-        }
-      }
-
-      return {vlm: null, error: new Error('Failed to initialize CactusVLM')}
-    })();
-
-    CactusVLM._initCache.set(key, initPromise);
-
-    const result = await initPromise;
-    if (result.error) {
-      CactusVLM._initCache.delete(key); 
-    }
-    return result;
-  }
-
-  async completion(
-    messages: CactusOAICompatibleMessage[],
-    params: VLMCompletionParams = {},
-    callback?: (data: any) => void,
-  ): Promise<NativeCompletionResult> {
-    const mode = params.mode || 'local';
-
-    let result: NativeCompletionResult;
-    let lastError: Error | null = null;
-
-    if (mode === 'remote') {
-      result = await this._handleRemoteCompletion(messages, params, callback);
-    } else if (mode === 'local') {
-      result = await this._handleLocalCompletion(messages, params, callback);
-    } else if (mode === 'localfirst') {
-      try {
-        result = await this._handleLocalCompletion(messages, params, callback);
-      } catch (e) {
-        lastError = e as Error;
-        try {
-          result = await this._handleRemoteCompletion(messages, params, callback);
-        } catch (remoteError) {
-          throw lastError;
-        }
-      }
-    } else if (mode === 'remotefirst') {
-      try {
-        result = await this._handleRemoteCompletion(messages, params, callback);
-      } catch (e) {
-        lastError = e as Error;
-        try {
-          result = await this._handleLocalCompletion(messages, params, callback);
-        } catch (localError) {
-          throw lastError;
-        }
-      }
-    } else {
-      throw new Error('Invalid mode: ' + mode + '. Must be "local", "remote", "localfirst", or "remotefirst"');
-    }
-
-    return result;
-  }
-
-  private _handleLocalCompletion = async(
-    messages: CactusOAICompatibleMessage[],
-    params: VLMCompletionParams,
-    callback?: (data: any) => void,
-  ): Promise<NativeCompletionResult> => {
-    const { newMessages, requiresReset } =
-      this.conversationHistoryManager.processNewMessages(messages);
-
-    if (requiresReset) {
-      this.context?.rewind();
-      this.conversationHistoryManager.reset();
-    }
-
-    if (newMessages.length === 0) {
-      console.warn('No messages to complete!');
-    }
-
-    let result: NativeCompletionResult;
-
-    if (params.images && params.images.length > 0) {
-      const formattedPrompt = await this.context.getFormattedChat(newMessages)
-      const prompt =
-        typeof formattedPrompt === 'string'
-          ? formattedPrompt
-          : formattedPrompt.prompt
-      result = await multimodalCompletion(
-        this.context.id,
-        prompt,
-        params.images,
-        { ...params, prompt, emit_partial_completion: !!callback },
-      )
-    } else {
-      result = await this.context.completion({ messages: newMessages, ...params }, callback)
-    }
-
-    this.conversationHistoryManager.update(newMessages, {
-      role: 'assistant',
-      content: result.content || result.text,
-    });
-
-    return result;
-  }
-
-  private async _handleRemoteCompletion(
-    messages: CactusOAICompatibleMessage[],
-    params: VLMCompletionParams,
-    callback?: (data: any) => void,
-  ): Promise<NativeCompletionResult> {
-    const prompt = messages.map((m) => `${m.role}: ${m.content}`).join('\n');
-    const imagePath = params.images && params.images.length > 0 ? params.images[0] : '';
-    
-    let responseText: string;
-    if (imagePath) {
-      responseText = await getVisionCompletion(messages, imagePath);
-    } else {
-      responseText = await getTextCompletion(messages);
-    }
-    
-    if (callback) {
-      for (let i = 0; i < responseText.length; i++) {
-        callback({ token: responseText[i] });
-      }
-    }
-    
-    return {
-      text: responseText,
-      reasoning_content: '',
-      tool_calls: [],
-      content: responseText,
-      tokens_predicted: responseText.split(' ').length,
-      tokens_evaluated: prompt.split(' ').length,
-      truncated: false,
-      stopped_eos: true,
-      stopped_word: '',
-      stopped_limit: 0,
-      stopping_word: '',
-      tokens_cached: 0,
-      timings: {
-        prompt_n: prompt.split(' ').length,
-        prompt_ms: 0,
-        prompt_per_token_ms: 0,
-        prompt_per_second: 0,
-        predicted_n: responseText.split(' ').length,
-        predicted_ms: 0,
-        predicted_per_token_ms: 0,
-        predicted_per_second: 0,
-      },
-    };
-  }
-
-  async rewind(): Promise<void> {
-    return this.context?.rewind()
-  }
-
-  async release(): Promise<void> {
-    return this.context.release()
-  }
-
-  async stopCompletion(): Promise<void> {
-    return await this.context.stopCompletion()
-  }
-
-  isJinjaSupported(): boolean {
-    return this.context.isJinjaSupported();
-  }
-}