npm install @cactus-compute/react-native
# or
yarn add @cactus-compute/react-native

import Cactus from '@cactus-compute/react-native';

const runInference = async () => {
  try {
    const model = await Cactus.init('/path/to/model', null, false);
    
    const messages = [
      { role: 'user', content: 'What is the capital of France?' }
    ];
    
    const result = await Cactus.complete(model, messages);
    console.log(result.response);
    
    await Cactus.destroy(model);
  } catch (error) {
    console.error('Error:', error);
  }
};

import Cactus from '@cactus-compute/react-native';

const streamCompletion = async () => {
  const model = await Cactus.init('/path/to/model');
  
  const messages = [
    { role: 'user', content: 'Tell me a story' }
  ];
  
  const options = {
    max_tokens: 256,
    temperature: 0.7,
  };
  
  const result = await Cactus.complete(
    model,
    messages,
    options,
    null,
    (token, tokenId) => {
      console.log('Token:', token);
    }
  );
  
  console.log('Final result:', result);
  
  await Cactus.destroy(model);
};

import Cactus from '@cactus-compute/react-native';

const transcribeAudio = async () => {
  const model = await Cactus.init('/path/to/whisper-model');
  
  // From file
  const result = await Cactus.transcribe(model, '/path/to/audio.wav');
  console.log('Transcription:', result.text);
  
  await Cactus.destroy(model);
};

import Cactus from '@cactus-compute/react-native';

const getEmbeddings = async () => {
  const model = await Cactus.init('/path/to/model');
  
  // Text embedding
  const embedding = await Cactus.embed(model, 'Hello, world!', true);
  console.log('Embedding dimension:', embedding.length);
  
  // Image embedding
  const imageEmbedding = await Cactus.imageEmbed(model, '/path/to/image.jpg');
  
  await Cactus.destroy(model);
};

import Cactus from '@cactus-compute/react-native';

const useVectorIndex = async () => {
  const index = await Cactus.indexInit('/path/to/index', 384);
  
  // Add documents
  await Cactus.indexAdd(
    index,
    [1, 2],
    ['First document', 'Second document'],
    [[0.1, 0.2, ...], [0.3, 0.4, ...]],
    null
  );
  
  // Query
  const results = await Cactus.indexQuery(
    index,
    [0.15, 0.25, ...],
    null
  );
  
  console.log('Search results:', results);
  
  await Cactus.indexDestroy(index);
};

Cactus.init(modelPath: string, corpusDir?: string | null, cacheIndex?: boolean): Promise<number>
Cactus.destroy(model: number): Promise<void>
Cactus.reset(model: number): Promise<void>
Cactus.stop(model: number): Promise<void>
Cactus.getLastError(): Promise<string | null>

interface Message {
  role: 'system' | 'user' | 'assistant';
  content: string;
  images?: string[];
}

interface CompletionOptions {
  max_tokens?: number;
  temperature?: number;
  top_p?: number;
  stop_sequences?: string[];
}

interface CompletionResult {
  success: boolean;
  response: string;
  function_calls: any[];
  cloud_handoff: boolean;
  confidence: number;
  time_to_first_token_ms: number;
  total_time_ms: number;
  prefill_tps: number;
  decode_tps: number;
  prefill_tokens: number;
  decode_tokens: number;
  total_tokens: number;
}

Cactus.complete(
  model: number,
  messages: Message[],
  options?: CompletionOptions | null,
  tools?: any[] | null,
  callback?: (token: string, tokenId: number) => void
): Promise<CompletionResult>

interface TranscriptionResult {
  text: string;
  segments?: any[];
}

Cactus.transcribe(
  model: number,
  audioPath?: string | null,
  prompt?: string | null,
  options?: any | null,
  callback?: (token: string, tokenId: number) => void,
  pcmData?: Uint8Array | null
): Promise<TranscriptionResult>

Cactus.streamTranscribeStart(model: number, options?: any | null): Promise<number>
Cactus.streamTranscribeProcess(stream: number, pcmData: Uint8Array): Promise<string>
Cactus.streamTranscribeStop(stream: number): Promise<string>

Cactus.embed(model: number, text: string, normalize: boolean): Promise<Float32Array>
Cactus.imageEmbed(model: number, imagePath: string): Promise<Float32Array>
Cactus.audioEmbed(model: number, audioPath: string): Promise<Float32Array>

Cactus.tokenize(model: number, text: string): Promise<number[]>
Cactus.scoreWindow(model: number, tokens: number[], start: number, end: number, context: number): Promise<any>

Cactus.vad(model: number, audioPath?: string | null, options?: any | null, pcmData?: Uint8Array | null): Promise<any>
Cactus.ragQuery(model: number, query: string, topK: number): Promise<any>

Cactus.indexInit(indexDir: string, embeddingDim: number): Promise<number>
Cactus.indexDestroy(index: number): Promise<void>
Cactus.indexAdd(
  index: number,
  ids: number[],
  documents: string[],
  embeddings: number[][],
  metadatas?: string[] | null
): Promise<void>
Cactus.indexDelete(index: number, ids: number[]): Promise<void>
Cactus.indexGet(index: number, ids: number[]): Promise<any>
Cactus.indexQuery(index: number, embedding: number[], options?: any | null): Promise<any>
Cactus.indexCompact(index: number): Promise<void>

Cactus.setTelemetryEnvironment(cacheDir: string): Promise<void>
Cactus.setAppId(appId: string): Promise<void>
Cactus.telemetryFlush(): Promise<void>
Cactus.telemetryShutdown(): Promise<void>

import RNFS from 'react-native-fs';

const modelPath = `${RNFS.MainBundlePath}/model`;
const model = await Cactus.init(modelPath);

import RNFS from 'react-native-fs';

const copyModel = async () => {
  const modelPath = `${RNFS.DocumentDirectoryPath}/model`;
  
  if (!(await RNFS.exists(modelPath))) {
    await RNFS.copyFileAssets('model', modelPath);
  }
  
  return modelPath;
};

const modelPath = await copyModel();
const model = await Cactus.init(modelPath);