@auxot/model-registry 1.1.0

package/README.md

@@ -0,0 +1,68 @@
+# @auxot/model-registry
+
+Shared model registry package for worker-cli and web applications.
+
+This package contains curated information about LLM models available for use with worker-cli, including model metadata, Hugging Face IDs, VRAM requirements, and capabilities.
+
+## Structure
+
+- `registry.json` - Generated JSON file containing model definitions (committed to repo)
+- `src/types.ts` - TypeScript type definitions
+- `src/schemas.ts` - Zod validation schemas
+- `src/loader.ts` - Runtime loader for registry.json
+- `src/query.ts` - Query functions for filtering and searching models
+- `scripts/build-registry.ts` - Build script to generate registry.json from Hugging Face
+
+## Usage
+
+```typescript
+import { loadRegistry, getModels, getModelById, suggestModelsForVRAM } from '@auxot/model-registry';
+
+// Load the registry
+const registry = loadRegistry();
+
+// Get all models
+const allModels = getModels(registry);
+
+// Filter models
+const chatModels = getModels(registry, { capabilities: ['chat'] });
+const largeModels = getModels(registry, { min_vram_gb: 20 });
+
+// Get a specific model
+const model = getModelById(registry, 'qwen2.5-coder-30b-q4_k_m');
+
+// Suggest models for VRAM budget
+const suggestions = suggestModelsForVRAM(registry, 24, 1); // 24GB VRAM, parallelism 1
+```
+
+## Building the Registry
+
+To generate or update `registry.json`, run:
+
+```bash
+pnpm --filter @auxot/model-registry run build:registry
+```
+
+This will scan Hugging Face for compatible models and generate the registry JSON file.
+
+The registry is committed to the repository, so it's available at runtime without needing to run the build script.
+
+## Registry JSON Structure
+
+See `src/types.ts` for the complete TypeScript definitions. The registry contains:
+
+- `version` - Registry version (semver)
+- `generated_at` - ISO timestamp when registry was generated
+- `models` - Array of model entries with:
+  - `id` - Unique identifier
+  - `model_name` - Normalized model name
+  - `huggingface_id` - Full Hugging Face repo ID
+  - `quantization` - Quantization level (e.g. "Q4_K_M")
+  - `family` - Model family (MoE or Dense)
+  - `parameters` - Parameter count (e.g. "30B")
+  - `default_context_size` - Default context window size
+  - `vram_requirements_gb` - Estimated VRAM needed
+  - `capabilities` - Model capabilities (chat, vision, embedding, code)
+  - `file_name` - GGUF filename
+  - `file_size_bytes` - File size (optional)
+

package/dist/src/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Model Registry Package
+ *
+ * Shared model registry for worker-cli and web applications.
+ * Contains curated information about LLM models available for use.
+ */
+export * from './types.js';
+export * from './schemas.js';
+export * from './loader.js';
+export * from './query.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,10 @@
+/**
+ * Model Registry Package
+ *
+ * Shared model registry for worker-cli and web applications.
+ * Contains curated information about LLM models available for use.
+ */
+export * from './types.js';
+export * from './schemas.js';
+export * from './loader.js';
+export * from './query.js';

package/dist/src/loader.d.ts

@@ -0,0 +1,16 @@
+import type { ModelRegistry } from './types.js';
+/**
+ * Load the model registry JSON file
+ *
+ * The registry.json file is generated by the build script and should be
+ * in the package root directory.
+ *
+ * @returns The loaded and validated model registry
+ * @throws Error if registry file cannot be loaded or is invalid
+ */
+export declare function loadRegistry(): ModelRegistry;
+/**
+ * Clear the cached registry (useful for testing or hot reloading)
+ */
+export declare function clearRegistryCache(): void;
+//# sourceMappingURL=loader.d.ts.map

package/dist/src/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAYhD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,IAAI,aAAa,CAkE5C;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAIzC"}

package/dist/src/loader.js

