react-native-executorch 0.5.1-rc.0 → 0.5.2

package/lib/utils/ResourceFetcher.js

@@ -0,0 +1,305 @@
+/**
+ * Resource Fetcher
+ *
+ * Provides an interface for downloading files (via `ResourceFetcher.fetch()`)
+ *
+ * Key functionality:
+ * - Download control: pause, resume, and cancel operations through:
+ *   - Single file: `.pauseFetching()`, `.resumeFetching()`, `.cancelFetching()`
+ * - Downloaded file management:
+ *   -  `.getFilesTotalSize()`, `.listDownloadedFiles()`, `.listDownloadedModels()`, `.deleteResources()`
+ *
+ * Remark: The pausing/resuming/canceling works only for fetching remote resources.
+ *
+ * Most exported functions accept:
+ * - Multiple `ResourceSource` arguments, (union type of string, number or object)
+ *
+ * Method `.fetch()` takes argument as callback that reports download progress.
+ * Method`.fetch()` returns array of paths to successfully saved files or null if the download was paused or cancelled  (then resume functions can return paths).
+ *
+ * Technical Implementation:
+ * - Maintains a `downloads` Map instance that tracks:
+ *   - Currently downloading resources
+ *   - Paused downloads
+ * - Successful downloads are automatically removed from the `downloads` Map
+ * - Uses the `ResourceSourceExtended` interface to enable pause/resume functionality:
+ *   - Wraps user-provided `ResourceSource` elements
+ *   - Implements linked list behavior via the `.next` attribute
+ *   - Automatically processes subsequent downloads when `.next` contains a valid resource
+ */
+import { cacheDirectory, createDownloadResumable, moveAsync, FileSystemSessionType, writeAsStringAsync, EncodingType, deleteAsync, readDirectoryAsync, } from 'expo-file-system';
+import { Asset } from 'expo-asset';
+import { RNEDirectory } from '../constants/directories';
+import { ResourceFetcherUtils, } from './ResourceFetcherUtils';
+export class ResourceFetcher {
+    static downloads = new Map(); //map of currently downloading (or paused) files, if the download was started by .fetch() method.
+    static async fetch(callback = () => { }, ...sources) {
+        if (sources.length === 0) {
+            throw new Error('Empty list given as an argument!');
+        }
+        const { results: info, totalLength } = await ResourceFetcherUtils.getFilesSizes(sources);
+        const head = {
+            source: info[0].source,
+            sourceType: info[0].type,
+            callback: info[0].type === 4 /* SourceType.REMOTE_FILE */
+                ? ResourceFetcherUtils.calculateDownloadProgress(totalLength, info[0].previousFilesTotalLength, info[0].length, callback)
+                : () => { },
+            results: [],
+        };
+        let node = head;
+        for (let idx = 1; idx < sources.length; idx++) {
+            node.next = {
+                source: info[idx].source,
+                sourceType: info[idx].type,
+                callback: info[idx].type === 4 /* SourceType.REMOTE_FILE */
+                    ? ResourceFetcherUtils.calculateDownloadProgress(totalLength, info[idx].previousFilesTotalLength, info[idx].length, callback)
+                    : () => { },
+                results: [],
+            };
+            node = node.next;
+        }
+        return this.singleFetch(head);
+    }
+    static async singleFetch(sourceExtended) {
+        const source = sourceExtended.source;
+        switch (sourceExtended.sourceType) {
+            case 0 /* SourceType.OBJECT */: {
+                return this.returnOrStartNext(sourceExtended, await this.handleObject(source));
+            }
+            case 1 /* SourceType.LOCAL_FILE */: {
+                return this.returnOrStartNext(sourceExtended, this.handleLocalFile(source));
+            }
+            case 2 /* SourceType.RELEASE_MODE_FILE */: {
+                return this.returnOrStartNext(sourceExtended, await this.handleReleaseModeFile(sourceExtended));
+            }
+            case 3 /* SourceType.DEV_MODE_FILE */: {
+                const result = await this.handleDevModeFile(sourceExtended);
+                if (result !== null) {
+                    return this.returnOrStartNext(sourceExtended, result);
+                }
+                return null;
+            }
+            default: {
+                //case SourceType.REMOTE_FILE
+                const result = await this.handleRemoteFile(sourceExtended);
+                if (result !== null) {
+                    return this.returnOrStartNext(sourceExtended, result);
+                }
+                return null;
+            }
+        }
+    }
+    //if any download ends successfully this function is called - it checks whether it should trigger next download or return list of paths.
+    static returnOrStartNext(sourceExtended, result) {
+        sourceExtended.results.push(result);
+        if (sourceExtended.next) {
+            const nextSource = sourceExtended.next;
+            nextSource.results.push(...sourceExtended.results);
+            return this.singleFetch(nextSource);
+        }
+        sourceExtended.callback(1);
+        return sourceExtended.results;
+    }
+    static async pause(source) {
+        const resource = this.downloads.get(source);
+        switch (resource.status) {
+            case 1 /* DownloadStatus.PAUSED */:
+                throw new Error("The file download is currently paused. Can't pause the download of the same file twice.");
+            default: {
+                resource.status = 1 /* DownloadStatus.PAUSED */;
+                await resource.downloadResumable.pauseAsync();
+            }
+        }
+    }
+    static async resume(source) {
+        const resource = this.downloads.get(source);
+        if (!resource.extendedInfo.fileUri ||
+            !resource.extendedInfo.cacheFileUri ||
+            !resource.extendedInfo.uri) {
+            throw new Error('Something went wrong. File uri info is not specified!');
+        }
+        switch (resource.status) {
+            case 0 /* DownloadStatus.ONGOING */:
+                throw new Error("The file download is currently ongoing. Can't resume the ongoing download.");
+            default: {
+                resource.status = 0 /* DownloadStatus.ONGOING */;
+                const result = await resource.downloadResumable.resumeAsync();
+                if (!this.downloads.has(source) ||
+                    this.downloads.get(source).status === 1 /* DownloadStatus.PAUSED */) {
+                    //if canceled or paused after earlier resuming.
+                    return null;
+                }
+                if (!result ||
+                    (result.status !== 200 /* HTTP_CODE.OK */ &&
+                        result.status !== 206 /* HTTP_CODE.PARTIAL_CONTENT */)) {
+                    throw new Error(`Failed to fetch resource from '${resource.extendedInfo.uri}'`);
+                }
+                await moveAsync({
+                    from: resource.extendedInfo.cacheFileUri,
+                    to: resource.extendedInfo.fileUri,
+                });
+                this.downloads.delete(source);
+                ResourceFetcherUtils.triggerHuggingFaceDownloadCounter(resource.extendedInfo.uri);
+                return this.returnOrStartNext(resource.extendedInfo, ResourceFetcherUtils.removeFilePrefix(resource.extendedInfo.fileUri));
+            }
+        }
+    }
+    static async cancel(source) {
+        const resource = this.downloads.get(source);
+        await resource.downloadResumable.cancelAsync();
+        this.downloads.delete(source);
+    }
+    static async pauseFetching(...sources) {
+        const source = this.findActive(sources);
+        await this.pause(source);
+    }
+    static async resumeFetching(...sources) {
+        const source = this.findActive(sources);
+        await this.resume(source);
+    }
+    static async cancelFetching(...sources) {
+        const source = this.findActive(sources);
+        await this.cancel(source);
+    }
+    static findActive(sources) {
+        for (const source of sources) {
+            if (this.downloads.has(source)) {
+                return source;
+            }
+        }
+        throw new Error('None of given sources are currently during downloading process.');
+    }
+    static async listDownloadedFiles() {
+        const files = await readDirectoryAsync(RNEDirectory);
+        return files.map((file) => `${RNEDirectory}${file}`);
+    }
+    static async listDownloadedModels() {
+        const files = await this.listDownloadedFiles();
+        return files.filter((file) => file.endsWith('.pte'));
+    }
+    static async deleteResources(...sources) {
+        for (const source of sources) {
+            const filename = ResourceFetcherUtils.getFilenameFromUri(source);
+            const fileUri = `${RNEDirectory}${filename}`;
+            if (await ResourceFetcherUtils.checkFileExists(fileUri)) {
+                await deleteAsync(fileUri);
+            }
+        }
+    }
+    static async getFilesTotalSize(...sources) {
+        return (await ResourceFetcherUtils.getFilesSizes(sources)).totalLength;
+    }
+    static async handleObject(source) {
+        if (typeof source !== 'object') {
+            throw new Error('Source is expected to be object!');
+        }
+        const jsonString = JSON.stringify(source);
+        const digest = ResourceFetcherUtils.hashObject(jsonString);
+        const filename = `${digest}.json`;
+        const path = `${RNEDirectory}${filename}`;
+        if (await ResourceFetcherUtils.checkFileExists(path)) {
+            return ResourceFetcherUtils.removeFilePrefix(path);
+        }
+        await ResourceFetcherUtils.createDirectoryIfNoExists();
+        await writeAsStringAsync(path, jsonString, {
+            encoding: EncodingType.UTF8,
+        });
+        return ResourceFetcherUtils.removeFilePrefix(path);
+    }
+    static handleLocalFile(source) {
+        if (typeof source !== 'string') {
+            throw new Error('Source is expected to be string.');
+        }
+        return ResourceFetcherUtils.removeFilePrefix(source);
+    }
+    static async handleReleaseModeFile(sourceExtended) {
+        const source = sourceExtended.source;
+        if (typeof source !== 'number') {
+            throw new Error('Source is expected to be string.');
+        }
+        const asset = Asset.fromModule(source);
+        const uri = asset.uri;
+        const filename = ResourceFetcherUtils.getFilenameFromUri(uri);
+        const fileUri = `${RNEDirectory}${filename}`;
+        const fileUriWithType = `${fileUri}.${asset.type}`;
+        if (await ResourceFetcherUtils.checkFileExists(fileUri)) {
+            return ResourceFetcherUtils.removeFilePrefix(fileUri);
+        }
+        await ResourceFetcherUtils.createDirectoryIfNoExists();
+        await asset.downloadAsync();
+        if (!asset.localUri) {
+            throw new Error(`Asset local URI is not available for ${source}`);
+        }
+        await moveAsync({ from: asset.localUri, to: fileUriWithType });
+        return ResourceFetcherUtils.removeFilePrefix(fileUriWithType);
+    }
+    static async handleDevModeFile(sourceExtended) {
+        const source = sourceExtended.source;
+        if (typeof source !== 'number') {
+            throw new Error('Source is expected to be a number.');
+        }
+        sourceExtended.uri = Asset.fromModule(source).uri;
+        return await this.handleRemoteFile(sourceExtended);
+    }
+    static async handleRemoteFile(sourceExtended) {
+        const source = sourceExtended.source;
+        if (typeof source === 'object') {
+            throw new Error('Source is expected to be a string or a number.');
+        }
+        if (this.downloads.has(source)) {
+            const resource = this.downloads.get(source);
+            if (resource.status === 1 /* DownloadStatus.PAUSED */) {
+                // if the download is paused, `fetch` is treated like `resume`
+                this.resume(source);
+            }
+            // if the download is ongoing, throw error.
+            throw new Error('Already downloading this file.');
+        }
+        if (typeof source === 'number' && !sourceExtended.uri) {
+            throw new Error('Source Uri is expected to be available here.');
+        }
+        if (typeof source === 'string') {
+            sourceExtended.uri = source;
+        }
+        const uri = sourceExtended.uri;
+        const filename = ResourceFetcherUtils.getFilenameFromUri(uri);
+        sourceExtended.fileUri = `${RNEDirectory}${filename}`;
+        sourceExtended.cacheFileUri = `${cacheDirectory}${filename}`;
+        if (await ResourceFetcherUtils.checkFileExists(sourceExtended.fileUri)) {
+            return ResourceFetcherUtils.removeFilePrefix(sourceExtended.fileUri);
+        }
+        await ResourceFetcherUtils.createDirectoryIfNoExists();
+        const downloadResumable = createDownloadResumable(uri, sourceExtended.cacheFileUri, { sessionType: FileSystemSessionType.BACKGROUND }, ({ totalBytesWritten, totalBytesExpectedToWrite }) => {
+            if (totalBytesExpectedToWrite === -1) {
+                // If totalBytesExpectedToWrite is -1, it means the server does not provide content length.
+                sourceExtended.callback(0);
+                return;
+            }
+            sourceExtended.callback(totalBytesWritten / totalBytesExpectedToWrite);
+        });
+        //create value for the this.download Map
+        const downloadResource = {
+            downloadResumable: downloadResumable,
+            status: 0 /* DownloadStatus.ONGOING */,
+            extendedInfo: sourceExtended,
+        };
+        //add key-value pair to map
+        this.downloads.set(source, downloadResource);
+        const result = await downloadResumable.downloadAsync();
+        if (!this.downloads.has(source) ||
+            this.downloads.get(source).status === 1 /* DownloadStatus.PAUSED */) {
+            // if canceled or paused during the download
+            return null;
+        }
+        if (!result || result.status !== 200 /* HTTP_CODE.OK */) {
+            throw new Error(`Failed to fetch resource from '${source}'`);
+        }
+        await moveAsync({
+            from: sourceExtended.cacheFileUri,
+            to: sourceExtended.fileUri,
+        });
+        this.downloads.delete(source);
+        ResourceFetcherUtils.triggerHuggingFaceDownloadCounter(uri);
+        return ResourceFetcherUtils.removeFilePrefix(sourceExtended.fileUri);
+    }
+}

