cactus-react-native 1.2.1 → 1.4.0

package/src/hooks/useCactusLM.ts

@@ -4,12 +4,16 @@ import { CactusFileSystem } from '../native';
 import { getErrorMessage } from '../utils/error';
 import type {
   CactusLMParams,
+  CactusLMCompleteParams,
   CactusLMCompleteResult,
+  CactusLMTokenizeParams,
+  CactusLMTokenizeResult,
+  CactusLMScoreWindowParams,
+  CactusLMScoreWindowResult,
   CactusLMEmbedParams,
   CactusLMEmbedResult,
   CactusLMImageEmbedParams,
   CactusLMImageEmbedResult,
-  CactusLMCompleteParams,
   CactusLMDownloadParams,
 } from '../types/CactusLM';
 import type { CactusModel } from '../types/CactusModel';
@@ -201,8 +205,62 @@ export const useCactusLM = ({
     [cactusLM, isGenerating]
   );
 
+  const tokenize = useCallback(
+    async ({
+      text,
+    }: CactusLMTokenizeParams): Promise<CactusLMTokenizeResult> => {
+      if (isGenerating) {
+        const message = 'CactusLM is already generating';
+        setError(message);
+        throw new Error(message);
+      }
+
+      setError(null);
+      setIsGenerating(true);
+      try {
+        return await cactusLM.tokenize({ text });
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      } finally {
+        setIsGenerating(false);
+      }
+    },
+    [cactusLM, isGenerating]
+  );
+
+  const scoreWindow = useCallback(
+    async ({
+      tokens,
+      start,
+      end,
+      context,
+    }: CactusLMScoreWindowParams): Promise<CactusLMScoreWindowResult> => {
+      if (isGenerating) {
+        const message = 'CactusLM is already generating';
+        setError(message);
+        throw new Error(message);
+      }
+
+      setError(null);
+      setIsGenerating(true);
+      try {
+        return await cactusLM.scoreWindow({ tokens, start, end, context });
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      } finally {
+        setIsGenerating(false);
+      }
+    },
+    [cactusLM, isGenerating]
+  );
+
   const embed = useCallback(
-    async ({ text }: CactusLMEmbedParams): Promise<CactusLMEmbedResult> => {
+    async ({
+      text,
+      normalize = false,
+    }: CactusLMEmbedParams): Promise<CactusLMEmbedResult> => {
       if (isGenerating) {
         const message = 'CactusLM is already generating';
         setError(message);
@@ -212,7 +270,7 @@ export const useCactusLM = ({
       setError(null);
       setIsGenerating(true);
       try {
-        return await cactusLM.embed({ text });
+        return await cactusLM.embed({ text, normalize });
       } catch (e) {
         setError(getErrorMessage(e));
         throw e;
@@ -303,6 +361,8 @@ export const useCactusLM = ({
     download,
     init,
     complete,
+    tokenize,
+    scoreWindow,
     embed,
     imageEmbed,
     reset,

package/src/hooks/useCactusSTT.ts

@@ -162,7 +162,7 @@ export const useCactusSTT = ({
 
   const transcribe = useCallback(
     async ({
-      audioFilePath,
+      audio,
       prompt,
       options,
       onToken,
@@ -178,7 +178,7 @@ export const useCactusSTT = ({
       setIsGenerating(true);
       try {
         return await cactusSTT.transcribe({
-          audioFilePath,
+          audio,
           prompt,
           options,
           onToken: (token) => {

package/src/index.tsx

@@ -1,10 +1,12 @@
 // Classes
 export { CactusLM } from './classes/CactusLM';
 export { CactusSTT } from './classes/CactusSTT';
+export { CactusIndex } from './classes/CactusIndex';
 
 // Hooks
 export { useCactusLM } from './hooks/useCactusLM';
 export { useCactusSTT } from './hooks/useCactusSTT';
+export { useCactusIndex } from './hooks/useCactusIndex';
 
 // Types
 export type { CactusModel } from './types/CactusModel';
@@ -17,6 +19,10 @@ export type {
   Tool,
   CactusLMCompleteParams,
   CactusLMCompleteResult,
+  CactusLMTokenizeParams,
+  CactusLMTokenizeResult,
+  CactusLMScoreWindowParams,
+  CactusLMScoreWindowResult,
   CactusLMEmbedParams,
   CactusLMEmbedResult,
   CactusLMImageEmbedParams,
@@ -31,6 +37,16 @@ export type {
   CactusSTTAudioEmbedParams,
   CactusSTTAudioEmbedResult,
 } from './types/CactusSTT';
+export type {
+  CactusIndexParams,
+  CactusIndexAddParams,
+  CactusIndexGetParams,
+  CactusIndexGetResult,
+  IndexQueryOptions,
+  CactusIndexQueryParams,
+  CactusIndexQueryResult,
+  CactusIndexDeleteParams,
+} from './types/CactusIndex';
 
 // Config
 export { CactusConfig } from './config/CactusConfig';

package/src/native/Cactus.ts

@@ -32,15 +32,9 @@ export class Cactus {
     callback?: (token: string, tokenId: number) => void
   ): Promise<CactusLMCompleteResult> {
     const messagesInternal: Message[] = [];
-    for (let i = 0; i < messages.length; i++) {
-      const message = messages[i]!;
-      const isLastMessage = i === messages.length - 1;
-
-      if (!message.images || !isLastMessage) {
-        messagesInternal.push({
-          ...message,
-          images: undefined,
-        });
+    for (const message of messages) {
+      if (!message.images) {
+        messagesInternal.push(message);
         continue;
       }
 
@@ -66,6 +60,7 @@ export class Cactus {
           top_k: options.topK,
           max_tokens: options.maxTokens,
           stop_sequences: options.stopSequences,
+          force_tools: options.forceTools,
         })
       : undefined;
     const toolsJson = JSON.stringify(tools);
@@ -97,13 +92,41 @@ export class Cactus {
     }
   }
 
+  public tokenize(text: string): Promise<number[]> {
+    return this.hybridCactus.tokenize(text);
+  }
+
+  public async scoreWindow(
+    tokens: number[],
+    start: number,
+    end: number,
+    context: number
+  ): Promise<number> {
+    const response = await this.hybridCactus.scoreWindow(
+      tokens,
+      start,
+      end,
+      context
+    );
+    try {
+      const parsed = JSON.parse(response);
+      return parsed.logprob;
+    } catch {
+      throw new Error('Unable to parse score window response');
+    }
+  }
+
   public async transcribe(
-    audioFilePath: string,
+    audio: string | number[],
     prompt: string,
     responseBufferSize: number,
     options?: TranscribeOptions,
     callback?: (token: string, tokenId: number) => void
   ): Promise<CactusSTTTranscribeResult> {
+    if (typeof audio === 'string') {
+      audio = audio.replace('file://', '');
+    }
+
     const optionsJson = options
       ? JSON.stringify({
           temperature: options.temperature,
@@ -115,7 +138,7 @@ export class Cactus {
       : undefined;
 
     const response = await this.hybridCactus.transcribe(
-      audioFilePath.replace('file://', ''),
+      audio,
       prompt,
       responseBufferSize,
       optionsJson,
@@ -140,8 +163,12 @@ export class Cactus {
     }
   }
 
-  public embed(text: string, embeddingBufferSize: number): Promise<number[]> {
-    return this.hybridCactus.embed(text, embeddingBufferSize);
+  public embed(
+    text: string,
+    embeddingBufferSize: number,
+    normalize: boolean
+  ): Promise<number[]> {
+    return this.hybridCactus.embed(text, embeddingBufferSize, normalize);
   }
 
   public async imageEmbed(

package/src/native/CactusFileSystem.ts

@@ -33,6 +33,10 @@ export class CactusFileSystem {
     return this.hybridCactusFileSystem.getModelPath(model);
   }
 
+  public static getIndexPath(name: string): Promise<string> {
+    return this.hybridCactusFileSystem.getIndexPath(name);
+  }
+
   public static downloadModel(
     model: string,
     url: string,

package/src/native/CactusIndex.ts

@@ -0,0 +1,54 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import type { CactusIndex as CactusIndexSpec } from '../specs/CactusIndex.nitro';
+import type {
+  CactusIndexGetResult,
+  CactusIndexQueryResult,
+  IndexQueryOptions,
+} from '../types/CactusIndex';
+
+export class CactusIndex {
+  private readonly hybridCactusIndex =
+    NitroModules.createHybridObject<CactusIndexSpec>('CactusIndex');
+
+  public init(indexPath: string, embeddingDim: number): Promise<void> {
+    return this.hybridCactusIndex.init(indexPath, embeddingDim);
+  }
+
+  public add(
+    ids: number[],
+    documents: string[],
+    embeddings: number[][],
+    metadatas?: string[]
+  ): Promise<void> {
+    return this.hybridCactusIndex.add(ids, documents, embeddings, metadatas);
+  }
+
+  public delete(ids: number[]): Promise<void> {
+    return this.hybridCactusIndex._delete(ids);
+  }
+
+  public get(ids: number[]): Promise<CactusIndexGetResult> {
+    return this.hybridCactusIndex.get(ids);
+  }
+
+  public query(
+    embeddings: number[][],
+    options?: IndexQueryOptions
+  ): Promise<CactusIndexQueryResult> {
+    const optionsJson = options
+      ? JSON.stringify({
+          top_k: options.topK,
+          score_threshold: options.scoreThreshold,
+        })
+      : undefined;
+    return this.hybridCactusIndex.query(embeddings, optionsJson);
+  }
+
+  public compact(): Promise<void> {
+    return this.hybridCactusIndex.compact();
+  }
+
+  public destroy(): Promise<void> {
+    return this.hybridCactusIndex.destroy();
+  }
+}

package/src/native/CactusUtil.ts

@@ -2,6 +2,8 @@ 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 =
@@ -10,7 +12,7 @@ export class CactusUtil {
   public static async registerApp(encryptedData: string): Promise<string> {
     if (Platform.OS === 'android') {
       const cactusDirectory = await CactusFileSystem.getCactusDirectory();
-      this.hybridCactusUtil.setAndroidDataDirectory(cactusDirectory);
+      await this.hybridCactusUtil.setAndroidDataDirectory(cactusDirectory);
     }
 
     return this.hybridCactusUtil.registerApp(encryptedData);
@@ -19,9 +21,23 @@ export class CactusUtil {
   public static async getDeviceId(): Promise<string | null> {
     if (Platform.OS === 'android') {
       const cactusDirectory = await CactusFileSystem.getCactusDirectory();
-      this.hybridCactusUtil.setAndroidDataDirectory(cactusDirectory);
+      await this.hybridCactusUtil.setAndroidDataDirectory(cactusDirectory);
     }
 
-    return this.hybridCactusUtil.getDeviceId();
+    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/native/index.ts

@@ -1,4 +1,5 @@
 export { Cactus } from './Cactus';
+export { CactusIndex } from './CactusIndex';
 export { CactusCrypto } from './CactusCrypto';
 export { CactusDeviceInfo } from './CactusDeviceInfo';
 export { CactusFileSystem } from './CactusFileSystem';

package/src/specs/Cactus.nitro.ts

@@ -13,14 +13,25 @@ export interface Cactus extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
     toolsJson?: string,
     callback?: (token: string, tokenId: number) => void
   ): Promise<string>;
+  tokenize(text: string): Promise<number[]>;
+  scoreWindow(
+    tokens: number[],
+    start: number,
+    end: number,
+    context: number
+  ): Promise<string>;
   transcribe(
-    audioFilePath: string,
+    audio: string | number[],
     prompt: string,
     responseBufferSize: number,
     optionsJson?: string,
     callback?: (token: string, tokenId: number) => void
   ): Promise<string>;
-  embed(text: string, embeddingBufferSize: number): Promise<number[]>;
+  embed(
+    text: string,
+    embeddingBufferSize: number,
+    normalize: boolean
+  ): Promise<number[]>;
   imageEmbed(imagePath: string, embeddingBufferSize: number): Promise<number[]>;
   audioEmbed(audioPath: string, embeddingBufferSize: number): Promise<number[]>;
   reset(): Promise<void>;

package/src/specs/CactusFileSystem.nitro.ts

@@ -18,4 +18,6 @@ export interface CactusFileSystem
     callback?: (progress: number) => void
   ): Promise<void>;
   deleteModel(model: string): Promise<void>;
+  // Index
+  getIndexPath(name: string): Promise<string>;
 }

package/src/specs/CactusIndex.nitro.ts

@@ -0,0 +1,31 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+interface CactusIndexGetResult {
+  documents: string[];
+  metadatas: string[];
+  embeddings: number[][];
+}
+
+interface CactusIndexQueryResult {
+  ids: number[][];
+  scores: number[][];
+}
+
+export interface CactusIndex
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  init(indexPath: string, embeddingDim: number): Promise<void>;
+  add(
+    ids: number[],
+    documents: string[],
+    embeddings: number[][],
+    metadatas?: string[]
+  ): Promise<void>;
+  _delete(ids: number[]): Promise<void>;
+  get(ids: number[]): Promise<CactusIndexGetResult>;
+  query(
+    embeddings: number[][],
+    optionsJson?: string
+  ): Promise<CactusIndexQueryResult>;
+  compact(): Promise<void>;
+  destroy(): Promise<void>;
+}

package/src/specs/CactusUtil.nitro.ts

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

package/src/telemetry/Telemetry.ts

@@ -110,7 +110,7 @@ export class Telemetry {
     try {
       this.deviceId =
         (await CactusUtil.getDeviceId()) ??
-        (await Database.registerDevice(deviceInfo));
+        (await Database.registerDevice({ deviceData: deviceInfo }));
     } catch (error) {
       console.log(error);
     }

package/src/types/CactusIndex.ts

@@ -0,0 +1,40 @@
+export interface CactusIndexParams {
+  name: string;
+  embeddingDim: number;
+}
+
+export interface CactusIndexAddParams {
+  ids: number[];
+  documents: string[];
+  embeddings: number[][];
+  metadatas?: string[];
+}
+
+export interface CactusIndexGetParams {
+  ids: number[];
+}
+
+export interface CactusIndexGetResult {
+  documents: string[];
+  metadatas: string[];
+  embeddings: number[][];
+}
+
+export interface IndexQueryOptions {
+  topK?: number;
+  scoreThreshold?: number;
+}
+
+export interface CactusIndexQueryParams {
+  embeddings: number[][];
+  options?: IndexQueryOptions;
+}
+
+export interface CactusIndexQueryResult {
+  ids: number[][];
+  scores: number[][];
+}
+
+export interface CactusIndexDeleteParams {
+  ids: number[];
+}

package/src/types/CactusLM.ts

@@ -20,6 +20,7 @@ export interface CompleteOptions {
   topK?: number;
   maxTokens?: number;
   stopSequences?: string[];
+  forceTools?: boolean;
 }
 
 export interface Tool {
@@ -60,8 +61,28 @@ export interface CactusLMCompleteResult {
   totalTokens: number;
 }
 
+export interface CactusLMTokenizeParams {
+  text: string;
+}
+
+export interface CactusLMTokenizeResult {
+  tokens: number[];
+}
+
+export interface CactusLMScoreWindowParams {
+  tokens: number[];
+  start: number;
+  end: number;
+  context: number;
+}
+
+export interface CactusLMScoreWindowResult {
+  score: number;
+}
+
 export interface CactusLMEmbedParams {
   text: string;
+  normalize?: boolean;
 }
 
 export interface CactusLMEmbedResult {

package/src/types/CactusSTT.ts

@@ -16,7 +16,7 @@ export interface TranscribeOptions {
 }
 
 export interface CactusSTTTranscribeParams {
-  audioFilePath: string;
+  audio: string | number[];
   prompt?: string;
   options?: TranscribeOptions;
   onToken?: (token: string) => void;