@yeaft/webchat-agent 1.0.508 → 1.0.510

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();