@yeaft/webchat-agent 1.0.294 → 1.0.296

package/yeaft/work-center/runner.js

@@ -265,7 +265,7 @@ export function workItemToolPolicySnapshot(workDir, attachmentRefs = [], mcpTool
   };
 }
 
-function wrapWorkItemTool(tool, canonicalDir, canonicalAttachmentFiles, isRunActive) {
+function wrapWorkItemTool(tool, canonicalDir, canonicalAttachmentFiles, isRunActive, operationLifecycle = null) {
   return {
     ...tool,
     async execute(input, ctx) {
@@ -273,12 +273,22 @@ function wrapWorkItemTool(tool, canonicalDir, canonicalAttachmentFiles, isRunAct
       const checkedInput = tool.name.startsWith('mcp__')
         ? input
         : assertToolInput(tool.name, input, canonicalDir, canonicalAttachmentFiles);
-      const output = await tool.execute(checkedInput, {
-        ...ctx,
-        cwd: canonicalDir,
-        workDir: canonicalDir,
-        imageAllowlist: canonicalAttachmentFiles.map(file => file.root),
-      });
+      const trackOperation = typeof operationLifecycle === 'function'
+        && tool.isReadOnly?.(checkedInput) !== true;
+      const operation = trackOperation ? operationLifecycle(tool.name, checkedInput) : null;
+      let output;
+      try {
+        output = await tool.execute(checkedInput, {
+          ...ctx,
+          cwd: canonicalDir,
+          workDir: canonicalDir,
+          imageAllowlist: canonicalAttachmentFiles.map(file => file.root),
+        });
+      } catch (error) {
+        operation?.complete('unknown', { error: String(error?.message || error) });
+        throw error;
+      }
+      operation?.complete('applied', { outputHash: hashMainlineSnapshot({ output: String(output || '') }) });
       if (!isRunActive()) throw new Error('Work Center Run lease was lost during tool execution');
       if (['FileRead', 'ViewImage'].includes(tool.name) && typeof output === 'string') {
         const withoutFilePaths = canonicalAttachmentFiles.reduce(
@@ -512,7 +522,9 @@ export function createSubmitWorkItemReplanTool({ vps, workItem, action, actions,
   });
 }
 
-export function createWorkItemToolRegistry({ workDir, attachmentFiles = [], isRunActive, mcpTools = [], runTools = [] }) {
+export function createWorkItemToolRegistry({
+  workDir, attachmentFiles = [], isRunActive, mcpTools = [], runTools = [], operationLifecycle = null,
+}) {
   const canonicalDir = canonicalWorkDir(path.resolve(workDir));
   const canonicalAttachmentFiles = attachmentFiles.map(file => ({
     ...file,
@@ -522,14 +534,20 @@ export function createWorkItemToolRegistry({ workDir, attachmentFiles = [], isRu
   const hasAttachments = canonicalAttachmentFiles.length > 0;
   for (const tool of allTools) {
     if (!WORK_ITEM_TOOL_ALLOWLIST.has(tool.name) || (hasAttachments && tool.name === 'Bash')) continue;
-    registry.register(wrapWorkItemTool(tool, canonicalDir, canonicalAttachmentFiles, isRunActive));
+    registry.register(wrapWorkItemTool(
+      tool, canonicalDir, canonicalAttachmentFiles, isRunActive, operationLifecycle,
+    ));
   }
   for (const tool of mcpTools) {
     if (!tool?.name?.startsWith('mcp__')) continue;
-    registry.register(wrapWorkItemTool(tool, canonicalDir, canonicalAttachmentFiles, isRunActive));
+    registry.register(wrapWorkItemTool(
+      tool, canonicalDir, canonicalAttachmentFiles, isRunActive, operationLifecycle,
+    ));
   }
   for (const tool of runTools) {
-    registry.register(wrapWorkItemTool(tool, canonicalDir, canonicalAttachmentFiles, isRunActive));
+    registry.register(wrapWorkItemTool(
+      tool, canonicalDir, canonicalAttachmentFiles, isRunActive, operationLifecycle,
+    ));
   }
   return registry;
 }
@@ -1016,12 +1034,38 @@ export class WorkItemRunner {
       attachmentContext.files.map(file => file.ref),
       [...mcpToolNames, ...runToolNames],
     );
+    let operationOrdinal = 0;
+    const operationLifecycle = (toolName, input) => {
+      operationOrdinal += 1;
+      const idempotencyKey = `${run.id}:tool:${operationOrdinal}`;
+      this.store.createOperation({
+        workItemId: workItem.id,
+        actionId: action.id,
+        runId: run.id,
+        operationType: toolName,
+        idempotencyKey,
+        replayPolicy: 'never_automatic',
+        payload: { inputHash: hashMainlineSnapshot(input) },
+      });
+      const claimed = this.store.claimOperation(idempotencyKey, ownerBootId, run.leaseEpoch, false);
+      if (!claimed) throw new Error(`Work Center could not claim Operation ${idempotencyKey}`);
+      return {
+        complete: (effectStatus, result) => {
+          if (!this.store.completeOperation(
+            idempotencyKey, ownerBootId, run.leaseEpoch, effectStatus, result,
+          )) {
+            throw new Error(`Work Center Operation ${idempotencyKey} lost its execution fence`);
+          }
+        },
+      };
+    };
     const toolRegistry = createWorkItemToolRegistry({
       workDir,
       attachmentFiles: attachmentContext.files,
       isRunActive,
       mcpTools: workspaceRuntime.mcpTools,
       runTools,
+      operationLifecycle,
     });
     const config = {
       ...runtime.config,
@@ -1136,6 +1180,7 @@ export class WorkItemRunner {
     if (typeof registerInputWake === 'function') {
       registerInputWake(() => engine.wakeForPendingUserMessage?.());
     }
+    const pendingEntriesById = new Map();
     const drainPendingUserMessages = () => {
       const pending = this.store.listPendingActionInputs?.(
         action.id, run.id, ownerBootId, run.leaseEpoch,
@@ -1149,13 +1194,49 @@ export class WorkItemRunner {
         const content = [item.text, attachmentLines.length > 0
           ? `Additional WorkItem attachments:\n${attachmentLines.join('\n')}` : '']
           .filter(Boolean).join('\n\n');
-        if (!content || !this.store.acknowledgeActionInput?.(
-          item.id, action.id, run.id, ownerBootId, run.leaseEpoch,
-        )) continue;
-        accepted.push({ content, preview: item.text || '[attachments]' });
+        if (!content) continue;
+        pendingEntriesById.set(String(item.id), item);
+        accepted.push({
+          content,
+          preview: item.text || '[attachments]',
+          durableInputId: String(item.id),
+        });
       }
       return accepted;
     };
+    const prepareProviderRequest = ({ entries, system, messages, model }) => {
+      const durableEntries = entries
+        .filter(entry => entry?.durableInputId)
+        .map(entry => pendingEntriesById.get(String(entry.durableInputId)))
+        .filter(Boolean);
+      const requestBody = { model, system, messages };
+      const turn = this.store.prepareEngineTurn?.(
+        action.id, run.id, ownerBootId, run.leaseEpoch, durableEntries,
+        { requestBody, dispatchCapability: 'unknown' },
+      );
+      if (!turn) throw new Error('Work Center could not persist the next provider turn');
+      return turn;
+    };
+    const startProviderRequest = turn => {
+      if (!turn) return;
+      const claimed = this.store.claimEngineTurn?.(turn.id, ownerBootId, run.leaseEpoch);
+      if (!claimed) throw new Error('Work Center provider turn lost its Run lease before dispatch');
+    };
+    const finishProviderRequest = (turn, result) => {
+      if (!turn) return;
+      if (!this.store.consumeEngineTurn?.(turn.id, ownerBootId, run.leaseEpoch, result)) {
+        throw new Error('Work Center provider response lost its EngineTurn fence');
+      }
+    };
+    const failProviderRequest = (turn, error) => {
+      if (!turn) return;
+      const failure = this.store.failEngineTurn?.(turn.id, ownerBootId, run.leaseEpoch, error);
+      if (failure && failure.allowRetry === false) {
+        error.retryable = false;
+        error.workItemFailureKind = 'provider_dispatch_unknown';
+        error.workItemFailureCode = 'engine_turn_dispatch_unknown';
+      }
+    };
     try {
       const prompt = v2Execution
         ? `${renderMainlineContextSnapshot(mainline.contextSnapshot)}${fixedPromptSuffix}`
@@ -1180,9 +1261,14 @@ export class WorkItemRunner {
         workDir,
         userAlreadyPersisted: true,
         drainPendingUserMessages,
+        prepareProviderRequest,
+        startProviderRequest,
+        finishProviderRequest,
+        failProviderRequest,
         closePendingUserInput: () => this.store.closeRunInput(
           run.id, ownerBootId, run.leaseEpoch,
         ),
+
         collabToolPolicy: 'single-vp',
       })) {
         if (event?.type === 'loop') {

package/yeaft/work-center/service.js

@@ -315,6 +315,47 @@ export class WorkCenterService {
         this.#emit({ type: 'work_item.deleted', workItem: { id, revision: deleted.revision } });
         return { id, deleted: true, cleanupWarning };
       }
+      case 'post_work_item_message': {
+        const clientMessageId = requiredString(payload.clientMessageId, 'clientMessageId');
+        const target = payload.target && typeof payload.target === 'object' ? payload.target : {};
+        if (target.kind === 'coordinator') {
+          return this.handle('work_item_message', { ...payload, clientMessageId }, requestContext);
+        }
+        if (target.kind === 'action') {
+          return this.handle('action_input', {
+            ...payload,
+            clientMessageId,
+            actionId: target.actionId,
+            generation: target.generation,
+          }, requestContext);
+        }
+        if (target.kind === 'request') {
+          const id = requiredString(payload.id, 'id');
+          const workItem = this.#requiredItem(id);
+          const action = this.#requiredAction(workItem, target.actionId);
+          if (action.status === 'failed' && !String(payload.text || '').trim()
+              && (!Array.isArray(payload.files) || payload.files.length === 0)) {
+            const detail = this.controller.retry(id, {
+              expected: {
+                actionId: action.id,
+                revision: payload.revision,
+                generation: target.generation,
+                statuses: ['failed'],
+              },
+            });
+            this.watcher.abortInvalidWorkItemRuns(id);
+            this.#emit({ type: 'action.retried', workItem: detail });
+            return detail;
+          }
+          return this.handle('action_input', {
+            ...payload,
+            clientMessageId,
+            actionId: target.actionId,
+            generation: target.generation,
+          }, requestContext);
+        }
+        throw new Error('WorkItem message target is invalid');
+      }
       case 'work_item_message': {
         if (!this.coordinator) throw new Error('Work Center Coordinator is unavailable');
         const id = requiredString(payload.id, 'id');
@@ -332,6 +373,7 @@ export class WorkCenterService {
             planRevision: payload.planRevision,
             ledgerRevision: payload.ledgerRevision,
             coordinatorRevision: payload.coordinatorRevision,
+            clientMessageId: typeof payload.clientMessageId === 'string' ? payload.clientMessageId : null,
             addedAttachments,
             attachments: [...(workItem.attachments || []), ...addedAttachments],
           }, {
@@ -387,6 +429,7 @@ export class WorkCenterService {
             actionId: typeof payload.actionId === 'string' ? payload.actionId : '',
             revision: payload.revision,
             generation,
+            clientMessageId: typeof payload.clientMessageId === 'string' ? payload.clientMessageId : null,
             addedAttachmentCount: addedAttachments.length,
             addedAttachments,
             attachments: [...(workItem.attachments || []), ...addedAttachments],
@@ -584,6 +627,18 @@ export class WorkCenterService {
   }
 
   start() {
+    for (const recoverable of this.store.getRecoverableCoordinatorTurns?.() || []) {
+      const started = this.store.resumeCoordinatorTurn(recoverable.workItemId, recoverable.turnId);
+      if (!started) continue;
+      const task = this.coordinator.resume(started, {
+        text: recoverable.text || '',
+        recovery: Boolean(recoverable.recovery),
+        addedAttachments: Array.isArray(recoverable.addedAttachments)
+          ? recoverable.addedAttachments : [],
+        onUpdate: (type, detail) => this.#emit({ type, workItem: detail }),
+      }).task;
+      task?.catch?.(() => {});
+    }
     this.#scanFailureRecoveries();
     if (!this.recoveryTimer) {
       this.recoveryTimer = setInterval(