npm - @yeaft/webchat-agent - Versions diffs - 1.0.255 → 1.0.256 - Mend

@yeaft/webchat-agent 1.0.255 → 1.0.256

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/local-runtime/version.json +1 -1
package/local-runtime/web/app.bundle.js +6 -5
package/local-runtime/web/app.bundle.js.gz +0 -0
package/local-runtime/web/index.html +1 -1
package/package.json +1 -1
package/yeaft/work-center/bridge.js +3 -1
package/yeaft/work-center/coordinator.js +17 -6
package/yeaft/work-center/projection.js +5 -0
package/yeaft/work-center/runner.js +16 -3
package/yeaft/work-center/service.js +56 -0
package/yeaft/work-center/store.js +27 -21

package/local-runtime/web/app.bundle.js.gz CHANGED Viewed

Binary file

package/local-runtime/web/index.html CHANGED Viewed

@@ -16,6 +16,6 @@
 </head>
 <body>
   <div id="app"></div>
-  <script type="module" src="app.bundle.js?v=d010a7c7"></script>
+  <script type="module" src="app.bundle.js?v=b3f82a98"></script>
 </body>
 </html>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.255",
+  "version": "1.0.256",
   "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/bridge.js CHANGED Viewed

@@ -220,7 +220,9 @@ export async function handleWorkCenterRequest(msg) {
         : (BROWSER_ACTION_DEBUG_OPS.has(op) ? browserFilePayload(op, msg.payload) : (msg.payload || {}));
       data = await workCenter.handle(op, payload);
     }
-    if (BROWSER_DETAIL_OPS.has(op)) data = workCenter.projectBrowserDetail(data);
+    if (BROWSER_DETAIL_OPS.has(op) && data?.accepted !== true) {
+      data = workCenter.projectBrowserDetail(data);
+    }
     send({
       type: 'work_center_response',
       requestId,

package/yeaft/work-center/coordinator.js CHANGED Viewed

@@ -16,6 +16,7 @@ const COORDINATOR_MAX_REPLY_CHARS = 8_000;
 const COORDINATOR_MAX_INSTRUCTION_CHARS = 8_000;
 const COORDINATOR_MAX_OUTPUT_TOKENS = 8_192;
 const COORDINATOR_MAX_SNAPSHOT_BYTES = 64 * 1024;
+const COORDINATOR_DECISION_ATTEMPTS = 2;
 const COORDINATOR_RECOVERY_DECISION_ATTEMPTS = 2;
 const COORDINATOR_MAX_CONVERSATION_MESSAGES = 20;
 const COORDINATOR_MAX_ACTIONS = 64;
@@ -302,7 +303,9 @@ export function normalizeCoordinatorResponse(value, detail, options = {}) {
     : {};
   const allowedKinds = options.recovery === true
     ? ['guide_actions', 'replan', 'request_human']
-    : ['answer', 'guide_actions', 'replan'];
+    : options.controlRequired === true
+      ? ['guide_actions', 'replan']
+      : ['answer', 'guide_actions', 'replan'];
   const kind = allowedKinds.includes(source.kind) ? source.kind : '';
   if (!kind) throw new Error('Work Center Coordinator decision kind is invalid');
   const reason = cleanText(source.reason, 2_000, 'decision reason');
@@ -494,12 +497,15 @@ export class WorkItemCoordinator {
     }, {
       attachments: input.attachments,
       addedAttachments,
+      recovery: input.recovery,
+      requireWaitingRecovery: input.controlRequired === true,
     });
     if (!started) throw new Error(`WorkItem not found: ${id}`);
     options.onUpdate?.('coordinator.turn_started', started.detail);
     return this.#scheduleTurn(started, {
       text: promptText,
       recovery: false,
+      controlRequired: input.controlRequired === true,
       addedAttachments,
       options,
     });
@@ -535,15 +541,17 @@ export class WorkItemCoordinator {
     const text = `Action stage "${action.stageId}" failed. Decide the next safe control transition. `
       + 'Failure is not a terminal WorkItem state: guide or replan executable work whenever possible. '
       + 'Request human input only when the snapshot lacks information required for a safe decision.';
-    return this.#scheduleTurn(started, { text, recovery: true, options });
+    return this.#scheduleTurn(started, { text, recovery: true, controlRequired: false, options });
   }
