@dr33m/react-native-litert-lm 0.5.0

package/lib/hooks.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useModel = useModel;
+const react_1 = require("react");
+const modelFactory_1 = require("./modelFactory");
+const modelRegistry_1 = require("./modelRegistry");
+const modelPath_1 = require("./modelPath");
+function useModel(pathOrUrl, config) {
+    const modelRef = (0, react_1.useRef)(null);
+    const [isReady, setIsReady] = (0, react_1.useState)(false);
+    const [isGenerating, setIsGenerating] = (0, react_1.useState)(false);
+    const [downloadProgress, setDownloadProgress] = (0, react_1.useState)(0);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [memorySummary, setMemorySummary] = (0, react_1.useState)(null);
+    // Destructure config into primitive values for stable dependency arrays.
+    // This prevents infinite re-render loops when consumers pass inline config
+    // objects (e.g. useModel(url, { backend: 'cpu' })) without useMemo.
+    const autoLoad = config?.autoLoad ?? true;
+    const enableMemoryTracking = config?.enableMemoryTracking ?? false;
+    const maxMemorySnapshots = config?.maxMemorySnapshots ?? 256;
+    const backend = config?.backend;
+    const systemPrompt = config?.systemPrompt;
+    const maxTokens = config?.maxTokens;
+    const maxContextTokens = config?.maxContextTokens;
+    const maxOutputTokens = config?.maxOutputTokens;
+    const temperature = config?.temperature;
+    const topK = config?.topK;
+    const topP = config?.topP;
+    const multimodal = config?.multimodal;
+    const tools = config?.tools;
+    const enableSpeculativeDecoding = config?.enableSpeculativeDecoding;
+    const enableThinking = config?.enableThinking;
+    const toolsKey = tools ? JSON.stringify(tools) : undefined;
+    // Build a stable config object from the destructured primitives
+    const nativeConfig = (0, react_1.useMemo)(() => ({
+        ...(backend !== undefined && { backend }),
+        ...(systemPrompt !== undefined && { systemPrompt }),
+        ...(maxTokens !== undefined && { maxTokens }),
+        ...(maxContextTokens !== undefined && { maxContextTokens }),
+        ...(maxOutputTokens !== undefined && { maxOutputTokens }),
+        ...(temperature !== undefined && { temperature }),
+        ...(topK !== undefined && { topK }),
+        ...(topP !== undefined && { topP }),
+        ...(multimodal !== undefined && { multimodal }),
+        ...(tools !== undefined && { tools }),
+        ...(enableSpeculativeDecoding !== undefined && {
+            enableSpeculativeDecoding,
+        }),
+        ...(enableThinking !== undefined && { enableThinking }),
+    }), [
+        backend,
+        systemPrompt,
+        maxTokens,
+        maxContextTokens,
+        maxOutputTokens,
+        temperature,
+        topK,
+        topP,
+        multimodal,
+        toolsKey,
+        enableSpeculativeDecoding,
+        enableThinking,
+    ]);
+    /**
+     * Refresh memory summary from the tracker's native buffer.
+     */
+    const refreshMemorySummary = (0, react_1.useCallback)(() => {
+        if (modelRef.current?.memoryTracker) {
+            setMemorySummary(modelRef.current.memoryTracker.getSummary());
+        }
+    }, []);
+    // Initialize the model instance
+    (0, react_1.useEffect)(() => {
+        modelRef.current = (0, modelFactory_1.createLLM)({
+            enableMemoryTracking,
+            maxMemorySnapshots,
+        });
+        // Reset ready state — the new instance has no model loaded yet.
+        // This prevents stale isReady=true after Fast Refresh (which
+        // preserves useState but re-runs useEffect).
+        setIsReady(false);
+        // Cleanup on unmount
+        return () => {
+            try {
+                modelRef.current?.close();
+            }
+            catch (e) {
+                console.warn("Failed to close model", e);
+            }
+        };
+    }, [enableMemoryTracking, maxMemorySnapshots]);
+    const load = (0, react_1.useCallback)(async () => {
+        setIsReady(false);
+        setError(null);
+        setDownloadProgress(0);
+        try {
+            if (modelRef.current) {
+                // Delegate URL handling + download to the factory's loadModel,
+                // passing our progress setter as the callback (eliminates
+                // duplicate download logic that was previously in this hook).
+                await modelRef.current.loadModel(pathOrUrl, nativeConfig, (progress) => {
+                    setDownloadProgress(progress);
+                });
+                setIsReady(true);
+            }
+        }
+        catch (e) {
+            setError(e.message || "Failed to load model");
+            console.error(e);
+        }
+    }, [pathOrUrl, nativeConfig]);
+    (0, react_1.useEffect)(() => {
+        if (autoLoad) {
+            load();
+        }
+    }, [autoLoad, load]);
+    const generate = (0, react_1.useCallback)(async (prompt) => {
+        if (!modelRef.current || !isReady) {
+            throw new Error("Model not ready");
+        }
+        setIsGenerating(true);
+        try {
+            const response = await modelRef.current.execute([{ type: "text", text: prompt }], undefined);
+            refreshMemorySummary();
+            return response;
+        }
+        catch (e) {
+            setError(e.message || "Generation failed");
+            throw e;
+        }
+        finally {
+            setIsGenerating(false);
+        }
+    }, [isReady, refreshMemorySummary]);
+    const reset = (0, react_1.useCallback)(() => {
+        if (modelRef.current) {
+            modelRef.current.resetConversation();
+        }
+    }, []);
+    const deleteModel = (0, react_1.useCallback)(async (fileName) => {
+        const resolvedName = fileName ?? (0, modelPath_1.extractFileName)(pathOrUrl);
+        modelRegistry_1.ModelRegistry.deleteFile(resolvedName);
+        setIsReady(false);
+        setDownloadProgress(0);
+    }, [pathOrUrl]);
+    return {
+        model: modelRef.current,
+        isReady,
+        isGenerating,
+        downloadProgress,
+        error,
+        generate,
+        reset,
+        deleteModel,
+        load,
+        memoryTracker: modelRef.current?.memoryTracker ?? null,
+        memorySummary,
+    };
+}

