cactus-react-native 0.2.10 → 1.0.1

package/src/lm.ts

@@ -1,324 +0,0 @@
-import { initLlama, LlamaContext } from './index'
-// @ts-ignore
-import { Platform } from 'react-native'
-import type {
-  ContextParams,
-  CompletionParams,
-  CactusOAICompatibleMessage,
-  NativeCompletionResult,
-  EmbeddingParams,
-  NativeEmbeddingResult,
-} from './index'
-
-import { Telemetry } from './telemetry'
-import { setCactusToken, getVertexAIEmbedding, getTextCompletion } from './remote'
-import { ConversationHistoryManager } from './chat'
-
-interface CactusLMReturn {
-  lm: CactusLM | null
-  error: Error | null
-}
-
-export class CactusLM {
-  protected context: LlamaContext
-  protected conversationHistoryManager: ConversationHistoryManager
-  private initParams: ContextParams
-  private static _initCache: Map<string, Promise<CactusLMReturn>> = new Map();
-
-  private static getCacheKey(params: ContextParams, cactusToken?: string, retryOptions?: { maxRetries?: number; delayMs?: number }): string {
-    return JSON.stringify({ params, cactusToken, retryOptions });
-  }
-
-  protected constructor(context: LlamaContext, initParams: ContextParams) {
-    this.context = context
-    this.initParams = initParams
-    this.conversationHistoryManager = new ConversationHistoryManager()
-  }
-
-  private static isContextNotFoundError(e: unknown): boolean {
-    const message = String((e as any)?.message ?? e ?? '')
-    return /context not found/i.test(message)
-  }
-
-  private async reinit(): Promise<void> {
-    const newContext = await initLlama(this.initParams)
-    this.context = newContext
-    this.conversationHistoryManager.reset()
-  }
-
-  private async run<T>(op: () => Promise<T>): Promise<T> {
-    try {
-      return await op()
-    } catch (e) {
-      if (!CactusLM.isContextNotFoundError(e)) throw e
-      await this.reinit()
-      return await op()
-    }
-  }
-
-  static async init(
-    params: ContextParams,
-    onProgress?: (progress: number) => void,
-    cactusToken?: string,
-    retryOptions?: { maxRetries?: number; delayMs?: number },
-  ): Promise<CactusLMReturn> {
-
-    if (cactusToken) {
-      setCactusToken(cactusToken);
-    }
-
-    const key = CactusLM.getCacheKey(params, cactusToken, retryOptions);
-    if (CactusLM._initCache.has(key)) {
-      return CactusLM._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);
-            return { lm: new CactusLM(context, config), 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 { lm: null, error: lastError };
-        }
-      }
-      return { lm: null, error: new Error('Failed to initialize CactusLM after all retries') };
-    })();
-
-    CactusLM._initCache.set(key, initPromise);
-
-    const result = await initPromise;
-    // Cache only while in-flight; never cache resolved instances
-    CactusLM._initCache.delete(key);
-    return result;
-  }
-
-  completion = async (
-    messages: CactusOAICompatibleMessage[],
-    params: CompletionParams & { mode?: string } = {},
-    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, 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, callback);
-        } catch (remoteError) {
-          throw lastError;
-        }
-      }
-    } else if (mode === 'remotefirst') {
-      try {
-        result = await this._handleRemoteCompletion(messages, 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: CompletionParams,
-    callback?: (data: any) => void,
-  ): Promise<NativeCompletionResult> => {
-    const { newMessages, requiresReset } =
-      this.conversationHistoryManager.processNewMessages(messages);
-
-    if (requiresReset) {
-      await this.run(() => this.context.rewind())
-      this.conversationHistoryManager.reset();
-    }
-
-    if (newMessages.length === 0) {
-      console.warn('No messages to complete!');
-    }
-
-    const result = await this.run(() =>
-      this.context.completion({ messages: newMessages, ...params }, callback),
-    )
-
-    this.conversationHistoryManager.update(newMessages, {
-      role: 'assistant',
-      content: result.content,
-    });
-
-    return result;
-  }
-
-  private async _handleRemoteCompletion(
-    messages: CactusOAICompatibleMessage[],
-    callback?: (data: any) => void,
-  ): Promise<NativeCompletionResult> {
-    const prompt = messages.map((m) => `${m.role}: ${m.content}`).join('\n');
-    
-    const 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 embedding(
-    text: string,
-    params?: EmbeddingParams,
-    mode: string = 'local',
-  ): Promise<NativeEmbeddingResult> {
-    let result: NativeEmbeddingResult;
-    let lastError: Error | null = null;
-
-    if (mode === 'remote') {
-      result = await this._handleRemoteEmbedding(text);
-    } else if (mode === 'local') {
-      result = await this._handleLocalEmbedding(text, params);
-    } else if (mode === 'localfirst') {
-      try {
-        result = await this._handleLocalEmbedding(text, params);
-      } catch (e) {
-        lastError = e as Error;
-        try {
-          result = await this._handleRemoteEmbedding(text);
-        } catch (remoteError) {
-          throw lastError;
-        }
-      }
-    } else if (mode === 'remotefirst') {
-      try {
-        result = await this._handleRemoteEmbedding(text);
-      } catch (e) {
-        lastError = e as Error;
-        try {
-          result = await this._handleLocalEmbedding(text, params);
-        } catch (localError) {
-          throw lastError;
-        }
-      }
-    } else {
-      throw new Error('Invalid mode: ' + mode + '. Must be "local", "remote", "localfirst", or "remotefirst"');
-    }
-    return result;
-  }
-
-  protected async _handleLocalEmbedding(text: string, params?: EmbeddingParams): Promise<NativeEmbeddingResult> {
-    return this.run(() => this.context.embedding(text, params))
-  }
-
-  protected async _handleRemoteEmbedding(text: string): Promise<NativeEmbeddingResult> {
-    const embeddingValues = await getVertexAIEmbedding(text);
-    return {
-      embedding: embeddingValues,
-    };
-  }
-
-  rewind = async (): Promise<void> => {
-    return this.run(() => this.context.rewind())
-  }
-
-  async release(): Promise<void> {
-    try {
-      return await this.context.release()
-    } catch (e) {
-      // Treat missing context as already released
-      if (CactusLM.isContextNotFoundError(e)) return
-      throw e
-    }
-  }
-
-  async stopCompletion(): Promise<void> {
-    return await this.run(() => this.context.stopCompletion())
-  }
-
-  isJinjaSupported(): boolean {
-    return this.context.isJinjaSupported();
-  }
-} 

package/src/projectId.ts

@@ -1 +0,0 @@
-export const PROJECT_ID = 'not-set';

package/src/remote.ts

@@ -1,113 +0,0 @@
-import type { CactusOAICompatibleMessage } from "./chat";
-
-let _cactusToken: string | null = null;
-
-export function setCactusToken(token: string | null): void {
-  _cactusToken = token;
-}
-
-export async function getVertexAIEmbedding(text: string): Promise<number[]> {
-  text = text
-  throw new Error('Remote embedding is not currently supported. The Cactus library is in active development - if you need this functionality, please contact us at founders@cactuscompute.com');
-}
-
-export async function getVertexAICompletion(
-  messages: CactusOAICompatibleMessage[],
-  imageData?: string,
-  imagePath?: string,
-  mimeType?: string,
-): Promise<string> {
-  if (_cactusToken === null) {
-    throw new Error('CactusToken not set. Please call CactusVLM.init with cactusToken parameter.');
-  }
-  const endpoint = 'https://openrouter.ai/api/v1/chat/completions';
-
-  const headers = {
-    'Authorization': `Bearer ${_cactusToken}`,
-    'Content-Type': 'application/json',
-  };
-
-  const requestBody = {
-    model: 'google/gemini-2.5-flash-lite',
-    messages: messages,
-  };
-
-  let imageUrl = ''
-  if (imageData) {
-    imageUrl = `data:${mimeType || 'image/jpeg'};base64,${imageData}`
-  } else if (imagePath) {
-    const RNFS = require('react-native-fs');
-    const base64Data = await RNFS.readFile(imagePath, 'base64');
-    imageUrl = `data:${mimeType || detectMimeType(imagePath)};base64,${base64Data}`
-  }
-
-  if (imageUrl) {
-    if (requestBody.messages[requestBody.messages.length - 1]?.role === 'user') {
-      requestBody.messages[requestBody.messages.length - 1] = {
-        role: 'user',
-        content: [
-          {
-            type: 'text',
-            text: requestBody.messages[requestBody.messages.length - 1]?.content || ''
-          },
-          {
-            type: 'image_url',
-            image_url: {
-              url: imageUrl
-            }
-          }
-        ]
-      }
-    }else{
-      console.warn('Image data provided but message is not a user message: ', requestBody.messages);
-    }
-  }
-
-  const response = await fetch(endpoint, {
-    method: 'POST',
-    headers,
-    body: JSON.stringify(requestBody),
-  });
-
-  if (response.status === 401) {
-    _cactusToken = null;
-    throw new Error('Authentication failed. Please update your cactusToken.');
-  } else if (!response.ok) {
-    const errorText = await response.text();
-    throw new Error(`HTTP ${response.status}: ${errorText}`);
-  }
-
-  const responseBody = await response.json();
-  const responseText = responseBody.choices[0].message.content;
-
-  return responseText;
-}
-
-export async function getTextCompletion(messages: CactusOAICompatibleMessage[]): Promise<string> {
-  return getVertexAICompletion(messages);
-}
-
-export async function getVisionCompletion(messages: CactusOAICompatibleMessage[], imagePath: string): Promise<string> {
-  return getVertexAICompletion(messages, undefined, imagePath);
-}
-
-export async function getVisionCompletionFromData(messages: CactusOAICompatibleMessage[], imageData: string, mimeType?: string): Promise<string> {
-  return getVertexAICompletion(messages, imageData, undefined, mimeType);
-}
-
-function detectMimeType(filePath: string): string {
-  const extension = filePath.toLowerCase().split('.').pop();
-  switch (extension) {
-    case 'jpg':
-    case 'jpeg':
-      return 'image/jpeg';
-    case 'png':
-      return 'image/png';
-    case 'gif':
-      return 'image/gif';
-    case 'webp':
-      return 'image/webp';
-    default:
-      return 'image/jpeg';
-  }
-} 

package/src/telemetry.ts

@@ -1,137 +0,0 @@
-import { Platform } from 'react-native'
-const packageJson = require('../package.json');
-import { PROJECT_ID } from './projectId';
-
-export interface TelemetryParams {
-  n_gpu_layers: number | null
-  n_ctx: number | null
-  model: string | null
-}
-
-interface TelemetryRecord {
-  project_id: string;
-  device_id?: string;
-  device_manufacturer?: string;
-  device_model?: string;
-  os: 'iOS' | 'Android';
-  os_version: string;
-  framework: string;
-  framework_version: string;
-  telemetry_payload?: Record<string, any>;
-  error_payload?: Record<string, any>;
-  timestamp: string;
-  model_filename: string | null;
-  n_ctx: number | null;
-  n_gpu_layers: number | null;
-}
-
-interface TelemetryConfig {
-  supabaseUrl: string;
-  supabaseKey: string;
-  table?: string;
-}
-
-export class Telemetry {
-  private static instance: Telemetry | null = null;
-  private config: Required<TelemetryConfig>;
-
-  private constructor(config: TelemetryConfig) {
-    this.config = {
-      table: 'telemetry',
-      ...config
-    };
-  }
-
-  private static getFilename(path: string): string {
-    try {
-      return path.split('/').pop() || path.split('\\').pop() || 'unknown';
-    } catch {
-      return 'unknown';
-    }
-  }
-
-  static autoInit(): void {
-    if (!Telemetry.instance) {
-      Telemetry.instance = new Telemetry({
-        supabaseUrl: 'https://vlqqczxwyaodtcdmdmlw.supabase.co',
-        supabaseKey: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InZscXFjenh3eWFvZHRjZG1kbWx3Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTE1MTg2MzIsImV4cCI6MjA2NzA5NDYzMn0.nBzqGuK9j6RZ6mOPWU2boAC_5H9XDs-fPpo5P3WZYbI', // Anon!
-      });
-    }
-  }
-
-  static init(config: TelemetryConfig): void {
-    if (!Telemetry.instance) {
-      Telemetry.instance = new Telemetry(config);
-    }
-  }
-
-  static track(payload: Record<string, any>, options: TelemetryParams, deviceMetadata?: Record<string, any>): void {
-    if (!Telemetry.instance) {
-      Telemetry.autoInit();
-    }
-    Telemetry.instance!.trackInternal(payload, options, deviceMetadata);
-  }
-
-  static error(error: Error, options: TelemetryParams): void {
-    if (!Telemetry.instance) {
-      Telemetry.autoInit();
-    }
-    Telemetry.instance!.errorInternal(error, options);
-  }
-
-  private trackInternal(payload: Record<string, any>, options: TelemetryParams, deviceMetadata?: Record<string, any>): void {
-    const record: TelemetryRecord = {
-      project_id: PROJECT_ID,
-      device_id: deviceMetadata?.deviceId,
-      device_manufacturer: deviceMetadata?.make,
-      device_model: deviceMetadata?.model,
-      os: Platform.OS === 'ios' ? 'iOS' : 'Android',
-      os_version: Platform.Version.toString(),
-      framework: 'react-native',
-      framework_version: packageJson.version,
-      telemetry_payload: payload,
-      timestamp: new Date().toISOString(),
-      model_filename: Telemetry.getFilename(options.model || ''),
-      n_ctx: options.n_ctx,
-      n_gpu_layers: options.n_gpu_layers,
-    };
-
-    this.sendRecord(record).catch(() => {});
-  }
-
-  private errorInternal(error: Error, options: TelemetryParams): void {
-    const errorPayload = {
-      message: error.message,
-      stack: error.stack,
-      name: error.name,
-    };
-
-    const record: TelemetryRecord = {
-      project_id: PROJECT_ID,
-      os: Platform.OS === 'ios' ? 'iOS' : 'Android',
-      os_version: Platform.Version.toString(),
-      framework: 'react-native',
-      framework_version: packageJson.version,
-      error_payload: errorPayload,
-      timestamp: new Date().toISOString(),
-      model_filename: Telemetry.getFilename(options.model || ''),
-      n_ctx: options.n_ctx,
-      n_gpu_layers: options.n_gpu_layers
-    };
-
-    this.sendRecord(record).catch(() => {});
-  }
-
-  private async sendRecord(record: TelemetryRecord): Promise<void> {
-    await (globalThis as any).fetch(`${this.config.supabaseUrl}/rest/v1/${this.config.table}`, {
-      method: 'POST',
-      headers: {
-        'apikey': this.config.supabaseKey,
-        'Authorization': `Bearer ${this.config.supabaseKey}`,
-        'Content-Type': 'application/json',
-        'Prefer': 'return=minimal'
-      },
-      body: JSON.stringify([record])
-    });
-  }
-}

package/src/tools.ts

@@ -1,94 +0,0 @@
-import type { NativeCompletionResult } from "./NativeCactus";
-
-export type OpenAIToolSchema = {
-  type: "function",
-  function: {
-    name: string,
-    description: string,
-    parameters: {
-      type: "object", 
-      properties: {[key: string]: Parameter},
-      required: string[]
-    }
-  }
-}
-
-interface Parameter {
-  type: string,
-  description: string,
-  required?: boolean 
-}
-
-interface Tool {
-  func: Function,
-  description: string,
-  parameters: {[key: string]: Parameter},
-  required: string[]
-}
-
-export class Tools {
-  private tools = new Map<string, Tool>();
-  
-  add(
-      func: Function, 
-      description: string,
-      parameters: {[key: string]: Parameter},
-    ) {
-      this.tools.set(func.name, { 
-        func, 
-        description,
-        parameters,
-        required: Object.entries(parameters)
-          .filter(([_, param]) => param.required)
-          .map(([key, _]) => key)
-      });
-      return func;
-    }
-  
-  getSchemas(): OpenAIToolSchema[] {
-      return Array.from(this.tools.entries()).map(([name, { description, parameters, required }]) => ({
-        type: "function",
-        function: {
-          name,
-          description,
-          parameters: {
-            type: "object",
-            properties: parameters,
-            required
-          }
-        }
-      }));
-    }
-  
-  async execute(name: string, args: any) {
-      const tool = this.tools.get(name);
-      if (!tool) throw new Error(`Tool ${name} not found`);
-      return await tool.func(...Object.values(args));
-  }
-}
-
-export async function parseAndExecuteTool(result: NativeCompletionResult, tools: Tools): Promise<{toolCalled: boolean, toolName?: string, toolInput?: any, toolOutput?: any}> {
-  if (!result.tool_calls || result.tool_calls.length === 0) {
-      return {toolCalled: false};
-  }
-  
-  try {
-      const toolCall = result.tool_calls[0];
-      if (!toolCall) {
-        return {toolCalled: false};
-      }
-      const toolName = toolCall.function.name;
-      const toolInput = JSON.parse(toolCall.function.arguments);
-      
-      const toolOutput = await tools.execute(toolName, toolInput);
-      
-      return {
-          toolCalled: true,
-          toolName,
-          toolInput,
-          toolOutput
-      };
-  } catch (error) {
-      return {toolCalled: false};
-  }
-}

package/src/tts.ts

@@ -1,42 +0,0 @@
-import {
-  LlamaContext,
-  initVocoder,
-  getFormattedAudioCompletion,
-  decodeAudioTokens,
-  releaseVocoder,
-} from './index'
-import type { NativeAudioDecodeResult } from './index'
-
-export class CactusTTS {
-  private context: LlamaContext
-
-  private constructor(context: LlamaContext) {
-    this.context = context
-  }
-
-  static async init(
-    context: LlamaContext,
-    vocoderModelPath: string,
-  ): Promise<CactusTTS> {
-    await initVocoder(context.id, vocoderModelPath)
-    return new CactusTTS(context)
-  }
-
-  async generate(
-    textToSpeak: string,
-    speakerJsonStr: string,
-  ): Promise<NativeAudioDecodeResult> {
-    const { formatted_prompt } = await getFormattedAudioCompletion(
-      this.context.id,
-      speakerJsonStr,
-      textToSpeak,
-    )
-    // To-DO: Fix
-    const tokens = (await this.context.tokenize(formatted_prompt)).tokens
-    return decodeAudioTokens(this.context.id, tokens)
-  }
-
-  async release(): Promise<void> {
-    return releaseVocoder(this.context.id)
-  }
-}