cactus-react-native 1.4.0 → 1.7.0

package/src/api/RemoteLM.ts

@@ -1,273 +0,0 @@
-import { CactusConfig } from '../config/CactusConfig';
-import { CactusImage } from '../native/CactusImage';
-import type {
-  CactusLMCompleteResult,
-  Message,
-  CompleteOptions,
-  Tool,
-} from '../types/CactusLM';
-
-export class RemoteLM {
-  private static readonly completionsUrl =
-    'https://openrouter.ai/api/v1/chat/completions';
-
-  private static readonly defaultModel = 'google/gemini-2.5-flash-lite';
-
-  public static async complete(
-    messages: Message[],
-    options?: CompleteOptions,
-    tools?: { type: 'function'; function: Tool }[],
-    callback?: (token: string) => void
-  ): Promise<CactusLMCompleteResult> {
-    if (!CactusConfig.cactusToken) {
-      throw new Error('cactusToken is required for hybrid completions');
-    }
-
-    const payload = JSON.stringify({
-      model: this.defaultModel,
-      messages: await this.transformMessages(messages),
-      tools,
-      temperature: options?.temperature,
-      top_p: options?.topP,
-      top_k: options?.topK,
-      max_tokens: options?.maxTokens,
-      stop: options?.stopSequences,
-      stream: !!callback,
-    });
-
-    return callback
-      ? await this.streamXHR(payload, callback)
-      : await this.nonStreamFetch(payload);
-  }
-
-  private static getMimeType(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:
-        throw new Error(`Unsupported image format: .${extension}`);
-    }
-  }
-
-  private static async transformMessages(messages: Message[]) {
-    const transformedMessages = [];
-
-    for (const message of messages) {
-      const content: {
-        type: string;
-        text?: string;
-        image_url?: { url: string };
-      }[] = [];
-
-      if (message.content) {
-        content.push({
-          type: 'text',
-          text: message.content,
-        });
-      }
-
-      if (message.images) {
-        for (const image of message.images) {
-          const imagePath = image.replace('file://', '');
-          const mimeType = this.getMimeType(imagePath);
-          const base64Data = await CactusImage.base64(imagePath);
-
-          content.push({
-            type: 'image_url',
-            image_url: {
-              url: `data:${mimeType};base64,${base64Data}`,
-            },
-          });
-        }
-      }
-
-      transformedMessages.push({ role: message.role, content });
-    }
-
-    return transformedMessages;
-  }
-
-  private static streamXHR(
-    payload: string,
-    callback: (token: string) => void
-  ): Promise<CactusLMCompleteResult> {
-    return new Promise((resolve, reject) => {
-      const xhr = new XMLHttpRequest();
-
-      xhr.timeout = 3 * 60 * 1000; // 3 minutes
-      xhr.ontimeout = () =>
-        reject(new Error('Remote streaming completion timed out'));
-
-      xhr.open('POST', this.completionsUrl);
-      xhr.setRequestHeader(
-        'Authorization',
-        `Bearer ${CactusConfig.cactusToken}`
-      );
-      xhr.setRequestHeader('HTTP-Referer', 'https://cactuscompute.com');
-      xhr.setRequestHeader('X-Title', 'Cactus React Native SDK');
-      xhr.setRequestHeader('Content-Type', 'application/json');
-
-      const startTime = performance.now();
-      let lastIndex = 0;
-      let buffer = '';
-      let response = '';
-      let toolCalls: { name: string; arguments: string }[] | undefined;
-      let timeToFirstTokenMs = 0;
-      let prefillTokens = 0;
-      let decodeTokens = 0;
-      let totalTokens = 0;
-
-      xhr.onprogress = () => {
-        const chunk = xhr.responseText.substring(lastIndex);
-        lastIndex = xhr.responseText.length;
-
-        buffer += chunk;
-
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-
-        for (const line of lines) {
-          if (!line.startsWith('data: ')) {
-            continue;
-          }
-
-          const jsonStr = line.slice(6).trim();
-          if (jsonStr === '[DONE]') {
-            continue;
-          }
-
-          try {
-            const data = JSON.parse(jsonStr);
-
-            if (timeToFirstTokenMs === 0) {
-              timeToFirstTokenMs = performance.now() - startTime;
-            }
-
-            const toolCallChunks = data?.choices?.[0]?.delta?.tool_calls;
-            if (toolCallChunks) {
-              if (!toolCalls) {
-                toolCalls = [];
-              }
-
-              for (const toolCallChunk of toolCallChunks) {
-                const index = toolCallChunk.index;
-
-                if (!toolCalls[index]) {
-                  toolCalls[index] = { name: '', arguments: '' };
-                }
-
-                if (toolCallChunk.function?.name) {
-                  toolCalls[index].name = toolCallChunk.function.name;
-                }
-
-                if (toolCallChunk.function?.arguments) {
-                  toolCalls[index].arguments +=
-                    toolCallChunk.function.arguments;
-                }
-              }
-            }
-
-            const content = data?.choices?.[0]?.delta?.content;
-            if (content) {
-              response += content;
-              callback(content);
-            }
-
-            if (data?.usage) {
-              prefillTokens = data.usage.prompt_tokens;
-              decodeTokens = data.usage.completion_tokens;
-              totalTokens = data.usage.total_tokens;
-            }
-          } catch {}
-        }
-      };
-
-      xhr.onload = () => {
-        const totalTimeMs = performance.now() - startTime;
-        const functionCalls = toolCalls?.map((toolCall) => ({
-          name: toolCall.name,
-          arguments: JSON.parse(toolCall.arguments) as { [key: string]: any },
-        }));
-
-        resolve({
-          success: true,
-          response,
-          functionCalls,
-          timeToFirstTokenMs,
-          totalTimeMs,
-          tokensPerSecond: (decodeTokens * 1000) / totalTimeMs,
-          prefillTokens,
-          decodeTokens,
-          totalTokens,
-        });
-      };
-
-      xhr.onerror = () =>
-        reject(new Error('Remote streaming completion failed'));
-
-      xhr.send(payload);
-    });
-  }
-
-  private static async nonStreamFetch(
-    payload: string
-  ): Promise<CactusLMCompleteResult> {
-    const startTime = performance.now();
-
-    const request = await fetch(this.completionsUrl, {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${CactusConfig.cactusToken}`,
-        'HTTP-Referer': 'https://cactuscompute.com',
-        'X-Title': 'Cactus React Native SDK',
-        'Content-Type': 'application/json',
-      },
-      body: payload,
-    });
-
-    if (!request.ok) {
-      throw new Error('Remote completion failed');
-    }
-
-    const data = await request.json();
-
-    const totalTimeMs = performance.now() - startTime;
-    const decodeTokens = data.usage.completion_tokens;
-
-    const toolCalls:
-      | {
-          function: {
-            name: string;
-            arguments: {
-              [key: string]: any;
-            };
-          };
-        }[]
-      | undefined = data.choices[0].message.tool_calls;
-
-    const functionCalls = toolCalls?.map((toolCall) => ({
-      name: toolCall.function.name,
-      arguments: toolCall.function.arguments,
-    }));
-
-    return {
-      success: true,
-      response: data.choices[0].message.content,
-      functionCalls,
-      timeToFirstTokenMs: totalTimeMs,
-      totalTimeMs,
-      tokensPerSecond: (decodeTokens * 1000) / totalTimeMs,
-      prefillTokens: data.usage.prompt_tokens,
-      decodeTokens,
-      totalTokens: data.usage.total_tokens,
-    };
-  }
-}

package/src/config/CactusConfig.ts

@@ -1,11 +0,0 @@
-export class CactusConfig {
-  // Telemetry
-  public static telemetryToken?: string;
-  public static isTelemetryEnabled: boolean = true;
-
-  // Hybrid mode
-  public static cactusToken?: string;
-
-  // Pro features
-  public static cactusProKey?: string;
-}

package/src/native/CactusCrypto.ts

@@ -1,11 +0,0 @@
-import { NitroModules } from 'react-native-nitro-modules';
-import type { CactusCrypto as CactusCryptoSpec } from '../specs/CactusCrypto.nitro';
-
-export class CactusCrypto {
-  private static readonly hybridCactusCrypto =
-    NitroModules.createHybridObject<CactusCryptoSpec>('CactusCrypto');
-
-  public static uuidv5(namespaceUuid: string, name: string): Promise<string> {
-    return this.hybridCactusCrypto.uuidv5(namespaceUuid, name);
-  }
-}

package/src/native/CactusDeviceInfo.ts

@@ -1,18 +0,0 @@
-import { NitroModules } from 'react-native-nitro-modules';
-import type {
-  CactusDeviceInfo as CactusDeviceInfoSpec,
-  DeviceInfo,
-} from '../specs/CactusDeviceInfo.nitro';
-
-export class CactusDeviceInfo {
-  private static readonly hybridCactusDeviceInfo =
-    NitroModules.createHybridObject<CactusDeviceInfoSpec>('CactusDeviceInfo');
-
-  public static getAppIdentifier(): Promise<string | undefined> {
-    return this.hybridCactusDeviceInfo.getAppIdentifier();
-  }
-
-  public static getDeviceInfo(): Promise<DeviceInfo> {
-    return this.hybridCactusDeviceInfo.getDeviceInfo();
-  }
-}

package/src/native/CactusUtil.ts

@@ -1,43 +0,0 @@
-import { NitroModules } from 'react-native-nitro-modules';
-import type { CactusUtil as CactusUtilSpec } from '../specs/CactusUtil.nitro';
-import { Platform } from 'react-native';
-import { CactusFileSystem } from './CactusFileSystem';
-import { CactusConfig } from '../config/CactusConfig';
-import { Database } from '../api/Database';
-
-export class CactusUtil {
-  private static readonly hybridCactusUtil =
-    NitroModules.createHybridObject<CactusUtilSpec>('CactusUtil');
-
-  public static async registerApp(encryptedData: string): Promise<string> {
-    if (Platform.OS === 'android') {
-      const cactusDirectory = await CactusFileSystem.getCactusDirectory();
-      await this.hybridCactusUtil.setAndroidDataDirectory(cactusDirectory);
-    }
-
-    return this.hybridCactusUtil.registerApp(encryptedData);
-  }
-
-  public static async getDeviceId(): Promise<string | null> {
-    if (Platform.OS === 'android') {
-      const cactusDirectory = await CactusFileSystem.getCactusDirectory();
-      await this.hybridCactusUtil.setAndroidDataDirectory(cactusDirectory);
-    }
-
-    const deviceId = await this.hybridCactusUtil.getDeviceId(
-      CactusConfig.cactusProKey
-    );
-
-    if (!deviceId) {
-      return null;
-    }
-
-    if (deviceId?.indexOf('|') !== -1) {
-      const parts = deviceId.split('|');
-      CactusConfig.cactusProKey = parts[1];
-      return await Database.registerDevice({ deviceId: parts[0] });
-    }
-
-    return deviceId;
-  }
-}

package/src/specs/CactusCrypto.nitro.ts

@@ -1,6 +0,0 @@
-import type { HybridObject } from 'react-native-nitro-modules';
-
-export interface CactusCrypto
-  extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
-  uuidv5(namespaceUuid: string, name: string): Promise<string>;
-}

package/src/specs/CactusDeviceInfo.nitro.ts

@@ -1,15 +0,0 @@
-import type { HybridObject } from 'react-native-nitro-modules';
-
-export interface DeviceInfo {
-  brand: string;
-  model: string;
-  device_id?: string;
-  os: string;
-  os_version: string;
-}
-
-export interface CactusDeviceInfo
-  extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
-  getAppIdentifier(): Promise<string | undefined>;
-  getDeviceInfo(): Promise<DeviceInfo>;
-}

package/src/specs/CactusUtil.nitro.ts

@@ -1,8 +0,0 @@
-import type { HybridObject } from 'react-native-nitro-modules';
-
-export interface CactusUtil
-  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
-  registerApp(encryptedData: string): Promise<string>;
-  getDeviceId(token?: string): Promise<string | null>;
-  setAndroidDataDirectory(dataDir: string): Promise<void>;
-}

package/src/telemetry/Telemetry.ts

@@ -1,236 +0,0 @@
-import { Database } from '../api/Database';
-import {
-  CactusCrypto,
-  CactusDeviceInfo,
-  CactusFileSystem,
-  CactusUtil,
-} from '../native';
-import { CactusConfig } from '../config/CactusConfig';
-import { packageVersion } from '../constants/packageVersion';
-import type { CactusLMCompleteResult } from '../types/CactusLM';
-import type { CactusSTTTranscribeResult } from '../types/CactusSTT';
-
-export interface LogRecord {
-  // Framework
-  framework: 'react-native';
-  framework_version: string;
-
-  // Event
-  event_type:
-    | 'init'
-    | 'completion'
-    | 'transcription'
-    | 'embedding'
-    | 'image_embedding'
-    | 'audio_embedding';
-  model: string;
-  success: boolean;
-  message?: string;
-
-  // Telemetry
-  telemetry_token?: string;
-  project_id?: string;
-  device_id?: string;
-
-  // LM
-  tokens?: number;
-  response_time?: number;
-  ttft?: number;
-  tps?: number;
-}
-
-export class Telemetry {
-  private static cactusTelemetryToken?: string;
-  private static projectId?: string;
-  private static deviceId?: string;
-
-  private static readonly namespaceUrl = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
-  private static readonly logBufferPaths = {
-    init: 'logs/init.json',
-    completion: 'logs/completion.json',
-    transcription: 'logs/transcription.json',
-    embedding: 'logs/embedding.json',
-    image_embedding: 'logs/image_embedding.json',
-    audio_embedding: 'logs/audio_embedding.json',
-  };
-
-  private static async handleLog(logRecord: LogRecord) {
-    if (!this.isInitialized()) {
-      return;
-    }
-
-    if (!CactusConfig.isTelemetryEnabled) {
-      return;
-    }
-
-    const logBufferPath = this.logBufferPaths[logRecord.event_type];
-
-    let logs = [];
-    if (await CactusFileSystem.fileExists(logBufferPath)) {
-      try {
-        logs = JSON.parse(await CactusFileSystem.readFile(logBufferPath));
-      } catch {
-        // Delete corrupted log buffer
-        await CactusFileSystem.deleteFile(logBufferPath);
-      }
-    }
-    logs.push(logRecord);
-
-    try {
-      await Database.sendLogRecords(logs);
-
-      if (await CactusFileSystem.fileExists(logBufferPath)) {
-        await CactusFileSystem.deleteFile(logBufferPath);
-      }
-    } catch {
-      await CactusFileSystem.writeFile(logBufferPath, JSON.stringify(logs));
-    }
-  }
-
-  public static isInitialized(): boolean {
-    return !!(this.projectId && this.deviceId);
-  }
-
-  public static async init(cactusTelemetryToken?: string): Promise<void> {
-    if (this.isInitialized()) {
-      return;
-    }
-
-    if (!CactusConfig.isTelemetryEnabled) {
-      return;
-    }
-
-    this.cactusTelemetryToken = cactusTelemetryToken;
-
-    const appIdentifier = await CactusDeviceInfo.getAppIdentifier();
-    const name = `https://cactus-react-native/${appIdentifier}/v1`;
-    this.projectId = await CactusCrypto.uuidv5(this.namespaceUrl, name);
-
-    const deviceInfo = await CactusDeviceInfo.getDeviceInfo();
-    try {
-      this.deviceId =
-        (await CactusUtil.getDeviceId()) ??
-        (await Database.registerDevice({ deviceData: deviceInfo }));
-    } catch (error) {
-      console.log(error);
-    }
-  }
-
-  public static logInit(
-    model: string,
-    success: boolean,
-    message?: string
-  ): Promise<void> {
-    return this.handleLog({
-      framework: 'react-native',
-      framework_version: packageVersion,
-      event_type: 'init',
-      model,
-      success,
-      message,
-      telemetry_token: this.cactusTelemetryToken,
-      project_id: this.projectId,
-      device_id: this.deviceId,
-    });
-  }
-
-  public static logCompletion(
-    model: string,
-    success: boolean,
-    message?: string,
-    result?: CactusLMCompleteResult
-  ): Promise<void> {
-    return this.handleLog({
-      framework: 'react-native',
-      framework_version: packageVersion,
-      event_type: 'completion',
-      model,
-      success,
-      message,
-      telemetry_token: this.cactusTelemetryToken,
-      project_id: this.projectId,
-      device_id: this.deviceId,
-      tokens: result?.totalTokens,
-      response_time: result?.totalTimeMs,
-      ttft: result?.timeToFirstTokenMs,
-      tps: result?.tokensPerSecond,
-    });
-  }
-
-  public static logTranscribe(
-    model: string,
-    success: boolean,
-    message?: string,
-    result?: CactusSTTTranscribeResult
-  ): Promise<void> {
-    return this.handleLog({
-      framework: 'react-native',
-      framework_version: packageVersion,
-      event_type: 'transcription',
-      model,
-      success,
-      message,
-      telemetry_token: this.cactusTelemetryToken,
-      project_id: this.projectId,
-      device_id: this.deviceId,
-      tokens: result?.totalTokens,
-      response_time: result?.totalTimeMs,
-      ttft: result?.timeToFirstTokenMs,
-      tps: result?.tokensPerSecond,
-    });
-  }
-
-  public static logEmbedding(
-    model: string,
-    success: boolean,
-    message?: string
-  ): Promise<void> {
-    return this.handleLog({
-      framework: 'react-native',
-      framework_version: packageVersion,
-      event_type: 'embedding',
-      model,
-      success,
-      message,
-      telemetry_token: this.cactusTelemetryToken,
-      project_id: this.projectId,
-      device_id: this.deviceId,
-    });
-  }
-
-  public static logImageEmbedding(
-    model: string,
-    success: boolean,
-    message?: string
-  ): Promise<void> {
-    return this.handleLog({
-      framework: 'react-native',
-      framework_version: packageVersion,
-      event_type: 'image_embedding',
-      model,
-      success,
-      message,
-      telemetry_token: this.cactusTelemetryToken,
-      project_id: this.projectId,
-      device_id: this.deviceId,
-    });
-  }
-
-  public static logAudioEmbedding(
-    model: string,
-    success: boolean,
-    message?: string
-  ): Promise<void> {
-    return this.handleLog({
-      framework: 'react-native',
-      framework_version: packageVersion,
-      event_type: 'audio_embedding',
-      model,
-      success,
-      message,
-      telemetry_token: this.cactusTelemetryToken,
-      project_id: this.projectId,
-      device_id: this.deviceId,
-    });
-  }
-}

package/src/types/CactusModel.ts

@@ -1,15 +0,0 @@
-export interface CactusModel {
-  // API
-  name: string;
-  slug: string;
-  quantization: number;
-  sizeMb: number;
-  downloadUrl: string;
-  supportsToolCalling: boolean;
-  supportsVision: boolean;
-  supportsCompletion: boolean;
-  createdAt: Date;
-
-  // Local
-  isDownloaded: boolean;
-}

package/src/types/CactusSTTModel.ts

@@ -1,10 +0,0 @@
-export interface CactusSTTModel {
-  // API
-  slug: string;
-  sizeMb: number;
-  downloadUrl: string;
-  createdAt: Date;
-
-  // Local
-  isDownloaded: boolean;
-}