@realtimex/folio 0.1.2

package/dist/api/src/services/ModelCapabilityService.js

@@ -0,0 +1,179 @@
+import { createLogger } from "../utils/logger.js";
+import { SDKService } from "./SDKService.js";
+const logger = createLogger("ModelCapabilityService");
+export class ModelCapabilityService {
+    static SUPPORTED_TTL_DAYS = 180;
+    static UNSUPPORTED_TTL_DAYS = 30;
+    static resolveVisionSupport(settingsRow) {
+        const provider = (settingsRow?.llm_provider || SDKService.DEFAULT_LLM_PROVIDER).trim();
+        const model = (settingsRow?.llm_model || SDKService.DEFAULT_LLM_MODEL).trim();
+        const state = this.getVisionState(settingsRow?.vision_model_capabilities, provider, model);
+        return {
+            provider,
+            model,
+            state,
+            shouldAttempt: state !== "unsupported",
+        };
+    }
+    static getVisionState(rawMap, provider, model) {
+        const map = this.normalizeCapabilityMap(rawMap);
+        const entry = map[this.capabilityKey(provider, model)];
+        if (!entry)
+            return "unknown";
+        if (entry.expires_at) {
+            const expiryTs = Date.parse(entry.expires_at);
+            if (Number.isFinite(expiryTs) && expiryTs <= Date.now()) {
+                return "unknown";
+            }
+        }
+        return entry.state;
+    }
+    static async learnVisionSuccess(opts) {
+        await this.writeCapability({
+            ...opts,
+            state: "supported",
+            reason: "vision_request_succeeded",
+            ttlDays: this.SUPPORTED_TTL_DAYS,
+        });
+    }
+    static async learnVisionFailure(opts) {
+        const classification = this.classifyVisionFailure(opts.error);
+        if (!classification.isCapabilityError) {
+            logger.info(`Vision failure for ${opts.provider}/${opts.model} treated as transient; leaving capability unknown`, {
+                reason: classification.reason,
+            });
+            return "unknown";
+        }
+        await this.writeCapability({
+            supabase: opts.supabase,
+            userId: opts.userId,
+            provider: opts.provider,
+            model: opts.model,
+            state: "unsupported",
+            reason: classification.reason,
+            ttlDays: this.UNSUPPORTED_TTL_DAYS,
+        });
+        return "unsupported";
+    }
+    static async writeCapability(opts) {
+        const { supabase, userId, provider, model, state, reason, ttlDays } = opts;
+        const { data, error: readErr } = await supabase
+            .from("user_settings")
+            .select("vision_model_capabilities")
+            .eq("user_id", userId)
+            .maybeSingle();
+        if (readErr) {
+            logger.warn("Failed to read user_settings for model capability write", { userId, readErr });
+            return;
+        }
+        const map = this.normalizeCapabilityMap(data?.vision_model_capabilities);
+        const now = new Date();
+        const expiresAt = new Date(now.getTime() + ttlDays * 24 * 60 * 60 * 1000).toISOString();
+        map[this.capabilityKey(provider, model)] = {
+            state,
+            learned_at: now.toISOString(),
+            expires_at: expiresAt,
+            reason,
+        };
+        const { error: writeErr } = await supabase
+            .from("user_settings")
+            .upsert({
+            user_id: userId,
+            vision_model_capabilities: map,
+        }, { onConflict: "user_id" });
+        if (writeErr) {
+            logger.warn("Failed to persist model capability state", { userId, provider, model, state, writeErr });
+            return;
+        }
+        logger.info(`Updated model capability for ${provider}/${model}: ${state}`, { reason, ttlDays });
+    }
+    static normalizeCapabilityMap(rawMap) {
+        if (!rawMap || typeof rawMap !== "object" || Array.isArray(rawMap)) {
+            return {};
+        }
+        const parsed = rawMap;
+        const normalized = {};
+        for (const [key, value] of Object.entries(parsed)) {
+            if (!value || typeof value !== "object" || Array.isArray(value)) {
+                continue;
+            }
+            const state = String(value.state || "");
+            if (state !== "supported" && state !== "unsupported") {
+                continue;
+            }
+            const learnedAt = value.learned_at;
+            const expiresAt = value.expires_at;
+            const reason = value.reason;
+            normalized[key] = {
+                state,
+                learned_at: typeof learnedAt === "string" ? learnedAt : new Date(0).toISOString(),
+                expires_at: typeof expiresAt === "string" ? expiresAt : undefined,
+                reason: typeof reason === "string" ? reason : undefined,
+            };
+        }
+        return normalized;
+    }
+    static capabilityKey(provider, model) {
+        return `${provider.toLowerCase().trim()}:${model.toLowerCase().trim()}`;
+    }
+    static classifyVisionFailure(error) {
+        const message = this.errorToMessage(error).toLowerCase();
+        if (!message)
+            return { isCapabilityError: false, reason: "empty_error" };
+        const capabilityHints = [
+            "image_url",
+            "vision",
+            "multimodal",
+            "multi-modal",
+            "unsupported content type",
+            "unsupported message content",
+            "does not support images",
+            "model does not support image",
+            "invalid content type",
+            "invalid image",
+            "unrecognized content type",
+        ];
+        if (capabilityHints.some((hint) => message.includes(hint))) {
+            return { isCapabilityError: true, reason: "capability_mismatch" };
+        }
+        const transientHints = [
+            "timeout",
+            "timed out",
+            "rate limit",
+            "too many requests",
+            "429",
+            "503",
+            "502",
+            "504",
+            "service unavailable",
+            "temporar",
+            "network",
+            "connection",
+            "unauthorized",
+            "forbidden",
+            "invalid api key",
+        ];
+        if (transientHints.some((hint) => message.includes(hint))) {
+            return { isCapabilityError: false, reason: "transient_or_auth" };
+        }
+        return { isCapabilityError: false, reason: "unknown_error_class" };
+    }
+    static errorToMessage(error) {
+        if (error instanceof Error)
+            return error.message;
+        if (typeof error === "string")
+            return error;
+        if (error && typeof error === "object") {
+            const candidate = error;
+            if (typeof candidate.message === "string")
+                return candidate.message;
+            try {
+                return JSON.stringify(error);
+            }
+            catch {
+                return String(error);
+            }
+        }
+        return String(error ?? "");
+    }
+}