agentgui 1.0.318 → 1.0.320

package/.prd

@@ -0,0 +1,262 @@
+# Model Download Fallback System - Integration PRD
+
+## CURRENT STATE VERIFIED
+
+### Phase 1-7 Status (CLAIMED DONE)
+✓ lib/model-downloader.js exists (289 lines, 8247 bytes)
+  - Exports: downloadWithFallback, getMetrics, getMetricsSummary, resetMetrics
+  - Implements 3-layer fallback: IPFS → HuggingFace → cache
+  - Parameters: ipfsCid, huggingfaceUrl, destPath, manifest, minBytes, preferredLayer
+  - Verification: SHA-256 hash + size check + ONNX format validation
+
+✓ scripts/publish-models-to-ipfs.js exists (173 lines, 5655 bytes)
+  - Requires: PINATA_API_KEY, PINATA_SECRET_KEY
+  - Uploads to Pinata, returns CIDs for whisper-base and tts-models
+  - Not yet executed (no real CIDs)
+
+✓ database.js IPFS infrastructure exists
+  - Tables: ipfs_cids, ipfs_downloads
+  - Query: getIpfsCidByModel(modelName, modelType)
+  - Initialization: Lines 385-415 with PLACEHOLDER CIDs
+  - WHISPER_CID = 'bafybeidyw252ecy4vs46bbmezrtw325gl2ymdltosmzqgx4edjsc3fbofy' (PLACEHOLDER)
+  - TTS_CID = 'bafybeidyw252ecy4vs46bbmezrtw325gl2ymdltosmzqgx4edjsc3fbofy' (PLACEHOLDER)
+
+✓ Metrics API endpoints exist in server.js (lines 2552-2606)
+  - GET /api/metrics/downloads
+  - GET /api/metrics/downloads/summary
+  - GET /api/metrics/downloads/health
+  - POST /api/metrics/downloads/reset
+
+✓ Manifest exists at ~/.gmgui/models/.manifests.json
+  - whisper-base: 7 files, 293.76 MB total, SHA-256 hashes present
+  - tts-models: 6 files, 198.60 MB total, SHA-256 hashes present
+  - Generated: 2026-02-21T03:49:32.766Z
+
+✓ Metrics file exists at ~/.gmgui/models/.metrics.json
+
+### Phase 8-10 Status (TODO)
+✗ lib/model-downloader.js NOT imported in server.js
+✗ server.js ensureModelsDownloaded() uses old webtalk/ipfs-downloader (lines 66-125)
+✗ Real IPFS CIDs not obtained (Pinata script not executed)
+✗ database.js still has placeholder CIDs
+
+## DEPENDENCIES & BLOCKING RELATIONSHIPS
+
+### Wave 1 (COMPLETE - all items removed from work breakdown)
+
+### Wave 2 (COMPLETE)
+✓ Pinata API keys: BLOCKED - not available, user needs to sign up at https://www.pinata.cloud/
+✓ Integration strategy designed - 150-200 line implementation, backward compatible, per-file iteration
+
+### Wave 3 (Depends on Wave 2)
+6. Execute publish-models-to-ipfs.js to get real CIDs (if keys available)
+   - Blocked by: Wave 2 item 4 (API keys)
+   - Blocks: Database CID update
+
+7. Add model-downloader import to server.js
+   - Blocked by: Wave 2 item 5 (integration strategy)
+   - Blocks: Integration implementation
+
+### Wave 4 (Depends on Wave 3)
+8. Update database.js with real IPFS CIDs
+   - Blocked by: Wave 3 item 6 (real CIDs obtained)
+   - Blocks: IPFS layer activation
+
+9. Replace ensureModelsDownloaded implementation
+   - Blocked by: Wave 3 item 7 (import added)
+   - Blocks: End-to-end testing
+
+### Wave 5 (Depends on Wave 4, final verification)
+10. Test fallback chain with fresh cache (delete ~/.gmgui/models, verify IPFS layer 1)
+    - Blocked by: Wave 4 items 8, 9
+    - Blocks: Nothing (end-to-end test)
+
+11. Test fallback to HuggingFace (simulate IPFS failure)
+    - Blocked by: Wave 4 items 8, 9
+    - Blocks: Nothing (end-to-end test)
+
+12. Verify metrics collection after real downloads
+    - Blocked by: Wave 4 items 8, 9
+    - Blocks: Nothing (validation)
+
+## UNKNOWNS TO RESOLVE
+
+### Code Implementation Unknowns (Wave 1 RESOLVED)
+✓ downloadWithFallback IPFS gateway list: YES - cycles all 4 gateways (Cloudflare, dweb.link, Pinata, ipfs.io) × 2 retries = 8 attempts
+✓ downloadWithFallback error handling: YES - properly catches and continues on gateway failure
+✓ downloadWithFallback progress reporting: YES - onProgress receives correct status for each layer
+✓ Manifest integration: YES - downloadWithFallback correctly validates against manifest SHA-256
+✓ File path construction: Direct iteration over manifest.files object, each key is relative path
+
+### Integration Unknowns (Wave 2 IN PROGRESS)
+- Current ensureModelsDownloaded flow: what does webtalk/ipfs-downloader.ensureModels do? (TO INVESTIGATE)
+- Backward compatibility: can we replace ensureModels without breaking existing installs? (TO INVESTIGATE)
+- Progress broadcasting: how to integrate downloadWithFallback progress with broadcastModelProgress? (TO DESIGN)
+- Error handling: what happens if all 3 layers fail? (TO DESIGN - already throws error, need UI integration)
+- Concurrent download handling: does model-downloader handle multiple simultaneous downloads? (TO INVESTIGATE)
+
+### Environment Unknowns
+- Pinata API keys: are they available? (blocks real IPFS publishing)
+- IPFS gateway reachability: can we access Cloudflare/dweb.link/Pinata from this environment?
+- Network constraints: timeouts sufficient for 280MB + 198MB downloads?
+
+### Database Unknowns
+- CID format: are placeholder CIDs correct format (bafybei...)?
+- Gateway URL: should database store per-gateway URLs or single gateway?
+- Download tracking: is recordDownloadStart properly integrated?
+
+## EDGE CASES & CORNER CASES
+
+### Network Scenarios
+- All IPFS gateways unreachable → fallback to HuggingFace
+- HuggingFace rate limiting → retry logic sufficient?
+- Partial download (connection drop mid-file) → temp file cleanup?
+- Network switching during download → resume or restart?
+- Firewall blocking IPFS ports → fallback working?
+
+### File System Scenarios
+- Disk full during download → cleanup and error reporting?
+- Permission denied on ~/.gmgui/models → fallback directory?
+- Corrupted manifest file → regenerate or error?
+- Partial manifest (missing sha256 for some files) → skip validation?
+- Concurrent writes to same file → locking mechanism?
+
+### Cache Scenarios
+- Cache hit but file corrupted → detect and re-download
+- Cache hit but wrong version → version check mechanism?
+- Stale cache (90+ days old) → serve stale or force refresh?
+- Manifest mismatch with actual files → which is source of truth?
+
+### IPFS Publishing Scenarios
+- Pinata upload timeout (slow upload) → retry with backoff?
+- Pinata quota exceeded → alternative publishing method?
+- CID changes on re-publish → database migration path?
+- Partial upload (some files missing) → validation before CID storage?
+
+### Integration Scenarios
+- Old webtalk code still called by other modules → identify dependencies
+- Config object mismatch between old/new systems → adapter needed?
+- Progress event format incompatibility → transform events?
+- Multiple conversations triggering download simultaneously → download once, notify all?
+
+### Metrics Scenarios
+- Metrics file corrupted → reset or recover?
+- Metrics file too large (>1GB) → rotation working?
+- Concurrent metric writes → locking or append-only safe?
+- Metric timestamp drift → clock synchronization issue?
+
+## ACCEPTANCE CRITERIA (GATE CONDITIONS)
+
+### Implementation Completeness
+- downloadWithFallback cycles through all 3 IPFS gateways before HuggingFace fallback
+- SHA-256 verification occurs for every downloaded file against manifest
+- Size validation (minBytes) occurs before SHA-256 check
+- Progress events emitted for each layer attempt
+- Metrics recorded for cache hit, each gateway attempt, HuggingFace attempt, all failures
+- Temp files (.tmp) cleaned up on failure
+- Backup files (.bak) created on corrupted cache detection
+
+### Integration Correctness
+- model-downloader.js imported in server.js
+- ensureModelsDownloaded calls downloadWithFallback for each file in manifest
+- Progress broadcasting compatible with existing WebSocket protocol
+- Error messages surfaced to UI via existing error broadcast mechanism
+- Concurrent download requests handled (single download, multiple waiters)
+- No regression in existing model download behavior
+
+### Database Accuracy
+- Real IPFS CIDs stored in database.js (not placeholders)
+- getIpfsCidByModel returns correct CID for whisper-base and tts-models
+- Download records created in ipfs_downloads table
+- Last accessed timestamp updated on CID retrieval
+
+### End-to-End Verification
+- Fresh install (empty ~/.gmgui/models) downloads all models successfully
+- IPFS layer succeeds (witnessed download from Cloudflare/dweb.link/Pinata gateway)
+- HuggingFace fallback works (simulate IPFS failure, verify HF download)
+- Cache layer works (second download instant, metrics show cache hit)
+- Corrupted cache detected and re-downloaded
+- Metrics populated with real download data
+- All 4 metrics endpoints return valid data
+
+### Performance & Reliability
+- 280MB whisper-base downloads in <5 minutes on 10Mbps connection
+- 198MB tts-models downloads in <4 minutes on 10Mbps connection
+- Gateway failover occurs within 30 seconds of timeout
+- No memory leaks during large file downloads
+- Progress updates at least every 5 seconds during active download
+
+### Code Quality
+- No duplicate code between old webtalk and new model-downloader
+- All functions under 200 lines
+- No hardcoded values (gateways, timeouts, paths configurable)
+- Error messages descriptive (include layer, gateway, error type)
+- No console.log for normal operations (use debug hooks or proper logging)
+
+## REMAINING WORK BREAKDOWN
+
+### Code Exploration (EXECUTE state, plugin:gm:dev) - Wave 2
+4. Read webtalk/ipfs-downloader.js ensureModels to understand replacement
+5. Read webtalk/whisper-models.js to understand file structure
+6. Read webtalk/tts-models.js to understand file structure
+7. Trace broadcastModelProgress usage in server.js
+
+### Integration Design (EXECUTE state, plugin:gm:dev)
+8. Map manifest files to downloadWithFallback calls
+9. Design progress event transformation (downloadWithFallback → broadcastModelProgress)
+10. Design error handling flow (all layers fail → user notification)
+11. Design concurrent request handling (lock/queue mechanism)
+12. Design backward compatibility (keep webtalk as fallback?)
+
+### Implementation (EMIT state, after all unknowns resolved)
+13. Add import statement for downloadWithFallback, getMetrics, etc.
+14. Rewrite ensureModelsDownloaded function body
+15. Test new implementation with existing cache
+16. Delete old webtalk calls if confirmed unused elsewhere
+
+### IPFS Publishing (EXECUTE state, conditional on API keys)
+17. Check for PINATA_API_KEY environment variable
+18. If keys available: execute scripts/publish-models-to-ipfs.js
+19. If keys unavailable: document blocking status for user
+20. Capture real CIDs from script output
+21. Update database.js lines 389-390 with real CIDs
+
+### Verification (VERIFY state, real execution)
+22. Delete ~/.gmgui/models directory
+23. Start server, trigger model download
+24. Witness IPFS gateway download (check logs for gateway URLs)
+25. Check metrics via GET /api/metrics/downloads
+26. Verify all files present with correct SHA-256
+27. Restart server, verify instant cache hit
+28. Simulate IPFS failure (block gateway URLs), verify HuggingFace fallback
+29. Check metrics show both IPFS and HuggingFace attempts
+
+## OPEN QUESTIONS FOR USER
+
+1. Pinata API keys: Are PINATA_API_KEY and PINATA_SECRET_KEY available? (blocks real IPFS publishing)
+2. Gateway preference: Should IPFS be preferred over HuggingFace, or configurable?
+3. Old webtalk code: Can we fully replace webtalk/ipfs-downloader, or keep as fallback?
+4. Metrics retention: Is 24-hour metrics retention sufficient, or longer?
+5. Error handling: Should download failure block server startup, or degrade gracefully?
+
+## ESTIMATED COMPLETION
+
+- Code exploration: 30 minutes (7 files to read and trace)
+- Integration design: 45 minutes (map files, design flows)
+- Implementation: 60 minutes (rewrite ensureModelsDownloaded, test)
+- IPFS publishing: 15 minutes (if keys available) or 0 minutes (if blocked)
+- Verification: 30 minutes (delete cache, test both layers, check metrics)
+
+Total: 3 hours (if keys available) or 2.75 hours (if blocked on publishing)
+
+## SUCCESS CRITERIA
+
+Work is complete when:
+- All 26 items above marked done (3 Wave 1 items removed as complete)
+- Fresh ~/.gmgui/models download succeeds via IPFS layer 1
+- Corrupted cache triggers re-download
+- HuggingFace fallback proven working (simulated IPFS failure)
+- Metrics show real download data for both layers
+- No regressions in existing functionality
+- Real IPFS CIDs in database (if keys available) OR documented blocking status
+- User can verify system working via metrics endpoints

