agentgui 1.0.309 → 1.0.310

package/CLAUDE.md

@@ -258,23 +258,113 @@ TTS      https://huggingface.co/datasets/AnEntrypoint/sttttsmodels/resolve/main/
 
 **Why Bundled Models?** Enables air-gapped deployments, reduces network load, supports edge environments with poor connectivity
 
-### Implementation Roadmap
-
-| Phase | Description | Priority |
-|-------|-------------|----------|
-| 1 | Integrate IPFS gateway discovery (default configurable) | HIGH |
-| 2 | Refactor `ensureModelsDownloaded()` to use fallback chain | HIGH |
-| 3 | Add metrics collection to download layer | HIGH |
-| 4 | Implement manifest-based version tracking | MEDIUM |
-| 5 | Add stale-while-revalidate background checks | MEDIUM |
-| 6 | Integrate bundled models option | LOW |
-| 7 | Add peer-to-peer discovery | LOW |
-
-### Critical TODOs Before Implementation
-
-1. Publish whisper-base to IPFS → obtain ipfsHash
-2. Publish TTS models to IPFS → obtain ipfsHash
-3. Create manifest templates for both models
-4. Design metrics storage schema (SQLite vs JSON)
-5. Plan background check scheduler
-6. Define dashboard UI for metrics visualization
+### Implementation Status
+
+| Phase | Description | Status | File(s) |
+|-------|-------------|--------|---------|
+| 1 | IPFS gateway discovery | ✅ DONE | `webtalk/ipfs-downloader.js` |
+| 2 | 3-layer fallback chain | ✅ DONE | `lib/model-downloader.js` |
+| 3 | Metrics collection | ✅ DONE | `lib/model-downloader.js` (JSON storage) |
+| 4 | Manifest generation with SHA-256 | ✅ DONE | Generated to `~/.gmgui/models/.manifests.json` |
+| 5 | Metrics API endpoints | ✅ DONE | `server.js` (4 endpoints added) |
+| 6 | IPFS publishing script | ✅ DONE | `scripts/publish-models-to-ipfs.js` |
+| 7 | Database IPFS tables | ✅ EXISTS | `database.js` (ipfs_cids, ipfs_downloads) |
+| 8 | Integration into ensureModels | ⏳ TODO | Need to wire into `server.js` |
+| 9 | Publish to IPFS (get real CIDs) | ⏳ TODO | Requires Pinata API keys |
+| 10 | Update database.js with real CIDs | ⏳ TODO | After publishing |
+| 11 | Stale-while-revalidate checks | 📋 FUTURE | Background job |
+| 12 | Bundled models | 📋 FUTURE | Tarball creation |
+| 13 | Peer-to-peer discovery | 📋 FUTURE | mDNS implementation |
+
+### Current Model Inventory
+
+**Models Downloaded Locally**: `~/.gmgui/models/`
+
+**Whisper Base** (280.15 MB) - 7 files:
+- `config.json` (0.00 MB) - SHA256: `f4d0608f7d918166...`
+- `tokenizer.json` (2.37 MB) - SHA256: `27fc476bfe7f1729...`
+- `tokenizer_config.json` (0.27 MB) - SHA256: `2e036e4dbacfdeb7...`
+- `onnx/encoder_model.onnx` (78.65 MB) - SHA256: `a9f3b752833b49e8...`
+- `onnx/decoder_model_merged.onnx` (198.86 MB) - SHA256: `514903744bb1b458...`
+
+**TTS Models** (189.40 MB) - 6 files:
+- `mimi_encoder.onnx` (69.78 MB) - SHA256: `360f050cd0b1e1c9...`
+- `flow_lm_main_int8.onnx` (72.81 MB) - SHA256: `fd5cdd7f7ab05f63...`
+- `mimi_decoder_int8.onnx` (21.63 MB) - SHA256: `501e16f51cf3fb91...`
+- `text_conditioner.onnx` (15.63 MB) - SHA256: `80ea69f46d8153a9...`
+- `flow_lm_flow_int8.onnx` (9.50 MB) - SHA256: `8d627d235c44a597...`
+- `tokenizer.model` (0.06 MB) - SHA256: `d461765ae1795666...`
+
+**Manifest Location**: `~/.gmgui/models/.manifests.json` (auto-generated with full SHA-256 hashes)
+
+### Next Steps to Complete Task 1C
+
+#### 1. Publish Models to IPFS (Get Real CIDs)
+
+```bash
+# Get free Pinata API keys at https://www.pinata.cloud/
+export PINATA_API_KEY=your_api_key
+export PINATA_SECRET_KEY=your_secret_key
+
+# Run publishing script
+node scripts/publish-models-to-ipfs.js
+```
+
+This will output real IPFS CIDs for both model sets.
+
+#### 2. Update database.js with Real CIDs
+
+Replace placeholder CIDs in `database.js` (lines 389-390):
+```javascript
+const WHISPER_CID = 'bafybeidyw252ecy4vs46bbmezrtw325gl2ymdltosmzqgx4edjsc3fbofy'; // PLACEHOLDER
+const TTS_CID = 'bafybeidyw252ecy4vs46bbmezrtw325gl2ymdltosmzqgx4edjsc3fbofy';     // PLACEHOLDER
+```
+
+Update with real CIDs from step 1.
+
+#### 3. Integrate Fallback Chain
+
+Modify `server.js` `ensureModelsDownloaded()` (starting line 66) to use the new 3-layer fallback:
+
+```javascript
+import { downloadWithFallback } from './lib/model-downloader.js';
+import { queries } from './database.js';
+
+// Get IPFS CIDs from database
+const whisperCidRecord = queries.getIpfsCidByModel('whisper-base', 'stt');
+const ttsCidRecord = queries.getIpfsCidByModel('tts', 'voice');
+
+// Load manifest
+const manifestPath = path.join(modelsDir, '.manifests.json');
+const manifests = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+
+// For each required file, use fallback chain:
+for (const [filename, fileInfo] of Object.entries(manifests['whisper-base'].files)) {
+  const destPath = path.join(whisperDir, filename);
+  await downloadWithFallback({
+    ipfsCid: `${whisperCidRecord.cid}/${filename}`,
+    huggingfaceUrl: `https://huggingface.co/onnx-community/whisper-base/resolve/main/${filename}`,
+    destPath,
+    manifest: fileInfo,
+    minBytes: fileInfo.size * 0.8,
+    preferredLayer: 'ipfs'
+  }, (progress) => {
+    broadcastModelProgress({ ...progress, file: filename, type: 'whisper' });
+  });
+}
+```
+
+### Metrics API Endpoints (Live)
+
+- `GET /gm/api/metrics/downloads` - All download metrics (last 24 hours)
+- `GET /gm/api/metrics/downloads/summary` - Aggregated statistics
+- `GET /gm/api/metrics/downloads/health` - Per-layer health status (success rates, latency)
+- `POST /gm/api/metrics/downloads/reset` - Clear metrics history
+
+### Architecture Files Created
+
+- `lib/model-downloader.js` - 3-layer fallback implementation with metrics
+- `lib/ipfs-publish.js` - Local IPFS publishing (requires kubo)
+- `scripts/publish-models-to-ipfs.js` - Pinata-based publishing (no local IPFS needed)
+- `~/.gmgui/models/.manifests.json` - Auto-generated with SHA-256 hashes
+- `~/.gmgui/models/.metrics.json` - Download metrics (auto-rotated daily)

package/lib/ipfs-publish.js

@@ -0,0 +1,136 @@
+import { createRequire } from 'module';
+import { create } from 'ipfs-http-client';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const require = createRequire(import.meta.url);
+
+export async function publishToIPFS(dirPath, options = {}) {
+  const {
+    gateway = '/ip4/127.0.0.1/tcp/5001',
+    pinToServices = ['pinata', 'lighthouse'],
+    onProgress = null
+  } = options;
+
+  try {
+    const ipfs = create({ url: gateway });
+
+    const dir = path.resolve(dirPath);
+    if (!fs.existsSync(dir)) {
+      throw new Error(`Directory not found: ${dir}`);
+    }
+
+    const files = [];
+    function addFiles(currentPath, basePath) {
+      const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(currentPath, entry.name);
+        const relativePath = path.relative(basePath, fullPath);
+
+        if (entry.isDirectory()) {
+          addFiles(fullPath, basePath);
+        } else {
+          files.push({
+            path: relativePath,
+            content: fs.readFileSync(fullPath)
+          });
+        }
+      }
+    }
+
+    addFiles(dir, dir);
+
+    if (onProgress) {
+      onProgress({ status: 'preparing', fileCount: files.length });
+    }
+
+    let uploadedCount = 0;
+    const results = [];
+
+    for await (const result of ipfs.addAll(files, { wrapWithDirectory: true, pin: true })) {
+      uploadedCount++;
+      results.push(result);
+
+      if (onProgress && result.path !== '') {
+        onProgress({
+          status: 'uploading',
+          file: result.path,
+          cid: result.cid.toString(),
+          uploaded: uploadedCount,
+          total: files.length
+        });
+      }
+    }
+
+    const rootCID = results[results.length - 1].cid.toString();
+
+    if (onProgress) {
+      onProgress({
+        status: 'complete',
+        rootCID,
+        fileCount: files.length,
+        results
+      });
+    }
+
+    return {
+      rootCID,
+      files: results.filter(r => r.path !== '').map(r => ({
+        path: r.path,
+        cid: r.cid.toString(),
+        size: r.size
+      }))
+    };
+  } catch (error) {
+    throw new Error(`IPFS publish failed: ${error.message}`);
+  }
+}
+
+export async function publishModels() {
+  const modelsDir = path.join(os.homedir(), '.gmgui', 'models');
+  const whisperDir = path.join(modelsDir, 'onnx-community', 'whisper-base');
+  const ttsDir = path.join(modelsDir, 'tts');
+
+  console.log('Publishing models to IPFS...\n');
+
+  const results = {};
+
+  if (fs.existsSync(whisperDir)) {
+    console.log('Publishing Whisper models...');
+    try {
+      const whisperResult = await publishToIPFS(whisperDir, {
+        onProgress: (progress) => {
+          if (progress.status === 'uploading') {
+            console.log(`  ${progress.uploaded}/${progress.total}: ${progress.file}`);
+          } else if (progress.status === 'complete') {
+            console.log(`✓ Whisper CID: ${progress.rootCID}\n`);
+          }
+        }
+      });
+      results.whisper = whisperResult;
+    } catch (error) {
+      console.error(`✗ Whisper publish failed: ${error.message}`);
+    }
+  }
+
+  if (fs.existsSync(ttsDir)) {
+    console.log('Publishing TTS models...');
+    try {
+      const ttsResult = await publishToIPFS(ttsDir, {
+        onProgress: (progress) => {
+          if (progress.status === 'uploading') {
+            console.log(`  ${progress.uploaded}/${progress.total}: ${progress.file}`);
+          } else if (progress.status === 'complete') {
+            console.log(`✓ TTS CID: ${progress.rootCID}\n`);
+          }
+        }
+      });
+      results.tts = ttsResult;
+    } catch (error) {
+      console.error(`✗ TTS publish failed: ${error.message}`);
+    }
+  }
+
+  return results;
+}

package/lib/model-downloader.js

@@ -0,0 +1,288 @@
+import { createRequire } from 'module';
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import os from 'os';
+
+const require = createRequire(import.meta.url);
+
+const GATEWAYS = [
+  'https://cloudflare-ipfs.com/ipfs/',
+  'https://dweb.link/ipfs/',
+  'https://gateway.pinata.cloud/ipfs/',
+  'https://ipfs.io/ipfs/'
+];
+
+const METRICS_PATH = path.join(os.homedir(), '.gmgui', 'models', '.metrics.json');
+
+function recordMetric(metric) {
+  const metricsDir = path.dirname(METRICS_PATH);
+  if (!fs.existsSync(metricsDir)) {
+    fs.mkdirSync(metricsDir, { recursive: true });
+  }
+
+  let metrics = [];
+  if (fs.existsSync(METRICS_PATH)) {
+    try {
+      metrics = JSON.parse(fs.readFileSync(METRICS_PATH, 'utf8'));
+    } catch (e) {
+      metrics = [];
+    }
+  }
+
+  metrics.push({
+    ...metric,
+    timestamp: new Date().toISOString()
+  });
+
+  const oneDayAgo = Date.now() - 24 * 60 * 60 * 1000;
+  metrics = metrics.filter(m => new Date(m.timestamp).getTime() > oneDayAgo);
+
+  fs.writeFileSync(METRICS_PATH, JSON.stringify(metrics, null, 2));
+}
+
+function verifyFileIntegrity(filepath, expectedHash, minBytes) {
+  if (!fs.existsSync(filepath)) {
+    return { valid: false, reason: 'file_not_found' };
+  }
+
+  const stats = fs.statSync(filepath);
+  if (minBytes && stats.size < minBytes) {
+    return { valid: false, reason: 'size_too_small', actual: stats.size, expected: minBytes };
+  }
+
+  if (expectedHash) {
+    const hash = crypto.createHash('sha256');
+    const data = fs.readFileSync(filepath);
+    hash.update(data);
+    const actualHash = hash.digest('hex');
+
+    if (actualHash !== expectedHash) {
+      return { valid: false, reason: 'hash_mismatch', actual: actualHash, expected: expectedHash };
+    }
+  }
+
+  return { valid: true };
+}
+
+async function downloadFromIPFS(cid, destPath, manifest, onProgress) {
+  const startTime = Date.now();
+
+  for (let gatewayIndex = 0; gatewayIndex < GATEWAYS.length; gatewayIndex++) {
+    const gateway = GATEWAYS[gatewayIndex];
+    const gatewayName = new URL(gateway).hostname;
+
+    for (let retry = 0; retry < 2; retry++) {
+      try {
+        if (onProgress) {
+          onProgress({
+            layer: 'ipfs',
+            gateway: gatewayName,
+            attempt: retry + 1,
+            status: 'attempting'
+          });
+        }
+
+        const { downloadWithProgress } = require('webtalk/ipfs-downloader');
+        const url = `${gateway}${cid}`;
+
+        await downloadWithProgress(url, destPath, (progress) => {
+          if (onProgress) {
+            onProgress({
+              layer: 'ipfs',
+              gateway: gatewayName,
+              status: 'downloading',
+              ...progress
+            });
+          }
+        });
+
+        const verification = verifyFileIntegrity(
+          destPath,
+          manifest?.sha256,
+          manifest?.size ? manifest.size * 0.8 : null
+        );
+
+        if (!verification.valid) {
+          if (fs.existsSync(destPath)) fs.unlinkSync(destPath);
+          throw new Error(`Verification failed: ${verification.reason}`);
+        }
+
+        recordMetric({
+          modelType: 'model',
+          layer: 'ipfs',
+          gateway: gatewayName,
+          status: 'success',
+          latency_ms: Date.now() - startTime,
+          bytes_downloaded: fs.statSync(destPath).size
+        });
+
+        return { success: true, source: 'ipfs', gateway: gatewayName };
+      } catch (error) {
+        recordMetric({
+          modelType: 'model',
+          layer: 'ipfs',
+          gateway: gatewayName,
+          status: 'error',
+          error_type: error.name,
+          error_message: error.message,
+          latency_ms: Date.now() - startTime
+        });
+
+        if (retry < 1) {
+          await new Promise(resolve => setTimeout(resolve, 1000 * (retry + 1)));
+        }
+      }
+    }
+  }
+
+  throw new Error('All IPFS gateways exhausted');
+}
+
+async function downloadFromHuggingFace(url, destPath, minBytes, onProgress) {
+  const startTime = Date.now();
+
+  try {
+    if (onProgress) {
+      onProgress({
+        layer: 'huggingface',
+        status: 'attempting'
+      });
+    }
+
+    const { downloadFile } = require('webtalk/whisper-models');
+    await downloadFile(url, destPath);
+
+    const verification = verifyFileIntegrity(destPath, null, minBytes);
+    if (!verification.valid) {
+      if (fs.existsSync(destPath)) fs.unlinkSync(destPath);
+      throw new Error(`Verification failed: ${verification.reason}`);
+    }
+
+    recordMetric({
+      modelType: 'model',
+      layer: 'huggingface',
+      status: 'success',
+      latency_ms: Date.now() - startTime,
+      bytes_downloaded: fs.statSync(destPath).size
+    });
+
+    return { success: true, source: 'huggingface' };
+  } catch (error) {
+    recordMetric({
+      modelType: 'model',
+      layer: 'huggingface',
+      status: 'error',
+      error_type: error.name,
+      error_message: error.message,
+      latency_ms: Date.now() - startTime
+    });
+
+    throw error;
+  }
+}
+
+export async function downloadWithFallback(options, onProgress) {
+  const {
+    ipfsCid,
+    huggingfaceUrl,
+    destPath,
+    manifest,
+    minBytes,
+    preferredLayer = 'ipfs'
+  } = options;
+
+  const dir = path.dirname(destPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  if (fs.existsSync(destPath)) {
+    const verification = verifyFileIntegrity(destPath, manifest?.sha256, minBytes);
+    if (verification.valid) {
+      recordMetric({
+        modelType: 'model',
+        layer: 'cache',
+        status: 'hit'
+      });
+      return { success: true, source: 'cache' };
+    } else {
+      console.warn(`Cache invalid (${verification.reason}), re-downloading...`);
+      const backupPath = `${destPath}.bak`;
+      if (fs.existsSync(backupPath)) fs.unlinkSync(backupPath);
+      fs.renameSync(destPath, backupPath);
+    }
+  }
+
+  const layers = preferredLayer === 'ipfs'
+    ? ['ipfs', 'huggingface']
+    : ['huggingface', 'ipfs'];
+
+  for (const layer of layers) {
+    try {
+      if (layer === 'ipfs' && ipfsCid) {
+        return await downloadFromIPFS(ipfsCid, destPath, manifest, onProgress);
+      } else if (layer === 'huggingface' && huggingfaceUrl) {
+        return await downloadFromHuggingFace(huggingfaceUrl, destPath, minBytes, onProgress);
+      }
+    } catch (error) {
+      console.warn(`${layer} layer failed:`, error.message);
+      continue;
+    }
+  }
+
+  recordMetric({
+    modelType: 'model',
+    status: 'all_layers_exhausted'
+  });
+
+  throw new Error('All download layers exhausted');
+}
+
+export function getMetrics() {
+  if (!fs.existsSync(METRICS_PATH)) {
+    return [];
+  }
+  return JSON.parse(fs.readFileSync(METRICS_PATH, 'utf8'));
+}
+
+export function getMetricsSummary() {
+  const metrics = getMetrics();
+
+  const summary = {
+    total: metrics.length,
+    cache_hits: metrics.filter(m => m.layer === 'cache' && m.status === 'hit').length,
+    ipfs: {
+      success: metrics.filter(m => m.layer === 'ipfs' && m.status === 'success').length,
+      error: metrics.filter(m => m.layer === 'ipfs' && m.status === 'error').length,
+      avg_latency: 0
+    },
+    huggingface: {
+      success: metrics.filter(m => m.layer === 'huggingface' && m.status === 'success').length,
+      error: metrics.filter(m => m.layer === 'huggingface' && m.status === 'error').length,
+      avg_latency: 0
+    }
+  };
+
+  const ipfsSuccess = metrics.filter(m => m.layer === 'ipfs' && m.status === 'success');
+  if (ipfsSuccess.length > 0) {
+    summary.ipfs.avg_latency = Math.round(
+      ipfsSuccess.reduce((sum, m) => sum + m.latency_ms, 0) / ipfsSuccess.length
+    );
+  }
+
+  const hfSuccess = metrics.filter(m => m.layer === 'huggingface' && m.status === 'success');
+  if (hfSuccess.length > 0) {
+    summary.huggingface.avg_latency = Math.round(
+      hfSuccess.reduce((sum, m) => sum + m.latency_ms, 0) / hfSuccess.length
+    );
+  }
+
+  return summary;
+}
+
+export function resetMetrics() {
+  if (fs.existsSync(METRICS_PATH)) {
+    fs.unlinkSync(METRICS_PATH);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.309",
+  "version": "1.0.310",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",

package/scripts/publish-models-to-ipfs.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import https from 'https';
+import FormData from 'form-data';
+
+const PINATA_API_KEY = process.env.PINATA_API_KEY || '';
+const PINATA_SECRET_KEY = process.env.PINATA_SECRET_KEY || '';
+
+async function uploadToPinata(dirPath, folderName) {
+  if (!PINATA_API_KEY || !PINATA_SECRET_KEY) {
+    throw new Error('PINATA_API_KEY and PINATA_SECRET_KEY environment variables required');
+  }
+
+  const form = new FormData();
+
+  function addFilesRecursive(currentPath, basePath) {
+    const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(currentPath, entry.name);
+      const relativePath = path.relative(basePath, fullPath);
+
+      if (entry.isDirectory()) {
+        addFilesRecursive(fullPath, basePath);
+      } else {
+        form.append('file', fs.createReadStream(fullPath), {
+          filepath: `${folderName}/${relativePath}`
+        });
+      }
+    }
+  }
+
+  addFilesRecursive(dirPath, dirPath);
+
+  const metadata = JSON.stringify({
+    name: folderName,
+    keyvalues: {
+      type: 'model',
+      timestamp: new Date().toISOString()
+    }
+  });
+  form.append('pinataMetadata', metadata);
+
+  const options = JSON.stringify({
+    wrapWithDirectory: false
+  });
+  form.append('pinataOptions', options);
+
+  return new Promise((resolve, reject) => {
+    const req = https.request({
+      method: 'POST',
+      hostname: 'api.pinata.cloud',
+      path: '/pinning/pinFileToIPFS',
+      headers: {
+        ...form.getHeaders(),
+        pinata_api_key: PINATA_API_KEY,
+        pinata_secret_api_key: PINATA_SECRET_KEY
+      }
+    }, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        if (res.statusCode === 200) {
+          resolve(JSON.parse(data));
+        } else {
+          reject(new Error(`Pinata API error: ${res.statusCode} - ${data}`));
+        }
+      });
+    });
+
+    req.on('error', reject);
+    form.pipe(req);
+  });
+}
+
+async function publishViaPinata() {
+  const modelsDir = path.join(os.homedir(), '.gmgui', 'models');
+  const whisperDir = path.join(modelsDir, 'onnx-community', 'whisper-base');
+  const ttsDir = path.join(modelsDir, 'tts');
+
+  console.log('Publishing models to IPFS via Pinata...\n');
+
+  const results = {};
+
+  if (fs.existsSync(whisperDir)) {
+    console.log('Publishing Whisper models...');
+    try {
+      const result = await uploadToPinata(whisperDir, 'whisper-base');
+      results.whisper = {
+        cid: result.IpfsHash,
+        size: result.PinSize,
+        timestamp: result.Timestamp
+      };
+      console.log(`✓ Whisper CID: ${result.IpfsHash}`);
+      console.log(`  Size: ${(result.PinSize / 1024 / 1024).toFixed(2)} MB\n`);
+    } catch (error) {
+      console.error(`✗ Whisper failed: ${error.message}\n`);
+    }
+  }
+
+  if (fs.existsSync(ttsDir)) {
+    console.log('Publishing TTS models...');
+    try {
+      const result = await uploadToPinata(ttsDir, 'tts-models');
+      results.tts = {
+        cid: result.IpfsHash,
+        size: result.PinSize,
+        timestamp: result.Timestamp
+      };
+      console.log(`✓ TTS CID: ${result.IpfsHash}`);
+      console.log(`  Size: ${(result.PinSize / 1024 / 1024).toFixed(2)} MB\n`);
+    } catch (error) {
+      console.error(`✗ TTS failed: ${error.message}\n`);
+    }
+  }
+
+  const manifestPath = path.join(modelsDir, '.manifests.json');
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+
+  if (results.whisper) {
+    manifest['whisper-base'].ipfsHash = results.whisper.cid;
+    manifest['whisper-base'].publishedAt = new Date().toISOString();
+  }
+  if (results.tts) {
+    manifest['tts-models'].ipfsHash = results.tts.cid;
+    manifest['tts-models'].publishedAt = new Date().toISOString();
+  }
+
+  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+  console.log(`✓ Updated manifests at ${manifestPath}`);
+
+  console.log('\n=== IPFS GATEWAYS ===');
+  if (results.whisper) {
+    console.log('\nWhisper models:');
+    console.log(`  Cloudflare: https://cloudflare-ipfs.com/ipfs/${results.whisper.cid}`);
+    console.log(`  dweb.link:  https://dweb.link/ipfs/${results.whisper.cid}`);
+    console.log(`  Pinata:     https://gateway.pinata.cloud/ipfs/${results.whisper.cid}`);
+  }
+  if (results.tts) {
+    console.log('\nTTS models:');
+    console.log(`  Cloudflare: https://cloudflare-ipfs.com/ipfs/${results.tts.cid}`);
+    console.log(`  dweb.link:  https://dweb.link/ipfs/${results.tts.cid}`);
+    console.log(`  Pinata:     https://gateway.pinata.cloud/ipfs/${results.tts.cid}`);
+  }
+
+  return results;
+}
+
+console.log('AgentGUI Model Publishing Tool\n');
+console.log('This script publishes Whisper and TTS models to IPFS via Pinata.');
+console.log('Required: PINATA_API_KEY and PINATA_SECRET_KEY environment variables.\n');
+console.log('Get free API keys at: https://www.pinata.cloud/\n');
+
+if (!PINATA_API_KEY || !PINATA_SECRET_KEY) {
+  console.error('ERROR: Missing Pinata credentials');
+  console.error('Set environment variables:');
+  console.error('  export PINATA_API_KEY=your_api_key');
+  console.error('  export PINATA_SECRET_KEY=your_secret_key\n');
+  process.exit(1);
+}
+
+publishViaPinata()
+  .then(results => {
+    console.log('\n✓ Publishing complete!');
+    console.log(JSON.stringify(results, null, 2));
+  })
+  .catch(error => {
+    console.error('\n✗ Publishing failed:', error.message);
+    process.exit(1);
+  });

