@yeaft/webchat-agent 1.0.546 → 1.0.548

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.546",
+  "version": "1.0.548",
   "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/workbench/file-ops.js

@@ -10,14 +10,27 @@ export const MAX_WORKBENCH_PREVIEW_BYTES = 20 * 1024 * 1024;
 export const WORKBENCH_FILE_CHUNK_BYTES = 1024 * 1024;
 export const WORKBENCH_VIDEO_CHUNK_BYTES = 1024 * 1024;
 
-async function validateResponseImagePath(filePath, workDir) {
+async function canonicalWorkspaceReadPath(filePath, workDir, errorMessage = 'File is outside the active workspace.') {
   const canonicalRoot = await realpath(resolve(workDir));
   const canonicalFile = await realpath(resolveAndValidatePath(filePath, canonicalRoot));
   const relativePath = relative(canonicalRoot, canonicalFile);
   const outside = relativePath === '..'
     || relativePath.startsWith(`..${platform() === 'win32' ? '\\' : '/'}`)
     || isAbsolute(relativePath);
-  if (outside) throw new Error('Response image is outside the active workspace.');
+  if (outside) {
+    const error = new Error(errorMessage);
+    error.code = 'FILE_OUTSIDE_WORKSPACE';
+    throw error;
+  }
+  return canonicalFile;
+}
+
+async function validateResponseImagePath(filePath, workDir) {
+  const canonicalFile = await canonicalWorkspaceReadPath(
+    filePath,
+    workDir,
+    'Response image is outside the active workspace.',
+  );
   const mimeType = BINARY_EXTENSIONS[extname(canonicalFile).toLowerCase()];
   if (!mimeType?.startsWith('image/')) throw new Error('Response preview only supports image files.');
   return canonicalFile;
@@ -169,7 +182,7 @@ export async function handleReadFile(msg) {
   try {
     const resolved = msg.responseImagePreview
       ? await validateResponseImagePath(filePath, workDir)
-      : resolveAndValidatePath(filePath, workDir);
+      : await canonicalWorkspaceReadPath(filePath, workDir);
     const ext = extname(resolved).toLowerCase();
     if (VIDEO_EXTENSIONS[ext]) {
       const error = new Error('Video files require the Workbench streaming protocol.');

package/yeaft/work-center/action-checkpoint.js

@@ -1,4 +1,5 @@
 const MAX_TOOL_EVENTS = 16;
+const MAX_TOOL_ID_LENGTH = 256;
 const MAX_TOOL_NAME_LENGTH = 80;
 const MAX_RESOURCE_LENGTH = 240;
 const MAX_RESPONSE_LENGTH = 4_000;
@@ -9,27 +10,33 @@ function boundedString(value, maxLength) {
 }
 
 function safeResource(value) {
-  const resource = boundedString(value, MAX_RESOURCE_LENGTH);
-  if (!resource) return '';
+  const raw = typeof value === 'string' ? value.trim() : '';
+  if (!raw) return '';
+  const looksLikeHttpUrl = /^https?:/i.test(raw);
   try {
-    const url = new URL(resource);
+    const url = new URL(raw);
     if (['http:', 'https:'].includes(url.protocol)) {
       return `${url.protocol}//${url.host}${url.pathname}`.slice(0, MAX_RESOURCE_LENGTH);
     }
-  } catch {}
-  return resource;
+    if (looksLikeHttpUrl) return '';
+  } catch {
+    if (looksLikeHttpUrl) return '';
+  }
+  return raw.slice(0, MAX_RESOURCE_LENGTH);
 }
 
 function normalizeToolEvent(value) {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
   const name = boundedString(value.name, MAX_TOOL_NAME_LENGTH);
   if (!name) return null;
-  const event = {
-    name,
-    status: value.status === 'error' ? 'error' : 'completed',
-  };
+  const status = ['running', 'error'].includes(value.status) ? value.status : 'completed';
+  const event = { name, status };
+  const id = boundedString(value.id, MAX_TOOL_ID_LENGTH);
+  if (id) event.id = id;
   const resource = safeResource(value.resource);
   if (resource) event.resource = resource;
+  const startedAt = Number(value.startedAt);
+  if (Number.isFinite(startedAt) && startedAt > 0) event.startedAt = startedAt;
   return event;
 }
 
@@ -48,9 +55,25 @@ export function normalizeActionCheckpoint(value) {
 
 export function appendCheckpointToolEvent(checkpoint, event) {
   const current = normalizeActionCheckpoint(checkpoint) || { version: 1, toolEvents: [] };
+  const normalized = normalizeToolEvent(event);
+  if (!normalized) return current;
+  const toolEvents = normalized.id
+    ? current.toolEvents.filter(item => item.id !== normalized.id)
+    : current.toolEvents;
+  return normalizeActionCheckpoint({
+    ...current,
+    toolEvents: [...toolEvents, normalized],
+  });
+}
+
+export function settleCheckpointToolEvents(checkpoint, status = 'error') {
+  const current = normalizeActionCheckpoint(checkpoint);
+  if (!current?.toolEvents.some(event => event.status === 'running')) return current;
   return normalizeActionCheckpoint({
     ...current,
-    toolEvents: [...current.toolEvents, event],
+    toolEvents: current.toolEvents.map(event => (
+      event.status === 'running' ? { ...event, status } : event
+    )),
   });
 }
 

package/yeaft/work-center/projection.js

@@ -10,6 +10,7 @@ import { runMatchesActionIdentity } from './action-identity.js';
 import { normalizeOutputs } from './evidence.js';
 import { taskSpecificActionBrief } from './workflow.js';
 import { buildMainlineProjection } from './mainline-projection.js';
+import { normalizeActionCheckpoint } from './action-checkpoint.js';
 
 const MAX_ACTION_MESSAGE_CHARS = 16_000;
 const MAX_ACTION_DIAGNOSTIC_CHARS = 8_000;
@@ -293,8 +294,13 @@ function normalizeProjectedMessage(message) {
   const text = typeof message.text === 'string'
     ? message.text.trim().slice(0, MAX_ACTION_MESSAGE_CHARS)
     : '';
+  const checkpoint = normalizeActionCheckpoint({ toolEvents: message.toolEvents });
+  const toolEvents = (checkpoint?.toolEvents || []).map((event, index) => ({
+    ...event,
+    id: event.id || `${index}`,
+  }));
   const attachments = projectAttachments(message.attachments);
-  if (!text && attachments.length === 0) return null;
+  if (!text && attachments.length === 0 && toolEvents.length === 0) return null;
   const speaker = message.role === 'user' ? null : projectVpSpeaker(message.speaker);
   return {
     id: String(message.id || ''),
@@ -302,6 +308,7 @@ function normalizeProjectedMessage(message) {
     kind: message.kind === 'input' ? 'input' : 'response',
     status: message.status || null,
     text,
+    toolEvents,
     attachments,
     ...(projectedMessageQuote(message.quote) ? { quote: projectedMessageQuote(message.quote) } : {}),
     createdAt: count(message.createdAt),
@@ -341,6 +348,7 @@ function runResponseMessage(run) {
     kind: 'response',
     status: run.status || 'running',
     text,
+    toolEvents: run.checkpoint?.toolEvents,
     createdAt: count(run.endedAt || run.startedAt),
     updatedAt: count(run.endedAt || run.startedAt),
     progressRevision: count(run.progressRevision),

package/yeaft/work-center/runner.js

@@ -30,6 +30,7 @@ import {
 import {
   appendCheckpointToolEvent,
   renderActionResumeBlock,
+  settleCheckpointToolEvents,
 } from './action-checkpoint.js';
 import { createSkillManager } from '../skills.js';
 import { loadMCPConfig } from '../config.js';
@@ -1303,6 +1304,7 @@ export class WorkItemRunner {
     let checkpoint = null;
     let terminalEngineError = null;
     const toolInputs = new Map();
+    const toolStartedAt = new Map();
     const usageStats = {
       llmRequestCount: 0,
       inputTokens: 0,
@@ -1318,6 +1320,14 @@ export class WorkItemRunner {
       ...executionStats(),
       checkpoint,
     });
+    const settleOpenTools = (status = 'error') => {
+      const settled = settleCheckpointToolEvents(checkpoint, status);
+      const changed = settled !== checkpoint;
+      checkpoint = settled;
+      toolInputs.clear();
+      toolStartedAt.clear();
+      return changed;
+    };
     const reportProgress = (force = false) => {
       if (typeof onProgress !== 'function') return;
       const now = Date.now();
@@ -1472,16 +1482,33 @@ export class WorkItemRunner {
             response: publicWorkItemResponse(event.response),
           });
         }
-        else if (event?.type === 'tool_start') toolInputs.set(event.id, event.input);
+        else if (event?.type === 'tool_start') {
+          const startedAt = Date.now();
+          toolInputs.set(event.id, event.input);
+          toolStartedAt.set(event.id, startedAt);
+          checkpoint = appendCheckpointToolEvent(checkpoint, {
+            id: event.id,
+            name: event.name,
+            status: 'running',
+            resource: checkpointResource(event.name, event.input, workDir),
+            startedAt,
+          });
+          reportProgress(true);
+        }
         else if (event?.type === 'tool_end') {
           toolCount += 1;
           const input = toolInputs.get(event.id);
           toolInputs.delete(event.id);
+          const startedAt = toolStartedAt.get(event.id);
+          toolStartedAt.delete(event.id);
           checkpoint = appendCheckpointToolEvent(checkpoint, {
+            id: event.id,
             name: event.name,
             status: event.isError ? 'error' : 'completed',
             resource: checkpointResource(event.name, input, workDir),
+            startedAt,
           });
+          reportProgress(true);
         }
         else if (event?.type === 'error' && !terminalEngineError) {
           terminalEngineError = event.error instanceof Error
@@ -1523,11 +1550,13 @@ export class WorkItemRunner {
         throw stopped;
       }
     } catch (error) {
+      if (settleOpenTools('error')) reportProgress(true);
       error.workItemExecutionStats = currentProgress();
       throw error;
     } finally {
       try { engine.abort?.('work_item_run_finished'); } catch {}
     }
+    settleOpenTools('error');
     const response = publicWorkItemResponse(text);
     reportProgress(true);
     const submittedPlan = !replanToolEnabled ? planCollector.value : null;