forkit-connect 0.1.0

package/dist/v1/providers.d.ts

@@ -0,0 +1,50 @@
+import type { DetectedModel, DetectedRuntime, RuntimeType, SourceLabel } from './types';
+export interface RuntimeProviderScanResult {
+    ok: boolean;
+    runtime: DetectedRuntime;
+    models: DetectedModel[];
+    error: string | null;
+}
+export interface RuntimeProvider {
+    readonly runtimeName: string;
+    readonly runtimeType: RuntimeType;
+    readonly endpoint: string;
+    scan(): Promise<RuntimeProviderScanResult>;
+}
+export interface ScanAggregateResult {
+    ok: boolean;
+    runtimes: DetectedRuntime[];
+    models: DetectedModel[];
+    results: RuntimeProviderScanResult[];
+}
+export interface NormalizeDetectedModelInput {
+    runtimeName: string;
+    runtimeType: RuntimeType;
+    modelName: string;
+    modelId?: string | null;
+    sourceEndpoint: string;
+    detectedAt: string;
+    digest: string;
+    sizeBytes?: number;
+    modifiedAt?: string | null;
+    sourceLabel?: SourceLabel;
+    metadata?: Record<string, unknown>;
+    checksumValue?: string | null;
+    checksumAlgorithm?: 'sha256' | null;
+    checksumSource?: 'manifest' | 'weights_blob' | 'file_hash' | null;
+    quantizationLevel?: string | null;
+    architectureFamily?: string | null;
+    parameterSize?: string | null;
+}
+export declare function normalizeDetectedModel(input: NormalizeDetectedModelInput): DetectedModel;
+export declare function buildDetectedRuntime(input: {
+    runtimeName: string;
+    runtimeType: RuntimeType;
+    endpoint: string;
+    status: 'detected' | 'connected' | 'error';
+    lastSeenAt: string;
+    error?: string | null;
+    sourceLabel?: SourceLabel;
+}): DetectedRuntime;
+export declare function scanProviders(providers: RuntimeProvider[]): Promise<ScanAggregateResult>;
+//# sourceMappingURL=providers.d.ts.map

package/dist/v1/providers.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeDetectedModel = normalizeDetectedModel;
+exports.buildDetectedRuntime = buildDetectedRuntime;
+exports.scanProviders = scanProviders;
+const discovery_1 = require("./discovery");
+function normalizeDetectedModel(input) {
+    const sourceLabel = input.sourceLabel ?? 'Verified by Runtime';
+    const modelId = input.modelId ?? null;
+    const metadata = input.metadata ?? {};
+    return {
+        runtime: input.runtimeName,
+        runtimeName: input.runtimeName,
+        runtimeType: input.runtimeType,
+        model: input.modelName,
+        modelId,
+        discoveryHash: '',
+        discoverySources: ['provider_scan'],
+        digest: input.digest,
+        sizeBytes: Number(input.sizeBytes ?? 0),
+        modifiedAt: input.modifiedAt ?? null,
+        sourceEndpoint: input.sourceEndpoint,
+        sourceLabel,
+        status: 'detected',
+        detectedAt: input.detectedAt,
+        runtime_name: input.runtimeName,
+        runtime_type: input.runtimeType,
+        model_name: input.modelName,
+        model_id: modelId,
+        source_endpoint: input.sourceEndpoint,
+        detected_at: input.detectedAt,
+        metadata,
+        checksumValue: input.checksumValue ?? null,
+        checksumAlgorithm: input.checksumAlgorithm ?? null,
+        checksumSource: input.checksumSource ?? null,
+        quantizationLevel: input.quantizationLevel ?? null,
+        architectureFamily: input.architectureFamily ?? null,
+        parameterSize: input.parameterSize ?? null,
+    };
+}
+function buildDetectedRuntime(input) {
+    return {
+        runtime: input.runtimeName,
+        runtimeName: input.runtimeName,
+        runtimeType: input.runtimeType,
+        endpoint: input.endpoint,
+        discoveryHash: '',
+        discoverySources: ['provider_scan'],
+        sourceLabel: input.sourceLabel ?? 'Verified by Runtime',
+        status: input.status,
+        lastSeenAt: input.lastSeenAt,
+        error: input.error ?? null,
+    };
+}
+function dedupeDetectedModels(models) {
+    const seen = new Map();
+    for (const model of models) {
+        seen.set(model.discoveryHash || `${model.runtime}#${model.model}#${model.digest}`, model);
+    }
+    return [...seen.values()];
+}
+function runtimeStatusRank(status) {
+    switch (status) {
+        case 'connected':
+            return 3;
+        case 'detected':
+            return 2;
+        case 'error':
+        default:
+            return 1;
+    }
+}
+function dedupeDetectedRuntimes(runtimes) {
+    const seen = new Map();
+    for (const runtime of runtimes) {
+        const key = `${runtime.runtime}#${runtime.runtimeType}#${(0, discovery_1.buildEndpointHash)(runtime.endpoint)}`;
+        const existing = seen.get(key);
+        if (!existing) {
+            seen.set(key, runtime);
+            continue;
+        }
+        const next = runtimeStatusRank(runtime.status) >= runtimeStatusRank(existing.status) ? runtime : existing;
+        seen.set(key, {
+            ...next,
+            discoverySources: [...new Set([...(existing.discoverySources || []), ...(runtime.discoverySources || [])])],
+            lastSeenAt: new Date(existing.lastSeenAt).getTime() >= new Date(runtime.lastSeenAt).getTime()
+                ? existing.lastSeenAt
+                : runtime.lastSeenAt,
+            error: next.error ?? existing.error ?? runtime.error ?? null,
+        });
+    }
+    return [...seen.values()];
+}
+async function scanProviders(providers) {
+    const results = await Promise.all(providers.map((provider) => provider.scan()));
+    const runtimes = dedupeDetectedRuntimes(results.map((result) => result.runtime));
+    const models = dedupeDetectedModels(results.flatMap((result) => result.models));
+    const ok = results.some((result) => result.ok);
+    return {
+        ok,
+        runtimes,
+        models,
+        results,
+    };
+}
+//# sourceMappingURL=providers.js.map