-  #scheduleTurn(started, { text, recovery, addedAttachments = [], options }) {
+  #scheduleTurn(started, {
+    text, recovery, controlRequired = false, addedAttachments = [], options,
+  }) {
     const abortController = new AbortController();
     this.activeTurns.set(started.turnId, abortController);
     const task = new Promise(resolve => setTimeout(resolve, 0))
       .then(() => this.#executeTurn(started, {
-        text, recovery, addedAttachments, options, abortController,
+        text, recovery, controlRequired, addedAttachments, options, abortController,
       }))
       .finally(() => {
         this.activeTurns.delete(started.turnId);
@@ -554,7 +562,7 @@ export class WorkItemCoordinator {
   }
   async #executeTurn(started, {
-    text, recovery, addedAttachments, options, abortController,
+    text, recovery, controlRequired, addedAttachments, options, abortController,
   }) {
     try {
       let normalized = null;
@@ -605,7 +613,9 @@ export class WorkItemCoordinator {
         } catch (error) {
           throw coordinatorExecutionError(error, 'selection');
         }
-        const maxAttempts = recovery ? COORDINATOR_RECOVERY_DECISION_ATTEMPTS : 1;
+        const maxAttempts = recovery
+          ? COORDINATOR_RECOVERY_DECISION_ATTEMPTS
+          : COORDINATOR_DECISION_ATTEMPTS;
         for (let index = 0; index < maxAttempts; index += 1) {
           attemptCount = index + 1;
           mutation = null;
@@ -645,6 +655,7 @@ export class WorkItemCoordinator {
             }
             normalized = normalizeCoordinatorResponse(result?.text, started.detail, {
               recovery,
+              controlRequired,
               recoveryActionId: started.fence.recovery?.actionId || null,
             });
             if (normalized.decision.kind === 'replan') {

package/yeaft/work-center/projection.js CHANGED Viewed

@@ -901,6 +901,11 @@ export function projectWorkItemDetail(detail, options = {}) {
         affectedActionIds: Array.isArray(message.decision.affectedActionIds)
           ? message.decision.affectedActionIds.map(id => String(id)).slice(0, 8) : [],
       } : null,
+      recovery: message.recovery && typeof message.recovery === 'object' ? {
+        actionId: truncateUtf8(String(message.recovery.actionId || ''), 256),
+        actionGeneration: Math.max(0, count(message.recovery.actionGeneration)),
+        stageId: truncateUtf8(String(message.recovery.stageId || ''), 256),
+      } : null,
       createdAt: count(message.createdAt),
       updatedAt: count(message.updatedAt || message.createdAt),
     })),

package/yeaft/work-center/runner.js CHANGED Viewed

@@ -32,6 +32,7 @@ import { MCPManager } from '../mcp.js';
 import { buildMcpFlattenedTools } from '../tools/mcp-tools.js';
 import { recallWorkspaceSessionContext } from './workspace-context.js';
 import { applyGeneratedPlan, BUILT_IN_ACTION_TYPES } from './workflow.js';
+import { applyAdditivePlanProposal } from './plan-mutation.js';
 import { normalizeContractPatch, validateCompletedResult } from './completion-contract.js';
 import { normalizeEvidence } from './evidence.js';
 import {
@@ -395,13 +396,18 @@ function plannedActionSchema(vpIds, { requireCandidates = true } = {}) {
   } };
 }
