react-native-executorch 0.4.9 → 0.5.0-nightly-6f4dd53-20251211

package/src/utils/ResourceFetcherUtils.ts

@@ -0,0 +1,184 @@
+import { RNEDirectory } from '../constants/directories';
+import { ResourceSource } from '../types/common';
+import { Asset } from 'expo-asset';
+import { Logger } from '../common/Logger';
+
+/**
+ * @internal
+ */
+import {
+  getInfoAsync,
+  makeDirectoryAsync,
+  type DownloadResumable,
+} from 'expo-file-system/legacy';
+
+export const enum HTTP_CODE {
+  OK = 200,
+  PARTIAL_CONTENT = 206,
+}
+
+export const enum DownloadStatus {
+  ONGOING,
+  PAUSED,
+}
+
+export const enum SourceType {
+  OBJECT,
+  LOCAL_FILE,
+  RELEASE_MODE_FILE,
+  DEV_MODE_FILE,
+  REMOTE_FILE,
+}
+
+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 namespace ResourceFetcherUtils {
+  export function getType(source: ResourceSource): SourceType {
+    if (typeof source === 'object') {
+      return SourceType.OBJECT;
+    } else if (typeof source === 'number') {
+      const uri = Asset.fromModule(source).uri;
+      if (uri.startsWith('http')) {
+        return SourceType.DEV_MODE_FILE;
+      }
+      return SourceType.RELEASE_MODE_FILE;
+    }
+    // typeof source == 'string'
+    if (source.startsWith('file://')) {
+      return SourceType.LOCAL_FILE;
+    }
+    return SourceType.REMOTE_FILE;
+  }
+
+  export async function getFilesSizes(sources: ResourceSource[]) {
+    const results: Array<{
+      source: ResourceSource;
+      type: SourceType;
+      length: number;
+      previousFilesTotalLength: number;
+    }> = [];
+    let totalLength = 0;
+    let previousFilesTotalLength = 0;
+    for (const source of sources) {
+      const type = ResourceFetcherUtils.getType(source);
+      let length = 0;
+      try {
+        if (type === SourceType.REMOTE_FILE && typeof source === 'string') {
+          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;
+      } finally {
+        results.push({ source, type, length, previousFilesTotalLength });
+      }
+    }
+    return { results, totalLength };
+  }
+
+  export function removeFilePrefix(uri: string) {
+    return uri.startsWith('file://') ? uri.slice(7) : uri;
+  }
+
+  export function hashObject(jsonString: string) {
+    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();
+  }
+
+  export function calculateDownloadProgress(
+    totalLength: number,
+    previousFilesTotalLength: number,
+    currentFileLength: number,
+    setProgress: (downloadProgress: number) => void
+  ) {
+    return (progress: number) => {
+      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);
+    };
+  }
+
+  /*
+   * 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
+   */
+  export async function triggerHuggingFaceDownloadCounter(uri: string) {
+    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' });
+    }
+  }
+
+  export async function createDirectoryIfNoExists() {
+    if (!(await checkFileExists(RNEDirectory))) {
+      await makeDirectoryAsync(RNEDirectory, { intermediates: true });
+    }
+  }
+
+  export async function checkFileExists(fileUri: string) {
+    const fileInfo = await getInfoAsync(fileUri);
+    return fileInfo.exists;
+  }
+
+  export function getFilenameFromUri(uri: string) {
+    let cleanUri = uri.replace(/^https?:\/\//, '');
+    cleanUri = cleanUri.split('#')?.[0] ?? cleanUri;
+    return cleanUri.replace(/[^a-zA-Z0-9._-]/g, '_');
+  }
+}

package/src/utils/llm.ts

@@ -1,4 +1,10 @@
 import { LLMTool, ToolCall } from '../types/llm';
+import * as z from 'zod/v4';
+import { Schema, 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: string) => ToolCall[] = (
   message: string
@@ -28,7 +34,65 @@ export const parseToolCall: (message: string) => ToolCall[] = (
 
     return results;
   } catch (e) {
-    console.error(e);
+    Logger.error(e);
     return [];
   }
 };
