@yeaft/webchat-agent 1.0.295 → 1.0.298

package/yeaft/work-center/projection.js

@@ -829,7 +829,14 @@ function projectMainlineBrowser(detail) {
 
 function waitingReason(detail) {
   if (typeof detail?.waitingReason === 'string') return detail.waitingReason;
-  if (detail?.status !== 'waiting' || !Array.isArray(detail.runs)) return '';
+  if (detail?.status !== 'waiting') return '';
+  const waitingEvent = Array.isArray(detail?.events)
+    ? detail.events.find(event => event?.type === 'action.waiting'
+      && event?.actionId === detail.currentActionId
+      && typeof event?.data?.reason === 'string')
+    : null;
+  if (waitingEvent) return waitingEvent.data.reason;
+  if (!Array.isArray(detail.runs)) return '';
   return detail.runs.find(run => (
     run?.actionId === detail.currentActionId && typeof run.waitingReason === 'string'
   ))?.waitingReason || '';
@@ -1029,6 +1036,8 @@ export function projectWorkCenterEvent(event) {
     type,
     ...(eventActionId ? { actionId: eventActionId } : {}),
     ...(typeof event?.runId === 'string' && event.runId ? { runId: event.runId } : {}),
+    ...(typeof event?.clientMessageId === 'string' && event.clientMessageId
+      ? { clientMessageId: truncateUtf8(event.clientMessageId, 256) } : {}),
     workItem: {
       ...projectWorkItemSummary(event?.workItem),
       actionStats: projectActionStats(event?.workItem, liveActionId),

package/yeaft/work-center/runner.js

@@ -1,5 +1,5 @@
 import { Engine } from '../engine.js';
-import { ToolRegistry } from '../tools/registry.js';
+import { ToolRegistry, isToolErrorOutput, toolErrorEffect } from '../tools/registry.js';
 import { defineTool } from '../tools/types.js';
 import { allTools } from '../tools/index.js';
 import { parsePatch } from '../tools/apply-patch.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,28 @@ 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.sideEffectScope !== 'run'
+        && 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;
+      }
+      const outputHash = hashMainlineSnapshot({ output: String(output || '') });
+      const returnedError = tool.errorOutput === 'json-error-envelope' && isToolErrorOutput(output);
+      const effectStatus = returnedError
+        ? toolErrorEffect(output) === 'none' ? 'failed_no_effect' : 'unknown'
+        : 'applied';
+      operation?.complete(effectStatus, { outputHash });
       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(
@@ -376,6 +392,7 @@ export function createSubmitWorkItemPlanTool({
     },
     isConcurrencySafe: () => false,
     isReadOnly: () => false,
+    sideEffectScope: 'run',
   });
 }
 
@@ -434,6 +451,7 @@ export function createProposeWorkItemActionsTool({
       ctx.requestEndTurn?.({ kind: 'work_item_actions_proposed', proposalId: input.proposalId });
       return JSON.stringify({ submitted: true, proposalId: input.proposalId, actionCount: input.actions.length });
     },
+    sideEffectScope: 'run',
   });
 }
 
@@ -455,6 +473,7 @@ export function createRequestWorkItemReplanTool({ workItem, collector, isRunActi
       ctx.requestEndTurn?.({ kind: 'work_item_replan_requested', proposalId: input.proposalId });
       return JSON.stringify({ submitted: true, proposalId: input.proposalId });
     },
+    sideEffectScope: 'run',
   });
 }
 
@@ -509,10 +528,13 @@ export function createSubmitWorkItemReplanTool({ vps, workItem, action, actions,
     },
     isConcurrencySafe: () => false,
     isReadOnly: () => false,
+    sideEffectScope: 'run',
   });
 }
 
