@yeaft/webchat-agent 1.0.120 → 1.0.122

package/connection/message-router.js

@@ -30,7 +30,34 @@ import { getLlmConfig, updateLlmConfig, getYeaftSettings, updateYeaftSettings, g
 import { discoverLlmModels } from '../llm-model-discovery.js';
 import { fetchModelsDev } from '../yeaft/llm/models-dev.js';
 import { handleYeaftSessionSend, handleYeaftSubAgentPrompt, handleYeaftTaskCancel, handleYeaftModeSwitch, handleYeaftModelSwitch, resetYeaftSession, handleYeaftLoadHistory, handleYeaftLoadMoreHistory, handleYeaftAbortThread, handleYeaftAbortAll, handleYeaftAbortTurn, handleYeaftVpSubscribe, handleYeaftVpCreate, handleYeaftVpUpdate, handleYeaftVpDelete, handleYeaftVpRead, handleYeaftListSessions, handleYeaftCreateSession, handleYeaftRenameSession, handleYeaftUpdateSession, handleYeaftUpdateSessionConfig, handleYeaftArchiveSession, handleYeaftDeleteSession, handleYeaftSessionAddMember, handleYeaftSessionRemoveMember, handleYeaftSessionSetDefaultVp, handleYeaftScanWorkdirSessions, handleYeaftRestoreSession, handleYeaftDreamTrigger, handleYeaftFetchToolStats, handleYeaftFetchDebugHistory, handleYeaftMcpList, handleYeaftMcpAdd, handleYeaftMcpRemove, handleYeaftMcpReload, broadcastLanguageChange, broadcastYeaftSessionSnapshotEager, preloadYeaftSkillSlashCommands } from '../yeaft/web-bridge.js';
-import { startYeaftStatusRefresh, refreshYeaftStatus } from '../yeaft/status-cache.js';
+import { startYeaftStatusRefresh, forceRefreshYeaftStatus } from '../yeaft/status-cache.js';
+
+export async function applyLlmConfigUpdate(msg, dependencies = {}) {
+  const updateConfig = dependencies.updateLlmConfig || updateLlmConfig;
+  const broadcastLanguage = dependencies.broadcastLanguageChange || broadcastLanguageChange;
+  const forceStatusRefresh = dependencies.forceRefreshYeaftStatus || forceRefreshYeaftStatus;
+  const send = dependencies.sendToServer || sendToServer;
+  const yeaftDir = dependencies.yeaftDir ?? ctx.CONFIG?.yeaftDir;
+  const incomingLanguage = typeof msg.config?.language === 'string' && msg.config.language
+    ? msg.config.language
+    : null;
+  const result = updateConfig(msg.config || {}, yeaftDir);
+  if (!result.error && incomingLanguage) broadcastLanguage(result.language);
+
+  let statusRefreshError = null;
+  if (!result.error) {
+    try {
+      const statusEvent = await forceStatusRefresh({ reason: 'llm_config_updated' });
+      statusRefreshError = statusEvent?.refreshError || null;
+    } catch (err) {
+      statusRefreshError = err?.message || String(err);
+    }
+  }
+
+  const response = { type: 'llm_config_updated', ...result, statusRefreshError };
+  send(response);
+  return response;
+}
 
 export async function handleMessage(msg) {
   switch (msg.type) {
@@ -326,32 +353,10 @@ export async function handleMessage(msg) {
     }
 
     case 'update_llm_config': {
-      // Capture the user's intent BEFORE updateLlmConfig — the return
-      // envelope ALWAYS populates `language` (falls back to 'en'), so
-      // gating on the *output* would broadcast on every provider /
-      // primaryModel / fastModel save, not just locale flips. Gate on
-      // the *input* `language` field instead.
-      const incomingLanguage = typeof msg.config?.language === 'string' && msg.config.language
-        ? msg.config.language
-        : null;
-      const result = updateLlmConfig(msg.config || {}, ctx.CONFIG?.yeaftDir);
-      // task-708: live locale propagation. When the user flips the UI
-      // language dropdown, push the new value into every cached Engine
-      // (per-VP pool + 1:1 chat session.engine) so the very next turn
-      // renders the system prompt in the chosen language without the
-      // user reloading the session.
-      if (!result.error && incomingLanguage) {
-        broadcastLanguageChange(result.language);
-      }
-      if (!result.error) {
-        refreshYeaftStatus({ reason: 'llm_config_updated' }).catch(() => {});
-        if (!incomingLanguage) {
-          resetYeaftSession().catch(err => {
-            console.error('[LLM] Failed to reload Yeaft session after local config update:', err.message);
-          });
-        }
-      }
-      sendToServer({ type: 'llm_config_updated', ...result });
+      // Saving the file and refreshing the model menu are separate outcomes.
+      // Always acknowledge the completed write; the frontend owns the single
+      // runtime reset it dispatches after a successful save.
+      await applyLlmConfigUpdate(msg);
       break;
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.120",
+  "version": "1.0.122",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/engine.js

@@ -23,7 +23,7 @@ import { join, resolve as resolvePath } from 'path';
 import { buildSystemPrompt, buildWorkerPrompt } from './prompts.js';
 import { getRuntimePlatformInfo } from './runtime-platform.js';
 import { LLMContextError, LLMAbortError, LLMRateLimitError, LLMServerError, LLMStreamIdleTimeoutError } from './llm/adapter.js';
-import { runMemoryPreflow, buildRelevantScopes } from './sessions/pre-flow.js';
+import { runMemoryPreflow, buildRelevantScopes, memoryScopeLabel } from './sessions/pre-flow.js';
 import { readProjectDoc, pickProjectDocFile, DEFAULT_PROJECT_DOC_MAX_BYTES } from './sessions/project-doc.js';
 import { partitionMessages } from './compact/partition.js';
 import { runCompact as runCompactOrchestrator } from './compact/orchestrator.js';
@@ -905,19 +905,19 @@ export class Engine {
     if (snap.resident.length > 0) {
       parts.push(zh ? '### 常驻记忆' : '### Resident');
       for (const r of snap.resident) {
-        parts.push(`- **${r.scope}**: ${r.summary}`);
+        parts.push(`- **${memoryScopeLabel(r.scope)}**: ${r.summary}`);
       }
     }
     if (snap.recent.length > 0) {
       parts.push(zh ? '### 最近记忆' : '### Recent');
       for (const s of snap.recent) {
-        parts.push(`- (${s.scope}) ${(s.body || '').trim()}`);
+        parts.push(`- (${memoryScopeLabel(s.scope)}) ${(s.body || '').trim()}`);
       }
     }
     if (snap.onDemand.length > 0) {
       parts.push(zh ? '### 按需记忆' : '### OnDemand');
       for (const s of snap.onDemand) {
-        parts.push(`- (${s.scope}) ${(s.body || '').trim()}`);
+        parts.push(`- (${memoryScopeLabel(s.scope)}) ${(s.body || '').trim()}`);
       }
     }
     return parts.join('\n');

package/yeaft/sessions/pre-flow.js

@@ -157,6 +157,24 @@ export function selectRespondingVps(input) {
 }
 
 
+/**
+ * Turn an internal memory scope into the compact label shown to the model.
+ * The active-scope prompt already carries the current session id, so repeating
+ * the full storage path on every memory entry only wastes context. Internal
+ * entries and debug events keep the original scope for ACLs and diagnostics.
+ *
+ * @param {string} scope
+ * @returns {string}
+ */
+export function memoryScopeLabel(scope) {
+  const value = typeof scope === 'string' && scope ? scope : 'unknown';
+  const sessionTopic = /^(?:sessions|session|group)\/[^/]+\/topic\/(.+)$/.exec(value);
+  if (sessionTopic) return `topic: ${sessionTopic[1]}`;
+  if (/^(?:sessions|session|group)\/[^/]+$/.test(value)) return 'session';
+  if (value.startsWith('topic/')) return `topic: ${value.slice(6)}`;
+  return value;
+}
+
 /**
  * Build the heading for a single scope's formatted memory block.
  *
@@ -167,6 +185,8 @@ export function selectRespondingVps(input) {
  * @returns {string}
  */
 function scopeHeading(scope) {
+  const label = memoryScopeLabel(scope);
+  if (label.startsWith('topic: ')) return `## Memory: Topic ${label.slice(7)}`;
   if (scope === 'user') return '## Memory: User';
   // Nested chat scopes first.
   let m = /^chat\/([^/]+)\/vp\/(.+)$/.exec(scope);
@@ -180,10 +200,6 @@ function scopeHeading(scope) {
   if (m) return `## Memory: Session ${m[1]} (user)`;
   m = /^session\/([^/]+)\/feature\/(.+)$/.exec(scope);
   if (m) return `## Memory: Feature ${m[2]}`;
-  m = /^sessions\/([^/]+)\/topic\/(.+)$/.exec(scope);
-  if (m) return `## Memory: Topic ${m[2]}`;
-  m = /^session\/([^/]+)\/topic\/(.+)$/.exec(scope);
-  if (m) return `## Memory: Topic ${m[2]}`;
   // Legacy nested group scopes (un-migrated data).
   m = /^group\/([^/]+)\/vp\/(.+)$/.exec(scope);
   if (m) return `## Memory: VP ${m[2]}`;
@@ -191,8 +207,6 @@ function scopeHeading(scope) {
   if (m) return `## Memory: Session ${m[1]} (user)`;
   m = /^group\/([^/]+)\/feature\/(.+)$/.exec(scope);
   if (m) return `## Memory: Feature ${m[2]}`;
-  m = /^group\/([^/]+)\/topic\/(.+)$/.exec(scope);
-  if (m) return `## Memory: Topic ${m[2]}`;
   if (scope.startsWith('session/')) return `## Memory: Session ${scope.slice(8)}`;
   if (scope.startsWith('group/')) return `## Memory: Session ${scope.slice(6)}`;
   if (scope.startsWith('vp/')) return `## Memory: VP ${scope.slice(3)}`;

package/yeaft/status-cache.js

@@ -53,6 +53,7 @@ export function createYeaftStatusCache(options = {}) {
   let snapshot = null;
   let timer = null;
   let inFlight = null;
+  let generation = 0;
 
   function current() {
     return snapshot ? { ...snapshot, availableModels: normalizeAvailableModels(snapshot.availableModels) } : null;
@@ -68,14 +69,16 @@ export function createYeaftStatusCache(options = {}) {
   async function refresh({ reason = 'manual', emitRefreshing = true, sessionStatus = null } = {}) {
     if (inFlight) return inFlight;
     const startedAt = now();
+    const refreshGeneration = generation;
     if (emitRefreshing && snapshot) {
       snapshot = { ...snapshot, refreshing: true, refreshStartedAt: startedAt, refreshReason: reason };
       emitSnapshot();
     }
-    inFlight = Promise.resolve()
+    const refreshPromise = Promise.resolve()
       .then(async () => {
         const yeaftDir = options.getYeaftDir ? options.getYeaftDir() : ctx.CONFIG?.yeaftDir;
         const config = await load({ ...(yeaftDir && { dir: yeaftDir }) });
+        if (refreshGeneration !== generation) return current();
         const previous = snapshot || {};
         snapshot = {
           ...previous,
@@ -94,6 +97,7 @@ export function createYeaftStatusCache(options = {}) {
         return emitSnapshot();
       })
       .catch((err) => {
+        if (refreshGeneration !== generation) return current();
         const message = err?.message || String(err);
         const previous = snapshot || {};
         snapshot = {
@@ -107,12 +111,28 @@ export function createYeaftStatusCache(options = {}) {
         };
         return emitSnapshot();
       })
-      .finally(() => { inFlight = null; });
-    return inFlight;
+      .finally(() => {
+        if (inFlight === refreshPromise) inFlight = null;
+      });
+    inFlight = refreshPromise;
+    return refreshPromise;
+  }
+
+  async function forceRefresh(options = {}) {
+    // Invalidate any disk read that started before the config write, wait for it
+    // to drain, then start a new read. A plain refresh() intentionally dedupes
+    // concurrent callers, which is wrong after a successful config update.
+    generation += 1;
+    if (inFlight) await inFlight;
+    return refresh({ ...options, emitRefreshing: options.emitRefreshing ?? false });
   }
 
   function hydrateFromSession(sessionLike, { reason = 'session_ready', emitEvent = true } = {}) {
     if (!sessionLike) return null;
+    // Session hydration is authoritative. Any refresh that started before this
+    // point loaded an older disk snapshot and must not overwrite it when it
+    // resolves later.
+    generation += 1;
     const previous = snapshot || {};
     snapshot = {
       ...previous,
@@ -144,7 +164,7 @@ export function createYeaftStatusCache(options = {}) {
     timer = null;
   }
 
-  return { current, refresh, hydrateFromSession, start, stop, emitSnapshot };
+  return { current, refresh, forceRefresh, hydrateFromSession, start, stop, emitSnapshot };
 }
 
 export const yeaftStatusCache = createYeaftStatusCache();
@@ -161,6 +181,10 @@ export function refreshYeaftStatus(options) {
   return yeaftStatusCache.refresh(options);
 }
 
+export function forceRefreshYeaftStatus(options) {
+  return yeaftStatusCache.forceRefresh(options);
+}
+
 export function hydrateYeaftStatusFromSession(sessionLike, options) {
   return yeaftStatusCache.hydrateFromSession(sessionLike, options);
 }