package/server.js

@@ -2549,6 +2549,71 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+    if (pathOnly === '/api/metrics/downloads' && req.method === 'GET') {
+      try {
+        const { getMetrics } = await import('./lib/model-downloader.js');
+        const metrics = getMetrics();
+        sendJSON(req, res, 200, { metrics });
+      } catch (err) {
+        sendJSON(req, res, 500, { error: err.message });
+      }
+      return;
+    }
+
+    if (pathOnly === '/api/metrics/downloads/summary' && req.method === 'GET') {
+      try {
+        const { getMetricsSummary } = await import('./lib/model-downloader.js');
+        const summary = getMetricsSummary();
+        sendJSON(req, res, 200, summary);
+      } catch (err) {
+        sendJSON(req, res, 500, { error: err.message });
+      }
+      return;
+    }
+
+    if (pathOnly === '/api/metrics/downloads/health' && req.method === 'GET') {
+      try {
+        const { getMetricsSummary } = await import('./lib/model-downloader.js');
+        const summary = getMetricsSummary();
+        const health = {
+          ipfs: {
+            status: summary.ipfs.success > 0 ? 'healthy' : summary.ipfs.error > 0 ? 'degraded' : 'unknown',
+            success_rate: summary.ipfs.success + summary.ipfs.error > 0
+              ? ((summary.ipfs.success / (summary.ipfs.success + summary.ipfs.error)) * 100).toFixed(2)
+              : 0,
+            avg_latency_ms: summary.ipfs.avg_latency
+          },
+          huggingface: {
+            status: summary.huggingface.success > 0 ? 'healthy' : summary.huggingface.error > 0 ? 'degraded' : 'unknown',
+            success_rate: summary.huggingface.success + summary.huggingface.error > 0
+              ? ((summary.huggingface.success / (summary.huggingface.success + summary.huggingface.error)) * 100).toFixed(2)
+              : 0,
+            avg_latency_ms: summary.huggingface.avg_latency
+          },
+          cache: {
+            hit_rate: summary.total > 0
+              ? ((summary.cache_hits / summary.total) * 100).toFixed(2)
+              : 0
+          }
+        };
+        sendJSON(req, res, 200, health);
+      } catch (err) {
+        sendJSON(req, res, 500, { error: err.message });
+      }
+      return;
+    }
+
+    if (pathOnly === '/api/metrics/downloads/reset' && req.method === 'POST') {
+      try {
+        const { resetMetrics } = await import('./lib/model-downloader.js');
+        resetMetrics();
+        sendJSON(req, res, 200, { ok: true, message: 'Metrics reset' });
+      } catch (err) {
+        sendJSON(req, res, 500, { error: err.message });
+      }
+      return;
+    }
+
     if (pathOnly === '/api/speech-status' && req.method === 'POST') {
       const body = await parseBody(req);
       if (body.forceDownload) {