package/lib/index.d.ts

@@ -0,0 +1,142 @@
+import type { Backend } from "./specs/LiteRTLM.nitro";
+export type { LiteRTLM, LLMConfig, Message, Backend, Role, GenerationStats, MemoryUsage, 
+/** New in v0.5: pass to execute() instead of individual send methods */
+MultimodalPart, PartType, 
+/** Tool calling types */
+ToolDefinition, ToolCall, ToolResponse, ExecuteResult, } from "./specs/LiteRTLM.nitro";
+export type { MemorySnapshot, MemoryTracker, MemoryTrackerSummary, } from "./memoryTracker";
+export { createMemoryTracker, createNativeBuffer } from "./memoryTracker";
+export type { LiteRTLMInstance } from "./modelFactory";
+export { ModelRegistry } from "./modelRegistry";
+export type { ModelDownloadOptions } from "./modelRegistry";
+export * from "./hooks";
+/**
+ * Creates a new LiteRT-LM inference engine instance.
+ *
+ * @example
+ * ```typescript
+ * import { createLLM } from 'react-native-litert-lm';
+ *
+ * const llm = createLLM();
+ * await llm.loadModel('/path/to/gemma-3n-e2b.litertlm', {
+ *   backend: 'gpu',
+ *   temperature: 0.7,
+ *   maxContextTokens: 4096,
+ *   maxOutputTokens: 512
+ * });
+ *
+ * // ── Unified entry point (recommended) ─────────────────────────────────────
+ * // Blocking text
+ * const response = await llm.execute([{ type: 'text', text: 'Hello!' }]);
+ *
+ * // Streaming text
+ * await llm.execute(
+ *   [{ type: 'text', text: 'Write me a haiku' }],
+ *   (token, done) => { process.stdout.write(token); }
+ * );
+ *
+ * // Multimodal (image path — auto-scaled to 1024px on both platforms)
+ * const desc = await llm.execute([
+ *   { type: 'text', text: 'Describe this image' },
+ *   { type: 'image', path: '/path/to/photo.jpg' },
+ * ]);
+ *
+ * // ── Legacy methods (still fully supported) ────────────────────────────────
+ * const r = await llm.sendMessage('Hello');
+ * llm.sendMessageAsync('Stream this', (t, done) => console.log(t));
+ *
+ * llm.close();
+ * ```
+ */
+export { createLLM } from "./modelFactory";
+/**
+ * Pre-defined model identifiers for common models.
+ * Use with model download utilities or as reference.
+ */
+export declare const Models: {
+    /** Gemma 4 E2B Instruct (2B parameters, latest generation) */
+    readonly GEMMA_4_E2B: "gemma-4-E2B-it-litert-lm";
+    /** Gemma 4 E4B Instruct (4B parameters, higher quality) */
+    readonly GEMMA_4_E4B: "gemma-4-E4B-it-litert-lm";
+    /** Gemma 3n E2B (2B parameters, efficient) */
+    readonly GEMMA_3N_E2B: "gemma-3n-E2B-it-litert-lm-preview";
+    /** Gemma 3n E4B (4B parameters, higher quality) */
+    readonly GEMMA_3N_E4B: "gemma-3n-E4B-it-litert-lm-preview";
+    /** Gemma 3 1B (smallest Gemma) */
+    readonly GEMMA_3_1B: "Gemma3-1B-IT_multi-prefill-seq_q4_ekv4096";
+    /** Phi-4 Mini Instruct */
+    readonly PHI_4_MINI: "Phi-4-mini-instruct_multi-prefill-seq_q8_ekv4096";
+    /** Qwen 2.5 1.5B Instruct */
+    readonly QWEN_2_5_1_5B: "Qwen2.5-1.5B-Instruct_multi-prefill-seq_q8_ekv4096";
+};
+export type ModelId = (typeof Models)[keyof typeof Models];
+/**
+ * Get the recommended backend for the current platform.
+ * Returns 'cpu' as the safe default. GPU (Metal on iOS, GPU delegate on Android)
+ * is faster but may not be available on all devices or model configurations.
+ *
+ * @returns The recommended backend ('cpu')
+ *
+ * @example
+ * ```typescript
+ * const backend = getRecommendedBackend();
+ * llm.loadModel(path, { backend });
+ * ```
+ */
+export declare function getRecommendedBackend(): Backend;
+/**
+ * Check if a backend configuration is supported on the current platform.
+ * Returns a warning message if the configuration may have issues.
+ *
+ * @param backend The backend to check
+ * @returns Warning message if there may be issues, undefined if OK
+ *
+ * @example
+ * ```typescript
+ * const warning = checkBackendSupport('npu');
+ * if (warning) {
+ *   console.warn(warning);
+ * }
+ * ```
+ */
+export declare function checkBackendSupport(backend: Backend): string | undefined;
+/**
+ * Check if multimodal features (image/audio) are supported on the current platform.
+ * Returns an error message if not supported, undefined if OK.
+ *
+ * Both iOS (v0.12.0 CLiteRTLM xcframework) and Android (LiteRT-LM SDK) ship the
+ * vision/audio executor ops, so there is no platform-level block. Whether a
+ * given call succeeds depends on the **loaded model**: only multimodal models
+ * (e.g. Gemma 3n) bundle the vision/audio executors. Pass `multimodal: true` to
+ * `loadModel` for such models, or rely on filename sniffing ("3n"/"gemma3").
+ *
+ * @returns Error message if multimodal is not supported, undefined if OK
+ *
+ * @example
+ * ```typescript
+ * const error = checkMultimodalSupport();
+ * if (error) {
+ *   console.warn(error);
+ *   // Fall back to text-only
+ * } else {
+ *   llm.sendMessageWithImage('Describe this', imagePath);
+ * }
+ * ```
+ */
+export declare function checkMultimodalSupport(): string | undefined;
+/**
+ * Download URL for the Gemma 3n E2B IT INT4 model (~1.3 GB).
+ * Public — hosted on litert.dev, no authentication required.
+ */
+export declare const GEMMA_3N_E2B_IT_INT4 = "https://litert.dev/gemma-3n-E2B-it-int4.litertlm";
+/**
+ * Download URL for the Gemma 4 E2B IT model (2.58 GB).
+ * Public — no HuggingFace account required.
+ */
+export declare const GEMMA_4_E2B_IT = "https://huggingface.co/litert-community/gemma-4-E2B-it-litert-lm/resolve/main/gemma-4-E2B-it.litertlm";
+/**
+ * Download URL for the Gemma 4 E4B IT model (3.65 GB).
+ * Higher quality than E2B but requires more device memory.
+ * Public — no HuggingFace account required.
+ */
+export declare const GEMMA_4_E4B_IT = "https://huggingface.co/litert-community/gemma-4-E4B-it-litert-lm/resolve/main/gemma-4-E4B-it.litertlm";