package/lib/utils/ResourceFetcherUtils.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @internal
+ */
+import { DownloadResumable } from 'expo-file-system';
+import { ResourceSource } from '../types/common';
+export declare const enum HTTP_CODE {
+    OK = 200,
+    PARTIAL_CONTENT = 206
+}
+export declare const enum DownloadStatus {
+    ONGOING = 0,
+    PAUSED = 1
+}
+export declare const enum SourceType {
+    OBJECT = 0,
+    LOCAL_FILE = 1,
+    RELEASE_MODE_FILE = 2,
+    DEV_MODE_FILE = 3,
+    REMOTE_FILE = 4
+}
+export interface ResourceSourceExtended {
+    source: ResourceSource;
+    sourceType: SourceType;
+    callback?: (downloadProgress: number) => void;
+    results: string[];
+    uri?: string;
+    fileUri?: string;
+    cacheFileUri?: string;
+    next?: ResourceSourceExtended;
+}
+export interface DownloadResource {
+    downloadResumable: DownloadResumable;
+    status: DownloadStatus;
+    extendedInfo: ResourceSourceExtended;
+}
+export declare namespace ResourceFetcherUtils {
+    function getType(source: ResourceSource): SourceType;
+    function getFilesSizes(sources: ResourceSource[]): Promise<{
+        results: {
+            source: ResourceSource;
+            type: SourceType;
+            length: number;
+            previousFilesTotalLength: number;
+        }[];
+        totalLength: number;
+    }>;
+    function removeFilePrefix(uri: string): string;
+    function hashObject(jsonString: string): string;
+    function calculateDownloadProgress(totalLength: number, previousFilesTotalLength: number, currentFileLength: number, setProgress: (downloadProgress: number) => void): (progress: number) => void;
+    function triggerHuggingFaceDownloadCounter(uri: string): Promise<void>;
+    function createDirectoryIfNoExists(): Promise<void>;
+    function checkFileExists(fileUri: string): Promise<boolean>;
+    function getFilenameFromUri(uri: string): string;
+}

