@masteryhub-its/speakout-local-client-model 0.0.1

package/lib/utils/constants.d.ts

@@ -0,0 +1,35 @@
+export declare const ONNX_CONFIG: {
+    EXECUTION_PROVIDER_WASM: string;
+    GRAPH_OPTIMIZATION_LEVEL: string;
+    TENSOR_TYPE_INT64: string;
+    DEFAULT_PROVIDER: string;
+    WASM_NUM_THREADS: number;
+};
+export declare const MODEL_PATH: string;
+export declare const TOKENIZER_PATH: string;
+export declare const DEFAULTS: {
+    THRESHOLD: number;
+    MAX_LENGTH: number;
+};
+export declare const ERROR_MESSAGES: {
+    ONNX_RUNTIME_NOT_AVAILABLE: string;
+    TOKENIZER_INIT_FAILED: string;
+    SESSION_NOT_INITIALIZED: string;
+    TOKENIZER_NOT_INITIALIZED: string;
+};
+export declare const MODEL_NAME = "asafaya/bert-mini-arabic";
+export declare const MAX_LENGTH = 128;
+export declare const NUM_LABELS = 2;
+export declare const SPECIAL_TOKENS: {
+    PAD: string;
+    CLS: string;
+    SEP: string;
+    UNK: string;
+    SUBWORD_PREFIX: string;
+};
+export declare const DEFAULT_TOKEN_IDS: {
+    PAD: number;
+    UNK: number;
+    CLS: number;
+    SEP: number;
+};

package/lib/utils/constants.js

@@ -0,0 +1,59 @@
+export const ONNX_CONFIG = {
+    EXECUTION_PROVIDER_WASM: "wasm",
+    GRAPH_OPTIMIZATION_LEVEL: "all",
+    TENSOR_TYPE_INT64: "int64",
+    DEFAULT_PROVIDER: "cpu",
+    WASM_NUM_THREADS: 1,
+};
+// Model file paths - resolved at runtime relative to package location
+const packageName = '@masteryhub-its/speakout-local-client-model';
+function getModelPath(filename) {
+    const basePath = `/node_modules/${packageName}/models/bert-mini-moderation-output/${filename}`;
+    if (typeof window !== 'undefined' && window.location) {
+        return new URL(basePath, window.location.origin).toString();
+    }
+    try {
+        if (typeof import.meta !== 'undefined' && import.meta.url) {
+            const currentUrl = new URL(import.meta.url);
+            const pathname = currentUrl.pathname;
+            const packageIndex = pathname.indexOf(packageName);
+            if (packageIndex !== -1) {
+                const packageBasePath = pathname.substring(0, packageIndex + packageName.length);
+                const packageBaseUrl = new URL(packageBasePath + '/', currentUrl.origin);
+                return new URL(`models/bert-mini-moderation-output/${filename}`, packageBaseUrl).toString();
+            }
+        }
+    }
+    catch {
+        // Fall through to return basePath
+    }
+    return basePath;
+}
+export const MODEL_PATH = getModelPath("model.int8.onnx");
+export const TOKENIZER_PATH = getModelPath("tokenizer.json");
+export const DEFAULTS = {
+    THRESHOLD: 0.5,
+    MAX_LENGTH: 128,
+};
+export const ERROR_MESSAGES = {
+    ONNX_RUNTIME_NOT_AVAILABLE: "ONNX Runtime not available. Please ensure onnxruntime-web is properly installed.",
+    TOKENIZER_INIT_FAILED: "Failed to initialize tokenizer. Please provide valid tokenizer URL (e.g., '/models/tokenizer.json').",
+    SESSION_NOT_INITIALIZED: "Model session is not initialized. Please call initialize() first.",
+    TOKENIZER_NOT_INITIALIZED: "Tokenizer is not initialized. Please call initialize() first.",
+};
+export const MODEL_NAME = "asafaya/bert-mini-arabic";
+export const MAX_LENGTH = 128;
+export const NUM_LABELS = 2;
+export const SPECIAL_TOKENS = {
+    PAD: "[PAD]",
+    CLS: "[CLS]",
+    SEP: "[SEP]",
+    UNK: "[UNK]",
+    SUBWORD_PREFIX: "##",
+};
+export const DEFAULT_TOKEN_IDS = {
+    PAD: 0,
+    UNK: 1,
+    CLS: 2,
+    SEP: 3,
+};

package/lib/utils/pathResolver.d.ts