-export function createProposeWorkItemActionsTool({ vps, workItem, actions, collector, isRunActive }) {
+export function createProposeWorkItemActionsTool({
+  vps, workItem, actions, collector, isRunActive, currentAction = null,
+}) {
   const vpCatalog = planningVpCatalog(vps);
   const vpIds = vpCatalog.map(vp => vp.id);
   const existing = actions.filter(action => !['superseded', 'cancelled'].includes(action.status));
+  const currentIdentity = currentAction
+    ? ` Current Action: stageId=${currentAction.stageId}; internalActionId=${currentAction.id}. Its graph references must use stageId.`
+    : '';
   return defineTool({
     name: 'ProposeWorkItemActions',
-    description: `Propose an additive change to the current WorkItem DAG. It is applied only if this Action completes and its Run lease plus basePlanRevision remain valid. Existing Actions: ${existing.map(action => `${action.id}/${action.stageId} (${action.status}, attempt ${action.attempt})`).join('; ')}. Available VPs: ${vpCatalog.map(vp => `${vp.id} (${vp.role || vp.area || 'VP'})`).join('; ')}. Only add new Actions and optionally add dependencies to attempt=0 ready Actions.`,
+    description: `Propose an additive change to the current WorkItem DAG. It is applied only if this Action completes and its Run lease plus basePlanRevision remain valid. Use stable stageId values in dependsOnActionIds, changesRequestedActionId, and dependencyPatches[].addDependsOnActionIds. The only internal id field is dependencyPatches[].actionId, which must use the displayed internalActionId of an eligible ready attempt=0 target.${currentIdentity} Existing Actions: ${existing.map(action => `stageId=${action.stageId} (internalActionId=${action.id}, ${action.status}, attempt ${action.attempt})`).join('; ')}. Available VPs: ${vpCatalog.map(vp => `${vp.id} (${vp.role || vp.area || 'VP'})`).join('; ')}. Only add new Actions and optionally add dependencies to attempt=0 ready Actions. This tool validates the complete additive DAG immediately; if validation fails, correct the proposal in the same turn.`,
     parameters: { type: 'object', additionalProperties: false,
       required: ['summary', 'evidence', 'acceptanceChecks', 'proposalId', 'basePlanRevision', 'actions'],
       properties: {
@@ -413,6 +419,13 @@ export function createProposeWorkItemActionsTool({ vps, workItem, actions, colle
     async execute(input, ctx = {}) {
       if (!isRunActive()) throw new Error('Work Center Run is no longer active');
       if (collector.value) throw new Error('A WorkItem plan mutation was already submitted for this Run');
+      applyAdditivePlanProposal({
+        workItem,
+        actions,
+        proposal: input,
+        availableVpIds: vpIds,
+      });
+      if (!isRunActive()) throw new Error('Work Center Run is no longer active');
       collector.value = { kind: 'expand', input: structuredClone(input) };
       ctx.requestEndTurn?.({ kind: 'work_item_actions_proposed', proposalId: input.proposalId });
       return JSON.stringify({ submitted: true, proposalId: input.proposalId, actionCount: input.actions.length });
@@ -981,7 +994,7 @@ export class WorkItemRunner {
       runTools.push(createProposeWorkItemActionsTool({
         vps: this.registry.listVps(), workItem,
         actions: this.store.getWorkItemDetail(workItem.id).actions,
-        collector: mutationCollector, isRunActive,
+        collector: mutationCollector, isRunActive, currentAction: executionAction,
       }));
       runTools.push(createRequestWorkItemReplanTool({ workItem, collector: mutationCollector, isRunActive }));
     }

package/yeaft/work-center/service.js CHANGED Viewed

@@ -60,6 +60,19 @@ function parseBoardCursor(value) {
   }
 }
+function coordinatorHumanRequest(detail, action, generation) {
+  if (detail?.status !== 'waiting'
+      || action?.status !== 'waiting'
+      || Number(action.generation) !== Number(generation)) return null;
+  return [...(Array.isArray(detail.messages) ? detail.messages : [])].reverse().find(message => (
+    message?.role === 'assistant'
+    && message.status === 'completed'
+    && message.decision?.kind === 'request_human'
+    && message.recovery?.actionId === action.id
+    && message.recovery?.actionGeneration === action.generation
+  )) || null;
+}
 function listBoardItems(store, payload) {
   const limit = Math.min(Math.max(Number(payload.limit) || 100, 1), 200);
   const cursor = parseBoardCursor(payload.cursor);
@@ -367,6 +380,49 @@ export class WorkCenterService {
           throw new Error('generation must be a positive integer');
         }
         const workItem = this.#requiredItem(id);
+        const targetAction = this.#requiredAction(workItem, payload.actionId);
+        const humanRequest = coordinatorHumanRequest(workItem, targetAction, generation);
+        if (humanRequest) {
+          let addedAttachments = [];
+          let turn;
+          try {
+            addedAttachments = appendWorkItemAttachments(workItem.attachments, payload.files, {
+              root: this.attachmentRoot,
+              workItemId: id,
+            });
+            turn = this.coordinator.message(id, {
+              text: typeof payload.text === 'string' ? payload.text : '',
+              revision: payload.revision,
+              planRevision: workItem.planRevision,
+              ledgerRevision: workItem.ledgerRevision,
+              coordinatorRevision: workItem.coordinatorRevision,
+              controlRequired: true,
+              recovery: { ...humanRequest.recovery },
+              addedAttachments,
+              attachments: [...(workItem.attachments || []), ...addedAttachments],
+            }, {
+              onUpdate: (type, nextWorkItem) => {
+                this.watcher.abortInvalidWorkItemRuns(id);
+                this.#emit({ type, workItem: nextWorkItem });
+              },
+            });
+          } catch (error) {
+            try {
+              if ((workItem.attachments || []).length === 0 && addedAttachments.length > 0) {
+                removeWorkItemAttachments(this.attachmentRoot, id);
+              } else {
+                removeWorkItemAttachmentFiles(this.attachmentRoot, id, addedAttachments);
+              }
+            } catch {}
+            throw error;
+          }
+          turn.task.catch(() => {});
+          return {
+            accepted: true,
+            routedTo: 'coordinator',
+            turnId: turn.detail.messages?.at(-1)?.turnId || null,
+          };
+        }
         let addedAttachments = [];
         let detail;
         try {

package/yeaft/work-center/store.js CHANGED Viewed

@@ -2207,27 +2207,33 @@ export class WorkItemStore {
       let recovery = options.recovery && typeof options.recovery === 'object'
         ? { ...options.recovery } : null;
       if (recovery) {
-        const failedAction = activeActions.find(action => action.id === recovery.actionId);
+        const recoveryAction = activeActions.find(action => action.id === recovery.actionId);
+        const requiredStatus = options.requireWaitingRecovery === true ? 'waiting' : 'failed';
         if (['done', 'cancelled'].includes(workItem.status)
-            || failedAction?.status !== 'failed'
-            || failedAction.generation !== recovery.actionGeneration
-            || failedAction.stageId !== recovery.stageId) {
-          throw new Error('WorkItem failure changed before Coordinator recovery started');
+            || recoveryAction?.status !== requiredStatus
+            || recoveryAction.generation !== recovery.actionGeneration
+            || recoveryAction.stageId !== recovery.stageId) {
+          throw new Error(options.requireWaitingRecovery === true
+            ? 'WorkItem human input target changed before the Coordinator turn started'
+            : 'WorkItem failure changed before Coordinator recovery started');
+        }
+        if (options.requireWaitingRecovery !== true) {
+          const priorAttempts = Number(this.db.prepare(`SELECT COUNT(*) AS count FROM events
+            WHERE work_item_id = ? AND type = 'coordinator.recovery_started'
+              AND action_id = ? AND action_generation = ?`).get(
+            id,
+            recoveryAction.id,
+            recoveryAction.generation,
+          )?.count) || 0;
+          recovery = { ...recovery, attempt: priorAttempts + 1 };
         }
-        const priorAttempts = Number(this.db.prepare(`SELECT COUNT(*) AS count FROM events
-          WHERE work_item_id = ? AND type = 'coordinator.recovery_started'
-            AND action_id = ? AND action_generation = ?`).get(
-          id,
-          failedAction.id,
-          failedAction.generation,
-        )?.count) || 0;
-        recovery = { ...recovery, attempt: priorAttempts + 1 };
       }
-      if (!recovery && !String(text || '').trim() && projectedAttachments.length === 0) {
+      const automaticRecovery = recovery && options.requireWaitingRecovery !== true;
+      if (!automaticRecovery && !String(text || '').trim() && projectedAttachments.length === 0) {
         throw new Error('WorkItem Coordinator message or attachments are required');
       }
       const turnId = randomUUID();
-      const userMessage = recovery ? null : {
+      const userMessage = automaticRecovery ? null : {
         id: randomUUID(), turnId, role: 'user', text, attachments: projectedAttachments,
         status: 'completed', createdAt: now,
       };
@@ -2250,7 +2256,7 @@ export class WorkItemStore {
         id, workItem.coordinatorRevision, workItem.revision, workItem.planRevision, workItem.ledgerRevision,
       );
       if (Number(changed.changes) !== 1) throw new Error('Coordinator turn lost its revision fence');
-      this.appendEvent(id, recovery ? 'coordinator.recovery_started' : 'coordinator.turn_started', {
+      this.appendEvent(id, automaticRecovery ? 'coordinator.recovery_started' : 'coordinator.turn_started', {
         turnId,
         status: 'thinking',
         coordinatorRevision,
@@ -2313,17 +2319,17 @@ export class WorkItemStore {
         throw new Error('Coordinator replan requires an AI-planned Action graph');
       }
       if (recovery && decision.kind === 'guide_actions') {
-        const failedAction = activeActions.find(action => (
+        const recoveryAction = activeActions.find(action => (
           action.id === recovery.actionId
           && action.generation === recovery.actionGeneration
           && action.stageId === recovery.stageId
-          && action.status === 'failed'
+          && ['failed', 'waiting'].includes(action.status)
         ));
-        if (!failedAction
+        if (!recoveryAction
             || !Array.isArray(decision.guidance)
             || decision.guidance.length !== 1
-            || decision.guidance[0]?.stageId !== failedAction.stageId) {
-          throw new Error('Coordinator recovery guidance must target only the failed Action identity');
+            || decision.guidance[0]?.stageId !== recoveryAction.stageId) {
+          throw new Error('Coordinator recovery guidance must target only the fenced Action identity');
         }
       }
       let nextWorkItem = workItem;