memryx-shim-provider

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.normalizeBaseUrl = normalizeBaseUrl;
exports.buildInventoryUrl = buildInventoryUrl;
exports.buildModelServiceStateUrl = buildModelServiceStateUrl;
exports.isGeneratorCapableModel = isGeneratorCapableModel;
exports.isEmbeddingCapableModel = isEmbeddingCapableModel;
exports.buildHostedDisplayName = buildHostedDisplayName;
exports.extractGeneratorModels = extractGeneratorModels;
exports.extractEmbeddingModels = extractEmbeddingModels;
exports.extractActiveGeneratorModelsFromState = extractActiveGeneratorModelsFromState;
exports.fetchGeneratorModelIds = fetchGeneratorModelIds;
exports.fetchEmbedModelIds = fetchEmbedModelIds;
exports.fetchPreferredHostedModelId = fetchPreferredHostedModelId;
const node_http_1 = __importDefault(require("node:http"));
const node_https_1 = __importDefault(require("node:https"));
const REQUEST_TIMEOUT_MS = 15000;
function normalizeBaseUrl(rawBaseUrl) {
    const trimmed = rawBaseUrl.replace(/\/+$/g, "");
    if (!trimmed)
        return "";
    if (trimmed.endsWith("/v1"))
        return trimmed;
    return `${trimmed}/v1`;
}
function buildInventoryUrl(rawBaseUrl, inventoryMode) {
    const apiBase = normalizeBaseUrl(rawBaseUrl);
    if (!apiBase)
        return "";
    const modelsBase = `${apiBase}/models`;
    return inventoryMode === "aggregate" ? modelsBase : `${modelsBase}?health=1`;
}
function buildModelServiceStateUrl(rawBaseUrl) {
    const apiBase = normalizeBaseUrl(rawBaseUrl);
    if (!apiBase)
        return "";
    return `${apiBase.replace(/\/v1$/i, "")}/api/model-service/state`;
}
function isGeneratorCapableModel(candidate) {
    const capability = String(candidate?.metadata?.capability ?? "").trim().toLowerCase();
    if (capability === "embedding" || capability === "embeddings") {
        return false;
    }
    const capabilities = Array.isArray(candidate?.metadata?.capabilities)
        ? candidate.metadata.capabilities.map(value => String(value).trim().toLowerCase())
        : [];
    if (capabilities.includes("embedding") || capabilities.includes("embeddings")) {
        return capabilities.some(value => value === "chat" || value === "vision" || value === "tool_use");
    }
    return true;
}
function isEmbeddingCapableModel(candidate) {
    const capability = String(candidate?.metadata?.capability ?? "").trim().toLowerCase();
    if (capability === "embedding" || capability === "embeddings") {
        return true;
    }
    const capabilities = Array.isArray(candidate?.metadata?.capabilities)
        ? candidate.metadata.capabilities.map(value => String(value).trim().toLowerCase())
        : [];
    return capabilities.includes("embedding") || capabilities.includes("embeddings");
}
function buildHostedDisplayName(model) {
    const explicit = String(model.displayName ?? "").trim();
    const base = explicit.length > 0 ? explicit : model.id;
    const prefixedBase = base.startsWith("MemryX Shim Hosted ::")
        ? base
        : `MemryX Shim Hosted :: ${base}`;
    const details = [
        String(model.metadata?.accelerator_plane ?? "").trim(),
        String(model.metadata?.backend ?? "").trim(),
        String(model.metadata?.capability ?? "").trim(),
        String(model.owned_by ?? "").trim(),
    ].filter(Boolean);
    if (details.length > 0) {
        return `${prefixedBase} [${details.slice(0, 4).join(" | ")}]`;
    }
    return prefixedBase;
}
function extractGeneratorModels(payload) {
    const candidates = Array.isArray(payload?.data)
        ? payload.data
        : Array.isArray(payload?.models)
            ? payload.models
            : [];
    const models = [];
    const seen = new Set();
    for (const candidate of candidates) {
        if (typeof candidate === "string" && candidate.length > 0) {
            if (seen.has(candidate)) {
                continue;
            }
            seen.add(candidate);
            models.push({
                id: candidate,
                displayName: `MemryX Shim Hosted :: ${candidate}`,
            });
            continue;
        }
        if (candidate && typeof candidate === "object" && typeof candidate.id === "string") {
            if (!isGeneratorCapableModel(candidate)) {
                continue;
            }
            const id = candidate.id.trim();
            if (id.length > 0 && !seen.has(id)) {
                seen.add(id);
                const normalized = {
                    id,
                    displayName: buildHostedDisplayName({
                        id,
                        displayName: candidate.displayName,
                        owned_by: candidate.owned_by,
                        metadata: candidate.metadata,
                    }),
                    owned_by: typeof candidate.owned_by === "string" ? candidate.owned_by.trim() || undefined : undefined,
                    metadata: candidate.metadata,
                };
                models.push(normalized);
            }
        }
    }
    return models;
}
function extractEmbeddingModels(payload) {
    const candidates = Array.isArray(payload?.data)
        ? payload.data
        : Array.isArray(payload?.models)
            ? payload.models
            : [];
    const models = [];
    const seen = new Set();
    for (const candidate of candidates) {
        if (typeof candidate === "string" && candidate.length > 0) {
            if (seen.has(candidate)) {
                continue;
            }
            seen.add(candidate);
            models.push({
                id: candidate,
                displayName: `MemryX Shim Embed :: ${candidate}`,
            });
            continue;
        }
        if (candidate && typeof candidate === "object" && typeof candidate.id === "string") {
            if (!isEmbeddingCapableModel(candidate)) {
                continue;
            }
            const id = candidate.id.trim();
            if (id.length > 0 && !seen.has(id)) {
                seen.add(id);
                models.push({
                    id,
                    displayName: buildHostedDisplayName({
                        id,
                        displayName: candidate.displayName,
                        owned_by: candidate.owned_by,
                        metadata: candidate.metadata,
                    }).replace(/^MemryX Shim Hosted :: /, "MemryX Shim Embed :: "),
                    owned_by: typeof candidate.owned_by === "string" ? candidate.owned_by.trim() || undefined : undefined,
                    metadata: candidate.metadata,
                });
            }
        }
    }
    return models;
}
function isActiveShimManagedModel(candidate) {
    const id = String(candidate?.id ?? "").trim();
    if (!id || candidate?.loaded !== true) {
        return false;
    }
    const source = String(candidate?.source ?? "").trim().toLowerCase();
    const lane = String(candidate?.lane ?? "").trim().toLowerCase();
    return (source === "shim_hosted" ||
        source === "radeon" ||
        lane === "hetero_vulkan" ||
        lane.startsWith("radeon_"));
}
function extractActiveGeneratorModelsFromState(payload) {
    const selectedModelId = String(payload?.selected_model_id ?? "").trim().toLowerCase();
    const hostedCandidates = Array.isArray(payload?.hosted_candidates) ? payload.hosted_candidates : [];
    const hostedById = new Map(hostedCandidates
        .map(candidate => {
        const id = String(candidate?.id ?? "").trim();
        return id ? [id.toLowerCase(), candidate] : undefined;
    })
        .filter((value) => Boolean(value)));
    const activeRows = Array.isArray(payload?.loaded_models)
        ? payload.loaded_models.filter(candidate => isActiveShimManagedModel(candidate))
        : [];
    const normalizedRows = activeRows.map(row => {
        const id = String(row?.id ?? "").trim();
        const hostedCandidate = hostedById.get(id.toLowerCase());
        return {
            ...hostedCandidate,
            ...row,
            id,
            displayName: String(row?.displayName ?? row?.display_name ?? hostedCandidate?.displayName ?? hostedCandidate?.display_name ?? id).trim() ||
                id,
            owned_by: String(row?.owned_by ?? hostedCandidate?.owned_by ?? "").trim() || undefined,
            metadata: row?.metadata && typeof row.metadata === "object"
                ? row.metadata
                : hostedCandidate?.metadata,
        };
    });
    const extracted = extractGeneratorModels({ data: normalizedRows });
    if (extracted.length > 0) {
        return extracted;
    }
    if (!selectedModelId) {
        return [];
    }
    const selectedCandidate = hostedById.get(selectedModelId);
    if (!selectedCandidate) {
        return [];
    }
    return extractGeneratorModels({
        data: [
            {
                ...selectedCandidate,
                id: String(selectedCandidate.id ?? "").trim(),
                displayName: String(selectedCandidate.displayName ?? selectedCandidate.display_name ?? selectedCandidate.id ?? "").trim() ||
                    String(selectedCandidate.id ?? "").trim(),
                loaded: true,
                source: String(selectedCandidate.source ?? "shim_hosted").trim() || "shim_hosted",
                lane: String(selectedCandidate.lane ?? "hetero_vulkan").trim() || "hetero_vulkan",
                status: String(selectedCandidate.status ?? "ready").trim() || "ready",
            },
        ],
    });
}
async function fetchGeneratorModelIds(rawBaseUrl, inventoryMode) {
    const stateUrl = buildModelServiceStateUrl(rawBaseUrl);
    const inventoryUrl = buildInventoryUrl(rawBaseUrl, inventoryMode);
    if (!stateUrl && !inventoryUrl) {
        return { inventoryUrl: "", models: [] };
    }
    if (stateUrl) {
        try {
            const statePayload = (await requestJson(stateUrl));
            const activeModels = extractActiveGeneratorModelsFromState(statePayload);
            if (activeModels.length > 0 || !inventoryUrl) {
                return {
                    inventoryUrl: stateUrl,
                    models: activeModels,
                };
            }
        }
        catch {
            // Fall back to the broader inventory probe when loaded-state probing fails.
        }
    }
    if (!inventoryUrl) {
        return { inventoryUrl: stateUrl || "", models: [] };
    }
    const payload = await requestJson(inventoryUrl);
    return { inventoryUrl, models: extractGeneratorModels(payload) };
}
async function fetchEmbedModelIds(rawBaseUrl, inventoryMode) {
    const stateUrl = buildModelServiceStateUrl(rawBaseUrl);
    const inventoryUrl = buildInventoryUrl(rawBaseUrl, inventoryMode);
    if (!stateUrl && !inventoryUrl) {
        return { inventoryUrl: "", models: [] };
    }
    if (stateUrl) {
        try {
            const statePayload = (await requestJson(stateUrl));
            const loadedModels = Array.isArray(statePayload?.loaded_models) ? statePayload.loaded_models : [];
            const embedded = extractEmbeddingModels({
                data: loadedModels.map(model => ({
                    id: String(model?.id ?? "").trim(),
                    displayName: String(model?.display_name ?? model?.displayName ?? model?.id ?? "").trim(),
                    owned_by: String(model?.metadata?.provider_plane ?? model?.owned_by ?? "").trim() || undefined,
                    metadata: model?.metadata,
                })),
            });
            if (embedded.length > 0 || !inventoryUrl) {
                return {
                    inventoryUrl: stateUrl,
                    models: embedded,
                };
            }
        }
        catch {
            // Fall back to the broader inventory probe when loaded-state probing fails.
        }
    }
    if (!inventoryUrl) {
        return { inventoryUrl: stateUrl || "", models: [] };
    }
    const payload = await requestJson(inventoryUrl);
    return { inventoryUrl, models: extractEmbeddingModels(payload) };
}
async function fetchPreferredHostedModelId(rawBaseUrl) {
    const apiBase = normalizeBaseUrl(rawBaseUrl);
    if (!apiBase) {
        return undefined;
    }
    const rootBase = apiBase.replace(/\/v1$/i, "");
    if (!rootBase) {
        return undefined;
    }
    const payload = (await requestJson(`${rootBase}/api/model-service/state`));
    const selected = typeof payload?.selected_model_id === "string" ? payload.selected_model_id.trim() : "";
    if (selected.length > 0) {
        return selected;
    }
    const loadedHosted = Array.isArray(payload?.loaded_models)
        ? payload.loaded_models.find(candidate => {
            const source = String(candidate?.source ?? "").trim().toLowerCase();
            const id = String(candidate?.id ?? "").trim();
            const status = String(candidate?.status ?? "").trim().toLowerCase();
            return source === "shim_hosted" && id.length > 0 && (candidate?.loaded ?? false) && status === "ready";
        })
        : undefined;
    const hostedId = typeof loadedHosted?.id === "string" ? loadedHosted.id.trim() : "";
    return hostedId.length > 0 ? hostedId : undefined;
}
function requestJson(url) {
    return new Promise((resolve, reject) => {
        const parsed = new URL(url);
        const client = parsed.protocol === "https:" ? node_https_1.default : node_http_1.default;
        const req = client.request(parsed, {
            method: "GET",
            headers: {
                Accept: "application/json",
            },
        }, res => {
            const statusCode = Number(res.statusCode || 0);
            if (statusCode < 200 || statusCode >= 300) {
                res.resume();
                reject(new Error(`HTTP ${statusCode} from ${url}`));
                return;
            }
            const chunks = [];
            res.on("data", chunk => {
                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
            });
            res.on("end", () => {
                try {
                    const raw = Buffer.concat(chunks).toString("utf8");
                    resolve(JSON.parse(raw));
                }
                catch (error) {
                    reject(error instanceof Error ? error : new Error(String(error)));
                }
            });
        });
        req.setTimeout(REQUEST_TIMEOUT_MS, () => {
            req.destroy(new Error(`Request timed out after ${REQUEST_TIMEOUT_MS}ms for ${url}`));
        });
        req.on("error", reject);
        req.end();
    });
}
//# sourceMappingURL=inventory.js.map