react-native-executorch 0.5.7 → 0.5.8

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

@@ -0,0 +1,127 @@
+/**
+ * @internal
+ */
+import { getInfoAsync, makeDirectoryAsync, } from 'expo-file-system';
+import { RNEDirectory } from '../constants/directories';
+import { Asset } from 'expo-asset';
+import { Logger } from '../common/Logger';
+export var ResourceFetcherUtils;
+(function (ResourceFetcherUtils) {
+    function getType(source) {
+        if (typeof source === 'object') {
+            return 0 /* SourceType.OBJECT */;
+        }
+        else if (typeof source === 'number') {
+            const uri = Asset.fromModule(source).uri;
+            if (!uri.includes('://')) {
+                return 2 /* SourceType.RELEASE_MODE_FILE */;
+            }
+            return 3 /* SourceType.DEV_MODE_FILE */;
+        }
+        else {
+            // typeof source == 'string'
+            if (source.startsWith('file://')) {
+                return 1 /* SourceType.LOCAL_FILE */;
+            }
+            return 4 /* SourceType.REMOTE_FILE */;
+        }
+    }
+    ResourceFetcherUtils.getType = getType;
+    async function getFilesSizes(sources) {
+        const results = [];
+        let totalLength = 0;
+        let previousFilesTotalLength = 0;
+        for (const source of sources) {
+            const type = await ResourceFetcherUtils.getType(source);
+            let length = 0;
+            if (type === 4 /* SourceType.REMOTE_FILE */ && typeof source === 'string') {
+                try {
+                    const response = await fetch(source, { method: 'HEAD' });
+                    if (!response.ok) {
+                        Logger.warn(`Failed to fetch HEAD for ${source}: ${response.status}`);
+                        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;
+                }
+                catch (error) {
+                    Logger.warn(`Error fetching HEAD for ${source}:`, error);
+                    continue;
+                }
+            }
+            results.push({ source, type, length, previousFilesTotalLength });
+        }
+        return { results, totalLength };
+    }
+    ResourceFetcherUtils.getFilesSizes = getFilesSizes;
+    function removeFilePrefix(uri) {
+        return uri.startsWith('file://') ? uri.slice(7) : uri;
+    }
+    ResourceFetcherUtils.removeFilePrefix = removeFilePrefix;
+    function hashObject(jsonString) {
+        let hash = 0;
+        for (let i = 0; i < jsonString.length; i++) {
+            // eslint-disable-next-line no-bitwise
+            hash = (hash << 5) - hash + jsonString.charCodeAt(i);
+            // eslint-disable-next-line no-bitwise
+            hash |= 0;
+        }
+        // eslint-disable-next-line no-bitwise
+        return (hash >>> 0).toString();
+    }
+    ResourceFetcherUtils.hashObject = hashObject;
+    function calculateDownloadProgress(totalLength, previousFilesTotalLength, currentFileLength, setProgress) {
+        return (progress) => {
+            if (progress === 1 &&
+                previousFilesTotalLength === totalLength - currentFileLength) {
+                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;
+            setProgress(updatedProgress);
+        };
+    }
+    ResourceFetcherUtils.calculateDownloadProgress = calculateDownloadProgress;
+    /*
+     * Increments the Hugging Face download counter if the URI points to a Software Mansion Hugging Face repo.
+     * More information: https://huggingface.co/docs/hub/models-download-stats
+     */
+    async function triggerHuggingFaceDownloadCounter(uri) {
+        const url = new URL(uri);
+        if (url.host === 'huggingface.co' &&
+            url.pathname.startsWith('/software-mansion/')) {
+            const baseUrl = `${url.protocol}//${url.host}${url.pathname.split('resolve')[0]}`;
+            fetch(`${baseUrl}resolve/main/config.json`, { method: 'HEAD' });
+        }
+    }
+    ResourceFetcherUtils.triggerHuggingFaceDownloadCounter = triggerHuggingFaceDownloadCounter;
+    async function createDirectoryIfNoExists() {
+        if (!(await checkFileExists(RNEDirectory))) {
+            await makeDirectoryAsync(RNEDirectory, { intermediates: true });
+        }
+    }
+    ResourceFetcherUtils.createDirectoryIfNoExists = createDirectoryIfNoExists;
+    async function checkFileExists(fileUri) {
+        const fileInfo = await getInfoAsync(fileUri);
+        return fileInfo.exists;
+    }
+    ResourceFetcherUtils.checkFileExists = checkFileExists;
+    function getFilenameFromUri(uri) {
+        let cleanUri = uri.replace(/^https?:\/\//, '');
+        cleanUri = cleanUri.split('#')?.[0] ?? cleanUri;
+        return cleanUri.replace(/[^a-zA-Z0-9._-]/g, '_');
+    }
+    ResourceFetcherUtils.getFilenameFromUri = getFilenameFromUri;
+})(ResourceFetcherUtils || (ResourceFetcherUtils = {}));

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

@@ -0,0 +1,72 @@
+import * as z from 'zod/v4';
+import { Validator } from 'jsonschema';
+import { jsonrepair } from 'jsonrepair';
+import { DEFAULT_STRUCTURED_OUTPUT_PROMPT } from '../constants/llmDefaults';
+import * as zCore from 'zod/v4/core';
+import { Logger } from '../common/Logger';
+export const parseToolCall = (message) => {
+    try {
+        const unparsedToolCalls = message.match('\\[(.|\\s)*\\]');
+        if (!unparsedToolCalls) {
+            throw Error('Regex did not match array.');
+        }
+        const parsedMessage = JSON.parse(unparsedToolCalls[0]);
+        const results = [];
+        for (const tool of parsedMessage) {
+            if ('name' in tool &&
+                typeof tool.name === 'string' &&
+                'arguments' in tool &&
+                tool.arguments !== null &&
+                typeof tool.arguments === 'object') {
+                results.push({
+                    toolName: tool.name,
+                    arguments: tool.arguments,
+                });
+            }
+        }
+        return results;
+    }
+    catch (e) {
+        Logger.error(e);
+        return [];
+    }
+};
+const filterObjectKeys = (obj, keysToRemove) => {
+    const entries = Object.entries(obj);
+    const filteredEntries = entries.filter(([key, _]) => !keysToRemove.includes(key));
+    return Object.fromEntries(filteredEntries);
+};
+export const getStructuredOutputPrompt = (responseSchema) => {
+    const schemaObject = responseSchema instanceof zCore.$ZodType
+        ? filterObjectKeys(z.toJSONSchema(responseSchema), [
+            '$schema',
+            'additionalProperties',
+        ])
+        : responseSchema;
+    const schemaString = JSON.stringify(schemaObject);
+    return DEFAULT_STRUCTURED_OUTPUT_PROMPT(schemaString);
+};
+const extractBetweenBrackets = (text) => {
+    const startIndex = text.search(/[\\{\\[]/); // First occurrence of either { or [
+    const openingBracket = text[startIndex];
+    const closingBracket = openingBracket === '{' ? '}' : ']';
+    if (!openingBracket)
+        throw Error("Couldn't find JSON in text");
+    return text.slice(text.indexOf(openingBracket), text.lastIndexOf(closingBracket) + 1);
+};
+// this is a bit hacky typing
+export const fixAndValidateStructuredOutput = (output, responseSchema) => {
+    const extractedOutput = extractBetweenBrackets(output);
+    const repairedOutput = jsonrepair(extractedOutput);
+    const outputJSON = JSON.parse(repairedOutput);
+    if (responseSchema instanceof zCore.$ZodType) {
+        return z.parse(responseSchema, outputJSON);
+    }
+    else {
+        const validator = new Validator();
+        validator.validate(outputJSON, responseSchema, {
+            throwAll: true,
+        });
+        return outputJSON;
+    }
+};

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.7",
+  "version": "0.5.8",
   "description": "An easy way to run AI models in React Native with ExecuTorch",
   "source": "./src/index.ts",
   "main": "./lib/module/index.js",

package/src/modules/natural_language_processing/LLMModule.ts

@@ -85,6 +85,10 @@ export class LLMModule {
     this.controller.interrupt();
   }
 
+  getGeneratedTokenCount() {
+    return this.controller.getGeneratedTokenCount();
+  }
+
   delete() {
     this.controller.delete();
   }

package/src/types/llm.ts

@@ -6,7 +6,6 @@ export interface LLMType {
   isGenerating: boolean;
   downloadProgress: number;
   error: string | null;
-  getGeneratedTokenCount: () => number;
   configure: ({
     chatConfig,
     toolsConfig,
@@ -16,6 +15,7 @@ export interface LLMType {
     toolsConfig?: ToolsConfig;
     generationConfig?: GenerationConfig;
   }) => void;
+  getGeneratedTokenCount: () => number;
   generate: (messages: Message[], tools?: LLMTool[]) => Promise<void>;
   sendMessage: (message: string) => Promise<void>;
   deleteMessage: (index: number) => void;