@yeaft/webchat-agent 1.0.256 → 1.0.258

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.256",
+  "version": "1.0.258",
   "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/work-center/action-identity.js

@@ -8,23 +8,31 @@ export function eventMatchesActionGeneration(event, action) {
 }
 
 export function currentActionInputEventIds(events, action) {
-  const inputEvents = new Map((Array.isArray(events) ? events : [])
-    .filter(event => event?.type === 'action.input_added' && event.actionId === action?.id)
+  const actionEvents = (Array.isArray(events) ? events : [])
+    .filter(event => event?.actionId === action?.id);
+  const inputEvents = new Map(actionEvents
+    .filter(event => event.type === 'action.input_added')
     .map(event => [String(event.id), event]));
   const valid = new Set();
+  const superseded = new Set();
   for (const event of inputEvents.values()) {
     if (eventMatchesActionGeneration(event, action)) valid.add(String(event.id));
   }
-  for (const event of Array.isArray(events) ? events : []) {
-    if (event?.type !== 'action.input_rebound' || event.actionId !== action?.id
-        || !eventMatchesActionGeneration(event, action)) continue;
+  for (const event of actionEvents) {
     const sourceEventIds = [
       event.data?.sourceEventId,
       ...(Array.isArray(event.data?.sourceEventIds) ? event.data.sourceEventIds : []),
-    ].filter(value => value != null);
+    ].filter(value => value != null).map(String);
+    if (event.type === 'action.input_superseded') {
+      for (const eventId of sourceEventIds) {
+        superseded.add(eventId);
+        valid.delete(eventId);
+      }
+      continue;
+    }
+    if (event.type !== 'action.input_rebound' || !eventMatchesActionGeneration(event, action)) continue;
     for (const eventId of sourceEventIds) {
-      const key = String(eventId);
-      if (inputEvents.has(key)) valid.add(key);
+      if (inputEvents.has(eventId) && !superseded.has(eventId)) valid.add(eventId);
     }
   }
   return valid;

package/yeaft/work-center/bridge.js

@@ -20,7 +20,7 @@ let shutdownPromise = null;
 let serviceFactory = null;
 
 const BROWSER_DETAIL_OPS = new Set([
-  'get', 'create', 'update', 'start', 'cancel', 'action_input', 'retry_action', 'guide', 'retry',
+  'get', 'create', 'update', 'start', 'cancel', 'resume', 'action_input', 'retry_action', 'guide', 'retry',
 ]);
 const BROWSER_ACTION_DEBUG_OPS = new Set(['get_action_messages', 'get_action_requests', 'get_action_request']);
 // `files` is an internal server-to-Agent field. The browser relay rejects any
@@ -34,6 +34,7 @@ const BROWSER_FILE_FIELDS = Object.freeze({
   ],
   action_input: ['id', 'text', 'actionId', 'revision', 'generation', 'files'],
   retry_action: ['id', 'actionId', 'revision', 'generation'],
+  resume: ['id', 'revision'],
   delete: ['id', 'revision'],
   guide: ['id', 'guidance', 'actionId', 'revision', 'generation', 'files'],
   get_action_messages: ['id', 'actionId', 'generation', 'cursor', 'limit'],

package/yeaft/work-center/controller.js

@@ -173,6 +173,30 @@ export class WorkflowController {
     return this.store.getWorkItemDetail(id);
   }
 
+  resume(id, input = {}) {
+    const revision = Number(input.revision);
+    if (!Number.isInteger(revision) || revision < 1) {
+      throw new Error('revision is required to resume a WorkItem');
+    }
+    const detail = this.store.resumeWorkItemAtomic(id, revision, workItem => {
+      const action = initialActionFor(workItem);
+      if (workItem.reuseMemory === false) return action;
+      const context = this.store.getReusableContext(workItem.workDir, workItem.id);
+      return {
+        ...action,
+        context,
+        instruction: actionInstruction(
+          action,
+          workItem,
+          context,
+          renderSessionContextSnapshot(workItem.sessionContext),
+        ),
+      };
+    });
+    if (!detail) throw new Error(`WorkItem not found: ${id}`);
+    return detail;
+  }
+
   guide(id, input = {}) {
     const guidance = typeof input.guidance === 'string' ? input.guidance.trim().slice(0, 8_000) : '';
     const addedAttachmentCount = Math.max(0, Number(input.addedAttachmentCount) || 0);

package/yeaft/work-center/service.js

@@ -307,6 +307,13 @@ export class WorkCenterService {
         this.#emit({ type: 'work_item.cancelled', workItem: detail });
         return detail;
       }
+      case 'resume': {
+        const id = requiredString(payload.id, 'id');
+        const detail = this.controller.resume(id, { revision: payload.revision });
+        this.watcher.abortInvalidWorkItemRuns(id);
+        this.#emit({ type: 'work_item.resumed', workItem: detail });
+        return detail;
+      }
       case 'delete': {
         const id = requiredString(payload.id, 'id');
         const deleted = this.store.deleteWorkItemAtomic(id, Number(payload.revision));

package/yeaft/work-center/store.js

@@ -8,7 +8,7 @@ import { currentActionInputEventIds, runMatchesActionIdentity } from './action-i
 import { canonicalActionInstruction, withoutActionInputContext } from './workflow.js';
 
 const SCHEMA_VERSION = 22;
-const OPEN_ACTION_STATUSES = "'ready','running','waiting'";
+const UNFINISHED_ACTION_STATUSES = "'ready','running','waiting','failed'";
 const MAX_REUSABLE_CONTEXT_ITEMS = 12;
 const MAX_RUN_RESPONSE_CHARS = 65_536;
 
@@ -2643,16 +2643,32 @@ export class WorkItemStore {
   }
 
   #invalidateExecution(workItem, actionStatus, runStatus, reason, now) {
-    const openActions = this.db.prepare(`SELECT * FROM actions WHERE work_item_id = ?
-      AND status IN (${OPEN_ACTION_STATUSES})`).all(workItem.id).map(mapAction);
-    this.#assertNoIntegrationReservation(openActions, now);
-    this.#supersedePendingActionInputs(openActions, reason, now);
-    if (workItem.currentRunId) {
-      this.db.prepare(`UPDATE runs SET status = ?, ended_at = ?, error = ?
-        WHERE id = ? AND status = 'running'`).run(runStatus, now, reason, workItem.currentRunId);
+    const unfinishedActions = this.db.prepare(`SELECT * FROM actions WHERE work_item_id = ?
+      AND status IN (${UNFINISHED_ACTION_STATUSES})`).all(workItem.id).map(mapAction);
+    this.#assertNoIntegrationReservation(unfinishedActions, now);
+    this.#supersedePendingActionInputs(unfinishedActions, reason, now);
+    const actionIds = unfinishedActions.map(action => action.id);
+    if (actionIds.length === 0) return;
+    const placeholders = actionIds.map(() => '?').join(',');
+    this.db.prepare(`UPDATE runs SET status = ?, ended_at = ?, error = ?, accepting_input = 0
+      WHERE work_item_id = ? AND action_id IN (${placeholders}) AND status = 'running'`).run(
+      runStatus,
+      now,
+      reason,
+      workItem.id,
+      ...actionIds,
+    );
+    const changed = this.db.prepare(`UPDATE actions SET status = ?, current_run_id = NULL,
+      lease_epoch = lease_epoch + 1, updated_at = ? WHERE work_item_id = ?
+      AND id IN (${placeholders}) AND status IN (${UNFINISHED_ACTION_STATUSES})`).run(
+      actionStatus,
+      now,
+      workItem.id,
+      ...actionIds,
+    );
+    if (Number(changed.changes) !== actionIds.length) {
+      throw new Error('Work Center execution changed while it was invalidated');
     }
-    this.db.prepare(`UPDATE actions SET status = ?, current_run_id = NULL, updated_at = ?
-      WHERE work_item_id = ? AND status IN (${OPEN_ACTION_STATUSES})`).run(actionStatus, now, workItem.id);
   }
 
   updateWorkItemAtomic(id, patch, makeInitialAction) {
@@ -2732,6 +2748,93 @@ export class WorkItemStore {
     });
   }
 
+  resumeWorkItemAtomic(id, expectedRevision, makeInitialAction) {
+    return withTransaction(this.db, () => {
+      const workItem = this.getWorkItem(id);
+      if (!workItem) return null;
+      if (!Number.isInteger(expectedRevision) || workItem.revision !== expectedRevision) {
+        throw new Error('WorkItem changed before it was resumed; refresh and try again');
+      }
+      if (workItem.status !== 'cancelled') {
+        throw new Error(`WorkItem in ${workItem.status} cannot be resumed`);
+      }
+
+      const now = this.now();
+      const cancelledActions = this.db.prepare(`SELECT * FROM actions WHERE work_item_id = ?
+        AND status = 'cancelled' ORDER BY sequence`).all(id).map(mapAction);
+      this.#assertNoIntegrationReservation(cancelledActions, now);
+      this.#supersedePendingActionInputs(
+        cancelledActions,
+        'WorkItem resume started a new Action generation',
+        now,
+      );
+      const resumedActions = [];
+      for (const action of cancelledActions) {
+        const context = carryCurrentActionInputContext(this.db, action);
+        const candidate = {
+          ...action,
+          context,
+          status: 'ready',
+          attempt: 0,
+          currentRunId: null,
+          resultRunId: null,
+          workspace: null,
+          generation: action.generation + 1,
+        };
+        candidate.instruction = canonicalActionInstruction(workItem, candidate, context);
+        candidate.specHash = actionSpecHash(candidate);
+        const changed = this.db.prepare(`UPDATE actions SET status = 'ready', attempt = 0,
+          current_run_id = NULL, lease_epoch = lease_epoch + 1, generation = generation + 1,
+          context = ?, instruction = ?, spec_hash = ?, identity_history = ?, result_run_id = NULL,
+          workspace = NULL, updated_at = ? WHERE id = ? AND work_item_id = ?
+          AND status = 'cancelled' AND generation = ? AND spec_hash = ?`).run(
+          stringify(context),
+          candidate.instruction,
+          candidate.specHash,
+          stringify(actionIdentityHistory(action, candidate.generation, candidate.specHash)),
+          now,
+          action.id,
+          id,
+          action.generation,
+          action.specHash,
+        );
+        if (Number(changed.changes) !== 1) {
+          throw new Error('WorkItem Action changed before it was resumed');
+        }
+        resumedActions.push(this.getAction(action.id));
+      }
+
+      if (resumedActions.length === 0) {
+        const initialAction = makeInitialAction(workItem);
+        resumedActions.push(this.#insertAction(id, {
+          ...initialAction,
+          contractRevision: workItem.revision,
+        }, this.#nextSequence(id), now));
+      }
+
+      const currentAction = resumedActions
+        .find(action => action.dependsOnStageIds.length === 0) || resumedActions[0];
+      const changedWorkItem = this.db.prepare(`UPDATE work_items SET status = 'ready',
+        current_action_id = ?, current_run_id = NULL, updated_at = ?
+        WHERE id = ? AND status = 'cancelled' AND revision = ?`).run(
+        currentAction.id,
+        now,
+        id,
+        expectedRevision,
+      );
+      if (Number(changedWorkItem.changes) !== 1) {
+        throw new Error('WorkItem changed before it was resumed; refresh and try again');
+      }
+      this.appendEvent(id, 'work_item.resumed', {
+        resumedActionIds: resumedActions.map(action => action.id),
+      }, {
+        actionId: currentAction.id,
+        actionGeneration: currentAction.generation,
+      });
+      return this.getWorkItemDetail(id);
+    });
+  }
+
   startWorkItemAtomic(id, makeInitialAction) {
     return withTransaction(this.db, () => {
       const workItem = this.getWorkItem(id);