@yeaft/webchat-agent 1.0.504 → 1.0.506

package/yeaft/conversation/recall-relevance.js

@@ -0,0 +1,103 @@
+// Deterministic, deliberately conservative relevance shared by indexed and
+// in-memory turn recall. No provider calls and no transcript mutation.
+const MAX_PROMPT_CHARS = 4096;
+const MAX_TERMS = 8;
+const STOP_WORDS = new Set(`a an and are as at be been but by can could did do does for from had has have how i if in is it its me my of on or our please should so that the their them there these they this to was we were what when where which who why will with would you your about again before earlier previous remember recall history message messages conversation turn turns tell show find help need want use using make get know explain answer question code file project problem fix work task test tests implementation implement change thanks continue revisit discuss discussed discussion decide decided follow-up
+的 了 是 在 和 与 或 我 你 他 她 它 我们 你们 他们 这个 那个 什么 怎么 如何 为什么 请 请问 帮 帮我 帮忙 可以 能 不能 是否 需要 想 要 再 还 又 也 就 都 把 将 给 对 从 到 上 下 中 里 有 没有 一下 一些 一个 这些 那些 之前 以前 上次 刚才 历史 记得 回忆 召回 消息 对话 问题 回答 内容 事情 继续 现在 今天 昨天 后来 然后 相关 具体 代码 文件 项目 实现 修改 功能 测试 方案 方法 工作 任务 谢谢 好的 好 看看 查找 搜索 查询 处理 解决 进行 使用 讨论 提到 记忆 总结 回顾 提醒`.split(/\s+/u));
+const segmenter = new Intl.Segmenter('zh', { granularity: 'word' });
+
+function isIdentifier(term) {
+  return /[\p{L}\d][_.:/@-][\p{L}\d]/u.test(term)
+    || /\p{L}.*\d|\d.*\p{L}/u.test(term)
+    || /[a-z][A-Z]/u.test(term);
+}
+
+/** Extract at most eight meaningful lexical terms; generic prompts yield []. */
+export function extractRecallTerms(prompt) {
+  // VP routing is not subject matter: "@vp-omni 继续" must not recall every
+  // earlier message addressed to that VP just because it looks like an ID.
+  const text = typeof prompt === 'string'
+    ? prompt.slice(0, MAX_PROMPT_CHARS).replace(/@vp-[A-Za-z0-9_-]+\b/gu, ' ') : '';
+  const tokens = [];
+  // Keep paths, issue IDs, snake_case and camelCase intact before segmentation.
+  const rest = text.replace(/[\p{L}\p{N}]+(?:[_.:/@-][\p{L}\p{N}]+)+|[A-Za-z][A-Za-z0-9]*/gu, token => {
+    tokens.push(token);
+    return ' ';
+  });
+  let singleHan = '';
+  const flushHan = () => {
+    if (singleHan.length >= 2) tokens.push(singleHan);
+    singleHan = '';
+  };
+  for (const part of segmenter.segment(rest)) {
+    // ICU dictionaries sometimes split technical words such as 缓存 into
+    // individual Han characters. Preserve short adjacent runs, not stop words.
+    if (part.isWordLike && /^\p{Script=Han}$/u.test(part.segment) && !STOP_WORDS.has(part.segment)) {
+      singleHan += part.segment;
+      if (singleHan.length === 4) flushHan();
+    } else {
+      flushHan();
+      if (part.isWordLike) tokens.push(part.segment);
+    }
+  }
+  flushHan();
+  const seen = new Set();
+  const terms = tokens.filter(term => {
+    const key = term.toLocaleLowerCase();
+    if (seen.has(key) || STOP_WORDS.has(key) || /^\d+$/u.test(key)
+      || Array.from(key).length < 2 || key.length > 96) return false;
+    seen.add(key);
+    return true;
+  });
+  // Identifiers are more useful than prose if a long prompt exhausts the cap.
+  return terms.sort((a, b) => Number(isIdentifier(b)) - Number(isIdentifier(a))).slice(0, MAX_TERMS);
+}
+
+/**
+ * Score full visible turn text. stats.termDocumentFrequency may be a bounded
+ * candidate sample, not corpus-wide IDF; its sample size must be explicit.
+ * Returns explainable rejection reasons rather than weak positive matches.
+ */
+export function scoreRecallTurn(promptOrTerms, text, stats = {}) {
+  const terms = (Array.isArray(promptOrTerms) ? promptOrTerms : extractRecallTerms(promptOrTerms)).slice(0, MAX_TERMS);
+  const body = String(text || '').toLocaleLowerCase();
+  const matchedTerms = terms.filter(term => {
+    const key = term.toLocaleLowerCase();
+    if (/^[a-z0-9_]+$/u.test(key)) {
+      const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      return new RegExp(`(?<![a-z0-9_])${escaped}(?![a-z0-9_])`, 'u').test(body);
+    }
+    return body.includes(key);
+  });
+  const identifierMatches = matchedTerms.filter(isIdentifier);
+  const independentTerms = matchedTerms.filter(term => !matchedTerms.some(other => (
+    other !== term && other.toLocaleLowerCase().includes(term.toLocaleLowerCase())
+  )));
+  const coverage = terms.length ? matchedTerms.length / terms.length : 0;
+  const sampleSize = Math.max(0, Number(stats.sampleSize) || 0);
+  const distinctiveness = matchedTerms.length ? Math.max(...matchedTerms.map(term => {
+    const frequency = stats.termDocumentFrequency?.[term.toLocaleLowerCase()];
+    return sampleSize >= 8 && Number.isFinite(frequency) ? 1 - frequency / sampleSize : 1;
+  })) : 0;
+  let reason = 'relevant';
+  if (!terms.length) reason = 'generic_prompt';
+  else if (!matchedTerms.length) reason = 'no_match';
+  else if (!identifierMatches.length && independentTerms.length < 2) reason = 'insufficient_keywords';
+  else if (!identifierMatches.length && coverage < 0.5) reason = 'low_coverage';
+  else if (!identifierMatches.length && distinctiveness < 0.15) reason = 'low_distinctiveness';
+  const score = reason === 'relevant'
+    ? Math.round((independentTerms.length * 2 + identifierMatches.length * 4 + coverage * 2 + distinctiveness) * 100) / 100
+    : 0;
+  return { score, matchedTerms, reason, coverage, distinctiveness, identifierMatches, sampleSize };
+}
+
+export const RECALL_LIMITS = Object.freeze({
+  maxTerms: MAX_TERMS,
+  maxCandidates: 128,
+  candidatesPerTerm: 32,
+  shortTermRows: 512,
+  maxBoundaryRows: 4096,
+  maxTurnRows: 64,
+  maxTurnBytes: 64 * 1024,
+  maxReadBytes: 256 * 1024,
+});

