react-native-executorch 0.5.3 → 0.5.5

package/lib/utils/ResourceFetcherUtils.js

@@ -1,127 +0,0 @@
-/**
- * @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

@@ -1,6 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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/src/utils/SpeechToTextModule/ASR.ts

@@ -1,303 +0,0 @@
-// NOTE: This will be implemented in C++
-
-import { TokenizerModule } from '../../modules/natural_language_processing/TokenizerModule';
-import {
-  DecodingOptions,
-  Segment,
-  SpeechToTextModelConfig,
-  WordObject,
-  WordTuple,
-} from '../../types/stt';
-import { ResourceFetcher } from '../ResourceFetcher';
-
-export class ASR {
-  private nativeModule: any;
-  private tokenizerModule: TokenizerModule = new TokenizerModule();
-
-  private timePrecision: number = 0.02; // Whisper timestamp precision
-  private maxDecodeLength: number = 128;
-  private chunkSize: number = 30; // 30 seconds
-  private minChunkSamples: number = 1 * 16000; // 1 second
-  private samplingRate: number = 16000;
-
-  private startOfTranscriptToken!: number;
-  private endOfTextToken!: number;
-  private timestampBeginToken!: number;
-
-  public async load(
-    model: SpeechToTextModelConfig,
-    onDownloadProgressCallback: (progress: number) => void
-  ) {
-    const tokenizerLoadPromise = this.tokenizerModule.load(model);
-    const encoderDecoderPromise = ResourceFetcher.fetch(
-      onDownloadProgressCallback,
-      model.encoderSource,
-      model.decoderSource
-    );
-    const [_, encoderDecoderResults] = await Promise.all([
-      tokenizerLoadPromise,
-      encoderDecoderPromise,
-    ]);
-    const encoderSource = encoderDecoderResults?.[0];
-    const decoderSource = encoderDecoderResults?.[1];
-    if (!encoderSource || !decoderSource) {
-      throw new Error('Download interrupted.');
-    }
-    this.nativeModule = await global.loadSpeechToText(
-      encoderSource,
-      decoderSource,
-      'whisper'
-    );
-
-    this.startOfTranscriptToken = await this.tokenizerModule.tokenToId(
-      '<|startoftranscript|>'
-    );
-    this.endOfTextToken = await this.tokenizerModule.tokenToId('<|endoftext|>');
-    this.timestampBeginToken = await this.tokenizerModule.tokenToId('<|0.00|>');
-  }
-
-  private async getInitialSequence(
-    options: DecodingOptions
-  ): Promise<number[]> {
-    const initialSequence: number[] = [this.startOfTranscriptToken];
-    if (options.language) {
-      const languageToken = await this.tokenizerModule.tokenToId(
-        `<|${options.language}|>`
-      );
-      const taskToken = await this.tokenizerModule.tokenToId('<|transcribe|>');
-      initialSequence.push(languageToken);
-      initialSequence.push(taskToken);
-    }
-    initialSequence.push(this.timestampBeginToken);
-    return initialSequence;
-  }
-
-  private async generate(
-    audio: number[],
-    temperature: number,
-    options: DecodingOptions
-  ): Promise<{
-    sequencesIds: number[];
-    scores: number[];
-  }> {
-    await this.encode(new Float32Array(audio));
-    const initialSequence = await this.getInitialSequence(options);
-    const sequencesIds = [...initialSequence];
-    const scores: number[] = [];
-
-    while (sequencesIds.length <= this.maxDecodeLength) {
-      const logits = this.softmaxWithTemperature(
-        Array.from(await this.decode(sequencesIds)),
-        temperature === 0 ? 1 : temperature
-      );
-      const nextTokenId =
-        temperature === 0
-          ? logits.indexOf(Math.max(...logits))
-          : this.sampleFromDistribution(logits);
-      const nextTokenProb = logits[nextTokenId]!;
-      sequencesIds.push(nextTokenId);
-      scores.push(nextTokenProb);
-      if (nextTokenId === this.endOfTextToken) {
-        break;
-      }
-    }
-
-    return {
-      sequencesIds: sequencesIds.slice(initialSequence.length),
-      scores: scores.slice(initialSequence.length),
-    };
-  }
-
-  private softmaxWithTemperature(logits: number[], temperature = 1.0) {
-    const max = Math.max(...logits);
-    const exps = logits.map((logit) => Math.exp((logit - max) / temperature));
-    const sum = exps.reduce((a, b) => a + b, 0);
-    return exps.map((exp) => exp / sum);
-  }
-
-  private sampleFromDistribution(probs: number[]): number {
-    const r = Math.random();
-    let cumulative = 0;
-    for (let i = 0; i < probs.length; i++) {
-      cumulative += probs[i]!;
-      if (r < cumulative) {
-        return i;
-      }
-    }
-    return probs.length - 1;
-  }
-
-  private async generateWithFallback(
-    audio: number[],
-    options: DecodingOptions
-  ) {
-    const temperatures = [0.0, 0.2, 0.4, 0.6, 0.8, 1.0];
-    let generatedTokens: number[] = [];
-
-    for (const temperature of temperatures) {
-      const result = await this.generate(audio, temperature, options);
-      const tokens = result.sequencesIds;
-      const scores = result.scores;
-
-      const seqLen = tokens.length;
-      const cumLogProb = scores.reduce(
-        (acc, score) => acc + Math.log(score),
-        0
-      );
-      const avgLogProb = cumLogProb / seqLen;
-
-      if (avgLogProb >= -1.0) {
-        generatedTokens = tokens;
-        break;
-      }
-    }
-
-    return this.calculateWordLevelTimestamps(generatedTokens, audio);
-  }
-
-  private async calculateWordLevelTimestamps(
-    generatedTokens: number[],
-    audio: number[]
-  ): Promise<Segment[]> {
-    const segments: Segment[] = [];
-
-    let tokens: number[] = [];
-    let prevTimestamp = this.timestampBeginToken;
-    for (let i = 0; i < generatedTokens.length; i++) {
-      if (generatedTokens[i]! < this.timestampBeginToken) {
-        tokens.push(generatedTokens[i]!);
-      }
-
-      if (
-        i > 0 &&
-        generatedTokens[i - 1]! >= this.timestampBeginToken &&
-        generatedTokens[i]! >= this.timestampBeginToken
-      ) {
-        const start = prevTimestamp;
-        const end = generatedTokens[i - 1]!;
-        const wordObjects = await this.estimateWordTimestampsLinear(
-          tokens,
-          start,
-          end
-        );
-        segments.push({
-          words: wordObjects,
-        });
-        tokens = [];
-        prevTimestamp = generatedTokens[i]!;
-      }
-    }
-
-    const start = prevTimestamp;
-    const end = generatedTokens.at(-2)!;
-    const wordObjects = await this.estimateWordTimestampsLinear(
-      tokens,
-      start,
-      end
-    );
-    segments.push({
-      words: wordObjects,
-    });
-
-    const scalingFactor =
-      audio.length /
-      this.samplingRate /
-      ((end - this.timestampBeginToken) * this.timePrecision);
-    if (scalingFactor < 1) {
-      for (const segment of segments) {
-        for (const word of segment.words) {
-          word.start *= scalingFactor;
-          word.end *= scalingFactor;
-        }
-      }
-    }
-
-    return segments;
-  }
-
-  private async estimateWordTimestampsLinear(
-    tokens: number[],
-    timestampStart: number,
-    timestampEnd: number
-  ): Promise<WordObject[]> {
-    const duration = (timestampEnd - timestampStart) * this.timePrecision;
-    const segmentText = (
-      (await this.tokenizerModule.decode(tokens)) as string
-    ).trim();
-
-    const words = segmentText.split(' ').map((w) => ` ${w}`);
-    const numOfCharacters = words.reduce(
-      (acc: number, word: string) => acc + word.length,
-      0
-    );
-
-    const timePerCharacter = duration / numOfCharacters;
-
-    const wordObjects: WordObject[] = [];
-    const startTimeOffset =
-      (timestampStart - this.timestampBeginToken) * this.timePrecision;
-
-    let prevCharNum = 0;
-    for (let j = 0; j < words.length; j++) {
-      const word = words[j]!;
-      const start = startTimeOffset + prevCharNum * timePerCharacter;
-      const end = start + timePerCharacter * word.length;
-      wordObjects.push({ word, start, end });
-      prevCharNum += word.length;
-    }
-
-    return wordObjects;
-  }
-
-  public async transcribe(
-    audio: number[],
-    options: DecodingOptions
-  ): Promise<Segment[]> {
-    let seek = 0;
-    const allSegments: Segment[] = [];
-
-    while (seek * this.samplingRate < audio.length) {
-      const chunk = audio.slice(
-        seek * this.samplingRate,
-        (seek + this.chunkSize) * this.samplingRate
-      );
-      if (chunk.length < this.minChunkSamples) {
-        return allSegments;
-      }
-      const segments = await this.generateWithFallback(chunk, options);
-      for (const segment of segments) {
-        for (const word of segment.words) {
-          word.start += seek;
-          word.end += seek;
-        }
-      }
-      allSegments.push(...segments);
-      const lastTimeStamp = segments.at(-1)!.words.at(-1)!.end;
-      seek = lastTimeStamp;
-    }
-
-    return allSegments;
-  }
-
-  public tsWords(segments: Segment[]): WordTuple[] {
-    const o: WordTuple[] = [];
-    for (const segment of segments) {
-      for (const word of segment.words) {
-        o.push([word.start, word.end, word.word]);
-      }
-    }
-    return o;
-  }
-
-  public segmentsEndTs(res: Segment[]) {
-    return res.map((segment) => segment.words.at(-1)!.end);
-  }
-
-  public async encode(waveform: Float32Array): Promise<void> {
-    await this.nativeModule.encode(waveform);
-  }
-
-  public async decode(tokens: number[]): Promise<Float32Array> {
-    return new Float32Array(await this.nativeModule.decode(tokens));
-  }
-}

package/src/utils/SpeechToTextModule/OnlineProcessor.ts

@@ -1,87 +0,0 @@
-// NOTE: This will be implemented in C++
-
-import { WordTuple, DecodingOptions, Segment } from '../../types/stt';
-import { ASR } from './ASR';
-import { HypothesisBuffer } from './hypothesisBuffer';
-
-export class OnlineASRProcessor {
-  private asr: ASR;
-
-  private samplingRate: number = 16000;
-  public audioBuffer: number[] = [];
-  private transcriptBuffer: HypothesisBuffer = new HypothesisBuffer();
-  private bufferTimeOffset: number = 0;
-  private committed: WordTuple[] = [];
-
-  constructor(asr: ASR) {
-    this.asr = asr;
-  }
-
-  public insertAudioChunk(audio: number[]) {
-    this.audioBuffer.push(...audio);
-  }
-
-  public async processIter(options: DecodingOptions) {
-    const res = await this.asr.transcribe(this.audioBuffer, options);
-    const tsw = this.asr.tsWords(res);
-    this.transcriptBuffer.insert(tsw, this.bufferTimeOffset);
-    const o = this.transcriptBuffer.flush();
-    this.committed.push(...o);
-
-    const s = 15;
-    if (this.audioBuffer.length / this.samplingRate > s) {
-      this.chunkCompletedSegment(res);
-    }
-
-    const committed = this.toFlush(o)[2];
-    const nonCommitted = this.transcriptBuffer
-      .complete()
-      .map((x) => x[2])
-      .join('');
-    return { committed, nonCommitted };
-  }
-
-  private chunkCompletedSegment(res: Segment[]) {
-    if (this.committed.length === 0) {
-      return;
-    }
-
-    const ends = this.asr.segmentsEndTs(res);
-    const t = this.committed.at(-1)![1];
-
-    if (ends.length > 1) {
-      let e = ends.at(-2)! + this.bufferTimeOffset;
-      while (ends.length > 2 && e > t) {
-        ends.pop();
-        e = ends.at(-2)! + this.bufferTimeOffset;
-      }
-
-      if (e <= t) {
-        this.chunkAt(e);
-      }
-    }
-  }
-
-  private chunkAt(time: number) {
-    this.transcriptBuffer.popCommitted(time);
-    const cutSeconds = time - this.bufferTimeOffset;
-    this.audioBuffer = this.audioBuffer.slice(
-      Math.floor(cutSeconds * this.samplingRate)
-    );
-    this.bufferTimeOffset = time;
-  }
-
-  public async finish() {
-    const o = this.transcriptBuffer.complete();
-    const f = this.toFlush(o);
-    this.bufferTimeOffset += this.audioBuffer.length / this.samplingRate;
-    return { committed: f[2] };
-  }
-
-  private toFlush(words: WordTuple[]): [number | null, number | null, string] {
-    const t = words.map((s) => s[2]).join(' ');
-    const b = words.length === 0 ? null : words[0]![0];
-    const e = words.length === 0 ? null : words.at(-1)![1];
-    return [b, e, t];
-  }
-}

package/src/utils/SpeechToTextModule/hypothesisBuffer.ts

@@ -1,79 +0,0 @@
-// NOTE: This will be implemented in C++
-
-import { WordTuple } from '../../types/stt';
-
-export class HypothesisBuffer {
-  private committedInBuffer: WordTuple[] = [];
-  private buffer: WordTuple[] = [];
-  private new: WordTuple[] = [];
-
-  private lastCommittedTime: number = 0;
-  public lastCommittedWord: string | null = null;
-
-  public insert(newWords: WordTuple[], offset: number) {
-    const newWordsOffset: WordTuple[] = newWords.map(([a, b, t]) => [
-      a + offset,
-      b + offset,
-      t,
-    ]);
-    this.new = newWordsOffset.filter(
-      ([a, _b, _t]) => a > this.lastCommittedTime - 0.5
-    );
-
-    if (this.new.length > 0) {
-      const [a, _b, _t] = this.new[0]!;
-      if (
-        Math.abs(a - this.lastCommittedTime) < 1 &&
-        this.committedInBuffer.length > 0
-      ) {
-        const cn = this.committedInBuffer.length;
-        const nn = this.new.length;
-
-        for (let i = 1; i <= Math.min(cn, nn, 5); i++) {
-          const c = this.committedInBuffer
-            .slice(-i)
-            .map((w) => w[2])
-            .join(' ');
-          const tail = this.new
-            .slice(0, i)
-            .map((w) => w[2])
-            .join(' ');
-          if (c === tail) {
-            for (let j = 0; j < i; j++) {
-              this.new.shift();
-            }
-            break;
-          }
-        }
-      }
-    }
-  }
-
-  public flush(): WordTuple[] {
-    const commit: WordTuple[] = [];
-    while (this.new.length > 0 && this.buffer.length > 0) {
-      if (this.new[0]![2] !== this.buffer[0]![2]) {
-        break;
-      }
-      commit.push(this.new[0]!);
-      this.lastCommittedWord = this.new[0]![2];
-      this.lastCommittedTime = this.new[0]![1];
-      this.buffer.shift();
-      this.new.shift();
-    }
-    this.buffer = this.new;
-    this.new = [];
-    this.committedInBuffer.push(...commit);
-    return commit;
-  }
-
-  public popCommitted(time: number) {
-    this.committedInBuffer = this.committedInBuffer.filter(
-      ([_a, b, _t]) => b > time
-    );
-  }
-
-  public complete(): WordTuple[] {
-    return this.buffer;
-  }
-}