@yeaft/webchat-agent 1.0.384 → 1.0.385

package/yeaft/sub-agent/public-event.js

@@ -0,0 +1,131 @@
+function cleanString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function publicError(value) {
+  if (!value) return null;
+  if (typeof value === 'string') return { name: 'Error', message: value };
+  return {
+    name: cleanString(value.name) || 'Error',
+    message: cleanString(value.message) || String(value),
+  };
+}
+
+/**
+ * Project one sub-agent event onto the public lifecycle boundary.
+ * Provider envelopes, accumulated messages, prompts, tool input/output, and
+ * raw loop diagnostics are intentionally not part of this projection.
+ */
+export function projectPublicSubAgentEvent(event) {
+  if (!event || typeof event !== 'object') return null;
+  const agentId = cleanString(event.agentId);
+  const agentName = cleanString(event.agentName);
+  const source = {
+    sessionId: cleanString(event.parentSessionId) || cleanString(event.sessionId),
+    vpId: cleanString(event.parentVpId) || cleanString(event.ownerVpId) || cleanString(event.vpId),
+    threadId: cleanString(event.parentThreadId) || cleanString(event.threadId) || 'main',
+  };
+  const base = {
+    type: event.type,
+    ...(agentId ? { agentId } : {}),
+    ...(agentName ? { agentName } : {}),
+    parentSessionId: source.sessionId,
+    parentVpId: source.vpId,
+    parentThreadId: source.threadId,
+  };
+
+  switch (event.type) {
+    case 'sub_agent_status':
+      return {
+        ...base,
+        status: cleanString(event.status) || 'unknown',
+        ...(event.error ? { error: publicError(event.error) } : {}),
+      };
+    case 'sub_agent_turn_end':
+      return {
+        ...base,
+        status: cleanString(event.status) || 'idle',
+        content: typeof event.content === 'string' ? event.content : '',
+      };
+    case 'text_delta':
+      return {
+        ...base,
+        text: typeof event.text === 'string' ? event.text : '',
+      };
+    case 'sub_agent_spawned':
+      return { ...base, status: 'running' };
+    case 'turn_open':
+      return {
+        ...base,
+        turnId: cleanString(event.turnId),
+        ...(event.at ? { at: event.at } : {}),
+      };
+    case 'turn_close':
+      return {
+        ...base,
+        turnId: cleanString(event.turnId),
+        totalMs: Number.isFinite(event.totalMs) ? event.totalMs : null,
+        totalTokens: Number.isFinite(event.totalTokens) ? event.totalTokens : null,
+        loopCount: Number.isFinite(event.loopCount) ? event.loopCount : null,
+      };
+    case 'tool_start':
+    case 'tool_end':
+      return {
+        ...base,
+        id: cleanString(event.id),
+        name: cleanString(event.name),
+        ...(event.type === 'tool_end' ? { isError: event.isError === true } : {}),
+      };
+    case 'usage':
+      return {
+        ...base,
+        inputTokens: Number(event.inputTokens) || 0,
+        outputTokens: Number(event.outputTokens) || 0,
+        cacheReadTokens: Number(event.cacheReadTokens) || 0,
+        cacheWriteTokens: Number(event.cacheWriteTokens) || 0,
+      };
+    case 'stop':
+      return { ...base, stopReason: cleanString(event.stopReason) || 'unknown' };
+    case 'error':
+      return { ...base, error: publicError(event.error), retryable: event.retryable === true };
+    case 'fallback':
+      return {
+        ...base,
+        from: cleanString(event.from),
+        to: cleanString(event.to),
+        reason: cleanString(event.reason),
+      };
+    case 'llm_retry':
+      return {
+        ...base,
+        attempt: Number(event.attempt) || 0,
+        maxRetries: Number(event.maxRetries) || 0,
+        delayMs: Number(event.delayMs) || 0,
+        errorClass: cleanString(event.errorClass),
+      };
+    default:
+      return null;
+  }
+}
+
+export function buildStreamSubAgentFrame({ event, sessionId, vpId = null, threadId = 'main', agentId = null } = {}) {
+  const payload = projectPublicSubAgentEvent({
+    ...event,
+    ...(agentId && !event?.agentId ? { agentId } : {}),
+    parentSessionId: event?.parentSessionId || sessionId || null,
+    parentVpId: event?.parentVpId || vpId || null,
+    parentThreadId: event?.parentThreadId || threadId || 'main',
+  });
+  if (!payload || !payload.agentId || !payload.parentSessionId) return null;
+  if (sessionId && payload.parentSessionId !== sessionId) return null;
+  return {
+    type: 'sub_agent',
+    subtype: payload.type === 'sub_agent_status' ? 'status' : 'event',
+    session_id: payload.parentSessionId,
+    agent_id: payload.agentId,
+    ...(payload.parentVpId ? { vp_id: payload.parentVpId, vpId: payload.parentVpId } : {}),
+    thread_id: payload.parentThreadId || 'main',
+    threadId: payload.parentThreadId || 'main',
+    payload,
+  };
+}

package/yeaft/sub-agent/runner.js