package/database.js

@@ -400,13 +400,13 @@ try {
     console.log('[MODELS] Registered Whisper STT IPFS CID:', WHISPER_CID);
   }
 
-  const existingTTS = db.prepare('SELECT * FROM ipfs_cids WHERE modelName = ? AND modelType = ?').get('tts', 'voice');
+  const existingTTS = db.prepare('SELECT * FROM ipfs_cids WHERE modelName = ? AND modelType = ?').get('tts-models', 'voice');
   if (!existingTTS) {
     const cidId = `cid-${Date.now()}-tts`;
     db.prepare(
       `INSERT INTO ipfs_cids (id, cid, modelName, modelType, modelHash, gatewayUrl, cached_at, last_accessed_at)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
-    ).run(cidId, TTS_CID, 'tts', 'voice', 'sha256-verified', LIGHTHOUSE_GATEWAY, Date.now(), Date.now());
+    ).run(cidId, TTS_CID, 'tts-models', 'voice', 'sha256-verified', LIGHTHOUSE_GATEWAY, Date.now(), Date.now());
     console.log('[MODELS] Registered TTS IPFS CID:', TTS_CID);
   }
 } catch (err) {

package/lib/download-metrics.js

@@ -0,0 +1,79 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const METRICS_PATH = path.join(os.homedir(), '.gmgui', 'models', '.metrics.json');
+
+export 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));
+}
+
+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/lib/file-verification.js

@@ -0,0 +1,26 @@
+import fs from 'fs';
+import crypto from 'crypto';
+
+export 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 };
+}

package/lib/model-downloader.js

@@ -1,8 +1,8 @@
 import { createRequire } from 'module';
 import fs from 'fs';
 import path from 'path';
-import crypto from 'crypto';
-import os from 'os';
+import { recordMetric } from './download-metrics.js';
+import { verifyFileIntegrity } from './file-verification.js';
 
 const require = createRequire(import.meta.url);
 
@@ -13,58 +13,6 @@ const GATEWAYS = [
   '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();
 
@@ -239,50 +187,4 @@ export async function downloadWithFallback(options, onProgress) {
   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);
-  }
-}
+export { getMetrics, getMetricsSummary, resetMetrics } from './download-metrics.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.318",
+  "version": "1.0.320",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",
@@ -26,6 +26,7 @@
     "better-sqlite3": "^12.6.2",
     "busboy": "^1.6.0",
     "express": "^5.2.1",
+    "form-data": "^4.0.5",
     "fsbrowse": "^0.2.18",
     "google-auth-library": "^10.5.0",
     "onnxruntime-node": "^1.24.1",

package/server.js

@@ -14,6 +14,7 @@ import Busboy from 'busboy';
 import fsbrowse from 'fsbrowse';
 import { queries } from './database.js';
 import { runClaudeWithStreaming } from './lib/claude-runner.js';
+import { downloadWithFallback } from './lib/model-downloader.js';
 const { downloadWithProgress } = createRequire(import.meta.url)('webtalk/ipfs-downloader');
 
 const ttsTextAccumulators = new Map();
@@ -77,39 +78,70 @@ async function ensureModelsDownloaded() {
       ? (fs.existsSync(path.join(process.env.PORTABLE_EXE_DIR, 'models', 'onnx-community')) ? path.join(process.env.PORTABLE_EXE_DIR, 'models') : gmguiModels)
       : gmguiModels;
 
-    const { ensureModels } = createRequire(import.meta.url)('webtalk/ipfs-downloader');
-    const { createConfig } = createRequire(import.meta.url)('webtalk/config');
-    const config = createConfig({
-      modelsDir: modelsBase,
-      ttsModelsDir: path.join(modelsBase, 'tts'),
-      sttModelsDir: path.join(modelsBase, 'stt'),
-    });
+    const manifestPath = path.join(gmguiModels, '.manifests.json');
+    if (!fs.existsSync(manifestPath)) {
+      throw new Error('Model manifest not found at ' + manifestPath);
+    }
 
-    const { checkTTSModelExists } = createRequire(import.meta.url)('webtalk/tts-models');
-    const { checkWhisperModelExists } = createRequire(import.meta.url)('webtalk/whisper-models');
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
 
-    const sttOk = await checkWhisperModelExists(config.defaultWhisperModel, config).catch(() => false);
-    const ttsOk = await checkTTSModelExists(config).catch(() => false);
-
-    if (sttOk && ttsOk) {
-      console.log('[MODELS] All model files present');
-      modelDownloadState.complete = true;
-      return true;
-    }
+    const whisperCidRecord = queries.getIpfsCidByModel('whisper-base', 'stt');
+    const ttsCidRecord = queries.getIpfsCidByModel('tts', 'voice');
 
     modelDownloadState.downloading = true;
     modelDownloadState.error = null;
 
-    await ensureModels(config, (progress) => {
-      broadcastModelProgress({
-        started: true,
-        done: progress.done || false,
-        downloading: progress.status === 'downloading',
-        type: progress.type,
-        source: 'ipfs',
-        ...progress,
-      });
-    });
+    const downloadModel = async (modelName, modelType, cidRecord) => {
+      const modelManifest = manifest[modelName];
+      if (!modelManifest) {
+        throw new Error(`Model ${modelName} not found in manifest`);
+      }
+
+      const isWhisper = modelType === 'stt';
+      const baseDir = isWhisper
+        ? path.join(modelsBase, 'onnx-community', 'whisper-base')
+        : path.join(modelsBase, 'tts');
+
+      fs.mkdirSync(baseDir, { recursive: true });
+
+      for (const [filename, fileInfo] of Object.entries(modelManifest.files)) {
+        const destPath = path.join(baseDir, filename);
+
+        if (fs.existsSync(destPath) && fs.statSync(destPath).size === fileInfo.size) {
+          console.log(`[MODELS] ${filename} already exists, skipping`);
+          continue;
+        }
+
+        const ipfsCid = cidRecord ? `${cidRecord.cid}/${filename}` : null;
+        const huggingfaceUrl = isWhisper
+          ? `https://huggingface.co/onnx-community/whisper-base/resolve/main/${filename}`
+          : `https://huggingface.co/datasets/AnEntrypoint/sttttsmodels/resolve/main/tts/${filename}`;
+
+        await downloadWithFallback({
+          ipfsCid,
+          huggingfaceUrl,
+          destPath,
+          manifest: fileInfo,
+          minBytes: fileInfo.size * 0.8,
+          preferredLayer: ipfsCid ? 'ipfs' : 'huggingface'
+        }, (progress) => {
+          broadcastModelProgress({
+            started: true,
+            done: progress.status === 'success',
+            downloading: progress.status === 'downloading',
+            type: modelType === 'stt' ? 'whisper' : 'tts',
+            source: progress.layer === 'cache' ? 'cache' : progress.layer,
+            status: progress.status,
+            file: filename,
+            progress: progress.total ? (progress.downloaded / progress.total * 100) : 0,
+            gateway: progress.gateway
+          });
+        });
+      }
+    };
+
+    await downloadModel('whisper-base', 'stt', whisperCidRecord);
+    await downloadModel('tts-models', 'voice', ttsCidRecord);
 
     modelDownloadState.complete = true;
     broadcastModelProgress({ started: true, done: true, downloading: false });

