@yeaft/webchat-agent 1.0.508 → 1.0.509

package/yeaft/history-window.js

@@ -27,7 +27,7 @@ export const DEFAULT_RUNTIME_CACHE_TURN_CAP = 25;
 export const DEFAULT_RUNTIME_CACHE_TOKEN_BUDGET = 32768;
 export const DEFAULT_RUNTIME_CACHE_MESSAGE_CAP = 256;
 
-const MINIMUM_RECENT_PROVIDER_TURNS = 20;
+const MINIMUM_RECENT_PROVIDER_TURNS = 5;
 const IMAGE_PART_TOKEN_COST = 1024;
 const DOCUMENT_PART_TOKEN_COST = 2048;
 const CONTENT_PART_FRAME_TOKENS = 2;
@@ -900,9 +900,10 @@ function describeBucket(turns, messages = turns.flatMap(turn => turn.text)) {
  * configured recent window fits; tools are optional enrichment, newest first.
  *
  * The active turn is outside both buckets and consumes the global budget first.
- * Its opening user row is protected. Oversized recent text is fitted only in the
- * disposable provider copy so one large turn cannot evict the rest of the recent
- * window. Related recall remains optional and complete. External recall must have
+ * Its opening user row is protected. Recent text stays complete: reduce the
+ * oldest end of the suffix down to five turns (or all available for a new
+ * Session); fail closed if that floor cannot fit. Related recall only uses
+ * remaining budget and stays optional and complete. External recall must have
  * comparable userSeq/source identities to establish
  * that it predates recent/current history; unknown chronology fails closed.
  *
@@ -918,7 +919,7 @@ export function buildHistoryBuckets(snapshot, options = {}) {
   const tokenBudget = bucketCap(options.messageTokenBudget, DEFAULT_MESSAGE_TOKEN_BUDGET);
   const messageCap = bucketCap(options.maxMessageCount, DEFAULT_RUNTIME_CACHE_MESSAGE_CAP);
   const recentCap = bucketCap(options.recentTurnCap, 20);
-  const relatedCap = bucketCap(options.relatedTurnCap, 8, 10);
+  const relatedCap = bucketCap(options.relatedTurnCap, 5, 5);
   const keepToolTurns = bucketCap(options.keepToolTurns, DEFAULT_KEEP_TOOL_TURNS);
   const allTurns = splitBucketTurns(source);
   const currentStart = Number.isInteger(options.currentTurnStartIndex)
@@ -1022,65 +1023,26 @@ export function buildHistoryBuckets(snapshot, options = {}) {
       // past-turn boundary is still a safe fence; never guess from text/time.
       || (turn.index == null && currentIdentity.userSeq == null && past.length > 0
         && bucketBefore(turn, past.at(-1)))));
-  // A candidate inside the initial recent cap can become related after budget
-  // eviction. Reserve before picking the final suffix so it can re-enter.
-  const reservable = relatedCap > 0 ? eligible.filter(turn => turn.tokens <= availableTokens
-    && turn.text.length <= availableRows
-    && (recentCap === 0 || !past.length || bucketBefore(turn, past.at(-1)))) : [];
-  const reserve = reservable.length ? Math.floor(availableTokens * 0.25) : 0;
-  const reservedRows = reservable.length
-    ? Math.max(Math.floor(availableRows * 0.25), Math.min(...reservable.map(turn => turn.text.length))) : 0;
-  function fitRecentTurn(turn, tokenLimit) {
-    if (turn.tokens <= tokenLimit) return turn.text;
-    const fitted = [];
-    let tokens = tokenLimit;
-    for (let index = 0; index < turn.text.length; index += 1) {
-      const remainingRows = turn.text.length - index;
-      const allowance = Math.max(2, Math.floor(tokens / remainingRows));
-      const message = shrinkMessageToBudget(turn.text[index], allowance);
-      const rows = dropEmptyAssistantRows([message]);
-      fitted.push(...rows);
-      tokens -= estimateMessagesTokens(rows);
-    }
-    return fitted;
+  // Recent text has first claim on history budget. Drop whole oldest turns,
+  // never reserve space for recall or truncate text to manufacture turn counts.
+  const recent = [];
+  let recentTokens = 0;
+  let recentRows = 0;
+  const recentCandidates = recentCap > 0 ? past.slice(-recentCap) : [];
+  for (let index = recentCandidates.length - 1; index >= 0; index -= 1) {
+    const turn = recentCandidates[index];
+    if (recentTokens + turn.tokens > availableTokens
+      || recentRows + turn.text.length > availableRows) break;
+    recent.unshift(turn);
+    recentTokens += turn.tokens;
+    recentRows += turn.text.length;
   }
-  function selectRecent(limit, rowLimit = availableRows) {
-    const candidates = past.slice(-recentCap);
-    if (!candidates.length || limit <= 0 || rowLimit <= 0) return [];
-    const preserveBoundaries = candidates.length >= MINIMUM_RECENT_PROVIDER_TURNS
-      && rowLimit >= candidates.reduce((sum, turn) => sum + turn.text.length, 0)
-      && limit >= candidates.length * 2;
-    if (!preserveBoundaries) {
-      const selected = [];
-      let tokens = 0;
-      let rows = 0;
-      for (let index = candidates.length - 1; index >= 0; index -= 1) {
-        const turn = candidates[index];
-        if (tokens + turn.tokens > limit || rows + turn.text.length > rowLimit) break;
-        selected.unshift(turn);
-        tokens += turn.tokens;
-        rows += turn.text.length;
-      }
-      return selected;
-    }
-
-    const selected = [];
-    let tokens = Math.floor(limit);
-    let rows = Math.floor(rowLimit);
-    for (const turn of candidates) {
-      const remainingTurns = candidates.length - selected.length;
-      if (rows < remainingTurns) break;
-      const allowance = Math.max(2, Math.floor(tokens / remainingTurns));
-      const fitted = fitRecentTurn(turn, allowance);
-      if (!fitted.length || fitted.length > rows - (remainingTurns - 1)) continue;
-      const used = estimateMessagesTokens(fitted);
-      selected.push({ ...turn, text: fitted, tokens: used });
-      tokens -= used;
-      rows -= fitted.length;
-    }
-    return selected;
+  const minimumRecent = Math.min(MINIMUM_RECENT_PROVIDER_TURNS, recentCandidates.length);
+  if (recent.length < minimumRecent) {
+    const error = new Error(`Context budget cannot retain ${minimumRecent} complete recent history turns`);
+    error.code = 'HISTORY_RECENT_BUDGET_EXCEEDED';
+    throw error;
   }
-  let recent = selectRecent(availableTokens - reserve, availableRows - reservedRows);
   let remainingTokens = availableTokens - recent.reduce((total, turn) => total + turn.tokens, 0);
   let remainingRows = availableRows - recent.reduce((total, turn) => total + turn.text.length, 0);
   const related = [];
@@ -1098,34 +1060,15 @@ export function buildHistoryBuckets(snapshot, options = {}) {
     remainingTokens -= turn.tokens;
     remainingRows -= turn.text.length;
   }
-  if (!related.length) recent = selectRecent(availableTokens);
-  else {
-    // Pay the actual related cost, not the provisional reserve. Expand the
-    // recent suffix only while every related turn remains strictly older.
-    const expanded = selectRecent(
-      availableTokens - related.reduce((sum, turn) => sum + turn.tokens, 0),
-      availableRows - related.reduce((sum, turn) => sum + turn.text.length, 0),
-    );
-    while (expanded.length > recent.length && related.some(turn => (
-      !bucketBefore(turn, expanded[0]) || bucketOverlap(turn, expanded[0])
-    ))) expanded.shift();
-    if (expanded.length > recent.length) recent = expanded;
-  }
   related.sort((a, b) => bucketBefore(a, b) ? -1 : bucketBefore(b, a) ? 1 : 0);
 
   const relatedMessages = related.flatMap(turn => turn.text);
-  const recentText = recent.flatMap(turn => turn.messages)
-    .filter(isVisibleConversationRow);
-  const recentWasFitted = recent.some(turn => turn.text !== turn.messages
-    && (turn.text.length !== bucketTextMessages(turn.messages).length
-      || turn.tokens !== estimateMessagesTokens(bucketTextMessages(turn.messages))));
-  const recentBaseline = recent.flatMap(turn => recentWasFitted ? turn.text : bucketTextMessages(turn.messages));
+  const recentBaseline = recent.flatMap(turn => turn.text);
   // Enrich only after both complete-text buckets and the active turn are paid.
   // Tool protocol is useful only for immediate continuity; unlike visible text,
   // it never reaches farther back than the configured recent tool window.
-  const toolCutIndex = indexOfNthTurnFromEnd(recentText, keepToolTurns);
   const recentToolSource = keepToolTurns > 0
-    ? recentText.slice(toolCutIndex < 0 ? 0 : toolCutIndex)
+    ? recent.slice(-keepToolTurns).flatMap(turn => turn.messages).filter(isVisibleConversationRow)
     : [];
   const recentMessages = withoutHistorySourceIndexes(addOptionalRecentToolPairs(
     recentBaseline,
@@ -1154,7 +1097,8 @@ export function buildHistoryBuckets(snapshot, options = {}) {
       budget: {
         messageTokenBudget: tokenBudget, maxMessageCount: messageCap,
         recentTurnCap: recentCap, relatedTurnCap: relatedCap,
-        relatedReservedTokens: reserve, availableHistoryTokens: availableTokens,
+        minimumRecentTurns: minimumRecent,
+        relatedReservedTokens: 0, availableHistoryTokens: availableTokens,
         usedTokens: estimateMessagesTokens(messages), usedMessages: messages.length,
       },
       dropped: {

package/yeaft/web-bridge.js

@@ -24,6 +24,7 @@ import { buildDreamOutputSnapshot } from './dream/output-snapshot.js';
 import { Engine } from './engine.js';
 import { loadSession } from './session.js';
 import { loadAgentMCPConfig, loadConfig, loadMCPConfig } from './config.js';
+import { resolveMaxOutputTokens } from './models.js';
 import {
   createManagedProjectSkill,
   createManagedSkill,
@@ -160,7 +161,8 @@ const SKILL_RELOAD_INTERVAL_MS = 2_000;
  * loads the Session.
  * @type {Map<string, {
  *   resolve:Function,
- *   reject?:Function,
+ *   reject:Function,
+ *   conversationId:string|null,
  *   sessionId:string,
  *   vpId:string,
  *   threadId:string,
@@ -176,6 +178,9 @@ const SKILL_RELOAD_INTERVAL_MS = 2_000;
  *   onAbort?:Function,
  * }>} */
 const pendingUserPrompts = new Map();
+// Instance-local retry receipts, never persisted with Session runtime data.
+const terminalUserPrompts = new Map();
+const MAX_TERMINAL_USER_PROMPTS = 256;
 
 /** @type {import('./session.js').Session | null} */
 let session = null;
@@ -2238,7 +2243,9 @@ async function routeEnvelopeToVpThread(sessionId, vpId, envelope) {
     });
   }
 
-  if (related) {
+  // An append shares the running query's request config. A quick send owns
+  // a separate query, so retain its envelope in this thread's normal inbox.
+  if (related && !envelope?._turnConfig) {
     const content = promptParts || prompt;
     const injectedBy = envelope?.msg?.meta?.injectedBy;
     const isInternalAppend = injectedBy === 'route_forward' || injectedBy === 'task_result';
@@ -3036,10 +3043,10 @@ function mergedStatusForProjectRuntime(runtime, ownerSession = session) {
 }
 
 /** Send a Yeaft Session metadata event over the legacy-compatible envelope. */
-function sendSessionEvent(event, { sessionId, chatId, vpId, turnId, threadId, requestId, requestClientId, perfTraceId } = {}) {
+function sendSessionEvent(event, { sessionId, chatId, vpId, turnId, threadId, requestId, requestClientId, perfTraceId, conversationId = yeaftConversationId } = {}) {
   sendToServer({
     type: 'yeaft_output',
-    conversationId: yeaftConversationId,
+    conversationId,
     ...(perfTraceId ? { perfTraceId } : {}),
     ...(requestId ? { requestId } : {}),
     ...(requestClientId ? { _requestClientId: requestClientId } : {}),
@@ -3085,26 +3092,52 @@ function replayPendingUserPrompts(sessionId) {
   }
 }
 
-function settlePendingUserPrompt(requestId, pending, { answers = null, timedOut = false } = {}) {
+function registerPendingUserPrompt(requestId, pending) {
+  pending.onAbort = () => settlePendingUserPrompt(requestId, pending, { aborted: true });
+  pending.timer = setTimeout(() => {
+    settlePendingUserPrompt(requestId, pending, { timedOut: true });
+  }, Math.max(0, pending.expiresAt - Date.now()));
+  pending.timer.unref?.();
+  pendingUserPrompts.set(requestId, pending);
+  if (pending.signal?.aborted) pending.onAbort();
+  else pending.signal?.addEventListener('abort', pending.onAbort, { once: true });
+}
+
+function settlePendingUserPrompt(requestId, pending, { answers = null, timedOut = false, aborted = false } = {}) {
   if (pendingUserPrompts.get(requestId) !== pending) return false;
   pendingUserPrompts.delete(requestId);
   if (pending.timer) clearTimeout(pending.timer);
   if (pending.signal && pending.onAbort) {
     try { pending.signal.removeEventListener('abort', pending.onAbort); } catch { /* ignore */ }
   }
-  try { pending.resumeQueryTimer?.(); } catch { /* best-effort */ }
-  sendSessionEvent({
-    type: timedOut ? 'ask_user_expired' : 'ask_user_answered',
+  if (!aborted) {
+    try { pending.resumeQueryTimer?.(); } catch { /* best-effort */ }
+  }
+  const expired = timedOut || aborted;
+  const event = {
+    type: expired ? 'ask_user_expired' : 'ask_user_answered',
     requestId,
     toolCallId: pending.toolCallId || null,
-    ...(timedOut ? { expiredAt: Date.now() } : { answers: answers || {} }),
-  }, {
+    ...(expired ? { expiredAt: Date.now() } : { answers: answers || {} }),
+  };
+  const identity = {
+    requestId,
+    toolCallId: pending.toolCallId,
+    conversationId: pending.conversationId,
     sessionId: pending.sessionId,
     vpId: pending.vpId,
     threadId: pending.threadId,
     turnId: pending.turnId,
-  });
-  pending.resolve(timedOut ? { __yeaftTimedOut: true } : (answers || {}));
+  };
+  terminalUserPrompts.set(requestId, { identity, event });
+  while (terminalUserPrompts.size > MAX_TERMINAL_USER_PROMPTS) {
+    terminalUserPrompts.delete(terminalUserPrompts.keys().next().value);
+  }
+  // Like prompt replay, live settlement belongs to the current projection,
+  // not the conversation generation captured when the question was created.
+  sendSessionEvent(event, { ...identity, conversationId: yeaftConversationId || pending.conversationId });
+  if (aborted) pending.reject(new Error('aborted'));
+  else pending.resolve(timedOut ? { __yeaftTimedOut: true } : (answers || {}));
   return true;
 }
 
@@ -4744,6 +4777,27 @@ function handleEngineEvent(event, hctx) {
  *   - No legacy "no-session" fallback paths — they were the source of the
  *     router_unavailable bug fixed in v0.1.671.
  */
+/** Validate a one-message override against the loaded Agent catalog, never Session config. */
+export function validateQuickSend(value, config) {
+  if (value === undefined) return null;
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error('quickSend must be an object');
+  }
+  const { model, effort, maxOutputTokens } = value;
+  const entry = typeof model === 'string' && model.includes('/')
+    ? config?.availableModels?.find(candidate => candidate.ref === model)
+    : null;
+  if (!entry) throw new Error('quickSend.model must name an available provider/model');
+  if (effort !== null && (typeof effort !== 'string' || !entry.effortOptions?.includes(effort))) {
+    throw new Error('quickSend.effort is not supported by the selected model');
+  }
+  if (maxOutputTokens !== null && (!Number.isSafeInteger(maxOutputTokens) || maxOutputTokens < 1
+      || maxOutputTokens > resolveMaxOutputTokens(entry.id, { modelInfo: entry }))) {
+    throw new Error('quickSend.maxOutputTokens must be null or a positive integer within the model output limit');
+  }
+  return { model, effort, maxOutputTokens };
+}
+
 async function runYeaftSessionSend(msg) {
   if (!msg || typeof msg !== 'object') return;
   const { text } = msg;
@@ -4800,6 +4854,20 @@ async function runYeaftSessionSend(msg) {
     return;
   }
 
+  // Reject malformed overrides before boot, roster changes, attachment writes,
+  // or coordinator persistence. The error includes the client id for retry.
+  let turnConfig = null;
+  try {
+    if (msg.quickSend !== undefined) {
+      turnConfig = validateQuickSend(msg.quickSend, loadConfig({ dir: yeaftDir }));
+    }
+  } catch (err) {
+    sendSessionOutputFrame({ type: 'error', code: 'invalid_quick_send',
+      message: err.message, clientMessageId: msg.id || null }, { sessionId });
+    sendSessionOutputFrame({ type: 'result', result_text: '', is_error: true }, { sessionId });
+    return;
+  }
+
   // Open the user-level session metadata first so project runtime loading can
   // use the stored workDir without blocking the user-message hot path. If
   // metadata is missing we still boot the agent runtime for a useful error
@@ -4981,6 +5049,7 @@ async function runYeaftSessionSend(msg) {
       // Live form — adapters need the base64 image blocks; runVpTurn
       // reads `_promptParts` off the envelope rather than going
       // back to disk on every fan-out target. NOT persisted.
+      _turnConfig: turnConfig,
       _promptParts: attachmentBundle.promptParts,
       _promptSuffix: attachmentBundle.promptSuffix,
       _perfTraceId: perfTraceId,
@@ -5166,6 +5235,12 @@ export function buildVpQueryOpts({ vpId, sessionCoordinator, sessionId, envelope
   // envelope inside router.forward.
   if (envelope && typeof envelope === 'object') {
     out.inboundEnvelope = envelope;
+    // Only direct delivery of this user message inherits quick-send settings.
+    // RouteForward and background reentry keep the recipient's own defaults.
+    if (envelope._turnConfig && !envelope.msg?.meta?.injectedBy
+        && (envelope.msg?.role === 'user' || envelope.msg?.from === 'user')) {
+      out.turnConfig = { ...envelope._turnConfig };
+    }
   }
   // TodoWrite per-thread isolation. Bind closures that read/write a slot
   // keyed by `${sessionId}::${vpId}::${threadId}` so concurrent threads for
@@ -5720,6 +5795,7 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
           const pending = {
             resolve,
             reject,
+            conversationId: yeaftConversationId,
             sessionId,
             vpId,
             threadId,
@@ -5734,20 +5810,8 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
             signal,
             onAbort: null,
           };
-          const onAbort = () => {
-            if (pendingUserPrompts.get(requestId) !== pending) return;
-            pendingUserPrompts.delete(requestId);
-            if (pending.timer) clearTimeout(pending.timer);
-            reject(new Error('aborted'));
-          };
-          pending.onAbort = onAbort;
-          pending.timer = setTimeout(() => {
-            settlePendingUserPrompt(requestId, pending, { timedOut: true });
-          }, ASK_USER_TIMEOUT_MS);
-          if (typeof pending.timer.unref === 'function') pending.timer.unref();
-          pendingUserPrompts.set(requestId, pending);
-          signal.addEventListener('abort', onAbort, { once: true });
-          sendPendingUserPrompt(requestId, pending);
+          registerPendingUserPrompt(requestId, pending);
+          if (pendingUserPrompts.has(requestId)) sendPendingUserPrompt(requestId, pending);
         }),
         threadId,
         vpTurnId: turnId,
@@ -6829,16 +6893,42 @@ export async function handleYeaftFetchDebugHistory(msg = {}) {
 }
 
 /** Resolve a pending Yeaft AskUser prompt from the web UI. */
-export function handleYeaftAskUserAnswer(msg) {
+export function handleYeaftAskUserAnswer(msg = {}) {
   const requestId = typeof msg?.requestId === 'string' ? msg.requestId : '';
+  const rejectAnswer = reason => {
+    // Echo only submitted identity: never expose the actual pending scope.
+    sendSessionEvent({
+      type: 'ask_user_answer_rejected', requestId,
+      toolCallId: msg?.toolCallId || null, reason,
+    }, {
+      requestId, requestClientId: msg?._requestClientId,
+      conversationId: msg?.conversationId ?? null,
+      sessionId: msg?.sessionId, vpId: msg?.vpId,
+      turnId: msg?.turnId, threadId: msg?.threadId,
+    });
+    return false;
+  };
   const pending = pendingUserPrompts.get(requestId);
-  if (!pending) return false;
-  if (msg.sessionId && msg.sessionId !== pending.sessionId) return false;
-  if (msg.vpId && msg.vpId !== pending.vpId) return false;
-  if (msg.turnId && msg.turnId !== pending.turnId) return false;
-  if (msg.threadId && msg.threadId !== pending.threadId) return false;
-  if (msg.toolCallId && msg.toolCallId !== pending.toolCallId) return false;
-
+  const terminal = terminalUserPrompts.get(requestId);
+  const identity = pending || terminal?.identity;
+  if (!identity) return rejectAnswer('unavailable');
+  // Retain legacy optional identity matching. conversationId is a projection
+  // generation, not Session ownership; it can change after a reconnect.
+  for (const field of ['sessionId', 'vpId', 'turnId', 'threadId', 'toolCallId']) {
+    if (msg[field] && msg[field] !== identity[field]) return rejectAnswer('identity_mismatch');
+  }
+  if (!pending) {
+    sendSessionEvent(terminal.event, {
+      ...terminal.identity,
+      conversationId: msg.conversationId ?? terminal.identity.conversationId,
+      requestClientId: msg._requestClientId,
+    });
+    return terminal.event.type === 'ask_user_answered' ? true : rejectAnswer('unavailable');
+  }
+  if (pending.expiresAt <= Date.now()) {
+    settlePendingUserPrompt(requestId, pending, { timedOut: true });
+    return rejectAnswer('unavailable');
+  }
   return settlePendingUserPrompt(requestId, pending, { answers: msg.answers || {} });
 }
 
@@ -8211,11 +8301,10 @@ export const __testHooks = {
     vpAborts.clear();
     vpInboxes.clear();
   },
-  seedPendingUserPrompt({ requestId = 'ask-test', sessionId = 'session-test', vpId = 'vp-test', threadId = 'main', turnId = 'turn-test', toolCallId = 'call-test', question = 'Continue?', options = [], createdAt = Date.now(), expiresAt = Date.now() + ASK_USER_TIMEOUT_MS } = {}) {
-    let resolved;
-    const promise = new Promise(resolve => { resolved = resolve; });
-    pendingUserPrompts.set(requestId, { resolve: resolved, sessionId, vpId, threadId, turnId, toolCallId, question, options, createdAt, expiresAt, timer: null });
-    return promise;
+  seedPendingUserPrompt({ requestId = 'ask-test', sessionId = 'session-test', vpId = 'vp-test', threadId = 'main', turnId = 'turn-test', toolCallId = 'call-test', conversationId = yeaftConversationId, question = 'Continue?', options = [], createdAt = Date.now(), expiresAt = Date.now() + ASK_USER_TIMEOUT_MS, signal = null } = {}) {
+    return new Promise((resolve, reject) => {
+      registerPendingUserPrompt(requestId, { resolve, reject, conversationId, sessionId, vpId, threadId, turnId, toolCallId, question, options, createdAt, expiresAt, signal });
+    });
   },
   replayPendingUserPrompts,
   settlePendingUserPromptForTest(requestId, opts = {}) {
@@ -8225,8 +8314,10 @@ export const __testHooks = {
   resetPendingUserPrompts() {
     for (const pending of pendingUserPrompts.values()) {
       if (pending.timer) clearTimeout(pending.timer);
+      if (pending.onAbort) pending.signal?.removeEventListener('abort', pending.onAbort);
     }
     pendingUserPrompts.clear();
+    terminalUserPrompts.clear();
   },
   resetVpStatusBroker() {
     if (vpStatusBroker) vpStatusBroker.reset();