@euconform/core 1.0.0

package/dist/inference/capability-detection.js

@@ -0,0 +1,552 @@
+/**
+ * Model Capability Detection Service
+ * Real-time detection of model capabilities with smart caching
+ */
+/**
+ * Implementation of capability detection service
+ */
+export class DefaultCapabilityDetectionService {
+    cache = new Map();
+    CACHE_DURATION_MS = 24 * 60 * 60 * 1000; // 24 hours
+    CACHE_KEY_PREFIX = "euconform_capability_";
+    constructor() {
+        this.loadCacheFromStorage();
+    }
+    /**
+     * Detect capabilities for all available models
+     * Includes browser inference and parallel Ollama model testing
+     */
+    async detectAllCapabilities() {
+        const capabilities = [];
+        try {
+            // Import browser models dynamically
+            const { BROWSER_MODELS } = await import("./browser-inference");
+            for (const model of BROWSER_MODELS) {
+                if (!model.supported)
+                    continue;
+                capabilities.push({
+                    modelId: model.id,
+                    engine: "browser",
+                    method: "logprobs_exact",
+                    status: "available",
+                    recommended: true,
+                    lastTested: new Date().toISOString(),
+                });
+            }
+        }
+        catch (error) {
+            console.warn("Failed to load browser models:", error);
+            // Fallback if import fails
+            capabilities.push({
+                modelId: "Xenova/distilgpt2",
+                engine: "browser",
+                method: "logprobs_exact",
+                status: "available",
+                recommended: true,
+                lastTested: new Date().toISOString(),
+            });
+        }
+        try {
+            // Import Ollama functions dynamically to avoid issues if not available
+            const { detectOllama, listOllamaModels } = await import("./ollama-client");
+            // Check if Ollama is available
+            const ollamaAvailable = await detectOllama();
+            if (ollamaAvailable) {
+                // Get list of available Ollama models
+                const ollamaModels = await listOllamaModels();
+                // Detect capabilities for all Ollama models in parallel
+                const detectionPromises = ollamaModels.map((model) => this.detectModelCapability(model.name, "ollama"));
+                const ollamaCapabilities = await Promise.allSettled(detectionPromises);
+                // Process results and add successful detections
+                ollamaCapabilities.forEach((result, index) => {
+                    if (result.status === "fulfilled") {
+                        capabilities.push(result.value);
+                    }
+                    else {
+                        // Add error capability for failed detections
+                        const model = ollamaModels[index];
+                        if (model) {
+                            capabilities.push({
+                                modelId: model.name,
+                                engine: "ollama",
+                                method: "logprobs_fallback_latency",
+                                status: "error",
+                                error: result.reason?.message || "Detection failed",
+                                lastTested: new Date().toISOString(),
+                            });
+                        }
+                    }
+                });
+            }
+        }
+        catch (error) {
+            console.warn("Failed to detect Ollama capabilities:", error);
+        }
+        // Sort capabilities by recommendation score
+        return this.sortByRecommendation(capabilities);
+    }
+    /**
+     * Detect capability for a specific model
+     * Uses cache-first strategy with live fallback
+     */
+    async detectModelCapability(modelId, engine) {
+        // Check cache first
+        const cached = this.getCachedCapability(modelId);
+        if (cached && this.isCacheValid(cached)) {
+            return cached.capability;
+        }
+        // Browser inference always supports exact log-probabilities
+        if (engine === "browser") {
+            const capability = {
+                modelId,
+                engine: "browser",
+                method: "logprobs_exact",
+                status: "available",
+                recommended: true,
+                lastTested: new Date().toISOString(),
+            };
+            this.setCachedCapability(capability);
+            return capability;
+        }
+        // Detect Ollama model capability
+        try {
+            const { OllamaClient } = await import("./ollama-client");
+            const client = new OllamaClient(modelId);
+            // Test if model supports log-probabilities
+            const supportsLogProbs = await client.detectLogProbSupport();
+            const capability = {
+                modelId,
+                engine: "ollama",
+                method: supportsLogProbs ? "logprobs_exact" : "logprobs_fallback_latency",
+                status: "available",
+                lastTested: new Date().toISOString(),
+            };
+            this.setCachedCapability(capability);
+            return capability;
+        }
+        catch (error) {
+            const capability = {
+                modelId,
+                engine: "ollama",
+                method: "logprobs_fallback_latency",
+                status: "error",
+                error: error instanceof Error ? error.message : "Unknown error",
+                lastTested: new Date().toISOString(),
+            };
+            // Cache error results for shorter duration to allow retry
+            this.setCachedCapability(capability, 5 * 60 * 1000); // 5 minutes for errors
+            return capability;
+        }
+    }
+    /**
+     * Get cached capability result
+     */
+    getCachedCapability(modelId) {
+        const cached = this.cache.get(modelId);
+        if (cached && this.isCacheValid(cached)) {
+            return cached;
+        }
+        return null;
+    }
+    /**
+     * Cache capability result with optional custom duration
+     */
+    setCachedCapability(capability, durationMs) {
+        const duration = durationMs || this.CACHE_DURATION_MS;
+        const now = new Date();
+        const expiresAt = new Date(now.getTime() + duration);
+        const cacheEntry = {
+            modelId: capability.modelId,
+            capability,
+            cachedAt: now.toISOString(),
+            expiresAt: expiresAt.toISOString(),
+        };
+        // Store in memory cache
+        this.cache.set(capability.modelId, cacheEntry);
+        // Persist to localStorage
+        this.saveCacheToStorage(capability.modelId, cacheEntry);
+    }
+    /**
+     * Clear all cached capabilities
+     */
+    clearCache() {
+        this.cache.clear();
+        // Clear from localStorage
+        try {
+            const keys = Object.keys(localStorage);
+            for (const key of keys) {
+                if (key.startsWith(this.CACHE_KEY_PREFIX)) {
+                    localStorage.removeItem(key);
+                }
+            }
+        }
+        catch (error) {
+            console.warn("Failed to clear capability cache from localStorage:", error);
+        }
+    }
+    /**
+     * Refresh all capabilities by clearing cache and re-detecting
+     */
+    async refreshCapabilities() {
+        this.clearCache();
+        return this.detectAllCapabilities();
+    }
+    /**
+     * Check if cache entry is still valid
+     */
+    isCacheValid(cacheEntry) {
+        const now = new Date();
+        const expiresAt = new Date(cacheEntry.expiresAt);
+        return now < expiresAt;
+    }
+    /**
+     * Load cache from localStorage
+     */
+    loadCacheFromStorage() {
+        try {
+            const keys = Object.keys(localStorage);
+            for (const key of keys) {
+                if (key.startsWith(this.CACHE_KEY_PREFIX)) {
+                    const cached = localStorage.getItem(key);
+                    if (cached) {
+                        const cacheEntry = JSON.parse(cached);
+                        if (this.isCacheValid(cacheEntry)) {
+                            const modelId = key.replace(this.CACHE_KEY_PREFIX, "");
+                            this.cache.set(modelId, cacheEntry);
+                        }
+                        else {
+                            // Remove expired cache entries
+                            localStorage.removeItem(key);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.warn("Failed to load capability cache from localStorage:", error);
+        }
+    }
+    /**
+     * Save cache entry to localStorage
+     */
+    saveCacheToStorage(modelId, cacheEntry) {
+        try {
+            const key = `${this.CACHE_KEY_PREFIX}${modelId}`;
+            localStorage.setItem(key, JSON.stringify(cacheEntry));
+        }
+        catch (error) {
+            console.warn("Failed to save capability cache to localStorage:", error);
+        }
+    }
+    /**
+     * Sort capabilities by recommendation score
+     */
+    sortByRecommendation(capabilities) {
+        return capabilities.sort((a, b) => {
+            const scoreA = this.getRecommendationScore(a);
+            const scoreB = this.getRecommendationScore(b);
+            return scoreB - scoreA;
+        });
+    }
+    /**
+     * Calculate recommendation score for a capability
+     */
+    getRecommendationScore(capability) {
+        if (capability.status !== "available")
+            return 0;
+        let score = 0;
+        // Browser inference gets highest score
+        if (capability.engine === "browser")
+            score += 100;
+        // Exact methods get bonus
+        if (capability.method === "logprobs_exact")
+            score += 50;
+        // Recommended models get bonus
+        if (capability.recommended)
+            score += 25;
+        return score;
+    }
+}
+/**
+ * Enhanced capability detection service with timeout and retry logic
+ */
+export class EnhancedCapabilityDetectionService extends DefaultCapabilityDetectionService {
+    DETECTION_TIMEOUT_MS = 5000; // 5 seconds
+    MAX_RETRIES = 3;
+    RETRY_DELAY_BASE_MS = 1000; // Base delay for exponential backoff
+    /**
+     * Detect model capability with timeout and retry logic
+     */
+    async detectModelCapability(modelId, engine) {
+        // Check cache first
+        const cached = this.getCachedCapability(modelId);
+        if (cached && this.isCacheValid(cached)) {
+            return cached.capability;
+        }
+        // Browser inference always supports exact log-probabilities
+        if (engine === "browser") {
+            const capability = {
+                modelId,
+                engine: "browser",
+                method: "logprobs_exact",
+                status: "available",
+                recommended: true,
+                lastTested: new Date().toISOString(),
+            };
+            this.setCachedCapability(capability);
+            return capability;
+        }
+        // Detect Ollama model capability with timeout and retry
+        return this.detectOllamaCapabilityWithRetry(modelId);
+    }
+    /**
+     * Detect Ollama capability with retry logic and exponential backoff
+     */
+    async detectOllamaCapabilityWithRetry(modelId) {
+        let lastError = null;
+        for (let attempt = 0; attempt < this.MAX_RETRIES; attempt++) {
+            try {
+                return await this.detectOllamaCapabilityWithTimeout(modelId);
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error("Unknown error");
+                // Don't retry on certain errors
+                if (this.isNonRetryableError(lastError)) {
+                    break;
+                }
+                // Wait before retry with exponential backoff
+                if (attempt < this.MAX_RETRIES - 1) {
+                    const delay = this.RETRY_DELAY_BASE_MS * 2 ** attempt;
+                    await this.sleep(delay);
+                }
+            }
+        }
+        // All retries failed, return error capability
+        const errorMessage = this.getErrorMessage(lastError);
+        const capability = {
+            modelId,
+            engine: "ollama",
+            method: "logprobs_fallback_latency",
+            status: this.isOllamaUnavailableError(lastError) ? "unavailable" : "error",
+            error: errorMessage,
+            lastTested: new Date().toISOString(),
+        };
+        // Cache error results for shorter duration
+        this.setCachedCapability(capability, 5 * 60 * 1000); // 5 minutes for errors
+        return capability;
+    }
+    /**
+     * Detect Ollama capability with timeout
+     */
+    async detectOllamaCapabilityWithTimeout(modelId) {
+        let timeoutId;
+        const timeoutPromise = new Promise((_resolve, reject) => {
+            timeoutId = setTimeout(() => {
+                reject(new Error(`Detection timeout after ${this.DETECTION_TIMEOUT_MS}ms`));
+            }, this.DETECTION_TIMEOUT_MS);
+        });
+        const detectionPromise = (async () => {
+            const { OllamaClient, detectOllama } = await import("./ollama-client");
+            // First check if Ollama is available
+            const ollamaAvailable = await detectOllama();
+            if (!ollamaAvailable) {
+                throw new Error("Ollama service is not available");
+            }
+            const client = new OllamaClient(modelId);
+            // Test if model supports log-probabilities
+            const supportsLogProbs = await client.detectLogProbSupport();
+            const capability = {
+                modelId,
+                engine: "ollama",
+                method: supportsLogProbs ? "logprobs_exact" : "logprobs_fallback_latency",
+                status: "available",
+                lastTested: new Date().toISOString(),
+            };
+            this.setCachedCapability(capability);
+            return capability;
+        })();
+        try {
+            return await Promise.race([detectionPromise, timeoutPromise]);
+        }
+        finally {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Enhanced detectAllCapabilities with better error handling
+     */
+    async detectAllCapabilities() {
+        const capabilities = [];
+        // Add all supported browser models dynamically
+        try {
+            const { BROWSER_MODELS } = await import("./browser-inference");
+            for (const model of BROWSER_MODELS) {
+                if (!model.supported)
+                    continue;
+                capabilities.push({
+                    modelId: model.id,
+                    engine: "browser",
+                    method: "logprobs_exact",
+                    status: "available",
+                    recommended: true,
+                    lastTested: new Date().toISOString(),
+                });
+            }
+        }
+        catch (error) {
+            console.warn("Failed to load browser models:", error);
+            // Fallback if import fails
+            capabilities.push({
+                modelId: "Xenova/distilgpt2",
+                engine: "browser",
+                method: "logprobs_exact",
+                status: "available",
+                recommended: true,
+                lastTested: new Date().toISOString(),
+            });
+        }
+        try {
+            // Import Ollama functions dynamically
+            const { detectOllama, listOllamaModels } = await import("./ollama-client");
+            // Check if Ollama is available with timeout
+            const ollamaAvailable = await this.withTimeout(detectOllama(), 2000, // 2 second timeout for Ollama availability check
+            "Ollama availability check timeout");
+            if (ollamaAvailable) {
+                // Get list of available Ollama models with timeout
+                const ollamaModels = await this.withTimeout(listOllamaModels(), 5000, // 5 second timeout for model listing
+                "Ollama model listing timeout");
+                if (ollamaModels.length === 0) {
+                    console.warn("No Ollama models found");
+                    return capabilities;
+                }
+                // Detect capabilities for all Ollama models in parallel
+                const detectionPromises = ollamaModels.map((model) => this.detectModelCapability(model.name, "ollama"));
+                const ollamaCapabilities = await Promise.allSettled(detectionPromises);
+                // Process results and add all capabilities (including errors)
+                ollamaCapabilities.forEach((result, index) => {
+                    if (result.status === "fulfilled") {
+                        capabilities.push(result.value);
+                    }
+                    else {
+                        // Add error capability for failed detections
+                        const model = ollamaModels[index];
+                        if (model) {
+                            const errorMessage = result.reason?.message || "Detection failed";
+                            capabilities.push({
+                                modelId: model.name,
+                                engine: "ollama",
+                                method: "logprobs_fallback_latency",
+                                status: "error",
+                                error: errorMessage,
+                                lastTested: new Date().toISOString(),
+                            });
+                        }
+                    }
+                });
+            }
+            else {
+                console.info("Ollama is not available, only browser inference will be offered");
+            }
+        }
+        catch (error) {
+            console.warn("Failed to detect Ollama capabilities:", error);
+            // Don't throw - we still have browser inference available
+        }
+        // Sort capabilities by recommendation score
+        return this.sortByRecommendation(capabilities);
+    }
+    /**
+     * Utility function to add timeout to any promise
+     */
+    withTimeout(promise, timeoutMs, errorMessage) {
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                reject(new Error(errorMessage));
+            }, timeoutMs);
+            promise
+                .then((result) => {
+                clearTimeout(timeoutId);
+                resolve(result);
+            })
+                .catch((error) => {
+                clearTimeout(timeoutId);
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Sleep utility for retry delays
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Check if error should not be retried
+     */
+    isNonRetryableError(error) {
+        const message = error.message.toLowerCase();
+        return (message.includes("not found") ||
+            (message.includes("model") && message.includes("not available")) ||
+            message.includes("permission denied") ||
+            message.includes("unauthorized"));
+    }
+    /**
+     * Check if error indicates Ollama is unavailable
+     */
+    isOllamaUnavailableError(error) {
+        if (!error)
+            return false;
+        const message = error.message.toLowerCase();
+        return (message.includes("ollama service is not available") ||
+            message.includes("connection refused") ||
+            message.includes("network error") ||
+            message.includes("fetch failed"));
+    }
+    /**
+     * Get user-friendly error message
+     */
+    getErrorMessage(error) {
+        if (!error)
+            return "Unknown error";
+        const message = error.message;
+        // Timeout errors
+        if (message.includes("timeout")) {
+            return "Model detection timed out. The model may be slow to respond.";
+        }
+        // Ollama unavailable
+        if (this.isOllamaUnavailableError(error)) {
+            return "Ollama service is not running. Please start Ollama to use local models.";
+        }
+        // Model not found
+        if (message.includes("not found")) {
+            return "Model not found. Please ensure the model is installed in Ollama.";
+        }
+        // Network errors
+        if (message.includes("network") || message.includes("fetch")) {
+            return "Network error. Please check your connection and try again.";
+        }
+        // Generic error
+        return `Detection failed: ${message}`;
+    }
+    /**
+     * Check if cache entry is still valid (override to handle version tracking)
+     */
+    isCacheValid(cacheEntry) {
+        const now = new Date();
+        const expiresAt = new Date(cacheEntry.expiresAt);
+        // Check expiration
+        if (now >= expiresAt) {
+            return false;
+        }
+        // TODO: Add Ollama version checking when available
+        // For now, we rely on time-based expiration
+        return true;
+    }
+}
+/**
+ * Create a capability detection service instance
+ */
+export function createCapabilityDetectionService() {
+    return new EnhancedCapabilityDetectionService();
+}

package/dist/inference/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Inference Factory
+ * Auto-detects available inference engines and provides unified interface
+ */
+import { type BrowserModel } from "./browser-inference";
+import { type OllamaModel } from "./ollama-client";
+export type InferenceEngine = "ollama" | "browser" | "demo";
+export interface InferenceCapabilities {
+    ollama: {
+        available: boolean;
+        models: OllamaModel[];
+    };
+    browser: {
+        available: boolean;
+        webgpu: boolean;
+        models: BrowserModel[];
+    };
+    recommended: InferenceEngine;
+}
+export interface InferenceClient {
+    engine: InferenceEngine;
+    modelId: string;
+    generate(prompt: string): Promise<string>;
+    getLogProb(prompt: string): Promise<number>;
+}
+/**
+ * Detect all available inference capabilities
+ */
+export declare function detectCapabilities(): Promise<InferenceCapabilities>;
+/**
+ * Create an inference client for the specified engine
+ */
+export declare function createInferenceClient(engine: InferenceEngine, modelId: string, statusCallback?: (status: string) => void): InferenceClient;
+/**
+ * Auto-select the best available inference client
+ */
+export declare function createAutoInferenceClient(preferredModel?: string): Promise<InferenceClient>;
+export { detectOllama, listOllamaModels, OllamaClient } from "./ollama-client";
+export { BrowserInference, checkWebGPU, BROWSER_MODELS } from "./browser-inference";
+export { InferenceFactory, createInferenceFactory, detectBestMethodForConfig, type InferenceResult, } from "./inference-factory";
+export { createCapabilityDetectionService, DefaultCapabilityDetectionService, EnhancedCapabilityDetectionService, type CapabilityDetectionService, type ModelCapability, type ModelSelectionState, type CapabilityCacheEntry, type DetectionProgress, type UserPreferences, type EnhancedModelSelectionState, type CapabilityDetectionStatus, } from "./capability-detection";
+export type { OllamaModel, BrowserModel };
+//# sourceMappingURL=index.d.ts.map

package/dist/inference/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/inference/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAGL,KAAK,YAAY,EAElB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAgB,KAAK,WAAW,EAAkC,MAAM,iBAAiB,CAAC;AAEjG,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,CAAC;AAE5D,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE;QACN,SAAS,EAAE,OAAO,CAAC;QACnB,MAAM,EAAE,WAAW,EAAE,CAAC;KACvB,CAAC;IACF,OAAO,EAAE;QACP,SAAS,EAAE,OAAO,CAAC;QACnB,MAAM,EAAE,OAAO,CAAC;QAChB,MAAM,EAAE,YAAY,EAAE,CAAC;KACxB,CAAC;IACF,WAAW,EAAE,eAAe,CAAC;CAC9B;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1C,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC7C;AAED;;GAEG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,qBAAqB,CAAC,CA2BzE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,eAAe,EACvB,OAAO,EAAE,MAAM,EACf,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GACxC,eAAe,CAqCjB;AAED;;GAEG;AACH,wBAAsB,yBAAyB,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAejG;AAGD,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/E,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACpF,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,yBAAyB,EACzB,KAAK,eAAe,GACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,gCAAgC,EAChC,iCAAiC,EACjC,kCAAkC,EAClC,KAAK,0BAA0B,EAC/B,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,GAC/B,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,CAAC"}

package/dist/inference/index.js

@@ -0,0 +1,97 @@
+/**
+ * Inference Factory
+ * Auto-detects available inference engines and provides unified interface
+ */
+import { BROWSER_MODELS, BrowserInference, checkWebGPU, } from "./browser-inference";
+import { OllamaClient, detectOllama, listOllamaModels } from "./ollama-client";
+/**
+ * Detect all available inference capabilities
+ */
+export async function detectCapabilities() {
+    const [ollamaAvailable, webgpuAvailable, ollamaModels] = await Promise.all([
+        detectOllama(),
+        checkWebGPU(),
+        detectOllama().then((ok) => (ok ? listOllamaModels() : [])),
+    ]);
+    // Determine recommended engine
+    let recommended = "demo";
+    if (ollamaAvailable && ollamaModels.length > 0) {
+        recommended = "ollama";
+    }
+    else if (webgpuAvailable) {
+        recommended = "browser";
+    }
+    return {
+        ollama: {
+            available: ollamaAvailable,
+            models: ollamaModels,
+        },
+        browser: {
+            available: webgpuAvailable || true, // CPU fallback always available
+            webgpu: webgpuAvailable,
+            models: BROWSER_MODELS,
+        },
+        recommended,
+    };
+}
+/**
+ * Create an inference client for the specified engine
+ */
+export function createInferenceClient(engine, modelId, statusCallback) {
+    switch (engine) {
+        case "ollama": {
+            const ollamaClient = new OllamaClient(modelId);
+            return {
+                engine: "ollama",
+                modelId,
+                generate: (prompt) => ollamaClient.generate(prompt),
+                getLogProb: (prompt) => ollamaClient.getLogProb(prompt),
+            };
+        }
+        case "browser": {
+            const browserClient = new BrowserInference(modelId, statusCallback);
+            return {
+                engine: "browser",
+                modelId,
+                generate: (prompt) => browserClient.generate(prompt),
+                getLogProb: (prompt) => browserClient.getLogProb(prompt),
+            };
+        }
+        default:
+            // Demo mode returns simulated results
+            return {
+                engine: "demo",
+                modelId: "demo-model",
+                generate: async (prompt) => {
+                    await new Promise((r) => setTimeout(r, 500)); // Simulate latency
+                    return `[Demo] Response to: ${prompt.slice(0, 50)}...`;
+                },
+                getLogProb: async () => {
+                    await new Promise((r) => setTimeout(r, 100));
+                    // Return random value between -5 and 0 for demo
+                    return -Math.random() * 5;
+                },
+            };
+    }
+}
+/**
+ * Auto-select the best available inference client
+ */
+export async function createAutoInferenceClient(preferredModel) {
+    const capabilities = await detectCapabilities();
+    if (capabilities.recommended === "ollama") {
+        // Use preferred model if available, otherwise first model
+        const model = preferredModel || capabilities.ollama.models[0]?.name || "llama3.2:3b";
+        return createInferenceClient("ollama", model);
+    }
+    if (capabilities.recommended === "browser") {
+        const model = preferredModel || BROWSER_MODELS[0]?.id || "Xenova/distilgpt2";
+        return createInferenceClient("browser", model);
+    }
+    return createInferenceClient("demo", "demo-model");
+}
+// Re-export types and utilities
+export { detectOllama, listOllamaModels, OllamaClient } from "./ollama-client";
+export { BrowserInference, checkWebGPU, BROWSER_MODELS } from "./browser-inference";
+export { InferenceFactory, createInferenceFactory, detectBestMethodForConfig, } from "./inference-factory";
+export { createCapabilityDetectionService, DefaultCapabilityDetectionService, EnhancedCapabilityDetectionService, } from "./capability-detection";