package/lib/utils/ResourceFetcherUtils.js

@@ -42,6 +42,9 @@ export var ResourceFetcherUtils;
                         continue;
                     }
                     const contentLength = response.headers.get('content-length');
+                    if (!contentLength) {
+                        Logger.warn(`No content-length header for ${source}`);
+                    }
                     length = contentLength ? parseInt(contentLength, 10) : 0;
                     previousFilesTotalLength = totalLength;
                     totalLength += length;
@@ -79,6 +82,11 @@ export var ResourceFetcherUtils;
                 setProgress(1);
                 return;
             }
+            // Avoid division by zero
+            if (totalLength === 0) {
+                setProgress(0);
+                return;
+            }
             const baseProgress = previousFilesTotalLength / totalLength;
             const scaledProgress = progress * (currentFileLength / totalLength);
             const updatedProgress = baseProgress + scaledProgress;
@@ -117,3 +125,4 @@ export var ResourceFetcherUtils;
     }
     ResourceFetcherUtils.getFilenameFromUri = getFilenameFromUri;
 })(ResourceFetcherUtils || (ResourceFetcherUtils = {}));
+//dassaads

package/lib/utils/llm.d.ts

@@ -0,0 +1,6 @@
+import { ToolCall } from '../types/llm';
+import { Schema } from 'jsonschema';
+import * as zCore from 'zod/v4/core';
+export declare const parseToolCall: (message: string) => ToolCall[];
+export declare const getStructuredOutputPrompt: <T extends zCore.$ZodType>(responseSchema: T | Schema) => string;
+export declare const fixAndValidateStructuredOutput: <T extends zCore.$ZodType>(output: string, responseSchema: T | Schema) => zCore.output<T>;