package/lib/index.js

@@ -0,0 +1,184 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GEMMA_4_E4B_IT = exports.GEMMA_4_E2B_IT = exports.GEMMA_3N_E2B_IT_INT4 = exports.Models = exports.createLLM = exports.ModelRegistry = exports.createNativeBuffer = exports.createMemoryTracker = void 0;
+exports.getRecommendedBackend = getRecommendedBackend;
+exports.checkBackendSupport = checkBackendSupport;
+exports.checkMultimodalSupport = checkMultimodalSupport;
+const react_native_1 = require("react-native");
+var memoryTracker_1 = require("./memoryTracker");
+Object.defineProperty(exports, "createMemoryTracker", { enumerable: true, get: function () { return memoryTracker_1.createMemoryTracker; } });
+Object.defineProperty(exports, "createNativeBuffer", { enumerable: true, get: function () { return memoryTracker_1.createNativeBuffer; } });
+var modelRegistry_1 = require("./modelRegistry");
+Object.defineProperty(exports, "ModelRegistry", { enumerable: true, get: function () { return modelRegistry_1.ModelRegistry; } });
+__exportStar(require("./hooks"), exports);
+/**
+ * Creates a new LiteRT-LM inference engine instance.
+ *
+ * @example
+ * ```typescript
+ * import { createLLM } from 'react-native-litert-lm';
+ *
+ * const llm = createLLM();
+ * await llm.loadModel('/path/to/gemma-3n-e2b.litertlm', {
+ *   backend: 'gpu',
+ *   temperature: 0.7,
+ *   maxContextTokens: 4096,
+ *   maxOutputTokens: 512
+ * });
+ *
+ * // ── Unified entry point (recommended) ─────────────────────────────────────
+ * // Blocking text
+ * const response = await llm.execute([{ type: 'text', text: 'Hello!' }]);
+ *
+ * // Streaming text
+ * await llm.execute(
+ *   [{ type: 'text', text: 'Write me a haiku' }],
+ *   (token, done) => { process.stdout.write(token); }
+ * );
+ *
+ * // Multimodal (image path — auto-scaled to 1024px on both platforms)
+ * const desc = await llm.execute([
+ *   { type: 'text', text: 'Describe this image' },
+ *   { type: 'image', path: '/path/to/photo.jpg' },
+ * ]);
+ *
+ * // ── Legacy methods (still fully supported) ────────────────────────────────
+ * const r = await llm.sendMessage('Hello');
+ * llm.sendMessageAsync('Stream this', (t, done) => console.log(t));
+ *
+ * llm.close();
+ * ```
+ */
+var modelFactory_1 = require("./modelFactory");
+Object.defineProperty(exports, "createLLM", { enumerable: true, get: function () { return modelFactory_1.createLLM; } });
+/**
+ * Pre-defined model identifiers for common models.
+ * Use with model download utilities or as reference.
+ */
+exports.Models = {
+    /** Gemma 4 E2B Instruct (2B parameters, latest generation) */
+    GEMMA_4_E2B: "gemma-4-E2B-it-litert-lm",
+    /** Gemma 4 E4B Instruct (4B parameters, higher quality) */
+    GEMMA_4_E4B: "gemma-4-E4B-it-litert-lm",
+    /** Gemma 3n E2B (2B parameters, efficient) */
+    GEMMA_3N_E2B: "gemma-3n-E2B-it-litert-lm-preview",
+    /** Gemma 3n E4B (4B parameters, higher quality) */
+    GEMMA_3N_E4B: "gemma-3n-E4B-it-litert-lm-preview",
+    /** Gemma 3 1B (smallest Gemma) */
+    GEMMA_3_1B: "Gemma3-1B-IT_multi-prefill-seq_q4_ekv4096",
+    /** Phi-4 Mini Instruct */
+    PHI_4_MINI: "Phi-4-mini-instruct_multi-prefill-seq_q8_ekv4096",
+    /** Qwen 2.5 1.5B Instruct */
+    QWEN_2_5_1_5B: "Qwen2.5-1.5B-Instruct_multi-prefill-seq_q8_ekv4096",
+};
+/**
+ * Get the recommended backend for the current platform.
+ * Returns 'cpu' as the safe default. GPU (Metal on iOS, GPU delegate on Android)
+ * is faster but may not be available on all devices or model configurations.
+ *
+ * @returns The recommended backend ('cpu')
+ *
+ * @example
+ * ```typescript
+ * const backend = getRecommendedBackend();
+ * llm.loadModel(path, { backend });
+ * ```
+ */
+function getRecommendedBackend() {
+    // CPU is the safe default — always available, broadly compatible.
+    // GPU is faster but may fail on some models/devices.
+    return "cpu";
+}
+/**
+ * Check if a backend configuration is supported on the current platform.
+ * Returns a warning message if the configuration may have issues.
+ *
+ * @param backend The backend to check
+ * @returns Warning message if there may be issues, undefined if OK
+ *
+ * @example
+ * ```typescript
+ * const warning = checkBackendSupport('npu');
+ * if (warning) {
+ *   console.warn(warning);
+ * }
+ * ```
+ */
+function checkBackendSupport(backend) {
+    if (backend === "gpu") {
+        if (react_native_1.Platform.OS === "android") {
+            // GPU uses OpenCL on Android. Supported on many devices (Mali, Adreno, etc.)
+            // but may not be available on all. The engine will automatically fall back
+            // to CPU if GPU initialization fails.
+            return "GPU acceleration uses OpenCL. If unavailable on this device, the engine will automatically fall back to CPU.";
+        }
+        // iOS always supports GPU via Metal
+        return undefined;
+    }
+    if (backend === "npu") {
+        if (react_native_1.Platform.OS === "android") {
+            return "NPU backend requires compatible hardware (Qualcomm Hexagon, MediaTek APU, etc.). Will automatically fall back to CPU if unavailable.";
+        }
+        if (react_native_1.Platform.OS === "ios") {
+            return "NPU (Neural Engine) is not yet supported on iOS. Mapped to GPU (Metal) internally.";
+        }
+    }
+    return undefined;
+}
+/**
+ * Check if multimodal features (image/audio) are supported on the current platform.
+ * Returns an error message if not supported, undefined if OK.
+ *
+ * Both iOS (v0.12.0 CLiteRTLM xcframework) and Android (LiteRT-LM SDK) ship the
+ * vision/audio executor ops, so there is no platform-level block. Whether a
+ * given call succeeds depends on the **loaded model**: only multimodal models
+ * (e.g. Gemma 3n) bundle the vision/audio executors. Pass `multimodal: true` to
+ * `loadModel` for such models, or rely on filename sniffing ("3n"/"gemma3").
+ *
+ * @returns Error message if multimodal is not supported, undefined if OK
+ *
+ * @example
+ * ```typescript
+ * const error = checkMultimodalSupport();
+ * if (error) {
+ *   console.warn(error);
+ *   // Fall back to text-only
+ * } else {
+ *   llm.sendMessageWithImage('Describe this', imagePath);
+ * }
+ * ```
+ */
+function checkMultimodalSupport() {
+    // Supported on both platforms with a multimodal model loaded.
+    return undefined;
+}
+/**
+ * Download URL for the Gemma 3n E2B IT INT4 model (~1.3 GB).
+ * Public — hosted on litert.dev, no authentication required.
+ */
+exports.GEMMA_3N_E2B_IT_INT4 = "https://litert.dev/gemma-3n-E2B-it-int4.litertlm";
+/**
+ * Download URL for the Gemma 4 E2B IT model (2.58 GB).
+ * Public — no HuggingFace account required.
+ */
+exports.GEMMA_4_E2B_IT = "https://huggingface.co/litert-community/gemma-4-E2B-it-litert-lm/resolve/main/gemma-4-E2B-it.litertlm";
+/**
+ * Download URL for the Gemma 4 E4B IT model (3.65 GB).
+ * Higher quality than E2B but requires more device memory.
+ * Public — no HuggingFace account required.
+ */
+exports.GEMMA_4_E4B_IT = "https://huggingface.co/litert-community/gemma-4-E4B-it-litert-lm/resolve/main/gemma-4-E4B-it.litertlm";