package/yeaft/conversation/search.js

@@ -54,8 +54,9 @@ function recordMessageScan(telemetry) {
 }
 
 function withSource(msg, source) {
+  const { providerState, thinkingBlocks, ...publicMessage } = msg;
   return {
-    ...msg,
+    ...publicMessage,
     content: searchableContent(msg),
     sessionId: msg.sessionId || source.sessionId || null,
     historySource: source.kind,

package/yeaft/debug-trace.js

@@ -621,6 +621,8 @@ function expandTrace(trace) {
   const turnsById = new Map([[trace.requestId || trace.traceId, summarizeTrace(trace, true)]]);
   let snapshot = null;
   let rawRequest = trace?.baseRequest?.rawRequest ?? null;
+  let latestRawRequestLoop = null;
+  let latestSystemPromptLoop = null;
   const loops = [];
   for (const loop of Array.isArray(trace?.loops) ? trace.loops : []) {
     snapshot = applyRequestDelta(snapshot || trace.baseRequest || null, loop.requestDelta || {});
@@ -633,8 +635,8 @@ function expandTrace(trace) {
       loopInstanceId: loop.loopInstanceId || loop.turnRowId || null,
       loopNumber: loop.loopNumber || 0,
       model: loop.model || null,
-      // Request snapshots are attached only to the latest loop below. Earlier
-      // loops retain their responses, calls and timing, not repeated history.
+      // Keep only the latest available raw request and system prompt, each on
+      // its actual source loop. Messages remain limited to the final loop.
       systemPrompt: '',
       messages: [],
       response: loop.response || '',
@@ -650,12 +652,21 @@ function expandTrace(trace) {
       vpId: trace.vpId || null,
       threadId: trace.threadId || null,
     });
+    const current = loops.at(-1);
+    if (rawRequest != null) {
+      if (latestRawRequestLoop) latestRawRequestLoop.rawRequest = null;
+      current.rawRequest = rawRequest;
+      latestRawRequestLoop = current;
+    }
+    if (snapshot.systemPrompt) {
+      if (latestSystemPromptLoop) latestSystemPromptLoop.systemPrompt = '';
+      current.systemPrompt = snapshot.systemPrompt;
+      latestSystemPromptLoop = current;
+    }
   }
   const latest = loops.at(-1);
   if (latest && snapshot) {
-    latest.systemPrompt = snapshot.systemPrompt || '';
     latest.messages = Array.isArray(snapshot.messages) ? snapshot.messages : [];
-    latest.rawRequest = rawRequest;
   }
   return { loops, turns: Array.from(turnsById.values()) };
 }

package/yeaft/effort.js

@@ -14,14 +14,15 @@
  *
  * Red lines:
  *   • Never error on unknown scenario — default to 'max'.
- *   • Feature flag YEAFT_THINKING_V1 is enforced at the adapter/router
- *     layer; this module just computes the intended value. If the flag
- *     is off, adapters drop it anyway.
- *   • Unsupported models silently drop effort at the router — this
- *     module does NOT consult the capability matrix.
+ *   • The ordinary picker preserves existing scenario defaults. Child effort
+ *     is separately constrained by the capability-aware final payload helpers.
+ *   • Child ceilings cannot be disabled by YEAFT_THINKING_V1, user overrides,
+ *     routing, nesting, or extraBody. Unsupported models omit effort fields.
  */
 
-import { normalizeEffort } from './models.js';
+import {
+  normalizeEffort, getThinkingCapability, getModelEffortOptions, thinkingBudgetForEffort,
+} from './models.js';
 
 /**
  * Number of tool-loop turns past which a query is considered "complex"
@@ -116,3 +117,155 @@ export function parseEffortPrefix(prompt) {
   const cleanedPrompt = prompt.slice(m[0].length);
   return { effort, cleanedPrompt };
 }
+
+// Ordinal levels, not lexical sorting or cross-model token-budget equivalence.
+export const EFFORT_LEVELS = Object.freeze(['minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
+const effortRank = value => EFFORT_LEVELS.indexOf(normalizeEffort(value));
+const atMost = (value, ceiling) => effortRank(value) >= 0 && effortRank(value) <= effortRank(ceiling);
+
+/** Copy only durable decision fields; never retain a mutable request/config object. */
+export function snapshotEffortDecision(decision = null) {
+  return Object.freeze({
+    requested: normalizeEffort(decision?.requested),
+    effective: normalizeEffort(decision?.effective),
+    source: typeof decision?.source === 'string' ? decision.source : 'unknown',
+    model: typeof decision?.model === 'string' ? decision.model : null,
+    wireMode: typeof decision?.wireMode === 'string' ? decision.wireMode : 'omitted',
+    thinkingEnabled: decision?.thinkingEnabled === true,
+    cap: normalizeEffort(decision?.cap),
+    ...(Number.isFinite(decision?.budgetTokens) ? { budgetTokens: decision.budgetTokens } : {}),
+  });
+}
+
+/** Capture the decision belonging to the provider response that generated a tool call. */
+export function captureParentEffortDecision(ctx = {}) {
+  return snapshotEffortDecision(ctx.effortDecision ?? ctx.parentEngineDeps?.effortDecision);
+}
+
+function effortError(model, target, detail = '') {
+  const error = new Error(`Sub-agent model "${model}" cannot express effort <= ${target}${detail ? ` (${detail})` : ''}. Select a compatible child model.`);
+  error.code = 'SUB_AGENT_EFFORT_UNREPRESENTABLE';
+  return error;
+}
+
+function capabilityContext(protocol, effortContext) {
+  return { ...effortContext, protocol: protocol || effortContext?.protocol };
+}
+
+/**
+ * Resolve the non-disableable child ceiling using the actual model's capabilities.
+ * Unknown/omitted parent wire defaults are conservative medium, never chat/max.
+ */
+export function resolveSubAgentEffort({ parentDecision = null, model, effortContext = {}, protocol } = {}) {
+  const parent = snapshotEffortDecision(parentDecision);
+  // An unsupported intermediate model has no wire effort, but must not erase
+  // an inherited lower ceiling when it delegates again.
+  let parentTarget = parent.effective || 'medium';
+  if (parent.cap && atMost(parent.cap, parentTarget)) parentTarget = parent.cap;
+  const target = atMost(parentTarget, 'high') ? parentTarget : 'high';
+  const context = capabilityContext(protocol, effortContext);
+  const capability = getThinkingCapability(model, context);
+  const base = {
+    requested: parentTarget, source: parent.effective ? 'inherited' : 'fallback',
+    model, cap: target, thinkingEnabled: false,
+  };
+  if (!capability.supportsThinking || capability.thinkingProtocol === 'none') {
+    return snapshotEffortDecision({ ...base, effective: null, wireMode: 'unsupported' });
+  }
+  const supported = getModelEffortOptions(model, context).filter(value => atMost(value, target));
+  const effective = EFFORT_LEVELS.filter(value => supported.includes(value)).at(-1);
+  if (!effective) throw effortError(model, target);
+  const wireMode = protocol === 'openai-responses' || capability.thinkingProtocol === 'openai-reasoning'
+    ? 'reasoning-effort'
+    : capability.thinkingProtocol === 'anthropic-adaptive' ? 'adaptive' : 'manual';
+  return snapshotEffortDecision({ ...base, effective, wireMode, thinkingEnabled: true });
+}
+
+function manualEffortForBudget(model, budget) {
+  if (!Number.isFinite(budget) || budget <= 0) return null;
+  // Round upward: a nonstandard budget must never masquerade as a lower tier.
+  return ['low', 'medium', 'high', 'max'].find(level => budget <= thinkingBudgetForEffort(model, level)) || 'ultra';
+}
+
+/**
+ * Read the FINAL wire payload. requested is observability only, not effective.
+ * Call after all extraBody/feature-flag/mapping changes, before serialization.
+ */
+export function captureEffortDecision({ body = {}, model, protocol, effortContext = {}, requested = null, source = 'scenario' } = {}) {
+  const context = capabilityContext(protocol, effortContext);
+  const capability = getThinkingCapability(model, context);
+  const base = { requested, source, model, cap: null, thinkingEnabled: false };
+  if (!capability.supportsThinking || capability.thinkingProtocol === 'none') {
+    return snapshotEffortDecision({ ...base, effective: null, wireMode: 'unsupported' });
+  }
+  if (protocol === 'openai-responses') {
+    const effective = normalizeEffort(body.reasoning?.effort);
+    if (effective) return snapshotEffortDecision({ ...base, effective, wireMode: 'reasoning-effort', thinkingEnabled: true });
+  } else if (body.thinking?.type === 'enabled') {
+    const budgetTokens = body.thinking.budget_tokens;
+    return snapshotEffortDecision({ ...base, effective: manualEffortForBudget(model, budgetTokens), wireMode: 'manual', thinkingEnabled: true, budgetTokens });
+  } else if (body.thinking?.type === 'adaptive') {
+    const effective = normalizeEffort(body.output_config?.effort);
+    if (effective) return snapshotEffortDecision({ ...base, effective, wireMode: 'adaptive', thinkingEnabled: true });
+  }
+  const modelDefault = body.thinking?.type === 'disabled' ? null : normalizeEffort(capability.defaultEffort);
+  return snapshotEffortDecision({ ...base, effective: modelDefault, source: modelDefault ? 'model-default' : source, wireMode: 'omitted' });
+}
+
+function removeEffortField(body, key) {
+  if (!body[key] || typeof body[key] !== 'object' || Array.isArray(body[key])) {
+    delete body[key];
+    return;
+  }
+  const { effort: _effort, ...rest } = body[key];
+  if (Object.keys(rest).length) body[key] = rest;
+  else delete body[key];
+}
+
+/**
+ * Mutate the FINAL provider body in place and return its immutable child decision.
+ * The router must preserve effortConstraint even when YEAFT_THINKING_V1 is off.
+ * All adapter stream/call paths invoke this AFTER extraBody, BEFORE fetch, and
+ * must not subsequently rewrite reasoning/thinking/output_config/max_tokens.
+ * @param {object} body Final body owned by the adapter (never caller config).
+ * @param {{ model: string, protocol: string, effortContext?: object,
+ *   effortConstraint: { parentDecision: object|null } }} options
+ */
+export function enforceSubAgentEffortPayload(body, { model, protocol, effortContext = {}, effortConstraint } = {}) {
+  if (!effortConstraint) return captureEffortDecision({ body, model, protocol, effortContext });
+  const decision = resolveSubAgentEffort({ parentDecision: effortConstraint.parentDecision, model, protocol, effortContext });
+  if (decision.wireMode === 'unsupported') {
+    removeEffortField(body, 'reasoning');
+    removeEffortField(body, 'output_config');
+    delete body.thinking;
+    return decision;
+  }
+  const context = capabilityContext(protocol, effortContext);
+  const options = getModelEffortOptions(model, context);
+  const wireEffort = protocol === 'openai-responses' ? body.reasoning?.effort : body.output_config?.effort;
+  const effective = options.includes(wireEffort) && atMost(wireEffort, decision.effective)
+    ? wireEffort : decision.effective;
+  if (protocol === 'openai-responses') {
+    body.reasoning = { ...(body.reasoning && typeof body.reasoning === 'object' && !Array.isArray(body.reasoning) ? body.reasoning : {}), effort: effective };
+    delete body.thinking;
+    removeEffortField(body, 'output_config');
+  } else if (decision.wireMode === 'adaptive') {
+    body.thinking = { type: 'adaptive' };
+    body.output_config = { ...(body.output_config && typeof body.output_config === 'object' && !Array.isArray(body.output_config) ? body.output_config : {}), effort: effective };
+    removeEffortField(body, 'reasoning');
+  } else {
+    const capability = getThinkingCapability(model, context);
+    let budget = thinkingBudgetForEffort(model, effective);
+    if (!budget) throw effortError(model, decision.cap, 'no manual thinking budget');
+    if (Number.isFinite(capability.maxBudgetTokens)) budget = Math.min(budget, capability.maxBudgetTokens);
+    const supplied = body.thinking?.type === 'enabled' ? body.thinking.budget_tokens : null;
+    if (Number.isInteger(supplied) && supplied >= 1024) budget = Math.min(budget, supplied);
+    if (Number.isFinite(body.max_tokens)) budget = Math.min(budget, Math.floor(body.max_tokens) - 1);
+    if (budget < 1024) throw effortError(model, decision.cap, 'max_tokens must allow at least 1024 thinking tokens');
+    body.thinking = { type: 'enabled', budget_tokens: budget };
+    removeEffortField(body, 'output_config');
+    removeEffortField(body, 'reasoning');
+    return snapshotEffortDecision({ ...decision, effective: manualEffortForBudget(model, budget), budgetTokens: budget });
+  }
+  return snapshotEffortDecision({ ...decision, effective });
+}