package/static/index.html

@@ -727,6 +727,26 @@
     ::-webkit-scrollbar-thumb { background-color: var(--color-border); border-radius: 3px; }
     ::-webkit-scrollbar-thumb:hover { background-color: var(--color-text-tertiary); }
 
+    /* DIALOGS */
+    .dialog-overlay { position: fixed; inset: 0; display: flex; align-items: center; justify-content: center; }
+    .dialog-backdrop { position: absolute; inset: 0; background: rgba(0,0,0,0.5); }
+    .dialog-box { position: fixed; top: 50%; left: 50%; transform: translate(-50%,-50%); background: var(--color-bg-secondary); border: 1px solid var(--color-border); border-radius: 8px; padding: 24px; min-width: 320px; max-width: 480px; box-shadow: 0 8px 32px rgba(0,0,0,0.2); }
+    .dialog-box h3, .dialog-box .dialog-title { font-size: 1rem; font-weight: 600; margin-bottom: 12px; color: var(--color-text-primary); }
+    .dialog-box p, .dialog-box .dialog-message { color: var(--color-text-secondary); margin-bottom: 16px; font-size: 0.875rem; }
+    .dialog-box input, .dialog-box textarea { width: 100%; padding: 8px 12px; border: 1px solid var(--color-border); border-radius: 6px; background: var(--color-bg-tertiary); color: var(--color-text-primary); font-size: 0.875rem; margin-bottom: 16px; }
+    .dialog-footer { display: flex; gap: 8px; justify-content: flex-end; }
+    .dialog-btn { padding: 6px 16px; border-radius: 6px; border: 1px solid var(--color-border); background: var(--color-bg-tertiary); color: var(--color-text-primary); cursor: pointer; font-size: 0.875rem; }
+    .dialog-btn-primary { background: var(--color-primary); border-color: var(--color-primary); color: #fff; }
+    .dialog-btn:hover { opacity: 0.85; }
+    .dialog-box-progress .dialog-progress-bar { height: 4px; background: var(--color-border); border-radius: 2px; overflow: hidden; margin-bottom: 8px; }
+    .dialog-box-progress .dialog-progress-fill { height: 100%; background: var(--color-primary); transition: width 0.3s; }
+
+    /* TOOL ICONS */
+    .folded-tool-icon { display: inline-flex; align-items: center; flex-shrink: 0; }
+    .folded-tool-icon svg { width: 16px; height: 16px; flex-shrink: 0; }
+    .folded-tool-bar { display: flex; align-items: center; gap: 6px; }
+    .tool-result-status { display: flex; align-items: center; gap: 6px; }
+
     /* RESPONSIVE */
     @media (max-width: 768px) {
       .sidebar {