@yeaft/webchat-agent 1.0.508 → 1.0.510

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.508",
+  "version": "1.0.510",
   "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/config-api.js

@@ -11,12 +11,60 @@
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { DEFAULT_YEAFT_DIR } from './init.js';
-import { normalizeProviderModels, parseModelRef, serializeModelForPersistence } from './models.js';
+import { getModelEffortOptions, normalizeEffort, normalizeProviderModels, parseModelRef, resolveMaxOutputTokens, serializeModelForPersistence } from './models.js';
+import { inferProtocolFromModelId } from './llm/router.js';
 import { clampYeaftField, normaliseTelemetrySection, normaliseYeaftSection } from './config.js';
 import { normaliseBrowserRuntimeSection, validateBrowserRuntimeUpdate } from '../browser-runtime/config.js';
 import { normalizePluginConfig } from './plugins.js';
 import { mutateAgentConfig, readAgentConfigForWrite } from './config-store.js';
-import { isGitHubCopilotProvider, serializeKnownProviderForPersistence } from './llm/known-providers.js';
+import { isGitHubCopilotProvider, normalizeKnownProviderForRuntime, serializeKnownProviderForPersistence } from './llm/known-providers.js';
+
+/** Agent-owned model catalog, with the same protocol/capability resolution as runtime. */
+function quickSendModels(config) {
+  return (Array.isArray(config.providers) ? config.providers : []).flatMap(raw => {
+    const provider = normalizeKnownProviderForRuntime(raw);
+    return normalizeProviderModels(provider).map(model => ({
+      id: model.id,
+      ref: provider.name ? `${provider.name}/${model.id}` : model.id,
+      provider: provider.name,
+      label: model.id,
+      effortOptions: getModelEffortOptions(model.id, {
+        ...model,
+        protocol: model.protocol || provider.protocol || inferProtocolFromModelId(model.id) || 'openai-responses',
+      }),
+      maxOutput: resolveMaxOutputTokens(model.id, { modelInfo: model }),
+    }));
+  });
+}
+
+/** Validate inside mutateAgentConfig's lock, against the resulting provider catalog. */
+function validateQuickSends(value, config) {
+  if (!Array.isArray(value) || value.length > 5) throw new Error('quickSends must be an array of at most 5 items');
+  const models = quickSendModels(config);
+  const ids = new Set();
+  return value.map(item => {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) throw new Error('Each quick send must be an object');
+    const id = typeof item.id === 'string' ? item.id.trim() : '';
+    const name = typeof item.name === 'string' ? item.name.trim() : '';
+    if (!id || id.length > 128 || ids.has(id)) throw new Error('Quick send id must be unique and 1–128 characters');
+    if (!name || name.length > 80) throw new Error('Quick send name must be 1–80 characters');
+    ids.add(id);
+    const ref = typeof item.model === 'string' ? item.model.trim() : '';
+    const matches = models.filter(model => model.ref === ref);
+    const candidates = matches.length ? matches : models.filter(model => model.id === ref);
+    if (candidates.length !== 1) throw new Error(`Quick send model must exist and be unambiguous: ${ref}`);
+    const model = candidates[0];
+    const effort = item.effort ?? null;
+    if (effort !== null && (!normalizeEffort(effort) || !model.effortOptions.includes(effort))) {
+      throw new Error(`Quick send effort is not available for ${model.ref}`);
+    }
+    const maxOutputTokens = item.maxOutputTokens ?? null;
+    if (maxOutputTokens !== null && (!Number.isSafeInteger(maxOutputTokens) || maxOutputTokens <= 0 || maxOutputTokens > model.maxOutput)) {
+      throw new Error(`Quick send maxOutputTokens must be a positive integer no greater than ${model.maxOutput}`);
+    }
+    return { id, name, model: model.ref, effort, maxOutputTokens };
+  });
+}
 
 /**
  * Read config.json before any public mutation. A missing file is a valid
@@ -44,7 +92,7 @@ function readLocalLlmConfig(dir) {
   const configPath = join(root, 'config.json');
 
   if (!existsSync(configPath)) {
-    return { providers: [], primaryModel: null, fastModel: null, language: 'en', needsSetup: true };
+    return { providers: [], primaryModel: null, fastModel: null, language: 'en', quickSends: [], availableModels: [], needsSetup: true };
   }
 
   const raw = readFileSync(configPath, 'utf8');
@@ -56,6 +104,8 @@ function readLocalLlmConfig(dir) {
     fastModel: json.fastModel || null,
     language: json.language || 'en',
     debug: json.debug === true,
+    quickSends: Array.isArray(json.quickSends) ? json.quickSends : [],
+    availableModels: quickSendModels(json),
     needsSetup: providers.length === 0 || providers.every(p => p.apiKey === 'proxy' || p.apiKey === '' || (!p.apiKey && !p.credentialProvider)),
   };
 }
@@ -169,6 +219,7 @@ export function updateLlmConfig(update, dir) {
       if (update.providers !== undefined) normalizeManagedModelDefaults(existing);
       if (update.language !== undefined) existing.language = update.language;
       if (update.debug !== undefined) existing.debug = update.debug === true;
+      if (update.quickSends !== undefined) existing.quickSends = validateQuickSends(update.quickSends, existing);
 
       const agentConfig = {
         providers: Array.isArray(existing.providers) ? existing.providers : [],
@@ -176,6 +227,8 @@ export function updateLlmConfig(update, dir) {
         fastModel: existing.fastModel || null,
         language: existing.language || 'en',
         debug: existing.debug === true,
+        quickSends: Array.isArray(existing.quickSends) ? existing.quickSends : [],
+        availableModels: quickSendModels(existing),
       };
       return {
         ...agentConfig,
@@ -216,7 +269,7 @@ export function getYeaftSettings(dir) {
  * (LLM provider / model fields are untouched) and validates each field:
  * `maxConcurrentThreads` must be 1..50, `autoArchiveIdleDays` must be
  * 1..3650, `recentTurnsLimit` must be 1..500, `relatedTurnsLimit` must be
- * 0..10 (0 disables related recall). Dream limits are read-only
+ * 0..5 (0 disables related recall). Dream limits are read-only
  * runtime defaults here; invalid values are rejected
  * outright so the UI sees an error rather than silently reverting — a
  * silent revert would make "I set it to 100 and nothing happened"
@@ -256,8 +309,8 @@ export function updateYeaftSettings(update, dir) {
   if (update.relatedTurnsLimit !== undefined) {
     const value = clampYeaftField(update.relatedTurnsLimit, 'relatedTurnsLimit');
     const n = Number(update.relatedTurnsLimit);
-    if (value === null || n < 0 || n > 10) {
-      return { error: 'relatedTurnsLimit must be between 0 and 10' };
+    if (value === null || n < 0 || n > 5) {
+      return { error: 'relatedTurnsLimit must be between 0 and 5' };
     }
   }
 

package/yeaft/config.js

@@ -55,8 +55,8 @@ const DEFAULTS = {
   // through history pagination/search. Range: 1–500.
   yeaftRecentTurnsLimit: 20,
   // Same-Session related Q&A turns, selected by deterministic full-text rules.
-  // Range: 0–10; 0 disables related recall without changing recent history.
-  yeaftRelatedTurnsLimit: 8,
+  // Range: 0–5; 0 disables related recall without changing recent history.
+  yeaftRelatedTurnsLimit: 5,
   // CLAUDE.md / AGENTS.md project-doc cap, in bytes. Mirrors Codex's
   // `project_doc_max_bytes`. 0 disables the feature (no project-doc
   // block is injected). Hand-edited values are NOT clamped — we let
@@ -306,7 +306,7 @@ export function clampYeaftField(v, field) {
   let hi;
   if (field === 'maxConcurrentThreads') { lo = 1; hi = 50; }
   else if (field === 'recentTurnsLimit') { lo = 1; hi = 500; }
-  else if (field === 'relatedTurnsLimit') { lo = 0; hi = 10; }
+  else if (field === 'relatedTurnsLimit') { lo = 0; hi = 5; }
   else { lo = 1; hi = 3650; } // autoArchiveIdleDays
   return Math.min(hi, Math.max(lo, Math.floor(n)));
 }

package/yeaft/conversation/history-index-worker.js

@@ -10,7 +10,7 @@ import {
   normalizeLiteralSearch,
 } from './visible-entry.js';
 import { fingerprintConversationSources } from './history-index-state.js';
-import { extractRecallTerms, scoreRecallTurn, RECALL_LIMITS } from './recall-relevance.js';
+import { extractRecallTerms, scoreRecallTurn, normalizeRecallLimit, RECALL_LIMITS } from './recall-relevance.js';
 
 const INDEX_SCHEMA_VERSION = 2;
 const SHORT_BLOOM_BYTES = 256;
@@ -433,7 +433,7 @@ function recallTurns(request) {
     const generation = Number(indexMeta.generation) || 0;
     const terms = extractRecallTerms(request.prompt);
     const cap = (value, fallback) => Math.min(fallback, Math.max(1, Math.floor(Number(value) || fallback)));
-    const limit = cap(request.limit, 10);
+    const limit = normalizeRecallLimit(request.limit);
     const maxTurnRows = cap(request.maxTurnRows, RECALL_LIMITS.maxTurnRows);
     const maxTurnBytes = cap(request.maxTurnBytes, RECALL_LIMITS.maxTurnBytes);
     const maxReadBytes = cap(request.maxReadBytes, RECALL_LIMITS.maxReadBytes);
@@ -445,6 +445,7 @@ function recallTurns(request) {
       limits: { ...RECALL_LIMITS, maxTurnRows, maxTurnBytes, maxReadBytes, limit },
       ...indexStats(indexMeta),
     };
+    if (limit === 0) return { turns: [], meta: { ...meta, status: 'disabled', reason: 'disabled' } };
     const sourceBefore = currentSourceToken();
     if (sourceBefore.fingerprint !== indexMeta.raw_source_fingerprint) {
       return { turns: [], meta: { ...meta, status: 'not_ready', reason: 'stale_result' } };

package/yeaft/conversation/history-index.js

@@ -2,7 +2,7 @@ import { Worker } from 'node:worker_threads';
 import { existsSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { writeAtomic } from '../storage/atomic.js';
-import { extractRecallTerms, scoreRecallTurn } from './recall-relevance.js';
+import { extractRecallTerms, scoreRecallTurn, normalizeRecallLimit } from './recall-relevance.js';
 import {
   conversationIndexDatabasePath,
   conversationIndexManifestPath,
@@ -556,8 +556,8 @@ export async function searchConversationIndex(ownerRoot, sessionId, query, opts
 /**
  * Recall complete visible user/assistant turns from this owner-root Session.
  * beforeSeq excludes that user turn and all later rows (exclusive seq fence).
- * limit defaults to 8, capped at 10. maxTurnRows/maxTurnBytes/maxReadBytes may
- * only lower hard worker caps. Canonical message IDs identify entries; their
+ * limit defaults to 5, capped at 5; 0 disables recall.
+ * maxTurnRows/maxTurnBytes/maxReadBytes may only lower hard worker caps. Canonical message IDs identify entries; their
  * sourceMessageIds preserve all persisted identities, including aggregated VP
  * replies. The first cold call yields not_ready and starts a background build;
  * later calls wait up to 1500ms for readiness and the worker read, without
@@ -569,6 +569,8 @@ export async function searchConversationIndex(ownerRoot, sessionId, query, opts
  */
 export async function recallConversationTurns(ownerRoot, sessionId, prompt, opts = {}) {
   const terms = extractRecallTerms(prompt);
+  const limit = normalizeRecallLimit(opts.limit);
+  if (limit === 0) return { turns: [], meta: { status: 'disabled', reason: 'disabled', terms } };
   const eligibility = scoreRecallTurn(terms, terms.join(' '));
   if (!eligibility.score) {
     return { turns: [], meta: { status: 'ready', reason: eligibility.reason, terms } };
@@ -577,7 +579,7 @@ export async function recallConversationTurns(ownerRoot, sessionId, prompt, opts
     return await requestConversationHistoryIndex(ownerRoot, sessionId, 'recall-turns', {
       prompt: typeof prompt === 'string' ? prompt.slice(0, 4096) : '',
       beforeSeq: opts.beforeSeq,
-      limit: Math.min(10, Math.max(1, Math.floor(Number(opts.limit) || 8))),
+      limit,
       maxTurnRows: opts.maxTurnRows,
       maxTurnBytes: opts.maxTurnBytes,
       maxReadBytes: opts.maxReadBytes,

package/yeaft/conversation/persist.js

@@ -1564,6 +1564,43 @@ export class ConversationStore {
     return pairSanitize(messages);
   }
 
+  /**
+   * Provider-only chronological history. UI pages deliberately cap raw rows;
+   * that cap is not a turn limit and must not truncate a tool-heavy query's
+   * context. Yield between bounded scan batches; never mutate the transcript.
+   * Stable user identities, not equal prompt text, define human turns.
+   * @returns {Promise<object[]>} Complete past turns before the durable user fence.
+   */
+  async loadProviderHistoryBySession(sessionId, turnsLimit = 20, { beforeSeq = Infinity } = {}) {
+    if (!sessionId || !(turnsLimit > 0)) return [];
+    const kept = [];
+    const pending = [];
+    const identities = new Set();
+    let scanned = 0;
+    let bytes = 0;
+    for (const row of this.#iterateSessionRows(sessionId, { beforeSeq, desc: true })) {
+      scanned += 1;
+      bytes += Buffer.byteLength(JSON.stringify(row));
+      if (scanned > 32768 || bytes > 64 * 1024 * 1024) {
+        const error = new Error('Recent history scan limit reached before completing the requested turn window');
+        error.code = 'HISTORY_RECENT_SCAN_LIMIT';
+        throw error;
+      }
+      if (scanned % 64 === 0) await new Promise(resolve => setImmediate(resolve));
+      if (!row || row.sessionId !== sessionId || isHiddenConversationRow(row)) continue;
+      if (row.role === 'user') {
+        const identity = row.clientMessageId ? `client:${row.clientMessageId}` : `message:${row.id}`;
+        identities.add(identity);
+        kept.push(...pending.splice(0), row);
+        // The requested oldest user closes the reverse scan. Do not read the
+        // previous turn's tool tail just to discover one more user boundary.
+        if (identities.size >= turnsLimit) break;
+      } else pending.push(row);
+    }
+    // Pending rows without their opening user are not a complete past turn.
+    return pairSanitize(kept.reverse());
+  }
+
   /**
    * Load every hot message stamped with `sessionId`.
    *

package/yeaft/conversation/recall-relevance.js

@@ -4,7 +4,35 @@ 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));
+for (const word of `system service config configuration settings build run error errors issue issues status result results request requests response responses check checks update updates version versions default option options limit limits page data user users model models tool tools server client input output changes details new old
+系统 服务 配置 设置 构建 运行 错误 报错 状态 结果 请求 响应 检查 更新 版本 默认 选项 限制 页面 数据 用户 模型 工具 服务端 客户端 输入 输出 改动 详细 新 旧`.split(/\s+/u)) STOP_WORDS.add(word);
 const segmenter = new Intl.Segmenter('zh', { granularity: 'word' });
+const MIN_COVERAGE = 0.6;
+const MIN_DISTINCTIVENESS = 0.5;
+const MIN_SCORE = 6.5;
+
+// Paths and concrete issue IDs are strong anchors even when a bounded sample
+// contains many discussions of that exact reference. Mere camel/snake casing
+// does not make an otherwise common word distinctive.
+function isExactReference(term) {
+  return term.includes('/')
+    || /\.[a-z][a-z0-9]{0,7}$/iu.test(term)
+    || /^[a-z][a-z0-9]*(?:[-_:][a-z0-9]+)*[-_:]\d[\da-z_-]*$/iu.test(term)
+    || /^(?:[a-z0-9]+[-_:])*[a-f0-9]{8,}$/iu.test(term);
+}
+
+function isGenericTerm(term) {
+  if (STOP_WORDS.has(term.toLocaleLowerCase())) return true;
+  const words = term.replace(/([a-z])([A-Z])/gu, '$1 $2').toLocaleLowerCase().split(/[\s_.:@-]+/u);
+  return words.every(word => STOP_WORDS.has(word));
+}
+
+/** Automatic recall accepts zero and never exceeds five, even for raw callers. */
+export function normalizeRecallLimit(value) {
+  const number = typeof value === 'number' || typeof value === 'string' && value.trim()
+    ? Number(value) : NaN;
+  return Number.isFinite(number) ? Math.min(5, Math.max(0, Math.floor(number))) : 5;
+}
 
 function isIdentifier(term) {
   return /[\p{L}\d][_.:/@-][\p{L}\d]/u.test(term)
@@ -20,7 +48,7 @@ export function extractRecallTerms(prompt) {
     ? 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 => {
+  const rest = text.replace(/(?:\.{0,2}\/)?[\p{L}\p{N}]+(?:[_.:/@-][\p{L}\p{N}]+)+|[A-Za-z][A-Za-z0-9]*/gu, token => {
     tokens.push(token);
     return ' ';
   });
@@ -44,7 +72,7 @@ export function extractRecallTerms(prompt) {
   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)
+    if (seen.has(key) || isGenericTerm(term) || /^\d+$/u.test(key)
       || Array.from(key).length < 2 || key.length > 96) return false;
     seen.add(key);
     return true;
@@ -59,17 +87,21 @@ export function extractRecallTerms(prompt) {
  * 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 terms = (Array.isArray(promptOrTerms) ? promptOrTerms : extractRecallTerms(promptOrTerms))
+    .filter(term => typeof term === 'string' && !isGenericTerm(term)).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)) {
+    if (/^[a-z0-9_]+$/u.test(key) || isIdentifier(term)) {
       const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-      return new RegExp(`(?<![a-z0-9_])${escaped}(?![a-z0-9_])`, 'u').test(body);
+      const boundary = isIdentifier(term) ? 'a-z0-9_.:/@-' : 'a-z0-9_';
+      const suffix = isIdentifier(term) ? '(?![a-z0-9_/@-]|[.:][a-z0-9_])' : `(?![${boundary}])`;
+      return new RegExp(`(?<![${boundary}])${escaped}${suffix}`, 'u').test(body);
     }
     return body.includes(key);
   });
   const identifierMatches = matchedTerms.filter(isIdentifier);
+  const exactReferenceMatches = matchedTerms.filter(isExactReference);
   const independentTerms = matchedTerms.filter(term => !matchedTerms.some(other => (
     other !== term && other.toLocaleLowerCase().includes(term.toLocaleLowerCase())
   )));
@@ -79,16 +111,17 @@ export function scoreRecallTurn(promptOrTerms, text, stats = {}) {
     const frequency = stats.termDocumentFrequency?.[term.toLocaleLowerCase()];
     return sampleSize >= 8 && Number.isFinite(frequency) ? 1 - frequency / sampleSize : 1;
   })) : 0;
+  const rawScore = Math.round((independentTerms.length * 2 + identifierMatches.length * 4
+    + coverage * 2 + distinctiveness) * 100) / 100;
   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 };
+  else if (coverage < MIN_COVERAGE) reason = 'low_coverage';
+  else if (!exactReferenceMatches.length && distinctiveness < MIN_DISTINCTIVENESS) reason = 'low_distinctiveness';
+  else if (rawScore < MIN_SCORE) reason = 'low_score';
+  const score = reason === 'relevant' ? rawScore : 0;
+  return { score, matchedTerms, reason, coverage, distinctiveness, identifierMatches, exactReferenceMatches, sampleSize };
 }
 
 export const RECALL_LIMITS = Object.freeze({