@yeaft/webchat-agent 1.0.640 → 1.0.642

package/yeaft/history-window.js

@@ -565,6 +565,130 @@ function truncateToolResultsForModel(messages, options = {}) {
   });
 }
 
+const TOOL_COMPACT_MARKER = '\n[tool result compacted for context budget; middle omitted]\n';
+const MIN_TOOL_SAMPLE_BYTES = 64;
+const TOOL_ERROR_FIELDS = new Set(['error', 'code', 'errorEffect', 'failureType', 'status']);
+const BINARY_PART_TYPES = new Set(['image', 'input_image', 'document', 'input_file']);
+
+function sampleToolText(text, retainedBytes) {
+  const bytes = Buffer.from(text, 'utf8');
+  if (bytes.length <= retainedBytes + Buffer.byteLength(TOOL_COMPACT_MARKER)) return text;
+  let headEnd = Math.floor(retainedBytes / 2);
+  let tailStart = bytes.length - (retainedBytes - headEnd);
+  // UTF-8 boundaries also keep CJK and astral characters intact. The marker is
+  // charged together with both samples by estimateContentTokens below.
+  while (headEnd > 0 && (bytes[headEnd] & 0xc0) === 0x80) headEnd -= 1;
+  while (tailStart < bytes.length && (bytes[tailStart] & 0xc0) === 0x80) tailStart += 1;
+  return bytes.subarray(0, headEnd).toString('utf8') + TOOL_COMPACT_MARKER
+    + bytes.subarray(tailStart).toString('utf8');
+}
+
+function sampleToolJson(value, retainedBytes) {
+  if (typeof value === 'string') return sampleToolText(value, retainedBytes);
+  if (!value || typeof value !== 'object' || BINARY_PART_TYPES.has(value.type)) return value;
+  if (Array.isArray(value)) return value.map(item => sampleToolJson(item, retainedBytes));
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+    key, TOOL_ERROR_FIELDS.has(key) ? item : sampleToolJson(item, retainedBytes),
+  ]));
+}
+
+function toolTextSampler(text) {
+  // Keep structured output parseable, including JSON inside text content parts
+  // and JSON string scalars. Only string leaves are sampled; flags, exit codes
+  // and Bash error markers stay whole. Unsafe numeric round trips and deeply
+  // nested structures stay intact for the existing protocol-unit budget fitter.
+  if (/^\s*[\[{"]/.test(text)) {
+    try {
+      const value = JSON.parse(text, (_key, item, context) => {
+        if (typeof item === 'number' && context?.source !== JSON.stringify(item)) {
+          throw new RangeError('JSON numeric representation would change');
+        }
+        return item;
+      });
+      const pending = [{ value, depth: 0 }];
+      while (pending.length > 0) {
+        const next = pending.pop();
+        if (!next.value || typeof next.value !== 'object') continue;
+        if (next.depth >= 64) return () => text;
+        for (const item of Object.values(next.value)) pending.push({ value: item, depth: next.depth + 1 });
+      }
+      return bytes => JSON.stringify(sampleToolJson(value, bytes));
+    } catch (error) {
+      // A valid but unsafe/deep JSON value must not crash sampling or silently
+      // change facts. Only invalid JSON falls through to ordinary text sampling.
+      if (!(error instanceof SyntaxError)) return () => text;
+    }
+  }
+  return bytes => sampleToolText(text, bytes);
+}
+
+function toolContentSampler(content) {
+  // Content parts keep their ordering, metadata and binary payloads. In
+  // particular, do not collapse mixed text/image/document output into JSON.
+  if (Array.isArray(content) && content.some(part => part && typeof part === 'object'
+    && (['text', 'input_text', 'output_text'].includes(part.type) || BINARY_PART_TYPES.has(part.type)))) {
+    const samplers = content.map(part => {
+      if (typeof part === 'string') return toolTextSampler(part);
+      if (part && ['text', 'input_text', 'output_text'].includes(part.type)
+        && typeof part.text === 'string') {
+        const sample = toolTextSampler(part.text);
+        return bytes => ({ ...part, text: sample(bytes) });
+      }
+      return () => part;
+    });
+    return bytes => samplers.map(sample => sample(bytes));
+  }
+  return toolTextSampler(serializeJsonValue(content));
+}
+
+function compactToolContentToBudget(content, tokenBudget) {
+  const sample = toolContentSampler(content);
+  const minimum = sample(MIN_TOOL_SAMPLE_BYTES);
+  if (estimateContentTokens(minimum) > tokenBudget) return minimum;
+  // Search measured content cost, not tokenBudget * chars/bytes. JSON escaping,
+  // CJK and multipart framing otherwise make small budgets easy to overshoot.
+  let low = MIN_TOOL_SAMPLE_BYTES;
+  let high = Math.max(low, Buffer.byteLength(serializeJsonValue(content), 'utf8'));
+  let fitted = minimum;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    const candidate = sample(mid);
+    if (estimateContentTokens(candidate) <= tokenBudget) {
+      low = mid;
+      fitted = candidate;
+    } else {
+      high = mid - 1;
+    }
+  }
+  return fitted;
+}
+
+function compactCurrentToolResults(messages, messageBudget) {
+  const out = messages.slice();
+  let excess = estimateMessagesTokens(out) - messageBudget;
+  let compactedToolResults = 0;
+  let compactedToolResultTokensSaved = 0;
+  // Protect the complete newest tool batch, not merely its last result. All
+  // parallel results are evidence for the next assistant continuation.
+  let latestEnd = out.length - 1;
+  while (latestEnd >= 0 && out[latestEnd]?.role !== 'tool') latestEnd -= 1;
+  let latestStart = latestEnd;
+  while (latestStart > 0 && out[latestStart - 1]?.role === 'tool') latestStart -= 1;
+  for (let index = 0; index < latestStart && excess > 0; index += 1) {
+    const message = out[index];
+    if (message?.role !== 'tool') continue;
+    const before = estimateContentTokens(message.content);
+    const content = compactToolContentToBudget(message.content, Math.max(0, before - excess));
+    const saved = before - estimateContentTokens(content);
+    if (saved <= 0) continue;
+    out[index] = { ...message, content };
+    excess -= saved;
+    compactedToolResults += 1;
+    compactedToolResultTokensSaved += saved;
+  }
+  return { messages: out, compactedToolResults, compactedToolResultTokensSaved };
+}
+
 const HISTORY_SOURCE_INDEX = Symbol('historySourceIndex');
 
 function withHistorySourceIndexes(messages, offset = 0) {
@@ -1139,8 +1263,9 @@ export function buildHistoryBuckets(snapshot, options = {}) {
  * Fit one provider-request copy to the actual model window. The caller tells
  * us where current-turn rows begin; only the prefix is subject to the history
  * budget. If the complete request is still too large, old history disappears
- * first, followed by the oldest disposable current-turn protocol units. The
- * source array and durable transcript are never mutated.
+ * first. Under current-turn pressure, sample old tool-result text before
+ * evicting disposable protocol units; the latest tool batch stays lossless
+ * until the final budget fallback. The source and transcript are never mutated.
  *
  * @param {Array<object>} messages
  * @param {{ contextWindow:number, systemTokens?:number, toolSchemaTokens?:number,
@@ -1167,9 +1292,9 @@ export function fitProviderRequestToContext(messages, options = {}) {
   const historySource = source.slice(0, split);
   const currentSource = source.slice(split);
 
-  let current = pairSanitize(truncateToolResultsForModel(
-    currentSource.map(message => ({ ...message })), { language: options.language },
-  ));
+  let current = pairSanitize(currentSource.map(message => ({ ...message })));
+  const compact = compactCurrentToolResults(current, messageBudget);
+  current = compact.messages;
   if (estimateMessagesTokens(current) > messageBudget || current.length > messageCap) {
     const fitted = [];
     if (current.length > 0 && messageBudget >= 2 && messageCap > 0) {
@@ -1222,6 +1347,8 @@ export function fitProviderRequestToContext(messages, options = {}) {
       currentMessagesAfter: current.length,
       droppedHistoryMessages: historySource.length - history.length,
       droppedCurrentMessages: currentSource.length - current.length,
+      compactedToolResults: compact.compactedToolResults,
+      compactedToolResultTokensSaved: compact.compactedToolResultTokensSaved,
     },
   };
 }

package/yeaft/routing/router.js

@@ -180,6 +180,10 @@ export function createRouter(deps = {}) {
         role: 'assistant',     // VP-authored — persists as assistant turn
         text,
         taskId: args.taskId ?? null,
+        // Runtime provenance follows the human request through handoffs; the
+        // coordinator forwards underscore fields without persisting them.
+        _causalRootId: args.inboundEnvelope?._causalRootId
+          || args.inboundEnvelope?._persistedUserMessage?.id || null,
         // route_forward is already visible as the source VP's tool action.
         // Persist the synthetic handoff for audit/dispatch, but keep it out
         // of UI replay and future visible history so it doesn't render as a

package/yeaft/sessions/index.js

@@ -43,6 +43,7 @@ export {
   ensureDefaultSessionIfEmpty,
   createSessionFromSpec,
   copySession,
+  mergeSessions,
   renameSession,
   archiveSession,
   deleteSession,

package/yeaft/sessions/session-crud.js

@@ -580,6 +580,14 @@ export function createSessionFromSpec(yeaftDir, spec, options = {}) {
  * Create an independent Session from an existing Session's durable state.
  * The Server inherits Project membership when it receives the copy result.
  * Server-owned assets retain their original ownership; message references are preserved.
+ * @param {string} yeaftDir Agent-owned data root
+ * @param {string} sourceSessionId Existing Session
+ * @param {{name?:string, throughBoundary?:object, throughTurnId?:string, throughMessageId?:string|null, beforeMessageId?:string}} [options]
+ * throughBoundary forwards the opaque raw-prefix token returned synchronously by
+ * ConversationStore.captureSessionCopyBoundary. A requested throughTurnId must
+ * end within that prefix or fail closed (never truncate an active turn).
+ * Legacy throughMessageId/null and beforeMessageId fences remain supported.
+ * @returns {object} New Session metadata with copiedMessageCount
  */
 export function copySession(yeaftDir, sourceSessionId, options = {}) {
   const sourceYeaftDir = resolveSessionYeaftDir(yeaftDir, sourceSessionId);
@@ -618,9 +626,10 @@ export function copySession(yeaftDir, sourceSessionId, options = {}) {
     }
 
     const transcript = new ConversationStore(sourceYeaftDir);
-    const transcriptOptions = Object.prototype.hasOwnProperty.call(options, 'throughTurnId')
-      ? { throughTurnId: options.throughTurnId }
-      : {};
+    const transcriptOptions = {};
+    for (const key of ['throughBoundary', 'throughTurnId', 'throughMessageId', 'beforeMessageId']) {
+      if (Object.prototype.hasOwnProperty.call(options, key)) transcriptOptions[key] = options[key];
+    }
     const { copiedCount } = transcript.copySession(sourceSessionId, copied.id, transcriptOptions);
     return { ...requireSessionMeta(sourceYeaftDir, copied.id), copiedMessageCount: copiedCount };
   } catch (error) {
@@ -633,6 +642,62 @@ export function copySession(yeaftDir, sourceSessionId, options = {}) {
   }
 }
 
+/**
+ * Create a NEW Session from two idle Sessions in this Agent data root.
+ * Source config, announcement, default VP and workDir win; roster is the
+ * source-first union. Server inherits source Project membership separately.
+ * Neither source transcript nor metadata is modified. Any failure after target
+ * creation removes the new Session (including attachments and discovery entry).
+ * Ambiguous/partial shared requests fail closed with ambiguous_merge_history.
+ *
+ * @param {string} yeaftDir Agent-owned data root
+ * @param {string} sourceId Source of config/project/workdir semantics
+ * @param {string} otherId Other idle Session; must differ from sourceId
+ * @param {{name?:string, libDir?:string}} [options]
+ * @returns {object} New Session metadata, copiedMessageCount and sharedTurnCount
+ * @throws {SessionCrudError} invalid_merge_source, not_found, or ambiguous_merge_history
+ */
+export function mergeSessions(yeaftDir, sourceId, otherId, options = {}) {
+  if (typeof sourceId !== 'string' || typeof otherId !== 'string'
+      || !/^[A-Za-z0-9_-]+$/.test(sourceId) || !/^[A-Za-z0-9_-]+$/.test(otherId)
+      || sourceId === otherId) {
+    throw new SessionCrudError('invalid_merge_source', sourceId, 'Merge requires two distinct Sessions');
+  }
+  const sourceRoot = resolveSessionYeaftDir(yeaftDir, sourceId);
+  const otherRoot = resolveSessionYeaftDir(yeaftDir, otherId);
+  if (resolve(sourceRoot) !== resolve(otherRoot)) {
+    throw new SessionCrudError('invalid_merge_source', sourceId, 'Merge sources must belong to the same Agent data root');
+  }
+  const sourceMeta = requireSessionMeta(sourceRoot, sourceId);
+  const otherMeta = requireSessionMeta(otherRoot, otherId);
+  const sourceConfig = loadSessionConfig(sourceRoot, sourceId);
+  const roster = [...new Set([...(sourceMeta.roster || []), ...(otherMeta.roster || [])])];
+  const merged = createSessionFromSpec(sourceRoot, {
+    name: String(options.name || '').trim() || `${sourceMeta.name} merged`,
+    roster,
+    defaultVpId: sourceMeta.defaultVpId || roster[0] || null,
+    workDir: sourceMeta.workDir || '',
+  }, { ...options, preserveEmptyRoster: true });
+  try {
+    saveSessionConfig(sourceRoot, merged.id, sourceConfig);
+    const target = requireSession(sourceRoot, merged.id);
+    try {
+      const meta = { ...target.getMeta(), announcement: sourceMeta.announcement || '', metadataUpdatedAt: new Date().toISOString() };
+      target.saveMeta(meta);
+      addOrUpdateManifestSession(sourceRoot, meta, target.dir);
+    } finally { target.close(); }
+    const { copiedCount, sharedTurnCount } = new ConversationStore(sourceRoot)
+      .mergeSessions(sourceId, otherId, merged.id, options);
+    return { ...requireSessionMeta(sourceRoot, merged.id), copiedMessageCount: copiedCount, sharedTurnCount };
+  } catch (error) {
+    deleteSession(sourceRoot, merged.id, options);
+    if (error?.code === 'ambiguous_merge_history' || error?.code === 'invalid_merge_source') {
+      throw new SessionCrudError(error.code, sourceId, error.message);
+    }
+    throw error;
+  }
+}
+
 function requireSessionMeta(yeaftDir, sessionId) {
   const handle = requireSession(yeaftDir, sessionId);
   try { return handle.getMeta(); } finally { handle.close(); }

package/yeaft/tools/agent.js

@@ -521,7 +521,10 @@ stops or finalizes work no longer needed.`,
           title: spec.mission || spec.task || name,
           resultDelivery: TASK_RESULT_DELIVERY.MODEL_REENTRY,
           runtime: { subAgentId: agentId, name, cwd: agent.cwd },
-          source: { threadId: callerScope.parentThreadId || ctx?.threadId || 'main' },
+          source: {
+            threadId: callerScope.parentThreadId || ctx?.threadId || 'main',
+            ...(ctx.causalRootId ? { causalRootId: ctx.causalRootId } : {}),
+          },
         });
         if (task?.id) {
           agent.taskId = task.id;