@yeaft/webchat-agent 0.1.802 → 0.1.804

package/connection/message-router.js

@@ -36,7 +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 { handleUnifyGroupChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyLoadMoreHistory, handleUnifyAbortThread, handleUnifyAbortAll, handleUnifyAbortTurn, handleUnifyVpSubscribe, handleUnifyVpCreate, handleUnifyVpUpdate, handleUnifyVpDelete, handleUnifyVpRead, handleUnifyListGroups, handleUnifyCreateGroup, handleUnifyRenameGroup, handleUnifyUpdateGroup, handleUnifyArchiveGroup, handleUnifyDeleteGroup, handleUnifyAddMember, handleUnifyRemoveMember, handleUnifySetDefaultVp, handleUnifyDreamTrigger, handleUnifyFetchToolStats, handleUnifyFetchDebugHistory, broadcastLanguageChange } from '../unify/web-bridge.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) {
   switch (msg.type) {
@@ -476,6 +476,9 @@ export async function handleMessage(msg) {
     case 'unify_update_group':
       handleUnifyUpdateGroup(msg);
       break;
+    case 'unify_update_group_config':
+      handleUnifyUpdateGroupConfig(msg);
+      break;
     case 'unify_archive_group':
       handleUnifyArchiveGroup(msg);
       break;

package/package.json

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

package/unify/groups/group-config.js

@@ -0,0 +1,167 @@
+/**
+ * group-config.js — Per-group configuration overrides.
+ *
+ * Each group may carry its own `config.json` at
+ *   ~/.yeaft/groups/<groupId>/config.json
+ *
+ * v1 schema (intentionally tiny — extend via additive keys only):
+ *   {
+ *     "model": "my-proxy/claude-sonnet-4-20250514"   // optional
+ *   }
+ *
+ * Missing file → empty object. Missing field → fall back to user-level
+ * config (`~/.yeaft/config.json` via loadConfig()). Resolution is a
+ * shallow overlay (group fields override user fields when truthy).
+ *
+ * Storage layer only — no engine wiring, no validation of model strings
+ * against the provider registry (that's done lazily at resolve time by
+ * the engine when it tries to dispatch to AdapterRouter).
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { writeAtomic } from '../storage/index.js';
+import { groupsRoot, resolveGroupYeaftDir } from './group-crud.js';
+
+const CONFIG_FILE = 'config.json';
+
+/** Whitelist of fields a group may override. Reject everything else. */
+const ALLOWED_KEYS = new Set(['model']);
+
+export class GroupConfigError extends Error {
+  constructor(code, message) {
+    super(message || code);
+    this.name = 'GroupConfigError';
+    this.code = code;
+  }
+}
+
+/**
+ * Resolve the on-disk path for a group's config.json. Honours the
+ * per-group workDir registry so groups bound to a project directory
+ * keep their config alongside the group meta.
+ */
+export function groupConfigPath(yeaftDir, groupId) {
+  if (!yeaftDir) return null;
+  const groupYeaftDir = resolveGroupYeaftDir(yeaftDir, groupId);
+  return join(groupsRoot(groupYeaftDir), groupId, CONFIG_FILE);
+}
+
+/**
+ * Read a group's config.json. Returns `{}` when the file is missing or
+ * corrupt — callers fall back to user-level defaults via
+ * `resolveGroupConfig`. We never auto-write on read.
+ *
+ * @param {string} yeaftDir
+ * @param {string} groupId
+ * @returns {object}
+ */
+export function loadGroupConfig(yeaftDir, groupId) {
+  if (!groupId || !yeaftDir) return {};
+  const path = groupConfigPath(yeaftDir, groupId);
+  if (!path || !existsSync(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {};
+    // Strip unknown keys at read time too — defensive against
+    // hand-edited files that predate a key removal.
+    const out = {};
+    for (const k of Object.keys(parsed)) {
+      if (ALLOWED_KEYS.has(k)) out[k] = parsed[k];
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Validate a partial group-config object. Throws GroupConfigError on
+ * any unknown key or malformed value. Empty / null values for known
+ * keys are allowed — they signal "fall back to user default".
+ *
+ * @param {object} cfg
+ */
+export function validateGroupConfig(cfg) {
+  if (cfg === null || cfg === undefined) return;
+  if (typeof cfg !== 'object' || Array.isArray(cfg)) {
+    throw new GroupConfigError('invalid_shape', 'config must be an object');
+  }
+  for (const k of Object.keys(cfg)) {
+    if (!ALLOWED_KEYS.has(k)) {
+      throw new GroupConfigError('unknown_key', `unknown config key: ${k}`);
+    }
+  }
+  if ('model' in cfg && cfg.model !== null && cfg.model !== undefined && cfg.model !== '') {
+    if (typeof cfg.model !== 'string' || !cfg.model.trim()) {
+      throw new GroupConfigError('invalid_model', 'model must be a non-empty string');
+    }
+  }
+}
+
+/**
+ * Shallow-merge `partial` into the group's existing config.json and
+ * persist atomically. Returns the resulting object. Passing `null` or
+ * empty string for a known key removes that key (so the group falls
+ * back to the user default).
+ *
+ * @param {string} yeaftDir
+ * @param {string} groupId
+ * @param {object} partial
+ * @returns {object}
+ */
+export function saveGroupConfig(yeaftDir, groupId, partial) {
+  if (!groupId) throw new GroupConfigError('missing_group_id', 'groupId required');
+  validateGroupConfig(partial);
+  const current = loadGroupConfig(yeaftDir, groupId);
+  const next = { ...current };
+  for (const [k, v] of Object.entries(partial || {})) {
+    if (!ALLOWED_KEYS.has(k)) continue;
+    if (v === null || v === undefined || v === '') {
+      delete next[k];
+    } else {
+      next[k] = typeof v === 'string' ? v.trim() : v;
+    }
+  }
+  const path = groupConfigPath(yeaftDir, groupId);
+  writeAtomic(path, `${JSON.stringify(next, null, 2)}\n`);
+  return next;
+}
+
+/**
+ * Initialise an empty config.json next to a brand-new group. Idempotent —
+ * leaves an existing file untouched. Called by `createGroupFromSpec`.
+ */
+export function ensureGroupConfigFile(yeaftDir, groupId) {
+  const path = groupConfigPath(yeaftDir, groupId);
+  if (!path || existsSync(path)) return;
+  try {
+    writeAtomic(path, `${JSON.stringify({}, null, 2)}\n`);
+  } catch {
+    // Best-effort — a permission failure here should never break group
+    // create. Read path returns {} on missing file anyway.
+  }
+}
+
+/**
+ * Resolve the effective config for a group by overlaying group-level
+ * overrides on top of the user-level config.
+ *
+ * Only fields that the per-group schema knows about are overlaid;
+ * everything else (providers, language, token budgets, ...) is taken
+ * verbatim from the user config.
+ *
+ * @param {object} userConfig — loadConfig() result
+ * @param {object} groupConfig — loadGroupConfig() result
+ * @returns {object} — A new config object safe to hand to the engine.
+ */
+export function resolveGroupConfig(userConfig, groupConfig) {
+  const base = userConfig ? { ...userConfig } : {};
+  const overrides = groupConfig && typeof groupConfig === 'object' ? groupConfig : {};
+  if (overrides.model && typeof overrides.model === 'string' && overrides.model.trim()) {
+    const model = overrides.model.trim();
+    base.model = model;
+    base.primaryModel = model;
+  }
+  return base;
+}

package/unify/groups/group-crud.js

@@ -53,6 +53,7 @@ import { seedDefaultGroup, DEFAULT_GROUP_ID } from './seed-default.js';
 import { nextGroupId, validateVpId, isReservedVpId } from './ids.js';
 import { scanVpLibrary, DEFAULT_VP_LIB_DIR } from '../vp/vp-store.js';
 import { seedSummaryIfMissingSync, removeScopeDirSync } from '../memory/store-v2.js';
+import { ensureGroupConfigFile, saveGroupConfig, loadGroupConfig } from './group-config.js';
 
 /**
  * Default memory root used when callers don't pass `options.memoryRoot`.
@@ -263,6 +264,20 @@ export function createGroupFromSpec(yeaftDir, spec, options = {}) {
   handle.close();
   if (normalizedWorkDir) registerGroupWorkDir(yeaftDir, id, normalizedWorkDir);
 
+  // Per-group config (v1: model only). We always create an empty
+  // config.json so the file's presence signals "owned by this group" and
+  // hand-editing tools can find a stub. Initial overrides from the
+  // wizard spec (currently just `config.model`) are persisted here so
+  // the engine cache picks them up on the very first turn.
+  try {
+    ensureGroupConfigFile(yeaftDir, id);
+    if (spec && spec.config && typeof spec.config === 'object') {
+      saveGroupConfig(yeaftDir, id, spec.config);
+    }
+  } catch (err) {
+    console.warn(`[group-crud] failed to seed config.json for ${id}:`, err?.message || err);
+  }
+
   // Seed Layer-A resident summary so the first session has memory content
   // even before Dream-v2 has run. No-op if a summary.md already exists.
   // Best-effort: a memory-root permission failure must NOT break group create.
@@ -313,6 +328,22 @@ export function updateGroupAnnouncement(yeaftDir, groupId, text) {
   return next;
 }
 
+/**
+ * (A.2.c) Update per-group config overrides (v1: just `model`).
+ * Returns the persisted config object so the caller can broadcast it.
+ *
+ * Throws GroupConfigError on validation failure (unknown key, bad type).
+ * Group must exist (we call requireGroup to assert).
+ */
+export function updateGroupConfig(yeaftDir, groupId, partial) {
+  const handle = requireGroup(yeaftDir, groupId);
+  try {
+    return saveGroupConfig(yeaftDir, groupId, partial || {});
+  } finally {
+    handle.close();
+  }
+}
+
 /**
  * (A.3) Archive — renames the dir to `.archived-<ts>-<id>`. Directory
  * prefix `.` keeps `listGroups` from picking it up (readdirSync filter in
@@ -488,6 +519,11 @@ export function snapshotGroups(yeaftDir) {
     const meta = existsSync(dir) ? loadGroupMeta(dir) : null;
     if (meta) byId.set(meta.id, meta);
   }
+  // Attach per-group config overrides (v1: just `model`). Frontend can
+  // render the effective model without re-querying.
+  for (const meta of byId.values()) {
+    meta.config = loadGroupConfig(yeaftDir, meta.id);
+  }
   return Array.from(byId.values()).sort((a, b) => String(a.createdAt || '').localeCompare(String(b.createdAt || '')));
 }
 

package/unify/groups/index.js

@@ -50,7 +50,16 @@ export {
   removeMember,
   setGroupDefaultVp,
   snapshotGroups,
+  updateGroupConfig,
+  updateGroupAnnouncement,
 } from './group-crud.js';
+export {
+  loadGroupConfig,
+  saveGroupConfig,
+  resolveGroupConfig,
+  validateGroupConfig,
+  GroupConfigError,
+} from './group-config.js';
 export {
   nextMsgId,
   nextGroupId,

package/unify/web-bridge.js

@@ -45,6 +45,8 @@ import {
   groupsRoot,
 } from './groups/group-crud.js';
 import { openGroup, loadGroupMeta } from './groups/group-store.js';
+import { loadGroupConfig, resolveGroupConfig, GroupConfigError } from './groups/group-config.js';
+import { updateGroupConfig } from './groups/group-crud.js';
 import { createCoordinator } from './groups/coordinator.js';
 import { seedDefaultGroup } from './groups/seed-default.js';
 import {
@@ -760,10 +762,16 @@ function getOrCreateVpEngine(groupId, vpId, threadId = 'main') {
   let eng = vpEngines.get(key);
   if (eng) return eng;
   if (!session) throw new Error('getOrCreateVpEngine: session not loaded');
+  // Per-group config overlay (v1: model only). Falls back to the
+  // session's user-level config when no override is set. The resolver
+  // never mutates session.config — it returns a new object.
+  const yeaftDir = ctx.CONFIG?.yeaftDir || session.yeaftDir;
+  const groupCfg = loadGroupConfig(yeaftDir, groupId);
+  const effectiveConfig = resolveGroupConfig(session.config, groupCfg);
   eng = new Engine({
     adapter: session.adapter,
     trace: session.trace,
-    config: session.config,
+    config: effectiveConfig,
     conversationStore: session.conversationStore,
     memoryIndex: session.memoryIndex || null,
     amsRegistry: session.amsRegistry,
@@ -1318,8 +1326,11 @@ function sendGroupRosterChanged(group) {
 }
 
 function groupErrorPayload(err) {
+  let code = 'unknown';
+  if (err instanceof GroupCrudError) code = err.code;
+  else if (err instanceof GroupConfigError) code = err.code;
   return {
-    code: err instanceof GroupCrudError ? err.code : 'unknown',
+    code,
     groupId: err && err.groupId,
     message: err && err.message,
   };
@@ -1404,6 +1415,36 @@ export function handleUnifyUpdateGroup(msg) {
   }
 }
 
+/**
+ * Update per-group config overrides (v1: `model`). Cache invalidation:
+ * drop every cached Engine whose key starts with `${groupId}::` so the
+ * next turn picks up the new model. The group meta itself is untouched.
+ *
+ * Payload: { groupId, requestId, config: { model?: string|null } }
+ *  - `model: ''` or `null` clears the override (group falls back to user default).
+ */
+export function handleUnifyUpdateGroupConfig(msg) {
+  const requestId = msg && msg.requestId;
+  const groupId = msg && msg.groupId;
+  const partial = (msg && msg.config && typeof msg.config === 'object') ? msg.config : null;
+  try {
+    if (!groupId) throw new GroupConfigError('missing_group_id', 'groupId required');
+    if (!partial) throw new GroupConfigError('invalid_patch', 'config object required');
+    const yeaftDir = ctx.CONFIG?.yeaftDir;
+    const savedConfig = updateGroupConfig(yeaftDir, groupId, partial);
+    // Drop cached engines so the next VP turn rebuilds with the new model.
+    const prefix = `${groupId}::`;
+    for (const k of Array.from(vpEngines.keys())) {
+      if (k.startsWith(prefix)) vpEngines.delete(k);
+    }
+    invalidateGroupContext(groupId);
+    sendGroupCrudResult({ op: 'update_config', requestId, ok: true, groupId, config: savedConfig });
+    sendGroupSnapshotBroadcast();
+  } catch (err) {
+    sendGroupCrudResult({ op: 'update_config', requestId, ok: false, error: groupErrorPayload(err) });
+  }
+}
+
 export function handleUnifyArchiveGroup(msg) {
   const requestId = msg && msg.requestId;
   const groupId = msg && msg.groupId;