feat(mlx): Add dynamic model registry with capability-based categories

- Add GET /api/mlx/registry endpoint to fetch model-zoo registry
- Group models by capability (chat, vision, embedding, audio, image-gen, etc.)
- Update PlannerSidebar to use dynamic MLX capability categories
- Models fetched from /api/mlx/registry?capability=X
- Supports filtering by capability type
- Removes hardcoded model lists in favor of registry-driven approach

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: KBLLR

server/routes/mlx.js

@@ -264,4 +264,88 @@ router.get('/models', async (req, res) => {
   }
 });
 
+/**
+ * GET /api/mlx/registry
+ * Fetch model-zoo registry grouped by capability
+ *
+ * Query params:
+ *   capability?: string (filter by capability: text-generation, vision, embedding, etc.)
+ *
+ * Response:
+ * {
+ *   ok: true,
+ *   categories: { [capability]: models[] },
+ *   total: number,
+ *   voices: string[],
+ *   requestId: string
+ * }
+ */
+router.get('/registry', async (req, res) => {
+  const requestId = req.requestId;
+  const { capability } = req.query;
+
+  try {
+    const fs = await import('fs/promises');
+    const path = await import('path');
+
+    // Read model-zoo registry from core-x root
+    const registryPath = path.resolve(process.cwd(), '../../model-zoo/registry.json');
+    let registry;
+
+    try {
+      const data = await fs.readFile(registryPath, 'utf-8');
+      registry = JSON.parse(data);
+    } catch (readError) {
+      // Try alternate path for avatar-labs registry
+      const altPath = path.resolve(process.cwd(), '../avatar-labs/public/models/registry.json');
+      const data = await fs.readFile(altPath, 'utf-8');
+      registry = JSON.parse(data);
+    }
+
+    // Group models by capability
+    const models = registry.models || [];
+    const categories = {};
+
+    for (const model of models) {
+      const caps = model.capabilities || [];
+      const type = model.type || 'unknown';
+
+      // Use primary capability or type
+      const primaryCap = caps[0] || type;
+
+      if (capability && primaryCap !== capability) continue;
+
+      if (!categories[primaryCap]) {
+        categories[primaryCap] = [];
+      }
+
+      categories[primaryCap].push({
+        id: model.id,
+        type: model.type,
+        capabilities: model.capabilities || [],
+        description: model.description,
+        tags: model.tags || []
+      });
+    }
+
+    res
+      .set('X-Request-ID', requestId)
+      .json({
+        ok: true,
+        categories,
+        total: models.length,
+        voices: registry.voices || [],
+        requestId
+      });
+  } catch (error) {
+    logger.error('[MLX] Registry fetch failed', { requestId, error: error.message });
+    res.status(500).json({
+      ok: false,
+      error: error.message,
+      categories: {},
+      requestId
+    });
+  }
+});
+
 export default router;

src/apps/planner/components/PlannerSidebar.jsx

@@ -86,33 +86,32 @@ function UniversityServicesList(connectedServices) {
   ];
 }
 
-function ModelProvidersList() {
-  // Local MLX model providers by capability
-  return [
-    // Text Generation
-    { id: 'mlx-llm', label: 'MLX Text', kind: 'model-provider', icon: 'chat', connected: true,
-      meta: { capability: 'text', models: ['gemma-3-4b-it', 'llama-3.1-8b', 'qwen2.5-7b', 'mistral-7b'] } },
-
-    // Vision & Multimodal
-    { id: 'mlx-vision', label: 'MLX Vision', kind: 'model-provider', icon: 'visibility', connected: true,
-      meta: { capability: 'vision', models: ['llava-1.5-7b', 'qwen-vl-chat'] } },
-
-    // Embeddings
-    { id: 'mlx-embed', label: 'MLX Embed', kind: 'model-provider', icon: 'hub', connected: true,
-      meta: { capability: 'embeddings', models: ['all-MiniLM-L6-v2', 'bge-small-en'] } },
-
-    // Speech-to-Text
-    { id: 'mlx-whisper', label: 'MLX Whisper', kind: 'model-provider', icon: 'mic', connected: true,
-      meta: { capability: 'stt', models: ['whisper-large-v3', 'whisper-medium'] } },
-
-    // Text-to-Speech
-    { id: 'mlx-tts', label: 'MLX TTS', kind: 'model-provider', icon: 'record_voice_over', connected: true,
-      meta: { capability: 'tts', models: ['kokoro-82m'] } },
+// MLX capability categories - models fetched dynamically from /api/mlx/registry
+const MLX_CAPABILITIES = [
+  { id: 'chat', capability: 'chat', label: 'Text Generation', icon: 'chat' },
+  { id: 'streaming', capability: 'streaming', label: 'Streaming LLM', icon: 'stream' },
+  { id: 'vision', capability: 'vision', label: 'Vision', icon: 'visibility' },
+  { id: 'embedding', capability: 'embedding', label: 'Embeddings', icon: 'hub' },
+  { id: 'audio-transcribe', capability: 'audio-transcribe', label: 'Speech-to-Text', icon: 'mic' },
+  { id: 'audio-generate', capability: 'audio-generate', label: 'Text-to-Speech', icon: 'record_voice_over' },
+  { id: 'image-generation', capability: 'image-generation', label: 'Image Generation', icon: 'image' },
+  { id: 'voice-cloning', capability: 'voice-cloning', label: 'Voice Cloning', icon: 'voice_over_off' },
+];
 
-    // Image Generation
-    { id: 'mlx-diffusion', label: 'MLX Diffusion', kind: 'model-provider', icon: 'image', connected: true,
-      meta: { capability: 'image-gen', models: ['sdxl-turbo', 'flux-schnell'] } },
-  ];
+function ModelProvidersList() {
+  // MLX model categories - fetches from /api/mlx/registry?capability=X
+  return MLX_CAPABILITIES.map(cap => ({
+    id: `mlx-${cap.id}`,
+    label: cap.label,
+    kind: 'model-provider',
+    icon: cap.icon,
+    connected: true,
+    meta: {
+      capability: cap.capability,
+      endpoint: `/api/mlx/registry?capability=${cap.capability}`,
+      dynamic: true // indicates models should be fetched
+    }
+  }));
 }
 
 function WorkflowsList(customWorkflows) {