@yeaft/webchat-agent 1.0.178 → 1.0.181

package/connection/message-router.js

@@ -113,6 +113,7 @@ export async function handleMessage(msg) {
 
       // ★ Flush 断连期间缓冲的消息
       await flushMessageBuffer();
+      await ctx.assetOutbox?.drain();
 
       // ★ Phase 1: 通知 server 同步完成
       sendToServer({ type: 'agent_sync_complete' });
@@ -130,6 +131,12 @@ export async function handleMessage(msg) {
         .finally(() => { preloadYeaftSkillSlashCommands(); });
       break;
 
+    case 'yeaft_asset_ack':
+      if ((msg.ok === true || msg.permanent === true) && ctx.assetOutbox?.acknowledge(msg.deliveryId)) {
+        ctx.assetOutbox.drain().catch(err => console.warn('[AssetOutbox] drain failed:', err?.message || err));
+      }
+      break;
+
     case 'create_conversation':
       await createConversation(msg);
       break;

package/context.js

@@ -47,6 +47,7 @@ export default {
   lastHeartbeatStallMs: 0,
   outboundSendQueue: [],
   outboundSendQueueActive: false,
+  assetOutbox: null,
   // 断连期间的消息缓冲队列（重连后 flush）
   messageBuffer: [],
   messageBufferMaxSize: 5000, // 防止内存无限增长

package/index.js

@@ -3,6 +3,7 @@ assertNodeVersion({ component: '@yeaft/webchat-agent' });
 
 import 'dotenv/config';
 import { platform, homedir } from 'os';
+import { createAssetOutbox } from './yeaft/asset-outbox.js';
 import { existsSync, readFileSync, writeFileSync, mkdirSync, cpSync, chmodSync, readdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { exec } from 'child_process';
@@ -107,6 +108,10 @@ const CONFIG = {
 // 初始化共享上下文
 ctx.CONFIG = CONFIG;
 ctx.saveConfig = saveConfig;
+ctx.assetOutbox = createAssetOutbox({
+  root: join(YEAFT_DIR, 'asset-outbox'),
+  send: message => ctx.sendToServer?.(message) || 'dropped',
+});
 
 // 初始加载 MCP servers（必须在 ctx.CONFIG 赋值之后）
 loadMcpServers();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.178",
+  "version": "1.0.181",
   "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/asset-outbox.js

@@ -0,0 +1,124 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { writeAtomic } from './storage/atomic.js';
+
+const DEFAULT_MAX_ITEMS = 128;
+const DEFAULT_MAX_BYTES = 256 * 1024 * 1024;
+
+function safeDeliveryId(value) {
+  return typeof value === 'string' && /^[A-Za-z0-9_-]{16,128}$/.test(value) ? value : null;
+}
+
+export function createAssetOutbox({
+  root,
+  send,
+  maxItems = DEFAULT_MAX_ITEMS,
+  maxBytes = DEFAULT_MAX_BYTES,
+  retryDelayMs = 30_000,
+} = {}) {
+  if (!root) throw new Error('Asset outbox root is required');
+  if (typeof send !== 'function') throw new Error('Asset outbox send function is required');
+  mkdirSync(root, { recursive: true });
+  let draining = null;
+  let retryTimer = null;
+
+  const itemPath = deliveryId => join(root, `${deliveryId}.json`);
+  const list = () => readdirSync(root)
+    .filter(name => /^[A-Za-z0-9_-]{16,128}\.json$/.test(name))
+    .map(name => {
+      const path = join(root, name);
+      try {
+        const stat = statSync(path);
+        return { path, size: stat.size, createdAt: stat.birthtimeMs || stat.mtimeMs };
+      } catch { return null; }
+    })
+    .filter(Boolean)
+    .sort((a, b) => a.createdAt - b.createdAt || a.path.localeCompare(b.path));
+
+  const read = path => {
+    try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
+  };
+
+  function enforceCapacity(extraBytes) {
+    const items = list();
+    const bytes = items.reduce((sum, item) => sum + item.size, 0);
+    if (items.length >= maxItems || bytes + extraBytes > maxBytes) {
+      throw new Error('Asset outbox is full; generated image was not queued');
+    }
+  }
+
+  function enqueue(message) {
+    const deliveryId = safeDeliveryId(message?.deliveryId) || randomUUID();
+    const payload = { ...message, type: 'yeaft_asset_put', deliveryId, queuedAt: Date.now() };
+    const data = JSON.stringify(payload);
+    enforceCapacity(Buffer.byteLength(data));
+    writeAtomic(itemPath(deliveryId), data);
+    return deliveryId;
+  }
+
+  function acknowledge(deliveryId) {
+    const id = safeDeliveryId(deliveryId);
+    if (!id) return false;
+    const path = itemPath(id);
+    if (!existsSync(path)) return false;
+    rmSync(path, { force: true });
+    return true;
+  }
+
+  const scheduleRetry = () => {
+    if (retryTimer || list().length === 0) return;
+    retryTimer = setTimeout(() => {
+      retryTimer = null;
+      drain().catch(err => console.warn('[AssetOutbox] retry failed:', err?.message || err));
+    }, retryDelayMs);
+    retryTimer.unref?.();
+  };
+
+  async function drain() {
+    if (draining) return draining;
+    if (retryTimer) {
+      clearTimeout(retryTimer);
+      retryTimer = null;
+    }
+    draining = (async () => {
+      for (const item of list()) {
+        const payload = read(item.path);
+        if (!payload || !safeDeliveryId(payload.deliveryId)) {
+          rmSync(item.path, { force: true });
+          continue;
+        }
+        let outcome;
+        try { outcome = await send(payload); } catch { outcome = 'dropped'; }
+        if (outcome !== 'sent') break;
+      }
+    })().finally(() => {
+      draining = null;
+      scheduleRetry();
+    });
+    return draining;
+  }
+
+  function removeSession(sessionId) {
+    let removed = 0;
+    for (const item of list()) {
+      const payload = read(item.path);
+      if (payload?.sessionId !== sessionId) continue;
+      rmSync(item.path, { force: true });
+      removed++;
+    }
+    return removed;
+  }
+
+  return {
+    enqueue,
+    acknowledge,
+    drain,
+    removeSession,
+    list,
+    close() {
+      if (retryTimer) clearTimeout(retryTimer);
+      retryTimer = null;
+    },
+  };
+}

package/yeaft/conversation/persist.js

@@ -263,6 +263,7 @@ function serializeMessage(msg) {
   // Defaults to 'main' for legacy messages (see migrate-messages-threadid.js).
   fm.push(`threadId: ${msg.threadId || 'main'}`);
   if (msg.turnId) fm.push(`turnId: ${msg.turnId}`);
+  if (msg.imageAssetAnchor) fm.push('imageAssetAnchor: true');
   // task-313: when a thread is merged into another, the messages keep
   // their original thread id in `sourceThreadId` so the UI can still
   // render a small "#source" pill next to each bubble.
@@ -285,6 +286,12 @@ function serializeMessage(msg) {
       fm.push(`attachmentsB64: ${b64}`);
     } catch { /* best-effort: attachments are UI metadata, not engine-critical */ }
   }
+  if (Array.isArray(msg.images) && msg.images.length > 0) {
+    try {
+      const b64 = Buffer.from(JSON.stringify(msg.images)).toString('base64');
+      fm.push(`imagesB64: ${b64}`);
+    } catch { /* best-effort: image display metadata is not engine-critical */ }
+  }
   // Internal/synthetic rows must round-trip so refresh/history replay can
   // keep them out of the user-visible conversation. Reflection folding uses
   // `_reflection`; other engine-only rows may use one of the explicit flags.
@@ -392,6 +399,7 @@ export function parseMessage(raw) {
       case 'tokens_est': msg.tokens_est = parseInt(value, 10); break;
       case 'threadId': msg.threadId = value; break;
       case 'turnId': msg.turnId = value; break;
+      case 'imageAssetAnchor': msg.imageAssetAnchor = value === 'true'; break;
       case 'sourceThreadId': msg.sourceThreadId = value; break;
       case 'sessionId': msg.sessionId = value; break;
       case 'chatId': msg.chatId = value; break;
@@ -403,6 +411,12 @@ export function parseMessage(raw) {
           if (Array.isArray(parsed)) msg.attachments = parsed;
         } catch { /* best-effort: ignore malformed attachment metadata */ }
         break;
+      case 'imagesB64':
+        try {
+          const parsed = JSON.parse(Buffer.from(value, 'base64').toString('utf8'));
+          if (Array.isArray(parsed)) msg.images = parsed;
+        } catch { /* best-effort: ignore malformed image metadata */ }
+        break;
       case '_reflection': msg._reflection = value === 'true'; break;
       case 'internal': msg.internal = value === 'true'; break;
       case 'systemOnly': msg.systemOnly = value === 'true'; break;

package/yeaft/engine.js

@@ -47,6 +47,7 @@ import { attachRouterPlan, extractPriorPlan, stripMetaForWire } from './router/c
 import { resolveThinking } from './router/thinking.js';
 import { approxTokens } from './memory/budget.js';
 import { COLLAB_TOOL_POLICY, normalizeToolOutput, truncateToolResultIfNeeded } from './tools/registry.js';
+import { extractDisplayImages, stripDisplayImageData } from './image-assets.js';
 import { acknowledgePendingNotifications, formatNotificationsForPrompt, peekPendingNotifications } from './sub-agent/notifications.js';
 import {
   TOOL_BATCH_SIZE,
@@ -2183,6 +2184,7 @@ export class Engine {
     let continueTurns = 0; // auto-continue counter
     let toolLoopTurns = 0; // task-327b: tool-use turns for long-loop auto-bump
     let fullResponseText = '';
+    let hasDisplayImageAnchor = false;
     let currentModel = this.#config.model;
     let cumulativeInputTokens = 0;
     let cumulativeOutputTokens = 0;
@@ -3068,6 +3070,7 @@ export class Engine {
             // for this turn. The hook still persists assistant + tool
             // rows for THIS VP's contribution.
             userAlreadyPersisted,
+            hasDisplayImageAnchor,
           });
 
           if (hookResult.consolidated) {
@@ -3252,6 +3255,7 @@ export class Engine {
         }
 
         let output;
+        let displayImages = [];
         let isError = false;
         currentToolCallForAsyncTask = {
           id: tc.id,
@@ -3285,7 +3289,12 @@ export class Engine {
               const rawOutput = await tool.execute(tc.input, toolCtx);
               output = normalizeToolOutput(rawOutput);
             }
-            yield { type: 'tool_end', id: tc.id, name: tc.name, output, isError: false, threadId: this.currentThreadId };
+            displayImages = extractDisplayImages(tc.name, output);
+            if (displayImages.length > 0) {
+              output = stripDisplayImageData(output, displayImages);
+            }
+            yield { type: 'tool_end', id: tc.id, name: tc.name, output, displayImages, isError: false, threadId: this.currentThreadId };
+            if (displayImages.some(image => image.deliveryQueued === true)) hasDisplayImageAnchor = true;
           } catch (err) {
             output = `Error: ${err.message}`;
             isError = true;
@@ -3310,6 +3319,7 @@ export class Engine {
           durationMs: toolDurationMs,
           isError,
           toolOutput: output,
+          ...(displayImages.length > 0 ? { displayImageCount: displayImages.length } : {}),
         };
 
         // 2026-05-13: feed the per-tool counters. Stays best-effort — a
@@ -3334,7 +3344,6 @@ export class Engine {
           toolOutput: output,
           durationMs: toolDurationMs,
           isError,
-          toolOutput: output,
         });
 
         // Append only the bounded copy to the model message history. Raw

package/yeaft/image-assets.js

@@ -0,0 +1,91 @@
+import { createHash } from 'node:crypto';
+
+const SUPPORTED_IMAGE_MIME = new Set(['image/png', 'image/jpeg', 'image/gif', 'image/webp']);
+const MAX_UI_IMAGE_BYTES = 20 * 1024 * 1024;
+
+function parseJsonObject(value) {
+  if (value && typeof value === 'object') return value;
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) return null;
+  try { return JSON.parse(trimmed); } catch { return null; }
+}
+
+function decodeDataUri(value) {
+  const match = typeof value === 'string'
+    ? value.match(/^data:(image\/[A-Za-z0-9.+-]+);base64,([A-Za-z0-9+/=\s]+)$/)
+    : null;
+  if (!match) return null;
+  const mimeType = match[1].toLowerCase();
+  if (!SUPPORTED_IMAGE_MIME.has(mimeType)) return null;
+  const data = match[2].replace(/\s+/g, '');
+  let buffer;
+  try { buffer = Buffer.from(data, 'base64'); } catch { return null; }
+  if (!buffer.length || buffer.length > MAX_UI_IMAGE_BYTES) return null;
+  return { mimeType, data, buffer };
+}
+
+function imageCandidates(payload) {
+  if (!payload) return [];
+  if (Array.isArray(payload)) return payload;
+  const out = [];
+  if (payload.image) out.push(typeof payload.image === 'object' ? payload.image : { image: payload.image });
+  if (payload.dataUri) out.push({ dataUri: payload.dataUri });
+  if (Array.isArray(payload.images)) out.push(...payload.images);
+  return out;
+}
+
+export function extractDisplayImages(toolName, output) {
+  const payload = parseJsonObject(output);
+  const images = [];
+  const seen = new Set();
+  for (const item of imageCandidates(payload)) {
+    const dataUri = typeof item === 'string'
+      ? item
+      : (item?.dataUri || item?.image || (item?.data && item?.mimeType ? `data:${item.mimeType};base64,${item.data}` : null));
+    const decoded = decodeDataUri(dataUri);
+    if (!decoded) continue;
+    const assetId = createHash('sha256').update(decoded.buffer).digest('hex');
+    if (seen.has(assetId)) continue;
+    seen.add(assetId);
+    const filename = String(item?.filename || payload?.filename || payload?.path || `${toolName || 'image'}-${assetId.slice(0, 12)}`)
+      .split(/[/\\]/)
+      .pop();
+    images.push({
+      assetId,
+      mimeType: decoded.mimeType,
+      filename,
+      size: decoded.buffer.length,
+      width: Number.isFinite(item?.width ?? payload?.width) ? Number(item?.width ?? payload.width) : null,
+      height: Number.isFinite(item?.height ?? payload?.height) ? Number(item?.height ?? payload.height) : null,
+      previewData: { data: decoded.data, mimeType: decoded.mimeType, filename },
+    });
+  }
+  return images;
+}
+
+export function imageMetadataForPersistence(image) {
+  if (!image?.assetId || !image?.mimeType) return null;
+  return {
+    assetId: image.assetId,
+    mimeType: image.mimeType,
+    filename: image.filename || 'image',
+    size: Number(image.size) || null,
+    width: Number(image.width) || null,
+    height: Number(image.height) || null,
+  };
+}
+
+export function stripDisplayImageData(output, images) {
+  if (!Array.isArray(images) || images.length === 0) {
+    return typeof output === 'string' ? output : JSON.stringify(output ?? '');
+  }
+  const payload = parseJsonObject(output);
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return '[image asset]';
+  const clean = { ...payload };
+  delete clean.image;
+  delete clean.images;
+  delete clean.dataUri;
+  if (typeof clean.data === 'string' && clean.data.length > 1024) delete clean.data;
+  return JSON.stringify({ ...clean, imageAssetIds: images.map(image => image.assetId) });
+}

package/yeaft/remote-image-download.js

@@ -0,0 +1,199 @@
+import { lookup as dnsLookup } from 'node:dns/promises';
+import { request as httpRequest } from 'node:http';
+import { request as httpsRequest } from 'node:https';
+import { isIP } from 'node:net';
+
+export const MAX_REMOTE_IMAGE_BYTES = 20 * 1024 * 1024;
+const MAX_REDIRECTS = 5;
+
+function parseIpv4(address) {
+  const parts = address.split('.').map(Number);
+  return parts.length === 4 && parts.every(part => Number.isInteger(part) && part >= 0 && part <= 255) ? parts : null;
+}
+
+function parseIpv6(address) {
+  const normalized = address.toLowerCase().split('%')[0];
+  if (!normalized || normalized.includes(':::')) return null;
+  const halves = normalized.split('::');
+  if (halves.length > 2) return null;
+  const parseHalf = (value) => {
+    if (!value) return [];
+    const groups = [];
+    for (const part of value.split(':')) {
+      if (part.includes('.')) {
+        const bytes = parseIpv4(part);
+        if (!bytes) return null;
+        groups.push((bytes[0] << 8) | bytes[1], (bytes[2] << 8) | bytes[3]);
+      } else if (!/^[0-9a-f]{1,4}$/.test(part)) {
+        return null;
+      } else {
+        groups.push(Number.parseInt(part, 16));
+      }
+    }
+    return groups;
+  };
+  const left = parseHalf(halves[0]);
+  const right = parseHalf(halves[1] || '');
+  if (!left || !right) return null;
+  if (halves.length === 1) return left.length === 8 ? left : null;
+  const zeros = 8 - left.length - right.length;
+  if (zeros < 1) return null;
+  return [...left, ...Array(zeros).fill(0), ...right];
+}
+
+function ipv4FromGroups(groups, index) {
+  const high = groups[index];
+  const low = groups[index + 1];
+  return `${high >>> 8}.${high & 0xff}.${low >>> 8}.${low & 0xff}`;
+}
+
+export function isPublicNetworkAddress(address) {
+  const version = isIP(address);
+  if (version === 4) {
+    const bytes = parseIpv4(address);
+    if (!bytes) return false;
+    const [a, b, c] = bytes;
+    if (a === 0 || a === 10 || a === 127 || a >= 224) return false;
+    if (a === 100 && b >= 64 && b <= 127) return false;
+    if (a === 169 && b === 254) return false;
+    if (a === 172 && b >= 16 && b <= 31) return false;
+    if (a === 192 && b === 0 && (c === 0 || c === 2)) return false;
+    if (a === 192 && b === 88 && c === 99) return false;
+    if (a === 192 && b === 168) return false;
+    if (a === 198 && (b === 18 || b === 19)) return false;
+    if (a === 198 && b === 51 && c === 100) return false;
+    if (a === 203 && b === 0 && c === 113) return false;
+    return true;
+  }
+  if (version !== 6) return false;
+  const normalized = address.toLowerCase().split('%')[0];
+  if (normalized === '::' || normalized === '::1') return false;
+  if (normalized.startsWith('fc') || normalized.startsWith('fd')) return false;
+  if (/^fe[89ab]/.test(normalized)) return false;
+  if (normalized.startsWith('ff')) return false;
+  const groups = parseIpv6(normalized);
+  if (!groups) return false;
+  const isMappedIpv4 = groups.slice(0, 5).every(group => group === 0) && groups[5] === 0xffff;
+  if (isMappedIpv4) return isPublicNetworkAddress(ipv4FromGroups(groups, 6));
+  const isCompatibleIpv4 = groups.slice(0, 6).every(group => group === 0);
+  const isNat64 = (groups[0] === 0x0064 && groups[1] === 0xff9b && groups.slice(2, 6).every(group => group === 0))
+    || (groups[0] === 0x0064 && groups[1] === 0xff9b && groups[2] === 0x0001);
+  const is6to4 = groups[0] === 0x2002;
+  const isTeredo = groups[0] === 0x2001 && groups[1] === 0;
+  const isIsatap = groups[5] === 0x5efe;
+  if (isCompatibleIpv4 || isNat64 || is6to4 || isTeredo || isIsatap) return false;
+  return !(groups[0] === 0x2001 && groups[1] === 0x0db8);
+}
+
+async function resolvePublicTarget(url, lookup = dnsLookup) {
+  if (!['http:', 'https:'].includes(url.protocol)) throw new Error('Generated image URL must use http or https');
+  if (url.username || url.password) throw new Error('Generated image URL must not contain credentials');
+  const hostname = url.hostname.replace(/^\[|\]$/g, '');
+  const literalVersion = isIP(hostname);
+  const records = literalVersion
+    ? [{ address: hostname, family: literalVersion }]
+    : await lookup(hostname, { all: true, verbatim: true });
+  if (!Array.isArray(records) || records.length === 0) throw new Error('Generated image host did not resolve');
+  if (records.some(record => !isPublicNetworkAddress(record.address))) {
+    throw new Error('Generated image URL resolves to a private or reserved network');
+  }
+  return records[0];
+}
+
+function detectMime(buffer) {
+  if (buffer.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) return 'image/png';
+  if (buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) return 'image/jpeg';
+  const head6 = buffer.subarray(0, 6).toString('ascii');
+  if (head6 === 'GIF87a' || head6 === 'GIF89a') return 'image/gif';
+  if (buffer.subarray(0, 4).toString('ascii') === 'RIFF' && buffer.subarray(8, 12).toString('ascii') === 'WEBP') return 'image/webp';
+  return null;
+}
+
+function requestOnce(url, target, { signal, requestImpl } = {}) {
+  return new Promise((resolve, reject) => {
+    const request = requestImpl || (url.protocol === 'https:' ? httpsRequest : httpRequest);
+    let settled = false;
+    const finishReject = (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err);
+    };
+    const req = request(url, {
+      signal,
+      lookup: (_hostname, _options, callback) => callback(null, target.address, target.family),
+      headers: { accept: 'image/png,image/jpeg,image/gif,image/webp' },
+    }, response => {
+      if (settled) {
+        response.destroy();
+        return;
+      }
+      settled = true;
+      resolve(response);
+    });
+    req.on('error', finishReject);
+    req.end();
+  });
+}
+
+async function readBounded(response, maxBytes) {
+  const declared = Number(response.headers['content-length']);
+  if (Number.isFinite(declared) && declared > maxBytes) {
+    response.destroy();
+    throw new Error('Generated image exceeds 20 MiB');
+  }
+  const chunks = [];
+  let total = 0;
+  try {
+    for await (const chunk of response) {
+      total += chunk.length;
+      if (total > maxBytes) {
+        response.destroy();
+        throw new Error('Generated image exceeds 20 MiB');
+      }
+      chunks.push(chunk);
+    }
+  } catch (err) {
+    response.destroy();
+    throw err;
+  }
+  if (total === 0) throw new Error('Generated image is empty');
+  return Buffer.concat(chunks, total);
+}
+
+export async function downloadRemoteImage(value, {
+  signal,
+  lookup = dnsLookup,
+  requestImpl,
+  maxBytes = MAX_REMOTE_IMAGE_BYTES,
+  maxRedirects = MAX_REDIRECTS,
+} = {}) {
+  let url;
+  try { url = new URL(value); } catch { throw new Error('Image API returned an invalid image URL'); }
+  for (let redirects = 0; ; redirects++) {
+    const target = await resolvePublicTarget(url, lookup);
+    const response = await requestOnce(url, target, { signal, requestImpl });
+    const status = Number(response.statusCode || 0);
+    if (status >= 300 && status < 400 && response.headers.location) {
+      response.destroy();
+      if (redirects >= maxRedirects) throw new Error('Generated image download exceeded redirect limit');
+      const nextUrl = new URL(response.headers.location, url);
+      if (url.protocol === 'https:' && nextUrl.protocol !== 'https:') {
+        throw new Error('Generated image redirect must not downgrade HTTPS');
+      }
+      url = nextUrl;
+      continue;
+    }
+    if (status < 200 || status >= 300) {
+      response.destroy();
+      throw new Error(`Image download returned ${status}`);
+    }
+    const mimeType = String(response.headers['content-type'] || '').split(';')[0].toLowerCase();
+    if (!['image/png', 'image/jpeg', 'image/gif', 'image/webp'].includes(mimeType)) {
+      response.destroy();
+      throw new Error(`Unsupported generated image type: ${mimeType}`);
+    }
+    const buffer = await readBounded(response, maxBytes);
+    if (detectMime(buffer) !== mimeType) throw new Error('Generated image MIME does not match file bytes');
+    return { buffer, mimeType, url: url.href };
+  }
+}

package/yeaft/routing/loop-guard.js

@@ -6,7 +6,7 @@
  *   1. Chain depth — a message's `causedBy` chain (A → @B → @C → @A …) must
  *      not exceed a max depth. Each route_forward call stamps the outbound
  *      envelope's `meta.causedBy` with a chain of msgIds, and the guard
- *      rejects when the chain length would exceed MAX_CHAIN_DEPTH (10).
+ *      rejects when the chain length would exceed MAX_CHAIN_DEPTH (30).
  *
  *   2. Rate throttle — within a sliding window (WINDOW_MS = 5000, default
  *      MAX_HITS_PER_WINDOW = 8), a single (sessionId, vpId) target may be
@@ -43,7 +43,7 @@
  *     advance the rate counter.
  */
 
-export const MAX_CHAIN_DEPTH = 10;
+export const MAX_CHAIN_DEPTH = 30;
 export const DEFAULT_WINDOW_MS = 5_000;
 export const DEFAULT_MAX_HITS_PER_WINDOW = 8;
 export const DEFAULT_MAX_KEYS = 1_000;
@@ -137,7 +137,7 @@ export function createLoopGuard(options = {}) {
       if (!sessionId || !targetVpId) {
         return { ok: false, reason: 'chain_depth_exceeded', detail: { missing: true } };
       }
-      if (Array.isArray(chain) && chain.length >= maxChainDepth) {
+      if (Array.isArray(chain) && chain.length > maxChainDepth) {
         return {
           ok: false,
           reason: 'chain_depth_exceeded',

package/yeaft/stop-hooks.js

@@ -74,6 +74,7 @@ export async function runStopHooks(context) {
     // row exactly once before fan-out. Each VP's stop-hook then skips
     // the user record but still writes its own assistant + tool rows.
     userAlreadyPersisted = false,
+    hasDisplayImageAnchor = false,
   } = context;
 
   // Model name for persisted messages: use primaryModel if provided, else config.model
@@ -125,6 +126,15 @@ export async function runStopHooks(context) {
         }
       }
       const recentMessages = messages.slice(turnStart);
+      const isPersistable = (msg) => Boolean(msg?.role) && (
+        (typeof msg.content === 'string' && msg.content.length > 0) ||
+        (msg.content && typeof msg.content !== 'string') ||
+        (Array.isArray(msg.toolCalls) && msg.toolCalls.length > 0) ||
+        msg.role === 'tool'
+      );
+      const imageAnchorMessage = hasDisplayImageAnchor
+        ? recentMessages.findLast(msg => msg?.role === 'assistant' && isPersistable(msg)) || null
+        : null;
       for (const msg of recentMessages) {
         if (!msg || !msg.role) continue;
         // Skip the user row if the orchestrator already wrote it once for
@@ -145,12 +155,7 @@ export async function runStopHooks(context) {
         if (userAlreadyPersisted && msg.role === 'user' && msg === recentMessages[0]) continue;
         // Allow empty assistant content when toolCalls are present;
         // tool messages have content by construction.
-        const hasContent =
-          (typeof msg.content === 'string' && msg.content.length > 0) ||
-          (msg.content && typeof msg.content !== 'string') ||
-          (Array.isArray(msg.toolCalls) && msg.toolCalls.length > 0) ||
-          msg.role === 'tool';
-        if (!hasContent) continue;
+        if (!isPersistable(msg)) continue;
 
         const record = {
           role: msg.role,
@@ -164,6 +169,7 @@ export async function runStopHooks(context) {
         if (Array.isArray(msg.toolCalls) && msg.toolCalls.length > 0) {
           record.toolCalls = msg.toolCalls;
         }
+        if (msg === imageAnchorMessage) record.imageAssetAnchor = true;
         if (msg.isError) record.isError = true;
         // Bug 6: stamp sessionId / threadId so replay can re-route by group.
         if (sessionId) record.sessionId = sessionId;

package/yeaft/tools/grep.js

@@ -8,12 +8,21 @@
 import { defineTool } from './types.js';
 import { spawn } from 'child_process';
 import { readdir, readFile, stat } from 'fs/promises';
+import { StringDecoder } from 'string_decoder';
 import { existsSync } from 'fs';
 import { resolve, join, relative, extname } from 'path';
 
 /** Max output lines. */
 const MAX_LINES = 250;
 
+/** Hard cap before Grep output reaches history, debug events, or WebSocket. */
+const MAX_OUTPUT_BYTES = 512 * 1024;
+const OUTPUT_TRUNCATED_MARKER = '\n\n[Output truncated]';
+const MAX_CAPTURE_BYTES = MAX_OUTPUT_BYTES - Buffer.byteLength(OUTPUT_TRUNCATED_MARKER, 'utf8');
+
+/** Keep one pathological source line from consuming the whole output budget. */
+const MAX_LINE_BYTES = 16 * 1024;
+
 /** Binary extensions to skip. */
 const BINARY_EXTS = new Set([
   '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp',
@@ -25,6 +34,77 @@ const BINARY_EXTS = new Set([
   '.sqlite', '.db',
 ]);
 
+const utf8Decoder = new TextDecoder('utf-8', { fatal: true });
+
+function decodeTextFile(buffer) {
+  // Extension lists are only a fast path. Generated artifacts and renamed
+  // binaries commonly have no useful extension, especially on Windows.
+  if (buffer.includes(0)) return null;
+  try { return utf8Decoder.decode(buffer); } catch { return null; }
+}
+
+function truncateUtf8(text, maxBytes) {
+  if (maxBytes <= 0) return '';
+  const buffer = Buffer.from(text, 'utf8');
+  if (buffer.length <= maxBytes) return text;
+  return new StringDecoder('utf8').write(buffer.subarray(0, maxBytes));
+}
+
+function boundToolOutput(text) {
+  if (Buffer.byteLength(text, 'utf8') <= MAX_OUTPUT_BYTES) return text;
+  return truncateUtf8(text, MAX_CAPTURE_BYTES) + OUTPUT_TRUNCATED_MARKER;
+}
+
+function formatGrepError(message) {
+  const errorMessage = `Grep failed: ${message}`;
+  const serialized = JSON.stringify({ error: errorMessage });
+  if (Buffer.byteLength(serialized, 'utf8') <= MAX_OUTPUT_BYTES) return serialized;
+
+  const markerBytes = Buffer.byteLength(OUTPUT_TRUNCATED_MARKER, 'utf8');
+  let low = 0;
+  let high = Math.max(0, Buffer.byteLength(errorMessage, 'utf8') - markerBytes);
+  let result = JSON.stringify({ error: OUTPUT_TRUNCATED_MARKER });
+
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const candidate = JSON.stringify({
+      error: truncateUtf8(errorMessage, mid) + OUTPUT_TRUNCATED_MARKER,
+    });
+    if (Buffer.byteLength(candidate, 'utf8') <= MAX_OUTPUT_BYTES) {
+      result = candidate;
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+
+  return result;
+}
+
+function createOutputCollector(maxBytes = MAX_OUTPUT_BYTES) {
+  const parts = [];
+  const contentBytes = Math.max(0, maxBytes - Buffer.byteLength(OUTPUT_TRUNCATED_MARKER, 'utf8'));
+  let bytes = 0;
+  let truncated = false;
+  return {
+    add(value) {
+      if (truncated) return false;
+      const normalized = String(value).replace(/\r/g, '');
+      const line = truncateUtf8(normalized, MAX_LINE_BYTES);
+      const lineWasTruncated = Buffer.byteLength(normalized, 'utf8') > Buffer.byteLength(line, 'utf8');
+      const separator = parts.length > 0 ? '\n' : '';
+      const remaining = contentBytes - bytes - Buffer.byteLength(separator, 'utf8');
+      if (remaining <= 0) { truncated = true; return false; }
+      const bounded = truncateUtf8(line, remaining);
+      parts.push(separator + bounded);
+      bytes += Buffer.byteLength(separator + bounded, 'utf8');
+      if (lineWasTruncated || bounded !== line) truncated = true;
+      return !truncated;
+    },
+    toString() { return parts.join('') + (truncated ? OUTPUT_TRUNCATED_MARKER : ''); },
+  };
+}
+
 /**
  * Check if ripgrep is available.
  */
@@ -39,7 +119,7 @@ function hasRipgrep() {
 /**
  * Run ripgrep and return results.
  */
-function runRipgrep(pattern, searchPath, options) {
+export function runRipgrep(pattern, searchPath, options, spawnProcess = spawn) {
   return new Promise((resolve, reject) => {
     const args = [
       pattern,
@@ -60,44 +140,72 @@ function runRipgrep(pattern, searchPath, options) {
     if (options.multiline) args.push('-U', '--multiline-dotall');
     args.push('--max-count', String(options.maxResults || 500));
 
-    const proc = spawn('rg', args, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
-    let stdout = '';
-    let stderr = '';
-
-    proc.stdout.on('data', (chunk) => {
-      stdout += chunk.toString();
-      // Truncate early if way too large
-      if (stdout.length > 512 * 1024) {
+    const proc = spawnProcess('rg', args, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let capturedBytes = 0;
+    let truncatedStream = null;
+    let settled = false;
+
+    function capture(streamName, chunk, chunks) {
+      if (truncatedStream) return;
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      const remaining = MAX_CAPTURE_BYTES - capturedBytes;
+      if (buffer.length > remaining) {
+        if (remaining > 0) chunks.push(buffer.subarray(0, remaining));
+        capturedBytes = MAX_CAPTURE_BYTES;
+        truncatedStream = streamName;
         try { proc.kill(); } catch {}
+        return;
       }
-    });
-    proc.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+      chunks.push(buffer);
+      capturedBytes += buffer.length;
+    }
+
+    function decodeCaptured(chunks, wasTruncated) {
+      // Buffer decoding normally expands each invalid byte to the three-byte
+      // U+FFFD replacement character. Use a one-byte replacement, then enforce
+      // the final encoded-byte boundary as a last line of defense.
+      const marker = wasTruncated ? OUTPUT_TRUNCATED_MARKER : '';
+      const maxTextBytes = MAX_OUTPUT_BYTES - Buffer.byteLength(marker, 'utf8');
+      const decoded = Buffer.concat(chunks).toString('utf8').replaceAll('\ufffd', '?').replace(/\r/g, '');
+      return truncateUtf8(decoded, maxTextBytes) + marker;
+    }
+
+    proc.stdout.on('data', (chunk) => capture('stdout', chunk, stdoutChunks));
+    proc.stderr.on('data', (chunk) => capture('stderr', chunk, stderrChunks));
     proc.on('close', (code) => {
-      if (code === 0 || code === 1) {
-        resolve(stdout);
-      } else {
-        reject(new Error(stderr || `rg exited with code ${code}`));
-      }
+      if (settled) return;
+      settled = true;
+      const stdout = decodeCaptured(stdoutChunks, truncatedStream === 'stdout');
+      const stderr = decodeCaptured(stderrChunks, truncatedStream === 'stderr');
+      if (code === 0 || code === 1 || truncatedStream === 'stdout') resolve(stdout);
+      else reject(new Error(stderr || `rg exited with code ${code}`));
+    });
+    proc.on('error', (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err);
     });
-    proc.on('error', reject);
   });
 }
 
 /**
  * Fallback: Node.js grep implementation.
  */
-async function nodeGrep(pattern, searchPath, options) {
+export async function nodeGrep(pattern, searchPath, options) {
   const regex = new RegExp(pattern, options.caseInsensitive ? 'gi' : 'g');
-  const results = [];
+  const output = createOutputCollector();
+  let resultCount = 0;
   const SKIP = new Set(['node_modules', '.git', '__pycache__', '.next', 'dist', 'build', '.cache']);
 
   async function searchDir(dir) {
-    if (results.length >= (options.maxResults || 500)) return;
+    if (resultCount >= (options.maxResults || 500)) return;
     let entries;
     try { entries = await readdir(dir, { withFileTypes: true }); } catch { return; }
 
     for (const entry of entries) {
-      if (results.length >= (options.maxResults || 500)) return;
+      if (resultCount >= (options.maxResults || 500)) return;
       const fullPath = join(dir, entry.name);
 
       if (entry.isDirectory()) {
@@ -111,22 +219,32 @@ async function nodeGrep(pattern, searchPath, options) {
           const fileStat = await stat(fullPath);
           if (fileStat.size > 1024 * 1024) continue; // skip files > 1MB
 
-          const content = await readFile(fullPath, 'utf-8');
+          const buffer = await readFile(fullPath);
+          const content = decodeTextFile(buffer);
+          if (content == null) continue;
           const relPath = relative(searchPath, fullPath);
 
           if (options.filesOnly) {
-            if (regex.test(content)) results.push(relPath);
+            if (regex.test(content)) {
+              resultCount += 1;
+              if (!output.add(relPath)) return;
+            }
             regex.lastIndex = 0;
           } else if (options.count) {
             const matches = content.match(regex);
-            if (matches) results.push(`${relPath}:${matches.length}`);
+            if (matches) {
+              resultCount += 1;
+              if (!output.add(`${relPath}:${matches.length}`)) return;
+            }
           } else {
             const lines = content.split('\n');
             for (let i = 0; i < lines.length; i++) {
               if (regex.test(lines[i])) {
-                results.push(`${relPath}:${i + 1}:${lines[i]}`);
+                resultCount += 1;
+                if (!output.add(`${relPath}:${i + 1}:${lines[i]}`)) return;
               }
               regex.lastIndex = 0;
+              if (resultCount >= (options.maxResults || 500)) return;
             }
           }
         } catch {
@@ -137,7 +255,7 @@ async function nodeGrep(pattern, searchPath, options) {
   }
 
   await searchDir(searchPath);
-  return results.join('\n');
+  return output.toString();
 }
 
 export default defineTool({
@@ -302,15 +420,18 @@ Guidelines:
         return '(no matches)';
       }
 
-      // Limit output lines
+      // Limit output lines, then enforce the byte budget at the actual tool
+      // boundary so prefixes, JSON escaping, and result markers are included.
       const lines = result.trim().split('\n');
       if (lines.length > head_limit) {
-        return lines.slice(0, head_limit).join('\n') + `\n\n... (${lines.length - head_limit} more results)`;
+        return boundToolOutput(
+          lines.slice(0, head_limit).join('\n') + `\n\n... (${lines.length - head_limit} more results)`,
+        );
       }
 
-      return result.trim();
+      return boundToolOutput(result.trim());
     } catch (err) {
-      return JSON.stringify({ error: `Grep failed: ${err.message}` });
+      return formatGrepError(err.message);
     }
   },
 });

package/yeaft/tools/image-generation.js

@@ -5,6 +5,7 @@
  */
 
 import { defineTool } from './types.js';
+import { downloadRemoteImage } from '../remote-image-download.js';
 
 export default defineTool({
   name: 'ImageGeneration',
@@ -83,29 +84,26 @@ Guidelines:
 
       const data = await response.json();
 
-      // If output_path specified, save the image
-      if (output_path && data.url) {
+      if (!data.url) return JSON.stringify({ error: 'Image API returned no image URL' });
+      const { buffer, mimeType } = await downloadRemoteImage(data.url, {
+        signal: ctx?.signal,
+        ...(ctx?.remoteImageDownload || {}),
+      });
+      let savedPath = null;
+      if (output_path) {
         const { resolve: resolvePath } = await import('path');
         const { writeFile } = await import('fs/promises');
-
-        const imgResponse = await fetch(data.url);
-        const buffer = Buffer.from(await imgResponse.arrayBuffer());
-        const absPath = resolvePath(ctx?.cwd || process.cwd(), output_path);
-        await writeFile(absPath, buffer);
-
-        return JSON.stringify({
-          success: true,
-          path: absPath,
-          size,
-          prompt: prompt.slice(0, 100),
-        });
+        savedPath = resolvePath(ctx?.cwd || process.cwd(), output_path);
+        await writeFile(savedPath, buffer);
       }
-
       return JSON.stringify({
         success: true,
-        url: data.url,
+        ...(savedPath ? { path: savedPath } : {}),
         size,
         prompt: prompt.slice(0, 100),
+        image: `data:${mimeType};base64,${buffer.toString('base64')}`,
+        mimeType,
+        filename: savedPath ? savedPath.split(/[/\\]/).pop() : `generated-${Date.now()}`,
       });
     } catch (err) {
       if (err.name === 'AbortError') return JSON.stringify({ error: 'Generation cancelled' });

package/yeaft/tools/route-forward.js

@@ -23,6 +23,7 @@
  * `{ ok: false, error }` so the VP can pivot (apologise, retry, ...).
  */
 
+import { MAX_CHAIN_DEPTH } from '../routing/loop-guard.js';
 import { defineTool } from './types.js';
 
 export default defineTool({
@@ -50,7 +51,7 @@ Arguments:
 Rules:
   - Forwarding to yourself is rejected (self_forward_rejected).
   - Forwarding to a non-member is rejected (target_not_in_roster).
-  - Forwards carry a causedBy chain; chains deeper than 10 hops are blocked
+  - Forwards carry a causedBy chain; chains deeper than ${MAX_CHAIN_DEPTH} hops are blocked
     (chain_depth_exceeded).
   - A single target may be forwarded to at most 8 times per 5-second window
     per session (throttled).
@@ -69,7 +70,7 @@ Returns JSON: { ok, dispatched?, error?, detail? }.`,
 规则：
   - 转发给自己会被拒绝（self_forward_rejected）。
   - 转发给非成员会被拒绝（target_not_in_roster）。
-  - 转发带有 causedBy 链；超过 10 跳的链会被阻止（chain_depth_exceeded）。
+  - 转发带有 causedBy 链；超过 ${MAX_CHAIN_DEPTH} 跳的链会被阻止（chain_depth_exceeded）。
   - 同一目标在每 5 秒窗口内最多被转发 8 次（节流限制）。
 
 返回 JSON：{ ok, dispatched?, error?, detail? }。`

package/yeaft/web-bridge.js

@@ -63,6 +63,7 @@ import {
 import { persistYeaftAttachments, attachmentsForPersistence, persistedAttachmentPreviewPayload } from './attachments.js';
 import { ConversationStore, parseSeqFromId } from './conversation/persist.js';
 import { isHiddenConversationRow } from './conversation/internal-control.js';
+import { imageMetadataForPersistence } from './image-assets.js';
 import { sliceLastNTurns } from './turn-utils.js';
 import { pairSanitize } from './pair-sanitize.js';
 import { filterSnapshotForVp } from './snapshot-filter.js';
@@ -999,6 +1000,7 @@ function projectPersistedToHistoryEntry(m) {
   if (m.id) entry.id = m.id;
   entry.threadId = m.threadId || m.turnId || 'main';
   if (m.turnId) entry.turnId = m.turnId;
+  if (m.imageAssetAnchor) entry.imageAssetAnchor = true;
   if (m.sessionId) entry.sessionId = m.sessionId;
   if (m.clientMessageId) entry.clientMessageId = m.clientMessageId;
   if (m.speakerVpId) entry.speakerVpId = m.speakerVpId;
@@ -1016,8 +1018,9 @@ function projectPersistedToHistoryEntry(m) {
   if (m.isError) entry.isError = true;
   if (m.ts) entry.ts = m.ts;
   else if (m.time) entry.ts = m.time;
+  if (Array.isArray(m.images) && m.images.length > 0) entry.images = m.images;
   if (Array.isArray(m.attachments) && m.attachments.length > 0) entry.attachments = m.attachments;
-  if ((entry.role === 'user' || entry.role === 'assistant') && !entry.content && !entry.attachments && !entry.toolCalls && !entry.toolSummaryCount) return null;
+  if ((entry.role === 'user' || entry.role === 'assistant') && !entry.content && !entry.attachments && !entry.images && !entry.toolCalls && !entry.toolSummaryCount) return null;
   return entry;
 }
 
@@ -1106,7 +1109,9 @@ function projectVisibleHistoryChunkMessages(messages = []) {
       ...(m.clientMessageId ? { clientMessageId: m.clientMessageId } : {}),
       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.images) && m.images.length > 0 ? { images: m.images } : {}),
       ...(m.speakerVpId ? { speakerVpId: m.speakerVpId } : {}),
       ...(Number.isFinite(m.toolSummaryCount) && m.toolSummaryCount > 0
         ? { toolSummaryCount: m.toolSummaryCount }
@@ -1156,7 +1161,13 @@ function emitLegacyHistoryOutputFrames(replayEntries) {
       if (entry.speakerVpId) envelopeOpts.vpId = entry.speakerVpId;
       sendSessionOutputFrame({
         type: 'assistant',
-        message: { id: entry.id || null, content: [{ type: 'text', text: entry.content }] },
+        message: {
+          id: entry.id || null,
+          content: [
+            ...(entry.content ? [{ type: 'text', text: entry.content }] : []),
+            ...((entry.images || []).map(image => ({ type: 'image_asset', image }))),
+          ],
+        },
         ts: entry.ts || null,
       }, envelopeOpts);
       if (Array.isArray(entry.toolCalls) && entry.toolCalls.length > 0) {
@@ -2851,6 +2862,7 @@ export function handleYeaftDeleteSession(msg) {
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     const result = deleteSession(yeaftDir, sessionId);
+    ctx.assetOutbox?.removeSession(sessionId);
     // Cascade: remove every persisted message stamped with this group id.
     // Hard delete (per user spec): no soft-archive, the bytes are gone.
     // Skipped silently if the session/store isn't initialized — the next
@@ -3299,12 +3311,34 @@ function handleEngineEvent(event, hctx) {
       }, envelope);
       break;
 
-    case 'tool_end':
+    case 'tool_end': {
+      const images = Array.isArray(event.displayImages) ? event.displayImages : [];
+      const displayOutput = typeof event.output === 'string' ? event.output : JSON.stringify(event.output ?? '');
+      for (const image of images) {
+        const persistedImage = imageMetadataForPersistence(image);
+        try {
+          if (!ctx.assetOutbox) throw new Error('asset outbox is unavailable');
+          const deliveryId = ctx.assetOutbox.enqueue({
+            conversationId: yeaftConversationId,
+            metadata: persistedImage,
+            sessionId: hctx.sessionId,
+            vpId: hctx.vpId,
+            turnId: hctx.turnId,
+            threadId: hctx.threadId || event.threadId,
+            image,
+          });
+          if (!deliveryId) throw new Error('asset outbox did not persist the image');
+          image.deliveryQueued = true;
+          ctx.assetOutbox.drain().catch(err => console.warn('[AssetOutbox] drain failed:', err?.message || err));
+        } catch (err) {
+          console.warn('[AssetOutbox] failed to queue image:', err?.message || err);
+        }
+      }
       if (hctx.toolResultsAccum) {
         hctx.toolResultsAccum.push({
           role: 'tool',
           toolCallId: event.id,
-          content: typeof event.output === 'string' ? event.output : JSON.stringify(event.output ?? ''),
+          content: displayOutput,
           isError: !!event.isError,
         });
       }
@@ -3330,7 +3364,7 @@ function handleEngineEvent(event, hctx) {
         tool_use_result: [{
           type: 'tool_result',
           tool_use_id: event.id,
-          content: event.output || '',
+          content: displayOutput,
           is_error: event.isError || false,
         }],
       }, envelope);
@@ -3341,6 +3375,7 @@ function handleEngineEvent(event, hctx) {
       // streaming' flicker on every tool call. Hold the 'tool' state
       // until the next real event arrives.
       break;
+    }
 
     case 'tool_result_update': {
       const content = typeof event.content === 'string'
@@ -6613,6 +6648,7 @@ export async function handleYeaftMcpReload(msg = {}) {
 
 export const __testHooks = {
   loadVisibleGroupHistoryPage,
+  projectVisibleHistoryChunkMessages,
   persistInboundMessageOnceByMsgId,
   buildPendingRescueEnvelope,
   runYeaftSessionSendForTest(msg) {