@yeaft/webchat-agent 0.1.833 → 0.1.836

package/connection/message-router.js

@@ -36,6 +36,7 @@ import { sendToServer, flushMessageBuffer } from './buffer.js';
 import { handleRestartAgent, handleUpgradeAgent } from './upgrade.js';
 import { loadMcpServers, updateMcpConfig } from '../mcp.js';
 import { getLlmConfig, updateLlmConfig, getUnifySettings, updateUnifySettings, getSearchSettings, updateSearchSettings, fetchTavilyUsage } from '../unify/config-api.js';
+import { fetchModelsDev } from '../unify/llm/models-dev.js';
 import { handleUnifyGroupChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyLoadMoreHistory, handleUnifyAbortThread, handleUnifyAbortAll, handleUnifyAbortTurn, handleUnifyVpSubscribe, handleUnifyVpCreate, handleUnifyVpUpdate, handleUnifyVpDelete, handleUnifyVpRead, handleUnifyListGroups, handleUnifyCreateGroup, handleUnifyRenameGroup, handleUnifyUpdateGroup, handleUnifyUpdateGroupConfig, handleUnifyArchiveGroup, handleUnifyDeleteGroup, handleUnifyAddMember, handleUnifyRemoveMember, handleUnifySetDefaultVp, handleUnifyDreamTrigger, handleUnifyFetchToolStats, handleUnifyFetchDebugHistory, broadcastLanguageChange } from '../unify/web-bridge.js';
 
 export async function handleMessage(msg) {
@@ -347,6 +348,31 @@ export async function handleMessage(msg) {
       break;
     }
 
+    // models.dev registry (community-maintained provider/model catalog).
+    // Used by the LLM settings preset picker to populate provider + model lists.
+    case 'get_models_dev_registry': {
+      try {
+        const data = await fetchModelsDev({
+          forceRefresh: !!msg.forceRefresh,
+          yeaftDir: ctx.CONFIG?.yeaftDir,
+        });
+        sendToServer({
+          type: 'models_dev_registry',
+          requestId: msg.requestId || null,
+          registry: data,
+          fetchedAt: Date.now(),
+        });
+      } catch (err) {
+        sendToServer({
+          type: 'models_dev_registry',
+          requestId: msg.requestId || null,
+          registry: {},
+          error: err?.message || String(err),
+        });
+      }
+      break;
+    }
+
     // task-318: Unify runtime settings (thread concurrency + auto-archive).
     // Read/write the nested `unify` section of config.json — LLM fields
     // untouched. On update we broadcast a `unify_settings_updated` event

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.833",
+  "version": "0.1.836",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/llm/models-dev.js

@@ -0,0 +1,160 @@
+/**
+ * models.dev registry integration — community-maintained provider/model database.
+ *
+ * Fetches https://models.dev/api.json (4000+ models across 109+ providers) and
+ * exposes provider/model metadata to the rest of the agent. Ported from hermes
+ * `agent/models_dev.py`.
+ *
+ * Cache hierarchy (when forceRefresh=false):
+ *   1. In-memory cache, populated and < TTL old → return immediately.
+ *   2. Disk cache file < TTL old by mtime → load, populate in-mem, return.
+ *   3. Network fetch → on success, save to disk + in-mem and return.
+ *   4. Network fails → fall back to ANY available disk cache (even stale)
+ *      with a short 5 min in-mem grace period.
+ *
+ * forceRefresh=true skips stages 1 and 2 (used by manual refresh button).
+ */
+
+import { readFile, writeFile, stat, mkdir, rename } from 'fs/promises';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+
+const MODELS_DEV_URL = 'https://models.dev/api.json';
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+const NETWORK_TIMEOUT_MS = 15000;
+const STALE_GRACE_MS = 5 * 60 * 1000; // 5 minutes when serving stale-after-failure
+
+let _memCache = null;
+let _memCacheTime = 0;
+
+function getCachePath(yeaftDir) {
+  const base = yeaftDir || join(homedir(), '.yeaft');
+  return join(base, 'models_dev_cache.json');
+}
+
+async function diskCacheAgeMs(yeaftDir) {
+  try {
+    const s = await stat(getCachePath(yeaftDir));
+    const age = Date.now() - s.mtimeMs;
+    return age < 0 ? null : age;
+  } catch {
+    return null;
+  }
+}
+
+async function loadDiskCache(yeaftDir) {
+  try {
+    const raw = await readFile(getCachePath(yeaftDir), 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+async function saveDiskCache(yeaftDir, data) {
+  try {
+    const path = getCachePath(yeaftDir);
+    await mkdir(dirname(path), { recursive: true });
+    const tmp = path + '.tmp';
+    await writeFile(tmp, JSON.stringify(data), 'utf8');
+    await rename(tmp, path);
+  } catch (e) {
+    // Cache is best-effort. Failure to persist must not break callers.
+  }
+}
+
+/**
+ * Fetch the models.dev registry with layered caching.
+ * @param {object} [opts]
+ * @param {boolean} [opts.forceRefresh] Skip in-mem + fresh-disk stages.
+ * @param {string}  [opts.yeaftDir] Override ~/.yeaft cache directory.
+ * @returns {Promise<object>} provider-id → provider entry; {} on total failure.
+ */
+export async function fetchModelsDev({ forceRefresh = false, yeaftDir = null } = {}) {
+  // Stage 1: in-memory cache.
+  if (!forceRefresh && _memCache && Date.now() - _memCacheTime < CACHE_TTL_MS) {
+    return _memCache;
+  }
+
+  // Stage 2: fresh-by-mtime disk cache short-circuits the network.
+  if (!forceRefresh) {
+    const age = await diskCacheAgeMs(yeaftDir);
+    if (age !== null && age < CACHE_TTL_MS) {
+      const data = await loadDiskCache(yeaftDir);
+      if (data && typeof data === 'object') {
+        _memCache = data;
+        _memCacheTime = Date.now() - age;
+        return _memCache;
+      }
+    }
+  }
+
+  // Stage 3: network fetch.
+  try {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), NETWORK_TIMEOUT_MS);
+    try {
+      const res = await fetch(MODELS_DEV_URL, { signal: ctrl.signal });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const data = await res.json();
+      if (data && typeof data === 'object') {
+        _memCache = data;
+        _memCacheTime = Date.now();
+        await saveDiskCache(yeaftDir, data);
+        return data;
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  } catch {
+    // Fall through to stale cache.
+  }
+
+  // Stage 4: stale disk cache fallback with short grace TTL so we retry soon.
+  if (!_memCache) {
+    const data = await loadDiskCache(yeaftDir);
+    if (data && typeof data === 'object') {
+      _memCache = data;
+      _memCacheTime = Date.now() - CACHE_TTL_MS + STALE_GRACE_MS;
+    }
+  }
+
+  return _memCache || {};
+}
+
+/**
+ * List all provider ids in the registry.
+ * @returns {Promise<string[]>}
+ */
+export async function listProviders({ yeaftDir = null } = {}) {
+  const data = await fetchModelsDev({ yeaftDir });
+  return Object.keys(data).sort();
+}
+
+/**
+ * Return raw provider entry from models.dev (with name, env, api, models).
+ */
+export async function getProviderInfo(providerId, { yeaftDir = null } = {}) {
+  const data = await fetchModelsDev({ yeaftDir });
+  const entry = data[providerId];
+  return entry && typeof entry === 'object' ? entry : null;
+}
+
+/**
+ * List model ids advertised by a provider.
+ * @returns {Promise<string[]>}
+ */
+export async function listProviderModels(providerId, { yeaftDir = null } = {}) {
+  const info = await getProviderInfo(providerId, { yeaftDir });
+  const models = info?.models;
+  if (!models || typeof models !== 'object') return [];
+  return Object.keys(models);
+}
+
+/**
+ * Reset the in-memory cache. Test seam.
+ */
+export function _resetMemCache() {
+  _memCache = null;
+  _memCacheTime = 0;
+}

package/unify/session.js

@@ -193,11 +193,28 @@ export async function loadSession(options = {}) {
     console.warn(`[Yeaft] ${yeaftDir} is not writable — running in read-only mode`);
   }
 
-  // ─── 3. Create debug trace ─────────────────────────────
+  // ─── 3. Create trajectory trace ─────────────────────────
+  // feat-always-on-trajectory-store: the trace is no longer gated on
+  // config.debug. It is a TRAJECTORY STORE: every turn's full
+  // (system_prompt, messages, tool_calls, tool_results, response, usage)
+  // is persisted to ~/.yeaft/debug.db so it can serve two purposes:
+  //   1. Debug panel hydration — user opens "请求日志" and sees prior turns.
+  //   2. SFT / RL training data — scripts can later dump JSONL trajectories.
+  // Cost is negligible (one insert per turn, WAL mode), and the data only
+  // accumulates while the user actually uses the agent. The previous gate
+  // silently discarded every turn unless the user had set debug:true in
+  // ~/.yeaft/config.json, which nobody ever did — wasting the asset.
   const trace = createTrace({
-    enabled: config.debug,
+    enabled: true,
     dbPath: join(yeaftDir, 'debug.db'),
   });
+  // Bound disk growth: prune trajectories older than 30 days on session load.
+  // Cheap (indexed DELETE), runs once per process start, not per turn. Without
+  // this the always-on store grows unbounded — cleanup() existed but had zero
+  // call sites before this PR.
+  try { trace.cleanup?.(30); } catch (err) {
+    console.warn('[Yeaft] trace.cleanup failed:', err?.message || err);
+  }
 
   // ─── 4. Create LLM adapter ────────────────────────────
   const adapter = await createLLMAdapter(config);