@@ -297,7 +297,14 @@ async function driveSubAgent(agent, subEngine, vpPersona, deps) {
   const idleAbandonMs = typeof deps.idleAbandonMs === 'number' && deps.idleAbandonMs > 0
     ? deps.idleAbandonMs : IDLE_ABANDON_MS;
 
-  const wrapEvt = (evt) => ({ ...evt, agentId: agent.id, agentName: agent.name });
+  const wrapEvt = (evt) => ({
+    ...evt,
+    agentId: agent.id,
+    agentName: agent.name,
+    parentSessionId: agent.parentSessionId || deps.parentSessionId || null,
+    parentVpId: agent.parentVpId || deps.parentVpId || null,
+    parentThreadId: agent.parentThreadId || deps.parentThreadId || 'main',
+  });
   let lastTaskLogRefreshAt = 0;
   const refreshTaskLog = ({ force = false } = {}) => {
     if (!agent.taskId || !deps.taskManager || !agent.parentSessionId) return;
@@ -599,6 +606,9 @@ function finalizeTerminal(agent, status, { error, deps } = {}) {
     agentName: agent.name,
     status,
     error: error || agent.error || null,
+    parentSessionId: agent.parentSessionId || deps?.parentSessionId || null,
+    parentVpId: agent.parentVpId || deps?.parentVpId || null,
+    parentThreadId: agent.parentThreadId || deps?.parentThreadId || 'main',
   };
   try { agent.outputLog?.write(evt); } catch { /* ignore */ }
   if (agent.taskId && deps?.taskManager && agent.parentSessionId) {

package/yeaft/tasks/result-delivery.js

@@ -0,0 +1,122 @@
+/**
+ * Shared ownership checks and stream-json projection for asynchronous tasks.
+ */
+
+import { TASK_RESULT_DELIVERY, isTerminalTaskStatus, taskResultDeliveryFor } from './store.js';
+import { formatTaskResultForVp } from './result-format.js';
+
+function cleanString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function taskThreadId(task) {
+  return cleanString(task?.source?.threadId) || cleanString(task?.runtime?.threadId) || 'main';
+}
+
+function publicTaskSnapshot(task) {
+  return {
+    id: task.id,
+    sessionId: task.sessionId,
+    ownerVpId: cleanString(task.ownerVpId),
+    kind: task.kind || 'tool',
+    status: task.status || 'unknown',
+    resultDelivery: taskResultDeliveryFor(task),
+    createdAt: task.createdAt || null,
+    startedAt: task.startedAt || null,
+    updatedAt: task.updatedAt || null,
+    endedAt: task.endedAt || null,
+  };
+}
+
+/**
+ * Project one TaskManager event for an active stream-json Session.
+ * Returns null for sibling, malformed, or unowned Session events.
+ */
+export function projectStreamTaskEvent(event, { sessionId } = {}) {
+  const task = event?.task;
+  const activeSessionId = cleanString(sessionId);
+  const taskSessionId = cleanString(task?.sessionId);
+  if (!event || typeof event !== 'object' || !task?.id || !activeSessionId || taskSessionId !== activeSessionId) {
+    return null;
+  }
+  const vpId = cleanString(task.ownerVpId);
+  const threadId = taskThreadId(task);
+  return {
+    type: 'task',
+    subtype: event.event || 'updated',
+    session_id: activeSessionId,
+    task_id: task.id,
+    taskId: task.id,
+    ...(vpId ? { vp_id: vpId, vpId } : {}),
+    thread_id: threadId,
+    threadId,
+    task: publicTaskSnapshot(task),
+  };
+}
+
+/**
+ * Build owner-scoped model context for a terminal model-reentry task.
+ * When an expected owner is supplied, Session, VP, and thread must match
+ * exactly before sensitive task details are formatted.
+ */
+export function taskResultReentryContext(event, { sessionId = null, owner = null } = {}) {
+  if (!event || event.event !== 'completed' || !event.task) return null;
+  const task = event.task;
+  if (!task.id
+      || !isTerminalTaskStatus(task.status)
+      || taskResultDeliveryFor(task) !== TASK_RESULT_DELIVERY.MODEL_REENTRY) return null;
+  const taskSessionId = cleanString(task.sessionId);
+  const activeSessionId = cleanString(sessionId);
+  if (!taskSessionId || (activeSessionId && taskSessionId !== activeSessionId)) return null;
+  const vpId = cleanString(task.ownerVpId);
+  const threadId = taskThreadId(task);
+  if (owner) {
+    if (cleanString(owner.sessionId) !== taskSessionId) return null;
+    if (cleanString(owner.vpId) !== vpId) return null;
+    if ((cleanString(owner.threadId) || 'main') !== threadId) return null;
+  }
+  return {
+    task,
+    sessionId: taskSessionId,
+    vpId,
+    threadId,
+    content: formatTaskResultForVp(task),
+    metadata: {
+      preview: `task ${task.kind || 'tool'} ${task.status || 'completed'}`,
+      sessionId: taskSessionId,
+      vpId,
+      threadId,
+      taskKind: task.kind,
+      taskStatus: task.status,
+    },
+  };
+}
+
+/** Deliver to a still-running exact owner Engine. */
+export function notifyPendingTaskOwner(event, asyncTaskOwners, { sessionId = null } = {}) {
+  const taskId = event?.task?.id;
+  const owner = taskId ? asyncTaskOwners?.get?.(taskId) : null;
+  if (!owner?.engine) return false;
+  const context = taskResultReentryContext(event, { sessionId, owner });
+  if (!context) return false;
+  const engine = owner.engine;
+  if (typeof engine.ownsPendingAsyncTask !== 'function'
+      || !engine.ownsPendingAsyncTask(taskId)
+      || typeof engine.notifyAsyncTaskCompleted !== 'function') return false;
+  try {
+    return engine.notifyAsyncTaskCompleted(taskId, context.content, context.metadata) === true;
+  } catch {
+    return false;
+  }
+}
+
+/** Project and, when ownership matches, deliver one TaskManager event. */
+export function emitStreamTaskEvent({ event, asyncTaskOwners, write, sessionId }) {
+  const frame = projectStreamTaskEvent(event, { sessionId });
+  if (!frame) return { projected: false, delivered: false };
+  if (typeof write === 'function') write(frame);
+  return {
+    projected: true,
+    delivered: notifyPendingTaskOwner(event, asyncTaskOwners, { sessionId }),
+  };
+}

package/yeaft/tasks/result-format.js

@@ -0,0 +1,28 @@
+/**
+ * Model-only rendering for asynchronous task results.
+ *
+ * This output may contain command, log, and provider result details. It is
+ * owner-scoped prompt context and must never be reused as a public wire
+ * projection.
+ */
+export function formatTaskResultForVp(task) {
+  const result = task?.result || {};
+  const log = task?.log || {};
+  const lines = [
+    `<task-result id="${task?.id || 'unknown'}" kind="${task?.kind || 'tool'}" status="${task?.status || 'unknown'}">`,
+    `title: ${task?.title || task?.kind || task?.id || 'task'}`,
+  ];
+  if (task?.runtime?.command) lines.push(`command: ${task.runtime.command}`);
+  if (result.exitCode !== undefined && result.exitCode !== null) lines.push(`exitCode: ${result.exitCode}`);
+  if (result.signal) lines.push(`signal: ${result.signal}`);
+  if (result.error) lines.push(`error: ${result.error}`);
+  if (result.summary) lines.push(`summary: ${result.summary}`);
+  if (log.path) lines.push(`log: ${log.path}`);
+  if (log.preview) {
+    lines.push('logTail:');
+    lines.push(String(log.preview).slice(-4000).split('\n').map(line => `  ${line}`).join('\n'));
+  }
+  lines.push('</task-result>');
+  lines.push('This is an asynchronous tool result from a background task, not a user message. Consume it now: tell the user the outcome or continue the work. Do not wait for another user turn.');
+  return lines.join('\n');
+}

package/yeaft/web-bridge.js

@@ -97,6 +97,7 @@ import { consumeNotificationForAgent } from './sub-agent/notifications.js';
 import { perfNowMs, recordAgentPerfTrace } from './perf-trace.js';
 import { recordAgentSessionCreated, recordAgentTurn } from '../metrics.js';
 import { TASK_RESULT_DELIVERY, isTerminalTaskStatus, taskResultDeliveryFor } from './tasks/store.js';
+import { formatTaskResultForVp } from './tasks/result-format.js';
 
 const LEGACY_SKILL_COMMAND_PREFIX = 'skill:';
 const YEAFT_SKILL_COMMAND_PREFIX = 'yeaft-skills:';
@@ -1947,29 +1948,6 @@ function enqueueForVp(sessionId, vpId, envelope) {
   registerRoutePromise(envelope?.msg?.id, routePromise);
 }
 
-function formatTaskResultForVp(task) {
-  const result = task?.result || {};
-  const log = task?.log || {};
-  const lines = [
-    `<task-result id="${task.id}" kind="${task.kind}" status="${task.status}">`,
-    `title: ${task.title || task.kind || task.id}`,
-  ];
-  if (task?.runtime?.command) lines.push(`command: ${task.runtime.command}`);
-  if (result.exitCode !== undefined && result.exitCode !== null) lines.push(`exitCode: ${result.exitCode}`);
-  if (result.signal) lines.push(`signal: ${result.signal}`);
-  if (result.error) lines.push(`error: ${result.error}`);
-  if (result.summary) lines.push(`summary: ${result.summary}`);
-  if (log.path) lines.push(`log: ${log.path}`);
-  if (log.preview) {
-    const preview = String(log.preview).slice(-4000);
-    lines.push('logTail:');
-    lines.push(preview.split('\n').map(line => `  ${line}`).join('\n'));
-  }
-  lines.push('</task-result>');
-  lines.push('This is an asynchronous tool result from a background task, not a user message. Consume it now: tell the user the outcome or continue the work. Do not wait for another user turn.');
-  return lines.join('\n');
-}
-
 function scheduleTaskResultRescue({ taskId, sessionId, vpId, threadId = 'main', content, taskKind, taskStatus }) {
   if (!sessionId || !vpId || !taskId) return false;
   const text = typeof content === 'string'