@@ -0,0 +1,9 @@
+export interface PathResolutionResult {
+    url: string;
+    method: 'relative' | 'node_modules' | 'extracted' | 'cached';
+    index: number;
+}
+export declare function setDebugLogging(enabled: boolean): void;
+export declare function resolveModelPath(fileName: string, expectedType: 'json' | 'binary'): Promise<PathResolutionResult>;
+export declare function clearPathCache(): void;
+export declare function getCachedPaths(): Map<string, string>;

package/lib/utils/pathResolver.js

@@ -0,0 +1,94 @@
+const PACKAGE_NAME = '@reham_h/speakout-local-client-model';
+const MODEL_SUBPATH = 'bert-mini-moderation-output';
+const pathCache = new Map();
+let debugEnabled = false;
+export function setDebugLogging(enabled) {
+    debugEnabled = enabled;
+}
+function debugLog(message, ...args) {
+    if (debugEnabled)
+        console.log(`[PathResolver] ${message}`, ...args);
+}
+function buildPossibleUrls(fileName) {
+    const baseUrl = import.meta.url;
+    const urls = [];
+    for (let depth = 1; depth <= 6; depth++) {
+        try {
+            urls.push(new URL('../'.repeat(depth) + `models/${MODEL_SUBPATH}/${fileName}`, baseUrl).toString());
+        }
+        catch { }
+    }
+    try {
+        const baseUrlObj = new URL(baseUrl);
+        const origin = baseUrlObj.origin;
+        urls.push(new URL(`/node_modules/${PACKAGE_NAME}/models/${MODEL_SUBPATH}/${fileName}`, origin).toString());
+        const urlPath = baseUrlObj.pathname;
+        if (urlPath.includes('node_modules')) {
+            const parts = urlPath.substring(urlPath.indexOf('node_modules')).split('/').filter(Boolean);
+            if (parts.length >= 3 && parts[0] === 'node_modules') {
+                urls.push(new URL(`/${parts[0]}/${parts[1]}/${parts[2]}/models/${MODEL_SUBPATH}/${fileName}`, origin).toString());
+            }
+        }
+    }
+    catch { }
+    return urls;
+}
+async function verifyFileContent(url, expectedType) {
+    try {
+        const response = await fetch(url);
+        if (!response.ok)
+            return false;
+        const contentType = response.headers.get('content-type') || '';
+        if (expectedType === 'json') {
+            if (!contentType.includes('application/json') && !contentType.includes('text/json')) {
+                if (contentType.includes('text/html'))
+                    return false;
+                const text = await response.clone().text();
+                const lower = text.trim().toLowerCase();
+                if (lower.startsWith('<!doctype') || lower.startsWith('<html'))
+                    return false;
+            }
+            return true;
+        }
+        else {
+            if (contentType.includes('text/html'))
+                return false;
+            const bytes = new Uint8Array((await response.clone().arrayBuffer()).slice(0, 100));
+            return !(bytes.length > 0 && bytes[0] === 0x3C);
+        }
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveModelPath(fileName, expectedType) {
+    const cacheKey = `${fileName}:${expectedType}`;
+    const cached = pathCache.get(cacheKey);
+    if (cached) {
+        debugLog(`Using cached path for ${fileName}: ${cached}`);
+        return { url: cached, method: 'cached', index: -1 };
+    }
+    const possibleUrls = buildPossibleUrls(fileName);
+    debugLog(`Resolving path for ${fileName}, trying ${possibleUrls.length} possible URLs`);
+    for (let i = 0; i < possibleUrls.length; i++) {
+        const url = possibleUrls[i];
+        debugLog(`  [${i + 1}/${possibleUrls.length}] Trying: ${url}`);
+        if (await verifyFileContent(url, expectedType)) {
+            pathCache.set(cacheKey, url);
+            const method = url.includes('/node_modules/')
+                ? (url.includes(PACKAGE_NAME) ? 'node_modules' : 'extracted')
+                : 'relative';
+            debugLog(`✓ Successfully resolved ${fileName} to: ${url} (method: ${method})`);
+            return { url, method, index: i };
+        }
+    }
+    throw new Error(`Failed to resolve path for ${fileName}. Tried ${possibleUrls.length} different paths. ` +
+        `Last attempted: ${possibleUrls[possibleUrls.length - 1] || 'none'}`);
+}
+export function clearPathCache() {
+    pathCache.clear();
+    debugLog('Path cache cleared');
+}
+export function getCachedPaths() {
+    return new Map(pathCache);
+}