-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 +544,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 +1044,37 @@ 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}`;
+      const claimed = this.store.createAndClaimOperation({
+        workItemId: workItem.id,
+        actionId: action.id,
+        runId: run.id,
+        operationType: toolName,
+        idempotencyKey,
+        replayPolicy: 'never_automatic',
+        payload: { inputHash: hashMainlineSnapshot(input) },
+      }, 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 +1189,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 +1203,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 +1270,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

@@ -60,6 +60,14 @@ function parseBoardCursor(value) {
   }
 }
 
+function removeUnpersistedAttachmentFiles(root, workItemId, addedAttachments, detail) {
+  if (!Array.isArray(addedAttachments) || addedAttachments.length === 0) return;
+  const persistedIds = new Set((Array.isArray(detail?.attachments) ? detail.attachments : [])
+    .map(attachment => attachment?.id).filter(Boolean));
+  const unpersisted = addedAttachments.filter(attachment => !persistedIds.has(attachment?.id));
+  if (unpersisted.length > 0) removeWorkItemAttachmentFiles(root, workItemId, unpersisted);
+}
+
 function listBoardItems(store, payload) {
   const limit = Math.min(Math.max(Number(payload.limit) || 100, 1), 200);
   const cursor = parseBoardCursor(payload.cursor);
@@ -106,6 +114,7 @@ export class WorkCenterService {
       listAvailableVpIds: options.listAvailableVpIds,
     });
     this.coordinator = options.coordinator || null;
+    if (this.coordinator) this.coordinator.ownerBootId = this.ownerBootId;
     this.onEvent = typeof options.onEvent === 'function' ? options.onEvent : () => {};
     this.recoveryTasks = new Map();
     this.recoveryQueue = new Map();
@@ -315,6 +324,52 @@ 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') {
+          const receipt = this.store.getCoordinatorClientMessageReceipt(payload.id, clientMessageId);
+          if (receipt) return { accepted: true, turnId: receipt.turnId || null, duplicate: true };
+          return this.handle('work_item_message', { ...payload, clientMessageId }, requestContext);
+        }
+        if (target.kind === 'action') {
+          if (this.store.hasActionInputClientMessage(payload.id, target.actionId, clientMessageId)) {
+            return this.store.getWorkItemDetail(payload.id);
+          }
+          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,12 +387,18 @@ 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],
           }, {
             onUpdate: (type, nextWorkItem) => {
               this.watcher.abortInvalidWorkItemRuns(id);
-              this.#emit({ type, workItem: nextWorkItem });
+              this.#emit({
+                type,
+                clientMessageId: typeof payload.clientMessageId === 'string'
+                  ? payload.clientMessageId : null,
+                workItem: nextWorkItem,
+              });
             },
           });
         } catch (error) {
@@ -350,6 +411,7 @@ export class WorkCenterService {
           } catch {}
           throw error;
         }
+        removeUnpersistedAttachmentFiles(this.attachmentRoot, id, addedAttachments, turn.detail);
         turn.task.catch(() => {});
         return { accepted: true, turnId: turn.detail.messages?.at(-1)?.turnId || null };
       }
@@ -387,6 +449,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],
@@ -401,9 +464,15 @@ export class WorkCenterService {
           } catch {}
           throw error;
         }
+        removeUnpersistedAttachmentFiles(this.attachmentRoot, id, addedAttachments, detail);
         this.watcher.abortInvalidWorkItemRuns(id);
         this.watcher.notifyActionInput(id, payload.actionId);
-        this.#emit({ type: 'action.input_added', workItem: detail });
+        this.#emit({
+          type: 'action.input_added',
+          actionId: payload.actionId,
+          clientMessageId: typeof payload.clientMessageId === 'string' ? payload.clientMessageId : null,
+          workItem: detail,
+        });
         return detail;
       }
       case 'guide': {
@@ -523,6 +592,35 @@ export class WorkCenterService {
     this.#drainFailureRecoveryQueue();
   }
 
+  #scanCoordinatorProviderRecoveries() {
+    if (this.shuttingDown || !this.coordinator) return;
+    this.store.recoverCoordinatorProviderTurns();
+    this.store.recoverCoordinatorMailbox();
+    for (const recoverable of this.store.getRecoverableCoordinatorTurns?.() || []) {
+      const claim = this.store.claimCoordinatorTurn(
+        recoverable.workItemId, recoverable.turnId, this.ownerBootId,
+      );
+      if (!claim) continue;
+      const started = this.store.resumeCoordinatorTurn(
+        recoverable.workItemId, recoverable.turnId, claim,
+      );
+      if (!started) continue;
+      const turn = 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 }),
+      });
+      turn?.task?.catch?.(() => {});
+    }
+  }
+
+  #scanRecoveries() {
+    this.#scanCoordinatorProviderRecoveries();
+    this.#scanFailureRecoveries();
+  }
+
   #scanFailureRecoveries() {
     if (this.shuttingDown || !this.coordinator) return;
     const now = Date.now();
@@ -584,10 +682,10 @@ export class WorkCenterService {
   }
 
   start() {
-    this.#scanFailureRecoveries();
+    this.#scanRecoveries();
     if (!this.recoveryTimer) {
       this.recoveryTimer = setInterval(
-        () => this.#scanFailureRecoveries(),
+        () => this.#scanRecoveries(),
         this.recoveryPollIntervalMs,
       );
       this.recoveryTimer.unref?.();