@@ -0,0 +1,85 @@
+import { readFileSync, statSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { validateModelRegistry } from './schemas.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Cache for loaded registry (loaded once, reused)
+ */
+let cachedRegistry = null;
+let cachedRegistryPath = null;
+let cachedRegistryMtime = null;
+/**
+ * Load the model registry JSON file
+ *
+ * The registry.json file is generated by the build script and should be
+ * in the package root directory.
+ *
+ * @returns The loaded and validated model registry
+ * @throws Error if registry file cannot be loaded or is invalid
+ */
+export function loadRegistry() {
+    // In development/build: registry.json is in package root
+    // In runtime (compiled): registry.json should be in package root (one level up from dist/src)
+    // Try package root first (for both development and runtime)
+    const registryPaths = [
+        join(__dirname, '..', '..', 'registry.json'), // From dist/src/ -> package root
+        join(__dirname, '..', 'registry.json'), // From dist/ -> package root (if running from dist/)
+        join(__dirname, 'registry.json'), // Same directory (if copied there)
+    ];
+    let registryPath = null;
+    let lastError = null;
+    // Find which registry path exists
+    for (const path of registryPaths) {
+        try {
+            statSync(path); // Check if file exists
+            registryPath = path;
+            break;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            continue;
+        }
+    }
+    if (!registryPath) {
+        throw new Error(`Failed to find registry.json. Tried: ${registryPaths.join(', ')}. ` +
+            `Last error: ${lastError?.message || 'unknown'}`);
+    }
+    // Check if file has been modified since last cache
+    try {
+        const stats = statSync(registryPath);
+        const currentMtime = stats.mtimeMs;
+        // If we have a cache and the file hasn't changed, return cached version
+        if (cachedRegistry !== null &&
+            cachedRegistryPath === registryPath &&
+            cachedRegistryMtime !== null &&
+            cachedRegistryMtime >= currentMtime) {
+            return cachedRegistry;
+        }
+        // File is new or modified, reload it
+        const content = readFileSync(registryPath, 'utf-8');
+        const registryData = JSON.parse(content);
+        // Validate the registry structure
+        const registry = validateModelRegistry(registryData);
+        // Update cache with new data and mtime
+        cachedRegistry = registry;
+        cachedRegistryPath = registryPath;
+        cachedRegistryMtime = currentMtime;
+        return registry;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to load model registry: ${error.message}`);
+        }
+        throw error;
+    }
+}
+/**
+ * Clear the cached registry (useful for testing or hot reloading)
+ */
+export function clearRegistryCache() {
+    cachedRegistry = null;
+    cachedRegistryPath = null;
+    cachedRegistryMtime = null;
+}

package/dist/src/query.d.ts

@@ -0,0 +1,25 @@
+import type { ModelRegistry, ModelRegistryEntry, ModelRegistryFilters } from './types.js';
+/**
+ * Query functions for the model registry
+ */
+/**
+ * Get all models from the registry (optionally filtered)
+ */
+export declare function getModels(registry: ModelRegistry, filters?: ModelRegistryFilters): ModelRegistryEntry[];
+/**
+ * Get a single model by ID
+ */
+export declare function getModelById(registry: ModelRegistry, id: string): ModelRegistryEntry | null;
+/**
+ * Suggest models that fit within the specified VRAM budget
+ *
+ * Returns models sorted by parameter count (larger first) that fit in the VRAM budget.
+ * Optionally allows for some parallelism (multiple models running simultaneously).
+ *
+ * @param registry The model registry
+ * @param vramGb Available VRAM in GB
+ * @param parallelism Number of models to run simultaneously (default: 1)
+ * @returns Array of suggested models, sorted by parameter count (largest first)
+ */
+export declare function suggestModelsForVRAM(registry: ModelRegistry, vramGb: number, parallelism?: number): ModelRegistryEntry[];
+//# sourceMappingURL=query.d.ts.map

package/dist/src/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAE1F;;GAEG;AAEH;;GAEG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,kBAAkB,EAAE,CAoCvG;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,aAAa,EAAE,EAAE,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAE3F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,aAAa,EACvB,MAAM,EAAE,MAAM,EACd,WAAW,GAAE,MAAU,GACtB,kBAAkB,EAAE,CAkCtB"}

package/dist/src/query.js

@@ -0,0 +1,80 @@
+/**
+ * Query functions for the model registry
+ */
+/**
+ * Get all models from the registry (optionally filtered)
+ */
+export function getModels(registry, filters) {
+    let models = registry.models;
+    if (filters) {
+        if (filters.family) {
+            models = models.filter((m) => m.family === filters.family);
+        }
+        if (filters.capabilities && filters.capabilities.length > 0) {
+            models = models.filter((m) => filters.capabilities.every((cap) => m.capabilities.includes(cap)));
+        }
+        if (filters.parameters) {
+            models = models.filter((m) => m.parameters === filters.parameters);
+        }
+        if (filters.min_vram_gb !== undefined) {
+            models = models.filter((m) => m.vram_requirements_gb >= filters.min_vram_gb);
+        }
+        if (filters.max_vram_gb !== undefined) {
+            models = models.filter((m) => m.vram_requirements_gb <= filters.max_vram_gb);
+        }
+        if (filters.model_name) {
+            const searchTerm = filters.model_name.toLowerCase();
+            models = models.filter((m) => m.model_name.toLowerCase().includes(searchTerm) ||
+                m.huggingface_id.toLowerCase().includes(searchTerm));
+        }
+    }
+    return models;
+}
+/**
+ * Get a single model by ID
+ */
+export function getModelById(registry, id) {
+    return registry.models.find((m) => m.id === id) ?? null;
+}
+/**
+ * Suggest models that fit within the specified VRAM budget
+ *
+ * Returns models sorted by parameter count (larger first) that fit in the VRAM budget.
+ * Optionally allows for some parallelism (multiple models running simultaneously).
+ *
+ * @param registry The model registry
+ * @param vramGb Available VRAM in GB
+ * @param parallelism Number of models to run simultaneously (default: 1)
+ * @returns Array of suggested models, sorted by parameter count (largest first)
+ */
+export function suggestModelsForVRAM(registry, vramGb, parallelism = 1) {
+    // Calculate effective VRAM per model (accounting for parallelism)
+    const effectiveVramPerModel = vramGb / parallelism;
+    // Filter models that fit in the effective VRAM
+    const fittingModels = registry.models.filter((m) => m.vram_requirements_gb <= effectiveVramPerModel);
+    // Sort by parameter count (largest first) then by VRAM (largest first)
+    const sorted = fittingModels.sort((a, b) => {
+        // Parse parameter count (e.g. "30B" -> 30, "7B" -> 7)
+        const parseParams = (params) => {
+            const match = params.match(/^(\d+(?:\.\d+)?)([BMK])?$/i);
+            if (!match)
+                return 0;
+            const value = parseFloat(match[1]);
+            const unit = match[2]?.toUpperCase();
+            if (unit === 'B')
+                return value * 1e9;
+            if (unit === 'M')
+                return value * 1e6;
+            if (unit === 'K')
+                return value * 1e3;
+            return value;
+        };
+        const paramsA = parseParams(a.parameters);
+        const paramsB = parseParams(b.parameters);
+        if (paramsA !== paramsB) {
+            return paramsB - paramsA; // Largest first
+        }
+        return b.vram_requirements_gb - a.vram_requirements_gb; // Largest first
+    });
+    return sorted;
+}

package/dist/src/schemas.d.ts

@@ -0,0 +1,131 @@
+import { z } from 'zod';
+import type { ModelRegistryEntry, ModelRegistry } from './types.js';
+export declare const ModelRegistryEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    model_name: z.ZodString;
+    huggingface_id: z.ZodString;
+    quantization: z.ZodString;
+    family: z.ZodEnum<["MoE", "Dense"]>;
+    parameters: z.ZodString;
+    default_context_size: z.ZodNumber;
+    max_context_size: z.ZodNumber;
+    vram_requirements_gb: z.ZodNumber;
+    capabilities: z.ZodArray<z.ZodEnum<["chat", "vision", "embedding", "code"]>, "many">;
+    file_name: z.ZodString;
+    file_size_bytes: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    model_name: string;
+    huggingface_id: string;
+    quantization: string;
+    family: "MoE" | "Dense";
+    parameters: string;
+    default_context_size: number;
+    max_context_size: number;
+    vram_requirements_gb: number;
+    capabilities: ("chat" | "vision" | "embedding" | "code")[];
+    file_name: string;
+    file_size_bytes?: number | null | undefined;
+}, {
+    id: string;
+    model_name: string;
+    huggingface_id: string;
+    quantization: string;
+    family: "MoE" | "Dense";
+    parameters: string;
+    default_context_size: number;
+    max_context_size: number;
+    vram_requirements_gb: number;
+    capabilities: ("chat" | "vision" | "embedding" | "code")[];
+    file_name: string;
+    file_size_bytes?: number | null | undefined;
+}>;
+export declare const ModelRegistrySchema: z.ZodObject<{
+    version: z.ZodString;
+    generated_at: z.ZodString;
+    models: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        model_name: z.ZodString;
+        huggingface_id: z.ZodString;
+        quantization: z.ZodString;
+        family: z.ZodEnum<["MoE", "Dense"]>;
+        parameters: z.ZodString;
+        default_context_size: z.ZodNumber;
+        max_context_size: z.ZodNumber;
+        vram_requirements_gb: z.ZodNumber;
+        capabilities: z.ZodArray<z.ZodEnum<["chat", "vision", "embedding", "code"]>, "many">;
+        file_name: z.ZodString;
+        file_size_bytes: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        model_name: string;
+        huggingface_id: string;
+        quantization: string;
+        family: "MoE" | "Dense";
+        parameters: string;
+        default_context_size: number;
+        max_context_size: number;
+        vram_requirements_gb: number;
+        capabilities: ("chat" | "vision" | "embedding" | "code")[];
+        file_name: string;
+        file_size_bytes?: number | null | undefined;
+    }, {
+        id: string;
+        model_name: string;
+        huggingface_id: string;
+        quantization: string;
+        family: "MoE" | "Dense";
+        parameters: string;
+        default_context_size: number;
+        max_context_size: number;
+        vram_requirements_gb: number;
+        capabilities: ("chat" | "vision" | "embedding" | "code")[];
+        file_name: string;
+        file_size_bytes?: number | null | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    generated_at: string;
+    models: {
+        id: string;
+        model_name: string;
+        huggingface_id: string;
+        quantization: string;
+        family: "MoE" | "Dense";
+        parameters: string;
+        default_context_size: number;
+        max_context_size: number;
+        vram_requirements_gb: number;
+        capabilities: ("chat" | "vision" | "embedding" | "code")[];
+        file_name: string;
+        file_size_bytes?: number | null | undefined;
+    }[];
+}, {
+    version: string;
+    generated_at: string;
+    models: {
+        id: string;
+        model_name: string;
+        huggingface_id: string;
+        quantization: string;
+        family: "MoE" | "Dense";
+        parameters: string;
+        default_context_size: number;
+        max_context_size: number;
+        vram_requirements_gb: number;
+        capabilities: ("chat" | "vision" | "embedding" | "code")[];
+        file_name: string;
+        file_size_bytes?: number | null | undefined;
+    }[];
+}>;
+export type ModelRegistryEntryInput = z.input<typeof ModelRegistryEntrySchema>;
+export type ModelRegistryInput = z.input<typeof ModelRegistrySchema>;
+/**
+ * Validate a model registry entry
+ */
+export declare function validateModelRegistryEntry(data: unknown): ModelRegistryEntry;
+/**
+ * Validate a complete model registry
+ */
+export declare function validateModelRegistry(data: unknown): ModelRegistry;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/src/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAwB,MAAM,YAAY,CAAC;AAY1F,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAanC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI9B,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC/E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAErE;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,OAAO,GAAG,kBAAkB,CAE5E;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,GAAG,aAAa,CAElE"}

package/dist/src/schemas.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+/**
+ * Model Registry Zod Schemas
+ *
+ * Validation schemas for the model registry JSON structure.
+ */
+const ModelCapabilitySchema = z.enum(['chat', 'vision', 'embedding', 'code']);
+const ModelFamilySchema = z.enum(['MoE', 'Dense']);
+export const ModelRegistryEntrySchema = z.object({
+    id: z.string(),
+    model_name: z.string(),
+    huggingface_id: z.string(),
+    quantization: z.string(),
+    family: ModelFamilySchema,
+    parameters: z.string(),
+    default_context_size: z.number().int().positive(),
+    max_context_size: z.number().int().positive(),
+    vram_requirements_gb: z.number().positive(),
+    capabilities: z.array(ModelCapabilitySchema).min(1),
+    file_name: z.string(),
+    file_size_bytes: z.number().int().positive().nullable().optional(),
+});
+export const ModelRegistrySchema = z.object({
+    version: z.string(),
+    generated_at: z.string(),
+    models: z.array(ModelRegistryEntrySchema),
+});
+/**
+ * Validate a model registry entry
+ */
+export function validateModelRegistryEntry(data) {
+    return ModelRegistryEntrySchema.parse(data);
+}
+/**
+ * Validate a complete model registry
+ */
+export function validateModelRegistry(data) {
+    return ModelRegistrySchema.parse(data);
+}

package/dist/src/types.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Model Registry Types
+ *
+ * Type definitions for the model registry JSON structure.
+ * The registry contains curated information about LLM models available for use with worker-cli.
+ */
+/**
+ * Model capabilities supported by workers
+ */
+export type ModelCapability = 'chat' | 'vision' | 'embedding' | 'code';
+/**
+ * Model family type (architecture)
+ */
+export type ModelFamily = 'MoE' | 'Dense';
+/**
+ * Individual model entry in the registry
+ */
+export interface ModelRegistryEntry {
+    /** Unique ID: "model-name-quantization" (e.g. "qwen2.5-coder-30b-q4_k_m") */
+    id: string;
+    /** Normalized model name (e.g. "Qwen2.5-Coder-30B") */
+    model_name: string;
+    /** Full Hugging Face repo ID (e.g. "Qwen/Qwen2.5-Coder-30B-A3B-Instruct-GGUF") */
+    huggingface_id: string;
+    /** Quantization level (e.g. "Q4_K_M", "Q8_0") */
+    quantization: string;
+    /** Model family (architecture) */
+    family: ModelFamily;
+    /** Parameter count (e.g. "30B", "7B") */
+    parameters: string;
+    /** Default context window size */
+    default_context_size: number;
+    /** Maximum context window size supported by the model */
+    max_context_size: number;
+    /** Estimated VRAM required in GB */
+    vram_requirements_gb: number;
+    /** Model capabilities */
+    capabilities: ModelCapability[];
+    /** GGUF filename pattern or exact name */
+    file_name: string;
+    /** File size in bytes (optional) */
+    file_size_bytes?: number | null;
+}
+/**
+ * Complete model registry structure
+ */
+export interface ModelRegistry {
+    /** Registry version (semver) */
+    version: string;
+    /** ISO timestamp when registry was generated */
+    generated_at: string;
+    /** List of models */
+    models: ModelRegistryEntry[];
+}
+/**
+ * Filters for querying the registry
+ */
+export interface ModelRegistryFilters {
+    /** Filter by family */
+    family?: ModelFamily;
+    /** Filter by capabilities (must have all specified) */
+    capabilities?: ModelCapability[];
+    /** Filter by parameter count (e.g. "30B") */
+    parameters?: string;
+    /** Minimum VRAM in GB */
+    min_vram_gb?: number;
+    /** Maximum VRAM in GB */
+    max_vram_gb?: number;
+    /** Filter by model name (partial match) */
+    model_name?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,QAAQ,GAAG,WAAW,GAAG,MAAM,CAAC;AAEvE;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,OAAO,CAAC;AAE1C;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,6EAA6E;IAC7E,EAAE,EAAE,MAAM,CAAC;IACX,uDAAuD;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB,kFAAkF;IAClF,cAAc,EAAE,MAAM,CAAC;IACvB,iDAAiD;IACjD,YAAY,EAAE,MAAM,CAAC;IACrB,kCAAkC;IAClC,MAAM,EAAE,WAAW,CAAC;IACpB,yCAAyC;IACzC,UAAU,EAAE,MAAM,CAAC;IACnB,kCAAkC;IAClC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,yDAAyD;IACzD,gBAAgB,EAAE,MAAM,CAAC;IACzB,oCAAoC;IACpC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,yBAAyB;IACzB,YAAY,EAAE,eAAe,EAAE,CAAC;IAChC,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,oCAAoC;IACpC,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,gCAAgC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,YAAY,EAAE,MAAM,CAAC;IACrB,qBAAqB;IACrB,MAAM,EAAE,kBAAkB,EAAE,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,uBAAuB;IACvB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,uDAAuD;IACvD,YAAY,CAAC,EAAE,eAAe,EAAE,CAAC;IACjC,6CAA6C;IAC7C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yBAAyB;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,yBAAyB;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,2CAA2C;IAC3C,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}

package/dist/src/types.js

@@ -0,0 +1,7 @@
+/**
+ * Model Registry Types
+ *
+ * Type definitions for the model registry JSON structure.
+ * The registry contains curated information about LLM models available for use with worker-cli.
+ */
+export {};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@auxot/model-registry",
+  "version": "1.1.0",
+  "type": "module",
+  "description": "Curated catalog of GGUF models for the Auxot GPU worker ecosystem",
+  "exports": {
+    ".": "./dist/src/index.js",
+    "./registry.json": "./registry.json"
+  },
+  "files": [
+    "dist/src/**/*.js",
+    "dist/src/**/*.d.ts",
+    "dist/src/**/*.d.ts.map",
+    "registry.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build:registry": "tsx scripts/build-registry.ts",
+    "patch:registry": "tsx scripts/build-registry.ts --patch",
+    "update:registry": "tsx scripts/build-registry.ts --update",
+    "build": "tsc",
+    "build:full": "pnpm run build:registry && pnpm run build"
+  },
+  "dependencies": {
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.6",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  }
+}