package/lib/inferenceRouting.d.ts

@@ -0,0 +1,18 @@
+import type { MultimodalPart } from "./specs/LiteRTLM.nitro";
+export type TokenCallback = (token: string, done: boolean) => void;
+/** Legacy inference entry points on LiteRTLM (createLLM routes these to execute). */
+export declare const LEGACY_INFERENCE_METHODS: readonly ["sendMessage", "sendMessageWithImage", "sendMessageWithAudio", "sendMultimodalMessage", "sendMessageAsync", "sendMessageWithImageAsync", "sendMessageWithAudioAsync"];
+export type LegacyInferenceMethod = (typeof LEGACY_INFERENCE_METHODS)[number];
+export declare function textPart(text: string): MultimodalPart;
+export declare function imagePart(path: string): MultimodalPart;
+export declare function audioPart(path: string): MultimodalPart;
+export type InferenceRoute = {
+    parts: MultimodalPart[];
+    onToken?: TokenCallback;
+};
+/**
+ * Maps legacy public API names to unified MultimodalPart payloads.
+ * JS source of truth — native legacy wrappers mirror these shapes for direct hybrid access.
+ */
+export declare function routeLegacyInference(method: string, args: unknown[]): InferenceRoute | null;
+export declare function isLegacyInferenceMethod(method: string): method is LegacyInferenceMethod;

