@yeaft/webchat-agent 1.0.589 → 1.0.591

package/yeaft/person/script-worker.js

@@ -0,0 +1,77 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { getQuickJS } from 'quickjs-emscripten';
+
+// Separate WASM interpreter, NOT node:vm. No host functions/modules are bound.
+// Parent termination bounds startup, computation, output extraction and cleanup.
+let runtime, context;
+try {
+  const engine = await getQuickJS();
+  runtime = engine.newRuntime();
+  runtime.setMemoryLimit(16 * 1024 * 1024);
+  runtime.setMaxStackSize(256 * 1024);
+  const deadline = Date.now() + 200;
+  runtime.setInterruptHandler(() => Date.now() > deadline);
+  context = runtime.newContext();
+  const { code, input } = workerData;
+  // Capture intrinsics before executing generated code; Function compiles ONLY a
+  // function body and has no access to this validation closure. Neither raw code
+  // interpolation nor mutable guest serializers can redefine the output boundary.
+  const source = `(() => {
+    'use strict';
+    const compile = Function, parse = JSON.parse, stringify = JSON.stringify;
+    const isArray = Array.isArray, finite = Number.isFinite;
+    const proto = Object.getPrototypeOf, objectProto = Object.prototype;
+    const descriptor = Object.getOwnPropertyDescriptor, keys = Reflect.ownKeys;
+    const create = Object.create, setProto = Object.setPrototypeOf, ErrorType = Error;
+    const input = parse(${JSON.stringify(JSON.stringify(input))});
+    const fn = compile('input', ${JSON.stringify(`'use strict';\n${code}`)});
+    const ancestors = create(null);
+    let nodes = 0;
+    function snapshot(v, depth) {
+      if (++nodes > 8192 || depth > 32) throw new ErrorType('JSON limit');
+      if (v === null || typeof v === 'string' || typeof v === 'boolean') return v;
+      if (typeof v === 'number' && finite(v)) return v;
+      if (typeof v !== 'object') throw new ErrorType('JSON only');
+      for (let i = 0; i < depth; i++) if (ancestors[i] === v) throw new ErrorType('JSON cycle');
+      const array = isArray(v), p = proto(v);
+      if (!array && p !== objectProto && p !== null) throw new ErrorType('JSON object only');
+      const names = keys(v);
+      const length = array ? descriptor(v, 'length').value : names.length;
+      if (length > 8192 || names.length !== length + (array ? 1 : 0)) throw new ErrorType('JSON keys');
+      const out = array ? setProto([], null) : create(null);
+      ancestors[depth] = v;
+      for (let i = 0; i < length; i++) {
+        const key = array ? '' + i : names[i];
+        if (typeof key !== 'string') throw new ErrorType('JSON key');
+        const d = descriptor(v, key);
+        if (!d || !d.enumerable || !descriptor(d, 'value')) throw new ErrorType('JSON data only');
+        out[key] = snapshot(d.value, depth + 1);
+      }
+      delete ancestors[depth];
+      return out;
+    }
+    const value = snapshot(fn(input), 0);
+    // Snapshot has null prototypes and data properties only: no guest getters or
+    // inherited toJSON are run during serialization, even after global mutation.
+    const json = stringify(value);
+    if (typeof json !== 'string' || json.length > 8192) throw new ErrorType('JSON output limit');
+    return json;
+  })()`;
+  const result = context.evalCode(source, 'created-capability.js');
+  if (result.error) {
+    result.error.dispose();
+    parentPort.postMessage({ ok: false, code: 'SCRIPT_EXECUTION' });
+  } else {
+    const json = context.getString(result.value);
+    result.value.dispose();
+    if (Buffer.byteLength(json, 'utf8') > 8192) parentPort.postMessage({ ok: false, code: 'SCRIPT_OUTPUT' });
+    else parentPort.postMessage({ ok: true, output: JSON.parse(json) });
+  }
+} catch {
+  // Guest error strings may contain arbitrary input; fixed codes only cross out.
+  parentPort.postMessage({ ok: false, code: 'SCRIPT_EXECUTION' });
+} finally {
+  context?.dispose();
+  runtime?.dispose();
+  parentPort.close();
+}