+
+const filterObjectKeys = (obj: object, keysToRemove: string[]) => {
+  const entries = Object.entries(obj);
+  const filteredEntries = entries.filter(
+    ([key, _]) => !keysToRemove.includes(key)
+  );
+  return Object.fromEntries(filteredEntries);
+};
+
+export const getStructuredOutputPrompt = <T extends zCore.$ZodType>(
+  responseSchema: T | Schema
+) => {
+  const schemaObject: Schema | zCore.JSONSchema.JSONSchema =
+    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: string): string => {
+  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 = <T extends zCore.$ZodType>(
+  output: string,
+  responseSchema: T | Schema
+): zCore.output<T> => {
+  const extractedOutput = extractBetweenBrackets(output);
+  const repairedOutput = jsonrepair(extractedOutput);
+  const outputJSON = JSON.parse(repairedOutput);
+
+  if (responseSchema instanceof zCore.$ZodType) {
+    return z.parse(responseSchema, outputJSON) as zCore.output<T>;
+  } else {
+    const validator = new Validator();
+    validator.validate(outputJSON, responseSchema, {
+      throwAll: true,
+    });
+    return outputJSON;
+  }
+};

package/third-party/include/c10/macros/Export.h

@@ -0,0 +1 @@
+#include <torch/headeronly/macros/Export.h>

package/third-party/include/c10/macros/Macros.h

@@ -0,0 +1 @@
+#include <torch/headeronly/macros/Macros.h>

package/third-party/include/c10/util/BFloat16-inl.h

@@ -0,0 +1 @@
+#include <torch/headeronly/util/BFloat16.h>

package/third-party/include/c10/util/BFloat16-math.h

@@ -0,0 +1,266 @@
+#pragma once
+
+#include <c10/util/BFloat16.h>
+#include <c10/util/Half.h>
+
+C10_CLANG_DIAGNOSTIC_PUSH()
+#if C10_CLANG_HAS_WARNING("-Wimplicit-float-conversion")
+C10_CLANG_DIAGNOSTIC_IGNORE("-Wimplicit-float-conversion")
+#endif
+
+namespace c10 {
+template <typename T>
+struct is_reduced_floating_point
+    : std::integral_constant<bool, std::is_same_v<T, c10::Half> ||
+                                       std::is_same_v<T, c10::BFloat16>> {};
+
+template <typename T>
+constexpr bool is_reduced_floating_point_v =
+    is_reduced_floating_point<T>::value;
+} // namespace c10
+
+namespace std {
+
+#if !defined(FBCODE_CAFFE2) && !defined(C10_NODEPRECATED)
+using c10::is_reduced_floating_point;
+using c10::is_reduced_floating_point_v;
+#endif // !defined(FBCODE_CAFFE2) && !defined(C10_NODEPRECATED)
+
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T acos(T a) {
+  return std::acos(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T asin(T a) {
+  return std::asin(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T atan(T a) {
+  return std::atan(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T atanh(T a) {
+  return std::atanh(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T erf(T a) {
+  return std::erf(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T erfc(T a) {
+  return std::erfc(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T exp(T a) {
+  return std::exp(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T expm1(T a) {
+  return std::expm1(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline bool isfinite(T a) {
+  return std::isfinite(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T log(T a) {
+  return std::log(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T log10(T a) {
+  return std::log10(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T log1p(T a) {
+  return std::log1p(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T log2(T a) {
+  return std::log2(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T ceil(T a) {
+  return std::ceil(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T cos(T a) {
+  return std::cos(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T floor(T a) {
+  return std::floor(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T nearbyint(T a) {
+  return std::nearbyint(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T sin(T a) {
+  return std::sin(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T tan(T a) {
+  return std::tan(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T sinh(T a) {
+  return std::sinh(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T cosh(T a) {
+  return std::cosh(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T tanh(T a) {
+  return std::tanh(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T trunc(T a) {
+  return std::trunc(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T lgamma(T a) {
+  return std::lgamma(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T sqrt(T a) {
+  return std::sqrt(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T rsqrt(T a) {
+  return 1.0 / std::sqrt(float(a));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T abs(T a) {
+  return std::abs(float(a));
+}
+#if defined(_MSC_VER) && defined(__CUDACC__)
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T pow(T a, double b) {
+  return std::pow(float(a), float(b));
+}
+#else
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T pow(T a, double b) {
+  return std::pow(float(a), b);
+}
+#endif
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T pow(T a, T b) {
+  return std::pow(float(a), float(b));
+}
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+inline T fmod(T a, T b) {
+  return std::fmod(float(a), float(b));
+}
+
+/*
+  The following function is inspired from the implementation in `musl`
+  Link to License: https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
+  ----------------------------------------------------------------------
+  Copyright © 2005-2020 Rich Felker, et al.
+
+  Permission is hereby granted, free of charge, to any person obtaining
+  a copy of this software and associated documentation files (the
+  "Software"), to deal in the Software without restriction, including
+  without limitation the rights to use, copy, modify, merge, publish,
+  distribute, sublicense, and/or sell copies of the Software, and to
+  permit persons to whom the Software is furnished to do so, subject to
+  the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+  ----------------------------------------------------------------------
+ */
+template <typename T, typename std::enable_if_t<
+                          c10::is_reduced_floating_point_v<T>, int> = 0>
+C10_HOST_DEVICE inline T nextafter(T from, T to) {
+  // Reference:
+  // https://git.musl-libc.org/cgit/musl/tree/src/math/nextafter.c
+  using int_repr_t = uint16_t;
+  constexpr uint8_t bits = 16;
+  union {
+    T f;
+    int_repr_t i;
+  } ufrom = {from}, uto = {to};
+
+  // get a mask to get the sign bit i.e. MSB
+  int_repr_t sign_mask = int_repr_t{1} << (bits - 1);
+
+  // short-circuit: if either is NaN, return NaN
+  if (from != from || to != to) {
+    return from + to;
+  }
+
+  // short-circuit: if they are exactly the same.
+  if (ufrom.i == uto.i) {
+    return from;
+  }
+
+  // mask the sign-bit to zero i.e. positive
+  // equivalent to abs(x)
+  int_repr_t abs_from = ufrom.i & ~sign_mask;
+  int_repr_t abs_to = uto.i & ~sign_mask;
+  if (abs_from == 0) {
+    // if both are zero but with different sign,
+    // preserve the sign of `to`.
+    if (abs_to == 0) {
+      return to;
+    }
+    // smallest subnormal with sign of `to`.
+    ufrom.i = (uto.i & sign_mask) | int_repr_t{1};
+    return ufrom.f;
+  }
+
+  // if abs(from) > abs(to) or sign(from) != sign(to)
+  if (abs_from > abs_to || ((ufrom.i ^ uto.i) & sign_mask)) {
+    ufrom.i--;
+  } else {
+    ufrom.i++;
+  }
+
+  return ufrom.f;
+}
+
+} // namespace std
+
+C10_CLANG_DIAGNOSTIC_POP()

package/third-party/include/c10/util/BFloat16.h

@@ -0,0 +1 @@
+#include <torch/headeronly/util/BFloat16.h>

package/third-party/include/c10/util/Half-inl.h

@@ -0,0 +1 @@
+#include <torch/headeronly/util/Half.h>

package/third-party/include/c10/util/Half.h

@@ -0,0 +1,8 @@
+#include <torch/headeronly/util/Half.h>
+
+// need to keep the following for BC because the APIs in here were exposed
+// before migrating Half to torch/headeronly
+#if (defined(CPU_CAPABILITY_AVX2) || defined(CPU_CAPABILITY_AVX512)) &&        \
+    !defined(__APPLE__)
+#include <ATen/cpu/vec/vec_half.h>
+#endif

package/third-party/include/c10/util/TypeSafeSignMath.h

@@ -0,0 +1 @@
+#include <torch/headeronly/util/TypeSafeSignMath.h>

package/third-party/include/c10/util/bit_cast.h

@@ -0,0 +1 @@
+#include <torch/headeronly/util/bit_cast.h>