cactus-react-native 1.2.1 → 1.5.0

package/src/hooks/useCactusLM.ts

@@ -4,23 +4,31 @@ 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';
+import type { CactusModel } from '../types/common';
 
 export const useCactusLM = ({
-  model = 'qwen3-0.6',
+  model = 'qwen3-0.6b',
   contextSize = 2048,
   corpusDir = undefined,
+  options: modelOptions = {
+    quantization: undefined,
+    pro: false,
+  },
 }: CactusLMParams = {}) => {
   const [cactusLM, setCactusLM] = useState(
-    () => new CactusLM({ model, contextSize, corpusDir })
+    () => new CactusLM({ model, contextSize, corpusDir, options: modelOptions })
   );
 
   // State
@@ -40,7 +48,17 @@ export const useCactusLM = ({
   }, [model]);
 
   useEffect(() => {
-    setCactusLM(new CactusLM({ model, contextSize, corpusDir }));
+    setCactusLM(
+      new CactusLM({
+        model,
+        contextSize,
+        corpusDir,
+        options: {
+          quantization: modelOptions.quantization,
+          pro: modelOptions.pro,
+        },
+      })
+    );
 
     setCompletion('');
     setIsGenerating(false);
@@ -69,7 +87,13 @@ export const useCactusLM = ({
     return () => {
       mounted = false;
     };
-  }, [model, contextSize, corpusDir]);
+  }, [
+    model,
+    contextSize,
+    corpusDir,
+    modelOptions.quantization,
+    modelOptions.pro,
+  ]);
 
   useEffect(() => {
     return () => {
@@ -201,8 +225,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 +290,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 +381,8 @@ export const useCactusLM = ({
     download,
     init,
     complete,
+    tokenize,
+    scoreWindow,
     embed,
     imageEmbed,
     reset,

package/src/hooks/useCactusSTT.ts

@@ -9,20 +9,32 @@ import type {
   CactusSTTDownloadParams,
   CactusSTTAudioEmbedParams,
   CactusSTTAudioEmbedResult,
+  CactusSTTStreamTranscribeInsertParams,
+  CactusSTTStreamTranscribeProcessParams,
+  CactusSTTStreamTranscribeProcessResult,
+  CactusSTTStreamTranscribeFinalizeResult,
 } from '../types/CactusSTT';
-import type { CactusSTTModel } from '../types/CactusSTTModel';
+import type { CactusModel } from '../types/common';
 
 export const useCactusSTT = ({
   model = 'whisper-small',
   contextSize = 2048,
+  options: modelOptions = {
+    quantization: undefined,
+    pro: false,
+  },
 }: CactusSTTParams = {}) => {
   const [cactusSTT, setCactusSTT] = useState(
-    () => new CactusSTT({ model, contextSize })
+    () => new CactusSTT({ model, contextSize, options: modelOptions })
   );
 
   // State
   const [transcription, setTranscription] = useState('');
+  const [streamTranscribeConfirmed, setStreamTranscribeConfirmed] =
+    useState('');
+  const [streamTranscribePending, setStreamTranscribePending] = useState('');
   const [isGenerating, setIsGenerating] = useState(false);
+  const [isStreamTranscribing, setIsStreamTranscribing] = useState(false);
   const [isInitializing, setIsInitializing] = useState(false);
   const [isDownloaded, setIsDownloaded] = useState(false);
   const [isDownloading, setIsDownloading] = useState(false);
@@ -37,10 +49,22 @@ export const useCactusSTT = ({
   }, [model]);
 
   useEffect(() => {
-    setCactusSTT(new CactusSTT({ model, contextSize }));
+    setCactusSTT(
+      new CactusSTT({
+        model,
+        contextSize,
+        options: {
+          quantization: modelOptions.quantization,
+          pro: modelOptions.pro,
+        },
+      })
+    );
 
     setTranscription('');
+    setStreamTranscribeConfirmed('');
+    setStreamTranscribePending('');
     setIsGenerating(false);
+    setIsStreamTranscribing(false);
     setIsInitializing(false);
     setIsDownloaded(false);
     setIsDownloading(false);
@@ -66,7 +90,7 @@ export const useCactusSTT = ({
     return () => {
       mounted = false;
     };
-  }, [model, contextSize]);
+  }, [model, contextSize, modelOptions.quantization, modelOptions.pro]);
 
   useEffect(() => {
     return () => {
@@ -162,7 +186,7 @@ export const useCactusSTT = ({
 
   const transcribe = useCallback(
     async ({
-      audioFilePath,
+      audio,
       prompt,
       options,
       onToken,
@@ -178,7 +202,7 @@ export const useCactusSTT = ({
       setIsGenerating(true);
       try {
         return await cactusSTT.transcribe({
-          audioFilePath,
+          audio,
           prompt,
           options,
           onToken: (token) => {
@@ -220,6 +244,83 @@ export const useCactusSTT = ({
     [cactusSTT, isGenerating]
   );
 
+  const streamTranscribeInit = useCallback(async () => {
+    if (isStreamTranscribing) {
+      return;
+    }
+
+    setError(null);
+    setStreamTranscribeConfirmed('');
+    setStreamTranscribePending('');
+    setIsStreamTranscribing(true);
+    try {
+      await cactusSTT.streamTranscribeInit();
+    } catch (e) {
+      setError(getErrorMessage(e));
+      setIsStreamTranscribing(false);
+      throw e;
+    }
+  }, [cactusSTT, isStreamTranscribing]);
+
+  const streamTranscribeInsert = useCallback(
+    async ({ audio }: CactusSTTStreamTranscribeInsertParams): Promise<void> => {
+      setError(null);
+      try {
+        await cactusSTT.streamTranscribeInsert({ audio });
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      }
+    },
+    [cactusSTT]
+  );
+
+  const streamTranscribeProcess = useCallback(
+    async ({
+      options,
+    }: CactusSTTStreamTranscribeProcessParams = {}): Promise<CactusSTTStreamTranscribeProcessResult> => {
+      setError(null);
+      try {
+        const result = await cactusSTT.streamTranscribeProcess({ options });
+        setStreamTranscribeConfirmed((prev) => prev + result.confirmed);
+        setStreamTranscribePending(result.pending);
+        return result;
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      }
+    },
+    [cactusSTT]
+  );
+
+  const streamTranscribeFinalize =
+    useCallback(async (): Promise<CactusSTTStreamTranscribeFinalizeResult> => {
+      setError(null);
+      try {
+        const result = await cactusSTT.streamTranscribeFinalize();
+        setStreamTranscribeConfirmed((prev) => prev + result.confirmed);
+        setStreamTranscribePending('');
+        setIsStreamTranscribing(false);
+        return result;
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      }
+    }, [cactusSTT]);
+
+  const streamTranscribeDestroy = useCallback(async (): Promise<void> => {
+    setError(null);
+    try {
+      await cactusSTT.streamTranscribeDestroy();
+    } catch (e) {
+      setError(getErrorMessage(e));
+      throw e;
+    } finally {
+      setIsStreamTranscribing(false);
+      setStreamTranscribePending('');
+    }
+  }, [cactusSTT]);
+
   const stop = useCallback(async () => {
     setError(null);
     try {
@@ -251,10 +352,13 @@ export const useCactusSTT = ({
       throw e;
     } finally {
       setTranscription('');
+      setStreamTranscribeConfirmed('');
+      setStreamTranscribePending('');
+      setIsStreamTranscribing(false);
     }
   }, [cactusSTT]);
 
-  const getModels = useCallback(async (): Promise<CactusSTTModel[]> => {
+  const getModels = useCallback(async (): Promise<CactusModel[]> => {
     setError(null);
     try {
       return await cactusSTT.getModels();
@@ -266,7 +370,10 @@ export const useCactusSTT = ({
 
   return {
     transcription,
+    streamTranscribeConfirmed,
+    streamTranscribePending,
     isGenerating,
+    isStreamTranscribing,
     isInitializing,
     isDownloaded,
     isDownloading,
@@ -277,6 +384,11 @@ export const useCactusSTT = ({
     init,
     transcribe,
     audioEmbed,
+    streamTranscribeInit,
+    streamTranscribeInsert,
+    streamTranscribeProcess,
+    streamTranscribeFinalize,
+    streamTranscribeDestroy,
     reset,
     stop,
     destroy,

package/src/index.tsx

@@ -1,14 +1,15 @@
 // 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';
-export type { CactusSTTModel } from './types/CactusSTTModel';
+export type { CactusModel, ModelOptions } from './types/common';
 export type {
   CactusLMParams,
   CactusLMDownloadParams,
@@ -17,6 +18,10 @@ export type {
   Tool,
   CactusLMCompleteParams,
   CactusLMCompleteResult,
+  CactusLMTokenizeParams,
+  CactusLMTokenizeResult,
+  CactusLMScoreWindowParams,
+  CactusLMScoreWindowResult,
   CactusLMEmbedParams,
   CactusLMEmbedResult,
   CactusLMImageEmbedParams,
@@ -30,7 +35,22 @@ export type {
   CactusSTTTranscribeResult,
   CactusSTTAudioEmbedParams,
   CactusSTTAudioEmbedResult,
+  CactusSTTStreamTranscribeInsertParams,
+  StreamTranscribeProcessOptions,
+  CactusSTTStreamTranscribeProcessParams,
+  CactusSTTStreamTranscribeProcessResult,
+  CactusSTTStreamTranscribeFinalizeResult,
 } from './types/CactusSTT';
+export type {
+  CactusIndexParams,
+  CactusIndexAddParams,
+  CactusIndexGetParams,
+  CactusIndexGetResult,
+  IndexQueryOptions,
+  CactusIndexQueryParams,
+  CactusIndexQueryResult,
+  CactusIndexDeleteParams,
+} from './types/CactusIndex';
 
 // Config
 export { CactusConfig } from './config/CactusConfig';