package/lib/inferenceRouting.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEGACY_INFERENCE_METHODS = void 0;
+exports.textPart = textPart;
+exports.imagePart = imagePart;
+exports.audioPart = audioPart;
+exports.routeLegacyInference = routeLegacyInference;
+exports.isLegacyInferenceMethod = isLegacyInferenceMethod;
+/** Legacy inference entry points on LiteRTLM (createLLM routes these to execute). */
+exports.LEGACY_INFERENCE_METHODS = [
+    "sendMessage",
+    "sendMessageWithImage",
+    "sendMessageWithAudio",
+    "sendMultimodalMessage",
+    "sendMessageAsync",
+    "sendMessageWithImageAsync",
+    "sendMessageWithAudioAsync",
+];
+function textPart(text) {
+    return { type: "text", text };
+}
+function imagePart(path) {
+    return { type: "image", path };
+}
+function audioPart(path) {
+    return { type: "audio", path };
+}
+const LEGACY_ROUTES = {
+    sendMessage: (args) => ({ parts: [textPart(args[0])] }),
+    sendMessageWithImage: (args) => ({
+        parts: [textPart(args[0]), imagePart(args[1])],
+    }),
+    sendMessageWithAudio: (args) => ({
+        parts: [textPart(args[0]), audioPart(args[1])],
+    }),
+    sendMultimodalMessage: (args) => ({ parts: args[0] }),
+    sendMessageAsync: (args) => ({
+        parts: [textPart(args[0])],
+        onToken: args[1],
+    }),
+    sendMessageWithImageAsync: (args) => ({
+        parts: [textPart(args[0]), imagePart(args[1])],
+        onToken: args[2],
+    }),
+    sendMessageWithAudioAsync: (args) => ({
+        parts: [textPart(args[0]), audioPart(args[1])],
+        onToken: args[2],
+    }),
+};
+const LEGACY_METHOD_SET = new Set(exports.LEGACY_INFERENCE_METHODS);
+/**
+ * Maps legacy public API names to unified MultimodalPart payloads.
+ * JS source of truth — native legacy wrappers mirror these shapes for direct hybrid access.
+ */
+function routeLegacyInference(method, args) {
+    if (!LEGACY_METHOD_SET.has(method)) {
+        return null;
+    }
+    return LEGACY_ROUTES[method](args);
+}
+function isLegacyInferenceMethod(method) {
+    return LEGACY_METHOD_SET.has(method);
+}