package/lib/utils/llm.js

@@ -6,6 +6,7 @@ import * as zCore from 'zod/v4/core';
 import { Logger } from '../common/Logger';
 export const parseToolCall = (message) => {
     try {
+        const a = 6;
         const unparsedToolCalls = message.match('\\[(.|\\s)*\\]');
         if (!unparsedToolCalls) {
             throw Error('Regex did not match array.');

package/lib/utils/stt.d.ts

@@ -0,0 +1 @@
+export declare const longCommonInfPref: (seq1: number[], seq2: number[], hammingDistThreshold: number) => number;

package/lib/utils/stt.js

@@ -0,0 +1,21 @@
+export const longCommonInfPref = (seq1, seq2, hammingDistThreshold) => {
+    let maxInd = 0;
+    let maxLength = 0;
+    for (let i = 0; i < seq1.length; i++) {
+        let j = 0;
+        let hammingDist = 0;
+        while (j < seq2.length &&
+            i + j < seq1.length &&
+            (seq1[i + j] === seq2[j] || hammingDist < hammingDistThreshold)) {
+            if (seq1[i + j] !== seq2[j]) {
+                hammingDist++;
+            }
+            j++;
+        }
+        if (j >= maxLength) {
+            maxLength = j;
+            maxInd = i;
+        }
+    }
+    return maxInd;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-executorch",
-  "version": "0.5.1-rc.0",
+  "version": "0.5.2",
   "description": "An easy way to run AI models in React Native with ExecuTorch",
   "source": "./src/index.ts",
   "main": "./lib/module/index.js",
@@ -31,10 +31,12 @@
   ],
   "scripts": {
     "example": "yarn workspace react-native-executorch-example",
-    "typecheck": "tsc",
+    "typecheck": "tsc --noEmit",
     "lint": "eslint \"**/*.{js,ts,tsx}\"",
     "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
-    "prepare": "bob build"
+    "prepare": "bob build",
+    "prepack": "cp ../../README.md ./README.md",
+    "postpack": "rm ./README.md"
   },
   "keywords": [
     "react-native",

package/src/constants/modelUrls.ts

@@ -1,10 +1,8 @@
 import { Platform } from 'react-native';
-import { AvailableModels } from '../types/stt';
 
 const URL_PREFIX =
   'https://huggingface.co/software-mansion/react-native-executorch';
-const VERSION_TAG = 'resolve/v0.4.0';
-const NEXT_VERSION_TAG = 'resolve/v0.5.0';
+const VERSION_TAG = 'resolve/v0.5.0';
 
 // LLMs
 
@@ -308,35 +306,70 @@ export const STYLE_TRANSFER_UDNIE = {
 };
 
 // S2T
-const MOONSHINE_TINY_DECODER_MODEL = `${URL_PREFIX}-moonshine-tiny/${VERSION_TAG}/xnnpack/moonshine_tiny_xnnpack_decoder.pte`;
-const MOONSHINE_TINY_ENCODER_MODEL = `${URL_PREFIX}-moonshine-tiny/${VERSION_TAG}/xnnpack/moonshine_tiny_xnnpack_encoder.pte`;
-const MOONSHINE_TOKENIZER = `${URL_PREFIX}-moonshine-tiny/${VERSION_TAG}/moonshine_tiny_tokenizer.json`;
-const WHISPER_TOKENIZER = `${URL_PREFIX}-whisper-tiny.en/${VERSION_TAG}/whisper_tokenizer.json`;
-const WHISPER_TINY_DECODER_MODEL = `${URL_PREFIX}-whisper-tiny.en/${VERSION_TAG}/xnnpack/whisper_tiny_en_xnnpack_decoder.pte`;
-const WHISPER_TINY_ENCODER_MODEL = `${URL_PREFIX}-whisper-tiny.en/${VERSION_TAG}/xnnpack/whisper_tiny_en_xnnpack_encoder.pte`;
-const WHISPER_TINY_MULTILINGUAL_ENCODER_MODEL = `${URL_PREFIX}-whisper-tiny/${VERSION_TAG}/xnnpack/xnnpack_whisper_encoder.pte`;
-const WHISPER_TINY_MULTILINGUAL_DECODER_MODEL = `${URL_PREFIX}-whisper-tiny/${VERSION_TAG}/xnnpack/xnnpack_whisper_decoder.pte`;
-const WHISPER_TINY_MULTILINGUAL_TOKENIZER = `${URL_PREFIX}-whisper-tiny/${VERSION_TAG}/tokenizer.json`;
-
-export const MOONSHINE_TINY = {
-  modelName: AvailableModels.MOONSHINE,
-  decoderSource: MOONSHINE_TINY_DECODER_MODEL,
-  encoderSource: MOONSHINE_TINY_ENCODER_MODEL,
-  tokenizerSource: MOONSHINE_TOKENIZER,
+const WHISPER_TINY_EN_TOKENIZER = `${URL_PREFIX}-whisper-tiny.en/${VERSION_TAG}/tokenizer.json`;
+const WHISPER_TINY_EN_ENCODER = `${URL_PREFIX}-whisper-tiny.en/${VERSION_TAG}/xnnpack/whisper_tiny_en_encoder_xnnpack.pte`;
+const WHISPER_TINY_EN_DECODER = `${URL_PREFIX}-whisper-tiny.en/${VERSION_TAG}/xnnpack/whisper_tiny_en_decoder_xnnpack.pte`;
+
+const WHISPER_BASE_EN_TOKENIZER = `${URL_PREFIX}-whisper-base.en/${VERSION_TAG}/tokenizer.json`;
+const WHISPER_BASE_EN_ENCODER = `${URL_PREFIX}-whisper-base.en/${VERSION_TAG}/xnnpack/whisper_base_en_encoder_xnnpack.pte`;
+const WHISPER_BASE_EN_DECODER = `${URL_PREFIX}-whisper-base.en/${VERSION_TAG}/xnnpack/whisper_base_en_decoder_xnnpack.pte`;
+
+const WHISPER_SMALL_EN_TOKENIZER = `${URL_PREFIX}-whisper-small.en/${VERSION_TAG}/tokenizer.json`;
+const WHISPER_SMALL_EN_ENCODER = `${URL_PREFIX}-whisper-small.en/${VERSION_TAG}/xnnpack/whisper_small_en_encoder_xnnpack.pte`;
+const WHISPER_SMALL_EN_DECODER = `${URL_PREFIX}-whisper-small.en/${VERSION_TAG}/xnnpack/whisper_small_en_decoder_xnnpack.pte`;
+
+const WHISPER_TINY_TOKENIZER = `${URL_PREFIX}-whisper-tiny/${VERSION_TAG}/tokenizer.json`;
+const WHISPER_TINY_ENCODER_MODEL = `${URL_PREFIX}-whisper-tiny/${VERSION_TAG}/xnnpack/whisper_tiny_encoder_xnnpack.pte`;
+const WHISPER_TINY_DECODER_MODEL = `${URL_PREFIX}-whisper-tiny/${VERSION_TAG}/xnnpack/whisper_tiny_decoder_xnnpack.pte`;
+
+const WHISPER_BASE_TOKENIZER = `${URL_PREFIX}-whisper-base/${VERSION_TAG}/tokenizer.json`;
+const WHISPER_BASE_ENCODER_MODEL = `${URL_PREFIX}-whisper-base/${VERSION_TAG}/xnnpack/whisper_base_encoder_xnnpack.pte`;
+const WHISPER_BASE_DECODER_MODEL = `${URL_PREFIX}-whisper-base/${VERSION_TAG}/xnnpack/whisper_base_decoder_xnnpack.pte`;
+
+const WHISPER_SMALL_TOKENIZER = `${URL_PREFIX}-whisper-small/${VERSION_TAG}/tokenizer.json`;
+const WHISPER_SMALL_ENCODER_MODEL = `${URL_PREFIX}-whisper-small/${VERSION_TAG}/xnnpack/whisper_small_encoder_xnnpack.pte`;
+const WHISPER_SMALL_DECODER_MODEL = `${URL_PREFIX}-whisper-small/${VERSION_TAG}/xnnpack/whisper_small_decoder_xnnpack.pte`;
+
+export const WHISPER_TINY_EN = {
+  isMultilingual: false,
+  encoderSource: WHISPER_TINY_EN_ENCODER,
+  decoderSource: WHISPER_TINY_EN_DECODER,
+  tokenizerSource: WHISPER_TINY_EN_TOKENIZER,
+};
+
+export const WHISPER_BASE_EN = {
+  isMultilingual: false,
+  encoderSource: WHISPER_BASE_EN_ENCODER,
+  decoderSource: WHISPER_BASE_EN_DECODER,
+  tokenizerSource: WHISPER_BASE_EN_TOKENIZER,
+};
+
+export const WHISPER_SMALL_EN = {
+  isMultilingual: false,
+  encoderSource: WHISPER_SMALL_EN_ENCODER,
+  decoderSource: WHISPER_SMALL_EN_DECODER,
+  tokenizerSource: WHISPER_SMALL_EN_TOKENIZER,
 };
 
 export const WHISPER_TINY = {
-  modelName: AvailableModels.WHISPER,
-  decoderSource: WHISPER_TINY_DECODER_MODEL,
+  isMultilingual: true,
   encoderSource: WHISPER_TINY_ENCODER_MODEL,
-  tokenizerSource: WHISPER_TOKENIZER,
+  decoderSource: WHISPER_TINY_DECODER_MODEL,
+  tokenizerSource: WHISPER_TINY_TOKENIZER,
+};
+
+export const WHISPER_BASE = {
+  isMultilingual: true,
+  encoderSource: WHISPER_BASE_ENCODER_MODEL,
+  decoderSource: WHISPER_BASE_DECODER_MODEL,
+  tokenizerSource: WHISPER_BASE_TOKENIZER,
 };
 
-export const WHISPER_TINY_MULTILINGUAL = {
-  modelName: AvailableModels.WHISPER_MULTILINGUAL,
-  decoderSource: WHISPER_TINY_MULTILINGUAL_DECODER_MODEL,
-  encoderSource: WHISPER_TINY_MULTILINGUAL_ENCODER_MODEL,
-  tokenizerSource: WHISPER_TINY_MULTILINGUAL_TOKENIZER,
+export const WHISPER_SMALL = {
+  isMultilingual: true,
+  encoderSource: WHISPER_SMALL_ENCODER_MODEL,
+  decoderSource: WHISPER_SMALL_DECODER_MODEL,
+  tokenizerSource: WHISPER_SMALL_TOKENIZER,
 };
 
 // Image segmentation
@@ -347,23 +380,23 @@ export const DEEPLAB_V3_RESNET50 = {
 };
 
 // Image Embeddings
-const CLIP_VIT_BASE_PATCH32_IMAGE_MODEL = `${URL_PREFIX}-clip-vit-base-patch32/${NEXT_VERSION_TAG}/clip-vit-base-patch32-vision_xnnpack.pte`;
+const CLIP_VIT_BASE_PATCH32_IMAGE_MODEL = `${URL_PREFIX}-clip-vit-base-patch32/${VERSION_TAG}/clip-vit-base-patch32-vision_xnnpack.pte`;
 
 export const CLIP_VIT_BASE_PATCH32_IMAGE = {
   modelSource: CLIP_VIT_BASE_PATCH32_IMAGE_MODEL,
 };
 
 // Text Embeddings
-const ALL_MINILM_L6_V2_MODEL = `${URL_PREFIX}-all-MiniLM-L6-v2/${NEXT_VERSION_TAG}/all-MiniLM-L6-v2_xnnpack.pte`;
-const ALL_MINILM_L6_V2_TOKENIZER = `${URL_PREFIX}-all-MiniLM-L6-v2/${NEXT_VERSION_TAG}/tokenizer.json`;
-const ALL_MPNET_BASE_V2_MODEL = `${URL_PREFIX}-all-mpnet-base-v2/${NEXT_VERSION_TAG}/all-mpnet-base-v2_xnnpack.pte`;
-const ALL_MPNET_BASE_V2_TOKENIZER = `${URL_PREFIX}-all-mpnet-base-v2/${NEXT_VERSION_TAG}/tokenizer.json`;
-const MULTI_QA_MINILM_L6_COS_V1_MODEL = `${URL_PREFIX}-multi-qa-MiniLM-L6-cos-v1/${NEXT_VERSION_TAG}/multi-qa-MiniLM-L6-cos-v1_xnnpack.pte`;
-const MULTI_QA_MINILM_L6_COS_V1_TOKENIZER = `${URL_PREFIX}-multi-qa-MiniLM-L6-cos-v1/${NEXT_VERSION_TAG}/tokenizer.json`;
-const MULTI_QA_MPNET_BASE_DOT_V1_MODEL = `${URL_PREFIX}-multi-qa-mpnet-base-dot-v1/${NEXT_VERSION_TAG}/multi-qa-mpnet-base-dot-v1_xnnpack.pte`;
-const MULTI_QA_MPNET_BASE_DOT_V1_TOKENIZER = `${URL_PREFIX}-multi-qa-mpnet-base-dot-v1/${NEXT_VERSION_TAG}/tokenizer.json`;
-const CLIP_VIT_BASE_PATCH32_TEXT_MODEL = `${URL_PREFIX}-clip-vit-base-patch32/${NEXT_VERSION_TAG}/clip-vit-base-patch32-text_xnnpack.pte`;
-const CLIP_VIT_BASE_PATCH32_TEXT_TOKENIZER = `${URL_PREFIX}-clip-vit-base-patch32/${NEXT_VERSION_TAG}/tokenizer.json`;
+const ALL_MINILM_L6_V2_MODEL = `${URL_PREFIX}-all-MiniLM-L6-v2/${VERSION_TAG}/all-MiniLM-L6-v2_xnnpack.pte`;
+const ALL_MINILM_L6_V2_TOKENIZER = `${URL_PREFIX}-all-MiniLM-L6-v2/${VERSION_TAG}/tokenizer.json`;
+const ALL_MPNET_BASE_V2_MODEL = `${URL_PREFIX}-all-mpnet-base-v2/${VERSION_TAG}/all-mpnet-base-v2_xnnpack.pte`;
+const ALL_MPNET_BASE_V2_TOKENIZER = `${URL_PREFIX}-all-mpnet-base-v2/${VERSION_TAG}/tokenizer.json`;
+const MULTI_QA_MINILM_L6_COS_V1_MODEL = `${URL_PREFIX}-multi-qa-MiniLM-L6-cos-v1/${VERSION_TAG}/multi-qa-MiniLM-L6-cos-v1_xnnpack.pte`;
+const MULTI_QA_MINILM_L6_COS_V1_TOKENIZER = `${URL_PREFIX}-multi-qa-MiniLM-L6-cos-v1/${VERSION_TAG}/tokenizer.json`;
+const MULTI_QA_MPNET_BASE_DOT_V1_MODEL = `${URL_PREFIX}-multi-qa-mpnet-base-dot-v1/${VERSION_TAG}/multi-qa-mpnet-base-dot-v1_xnnpack.pte`;
+const MULTI_QA_MPNET_BASE_DOT_V1_TOKENIZER = `${URL_PREFIX}-multi-qa-mpnet-base-dot-v1/${VERSION_TAG}/tokenizer.json`;
+const CLIP_VIT_BASE_PATCH32_TEXT_MODEL = `${URL_PREFIX}-clip-vit-base-patch32/${VERSION_TAG}/clip-vit-base-patch32-text_xnnpack.pte`;
+const CLIP_VIT_BASE_PATCH32_TEXT_TOKENIZER = `${URL_PREFIX}-clip-vit-base-patch32/${VERSION_TAG}/tokenizer.json`;
 
 export const ALL_MINILM_L6_V2 = {
   modelSource: ALL_MINILM_L6_V2_MODEL,

package/src/constants/ocr/models.ts

@@ -2,7 +2,7 @@ import { alphabets, symbols } from './symbols';
 
 const URL_PREFIX =
   'https://huggingface.co/software-mansion/react-native-executorch';
-const VERSION_TAG = 'resolve/v0.4.0';
+const VERSION_TAG = 'resolve/v0.5.0';
 
 const DETECTOR_CRAFT_1280_MODEL = `${URL_PREFIX}-detector-craft/${VERSION_TAG}/xnnpack/xnnpack_craft_1280.pte`;
 const DETECTOR_CRAFT_800_MODEL = `${URL_PREFIX}-detector-craft/${VERSION_TAG}/xnnpack/xnnpack_craft_800.pte`;