package/yeaft/person/sqlite-repository.js

@@ -1,6 +1,7 @@
 import { Worker } from 'node:worker_threads';
 import { join, resolve } from 'node:path';
 import { digest, fail, identifier, PersonError, text } from './contracts.js';
+import { validateCreatedCapability } from './created-capability-contract.js';
 
 const storageError = code => {
   const error = new PersonError(code);
@@ -91,6 +92,8 @@ export class SqlitePersonRepository {
   async append(episode, kind, data) { return this.request('append', [episode, kind, data]); }
   async startCall(episode, data) { return this.request('startCall', [episode, data]); }
   async finalizeCall(episode, data) { return this.request('finalizeCall', [episode, data]); }
+  async createdCapabilities(episode) { return this.request('createdCapabilities', [episode]); }
+  async saveCreatedCapability(episode, input) { return this.request('saveCreatedCapability', [episode, validateCreatedCapability(input)]); }
   async context(episode) { return this.request('context', [episode]); }
   async recall(ownerId, options) { return this.request('recall', [ownerId, options]); }
   async commit(episode, proposal, selection, callId, reportedSources = new Map()) { return this.request('commit', [episode, proposal, selection, callId, reportedSources]); }

package/yeaft/person/sqlite-schema.js

@@ -8,6 +8,8 @@ export const TABLES = Object.freeze({
   concept_revisions: { keys: ['id', 'revision'], columns: [] },
   state_commits: { keys: ['version'], columns: ['id'] },
   traces: { keys: ['id'], columns: ['seq'] },
+  created_capabilities: { keys: ['id'], columns: ['version'] },
+  created_capability_revisions: { keys: ['id', 'version'], columns: [] },
 });
 
 export const SCHEMA = `
@@ -66,6 +68,21 @@ CREATE TABLE IF NOT EXISTS traces (
   PRIMARY KEY(namespace, ownerId, personId, id), UNIQUE(namespace, ownerId, personId, seq),
   FOREIGN KEY(namespace, ownerId, personId) REFERENCES persons(namespace, ownerId, personId)
 ) STRICT;
+CREATE INDEX IF NOT EXISTS traces_call_output ON traces(namespace, ownerId, personId,
+  json_extract(record, '$.episodeId'), json_extract(record, '$.callId'))
+  WHERE json_extract(record, '$.kind') = 'call_output';
+CREATE TABLE IF NOT EXISTS created_capabilities (
+  namespace TEXT NOT NULL, ownerId TEXT NOT NULL, personId TEXT NOT NULL,
+  id TEXT NOT NULL, version INTEGER NOT NULL CHECK(version BETWEEN 1 AND 32),
+  record TEXT NOT NULL CHECK(json_valid(record)), PRIMARY KEY(namespace, ownerId, personId, id),
+  FOREIGN KEY(namespace, ownerId, personId) REFERENCES persons(namespace, ownerId, personId)
+) STRICT;
+CREATE TABLE IF NOT EXISTS created_capability_revisions (
+  namespace TEXT NOT NULL, ownerId TEXT NOT NULL, personId TEXT NOT NULL,
+  id TEXT NOT NULL, version INTEGER NOT NULL CHECK(version BETWEEN 1 AND 32),
+  record TEXT NOT NULL CHECK(json_valid(record)), PRIMARY KEY(namespace, ownerId, personId, id, version),
+  FOREIGN KEY(namespace, ownerId, personId) REFERENCES persons(namespace, ownerId, personId)
+) STRICT;
 -- This journal is authority data, not a disposable search index. A committed seq is
 -- never reused, including after reopening; gaps between owners are intentional.
 CREATE TABLE IF NOT EXISTS memory_changes (

package/yeaft/person/sqlite-store.js

@@ -4,6 +4,7 @@ import { dirname } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { isMainThread } from 'node:worker_threads';
 import { bytes, digest, fail, identifier, LIMITS, PersonError, text } from './contracts.js';
+import { CREATED_CAPABILITY_LIMITS, createdCapabilityRecord, validateCreatedCapability } from './created-capability-contract.js';
 import { SCHEMA, TABLES } from './sqlite-schema.js';
 import { capabilityExperienceView, recordCapabilityExperience } from './capability-experience.js';
 
@@ -11,8 +12,20 @@ const SCOPE = 'namespace = ? AND ownerId = ? AND personId = ?';
 const scopeValues = s => [s.namespace, s.ownerId, s.personId];
 // Query-only projections; record retains the original public Unicode text.
 const SEARCH_COLUMNS = Object.freeze({ messages: 'text', concepts: 'statement' });
-const dates = new Set(['createdAt', 'updatedAt', 'endedAt', 'leaseUntil', 'callFinalizeUntil']);
-const decode = row => row ? JSON.parse(row.record, (key, value) => dates.has(key) && typeof value === 'string' ? new Date(value) : value) : null;
+const metadataDates = Object.freeze({
+  persons: ['createdAt', 'leaseUntil'], episodes: ['createdAt', 'endedAt', 'callFinalizeUntil'],
+  messages: ['createdAt'], states: ['updatedAt'], concepts: ['updatedAt'], concept_revisions: ['updatedAt'],
+  state_commits: ['createdAt'], traces: ['createdAt'],
+});
+const decode = (row, table) => {
+  if (!row) return null;
+  const record = JSON.parse(row.record);
+  // Only known storage metadata is a Date. Trace payloads and created-definition
+  // JSON may use these names at any depth without changing their string values.
+  for (const key of metadataDates[table] ?? []) if (typeof record[key] === 'string') record[key] = new Date(record[key]);
+  if (table === 'state_commits' && typeof record.state?.updatedAt === 'string') record.state.updatedAt = new Date(record.state.updatedAt);
+  return record;
+};
 const publicDoc = doc => {
   if (!doc) return null;
   const { _id, ownerId, namespace, personId, ...rest } = doc;
@@ -32,8 +45,8 @@ const publicOutput = (output, failed) => {
   return failed ? { text: output.text, retainedBytes, observedBytes, complete: false, accepted: false, availability: 'captured', usage, stopReason }
     : { text: output.text, bytes: retainedBytes, complete: true, usage, stopReason };
 };
-const READS = new Set(['getPerson', 'context', 'recall', 'list', 'searchChanges', 'resolveMemories']);
-const WRITES = new Set(['open', 'recover', 'admit', 'heartbeat', 'append', 'startCall', 'finalizeCall', 'commit', 'finish', 'cancel', 'settings', 'snapshot']);
+const READS = new Set(['getPerson', 'context', 'recall', 'list', 'searchChanges', 'resolveMemories', 'createdCapabilities']);
+const WRITES = new Set(['open', 'recover', 'admit', 'heartbeat', 'append', 'startCall', 'finalizeCall', 'commit', 'finish', 'cancel', 'settings', 'snapshot', 'saveCreatedCapability']);
 const memoryKind = kind => { if (!['messages', 'concepts'].includes(kind)) fail('INVALID_REQUEST'); return kind; };
 const boundedLimit = (limit, max = 100) => { if (!Number.isSafeInteger(limit) || limit < 1 || limit > max) fail('INVALID_REQUEST'); return limit; };
 const sequence = value => {
@@ -101,7 +114,8 @@ export class SqlitePersonStore {
   // All clauses at call sites below are fixed application strings; values are bound.
   rows(table, scope, clause = '', params = []) {
     this.table(table);
-    return this.sql(`SELECT record FROM ${table} WHERE ${SCOPE}${clause}`).all(...scopeValues(scope), ...params).map(decode);
+    return this.sql(`SELECT record FROM ${table} WHERE ${SCOPE}${clause}`).all(...scopeValues(scope), ...params)
+      .map(row => decode(row, table));
   }
   one(table, scope, clause = '', params = []) { return this.rows(table, scope, `${clause} LIMIT 1`, params)[0] ?? null; }
   put(table, record, insert = false) {
@@ -220,6 +234,8 @@ export class SqlitePersonStore {
     const p = this.own(episode); p.leaseUntil = new Date(this.now.getTime() + this.leaseMs); p.writeSerial++; this.put('persons', p);
   }
   append(episode, kind, data) {
+    // Call proof/publication events are emitted only by their transactional methods.
+    if (['call_started', 'call_output', 'call_failed', 'capability_created'].includes(kind)) fail('INVALID_REQUEST');
     const p = this.own(episode);
     const record = this.one('episodes', this.episodeScope(episode), ' AND id = ?', [episode.id]);
     if (!record || record.status !== 'running') fail('STALE');
@@ -255,6 +271,28 @@ export class SqlitePersonStore {
     });
     return live;
   }
+  createdCapabilities(episode) {
+    this.own(episode);
+    return this.rows('created_capabilities', this.episodeScope(episode), ' ORDER BY id ASC LIMIT 32').map(publicDoc);
+  }
+  saveCreatedCapability(episode, input) {
+    const { definition, evidence, callId } = validateCreatedCapability(input);
+    this.own(episode);
+    const scope = this.episodeScope(episode), active = this.one('episodes', scope, ' AND id = ?', [episode.id]);
+    if (!active || active.status !== 'running' || active.epoch !== episode.epoch || active.workerId !== episode.workerId) fail('STALE');
+    const proof = this.one('traces', scope, " AND json_extract(record, '$.episodeId') = ? AND json_extract(record, '$.kind') = 'call_output' AND json_extract(record, '$.callId') = ? AND json_extract(record, '$.output.complete') = 1", [episode.id, callId]);
+    if (!proof || active.openCall?.callId === callId) fail('INVALID_REQUEST');
+    const current = this.one('created_capabilities', scope, ' AND id = ?', [definition.id]);
+    if ((current?.version ?? 0) !== definition.expectedVersion) fail('STALE');
+    if (definition.expectedVersion >= CREATED_CAPABILITY_LIMITS.versions || (!current &&
+        this.sql(`SELECT count(*) AS n FROM created_capabilities WHERE ${SCOPE}`).get(...scopeValues(scope)).n >= CREATED_CAPABILITY_LIMITS.ids)) fail('CONTEXT_LIMIT');
+    const record = this.doc(scope, createdCapabilityRecord(definition, evidence, { episode, callId, now: this.now }));
+    this.put('created_capability_revisions', record, true);
+    this.put('created_capabilities', record);
+    this.trace(episode.ownerId, episode.id, 'capability_created', { callId, capabilityId: record.id,
+      capabilityManifest: { id: record.id, version: record.version, revision: record.revision }, evidence: record.evidence });
+    return publicDoc(record);
+  }
   focused(scope, ids) {
     return ids.map(id => this.one('concepts', scope, ' AND id = ?', [id])).filter(Boolean);
   }
@@ -366,7 +404,7 @@ export class SqlitePersonStore {
     this.getPerson(ownerId); after = sequence(after); boundedLimit(limit, 1000);
     const rows = this.sql(`SELECT seq, kind, id, revision, record FROM memory_changes WHERE ${SCOPE} AND seq > ? ORDER BY seq ASC LIMIT ?`)
       .all(...scopeValues(this.scope(ownerId)), after, limit + 1);
-    const items = rows.slice(0, limit).map(row => ({ ...row, record: decode(row) }));
+    const items = rows.slice(0, limit).map(row => ({ ...row, record: decode(row, row.kind) }));
     return { items, lastSeq: items.at(-1)?.seq ?? after, hasMore: rows.length > limit };
   }
   resolveMemories(ownerId, kind, refs) {

package/yeaft/tool-folding/index.js

@@ -125,6 +125,16 @@ export function buildDuplicateReminder({ toolName, count, lastResultBrief }) {
     + `Consider whether re-running this tool is necessary or if you should try a different approach.`;
 }
 
+function toolOutputForReflection(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content) && content.every(part => part && ['text', 'image', 'document'].includes(part.type))) {
+    // Reflection consumes text, not a base64 dump of visual context. The image
+    // has already been delivered to the primary model in the paired result.
+    return content.map(part => part.type === 'text' ? part.text : `[${part.type} content omitted from reflection]`).join('\n');
+  }
+  return JSON.stringify(content);
+}
+
 /**
  * Convert assistant.toolCalls + matching tool results into the
  * { name, input, output, isError } pairs the reflector prompt expects.
@@ -159,14 +169,14 @@ export function extractToolPairsFromRange(messages, startIdx, endIdx) {
     } else if (m.role === 'tool') {
       const ent = m.toolCallId ? byId.get(m.toolCallId) : null;
       if (ent) {
-        ent.output = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
+        ent.output = toolOutputForReflection(m.content);
         ent.isError = !!m.isError;
       } else {
         // Orphan tool result — still include for completeness.
         pairs.push({
           name: '(orphan)',
           input: {},
-          output: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
+          output: toolOutputForReflection(m.content),
           isError: !!m.isError,
         });
       }

package/yeaft/tools/registry.js

@@ -238,6 +238,17 @@ function truncateUtf8(text, maxBytes) {
 }
 
 export function truncateToolResultIfNeeded(output, { toolName, language } = {}) {
+  // Provider content parts are not JSON text. Bound their text together while
+  // preserving binary blocks; history-window budgets/omits attachments whole.
+  // Arbitrary structured tool output still follows the legacy JSON path.
+  if (Array.isArray(output) && output.length > 0
+      && output.every(part => part && ['text', 'image', 'document'].includes(part.type))) {
+    const text = output.filter(part => part.type === 'text').map(part => part.text || '').join('\n');
+    return [
+      ...(text ? [{ type: 'text', text: truncateToolResultIfNeeded(text, { toolName, language }) }] : []),
+      ...output.filter(part => part.type !== 'text'),
+    ];
+  }
   const text = normalizeToolOutput(output);
   const originalBytes = Buffer.byteLength(text, 'utf8');
   if (originalBytes <= TOOL_RESULT_MAX_BYTES) return text;

package/yeaft/tools/view-image.js

@@ -123,8 +123,9 @@ export default defineTool({
     en: `Load a local image file and attach it to the conversation so the LLM can see it.
 
 Returns a base64 data URI (\`image\` field) plus metadata (format, dimensions,
-size). The caller/bridge is responsible for turning the data URI into the
-provider-specific image content block.
+size). The engine delivers the image as a native multimodal tool result.
+Inspect the whole image first. Crop/zoom only details that are unreadable; OCR
+is optional for text extraction, not a prerequisite for seeing the image.
 
 When to call:
   - User references a local image path (screenshot, design, log/chart) and
@@ -151,8 +152,8 @@ Max size: 20 MiB by default (configurable via ctx.maxImageBytes).
 Path must live under the project directory or an explicit host allowlist.`,
     zh: `加载本地图片文件并附加到对话中，使 LLM 可以查看。
 
-返回 base64 data URI（image 字段）及元数据（格式、尺寸、大小）。调用方/桥接层负责将 data URI 转换为
-provider 特定的图片内容块。
+返回 base64 data URI（image 字段）及元数据（格式、尺寸、大小）。引擎将图片作为原生多模态工具结果交给模型。
+先直接查看整图；仅对确实看不清的细节裁剪/放大。OCR 用于需要时提取文字，不是看图的前置步骤。
 
 何时调用：
   - 用户引用本地图片路径（截图、设计稿、日志/图表）并要求你读取、分析或描述它。

package/yeaft/web-bridge.js

@@ -1454,12 +1454,15 @@ function projectPersistedToVisibleHistoryEntry(m) {
   return entry && (entry.role === 'user' || entry.role === 'assistant') ? entry : null;
 }
 
-function hydrateHistoryAttachmentPreviews(attachments) {
+function hydrateHistoryAttachmentPreviews(attachments, sessionId) {
   if (!Array.isArray(attachments) || attachments.length === 0) return [];
   return attachments.map((att) => {
     if (!att || typeof att !== 'object') return att;
     if (!att.isImage || att.preview || att.previewData) return att;
-    const payload = persistedAttachmentPreviewPayload(att);
+    const payload = sessionId ? persistedAttachmentPreviewPayload(att, {
+      yeaftDir: session?.yeaftDir || ctx.CONFIG?.yeaftDir || DEFAULT_YEAFT_DIR,
+      sessionId,
+    }) : null;
     return payload ? { ...att, previewData: payload } : att;
   });
 }
@@ -1538,7 +1541,7 @@ function projectVisibleHistoryChunkMessages(messages = []) {
       threadId: m.threadId || m.turnId || 'main',
       ...(m.turnId ? { turnId: m.turnId } : {}),
       ...(m.imageAssetAnchor === true ? { imageAssetAnchor: true } : {}),
-      ...(Array.isArray(m.attachments) && m.attachments.length > 0 ? { attachments: hydrateHistoryAttachmentPreviews(m.attachments) } : {}),
+      ...(Array.isArray(m.attachments) && m.attachments.length > 0 ? { attachments: hydrateHistoryAttachmentPreviews(m.attachments, m.sessionId) } : {}),
       ...(m.quote ? { quote: m.quote } : {}),
       ...(Array.isArray(m.images) && m.images.length > 0 ? { images: m.images } : {}),
       ...(m.speakerVpId ? { speakerVpId: m.speakerVpId } : {}),
@@ -1596,7 +1599,7 @@ function emitLegacyHistoryOutputFrames(replayEntries) {
         message: {
           content: entry.content,
           id: entry.id || null,
-          ...(Array.isArray(entry.attachments) && entry.attachments.length > 0 ? { attachments: hydrateHistoryAttachmentPreviews(entry.attachments) } : {}),
+          ...(Array.isArray(entry.attachments) && entry.attachments.length > 0 ? { attachments: hydrateHistoryAttachmentPreviews(entry.attachments, entry.sessionId) } : {}),
           ...(entry.quote ? { quote: entry.quote } : {}),
         },
         ts: entry.ts || null,
@@ -4920,9 +4923,9 @@ async function runYeaftSessionSend(msg) {
   // ── Attachments (images + files) ───────────────────────────────
   // Server has already resolved fileId → { name, mimeType, data:base64,
   // isImage } via the client-conversation.js relay
-  // for `yeaft_*`). We persist files to disk under the agent's CWD so
-  // file-tools (file-read / bash) can pick them up with relative paths,
-  // and we build per-image content blocks for the LLM call. The
+  // for `yeaft_*`). Session files belong to the instance data root, not
+  // the agent CWD or project workDir. Absolute controlled references work
+  // with file-tools; per-image content blocks go directly to the model. The
   // resolved metadata WITHOUT base64 rides on coord.ingest meta so it
   // shows up in the persisted group log and on the envelope every VP
   // driver receives.
@@ -4931,9 +4934,10 @@ async function runYeaftSessionSend(msg) {
   const attachmentsStart = perfNowMs();
   if (inboundFiles.length > 0) {
     try {
-      attachmentBundle = persistYeaftAttachments(inboundFiles, { subdir: sessionId });
+      attachmentBundle = persistYeaftAttachments(inboundFiles, { yeaftDir, sessionId });
     } catch (err) {
       console.warn('[Yeaft] yeaft_session_chat: attachment persist failed', err?.message || err);
+      attachmentBundle.failed = inboundFiles.map(file => ({ name: file?.name || '<unknown>', error: err?.message || String(err) }));
     }
   }
   // Surface partial / total upload failures to the user. We don't abort