maka-agent 0.2.0-dev.52.20260926 → 0.2.0-dev.53.20260927

package/node_modules/@maka/runtime/dist/computer-use-tools.js

@@ -635,7 +635,9 @@ export function buildComputerUseTools(deps) {
             target,
         };
     }
-    function registerObservation(record, observation) {
+    function acceptObservation(state, record, lease, observation) {
+        if (!state.validateObservationLease(lease).ok)
+            return undefined;
         const normalized = {
             ...observation,
             elements: observation.elements.map((element) => ({
@@ -660,6 +662,7 @@ export function buildComputerUseTools(deps) {
         record.windowId = observation.windowId;
         record.obscuringRects = observation.obscuringRects;
         record.elements = new Map(normalized.elements.map((element) => [element.elementId, element]));
+        state.freshObservationSucceeded();
         return { ...normalized, observationId: frame.frameId };
     }
     function bindingFailure(reason, action) {
@@ -920,12 +923,7 @@ export function buildComputerUseTools(deps) {
         const fresh = captured && result.screenshot && !captured.screenshot
             ? { ...captured, screenshot: result.screenshot }
             : captured;
-        if (!fresh || !state.validateObservationLease(observationLease.lease).ok) {
-            return undefined;
-        }
-        const registered = registerObservation(record, fresh);
-        const snapshot = state.freshObservationSucceeded();
-        return snapshot.status === 'active' ? registered : undefined;
+        return fresh ? acceptObservation(state, record, observationLease.lease, fresh) : undefined;
     }
     async function withInvocationQueue(sessionId, signal, operation) {
         const previous = invocationQueues.get(sessionId) ?? Promise.resolve();
@@ -1102,6 +1100,51 @@ export function buildComputerUseTools(deps) {
             throw error;
         }
     }
+    async function executeBoundAction(input) {
+        const { state, lease, record, binding, action, signal } = input;
+        let result;
+        let consumeFailure;
+        let presentation;
+        try {
+            const blocked = validateActionLease(state, lease);
+            if (blocked)
+                return { blocked };
+            const context = { ...input.context, boundAction: binding };
+            presentation = await runWithPresentation(action, context, signal, () => input.dispatch(context), () => validateActionLease(state, lease), input.generation);
+            if (presentation.blocked)
+                return { blocked: presentation.blocked };
+            if (!presentation.result) {
+                presentation.finish();
+                return { blocked: bindingFailure('capture_failed', action.type) };
+            }
+            result = preservePartialDelivery(presentation.result);
+            applyTypedOutcomeState(state, result.outcome);
+            if (result.outcome.ok) {
+                const blocked = validateActionLease(state, lease);
+                if (blocked) {
+                    presentation.finish();
+                    return { blocked };
+                }
+            }
+        }
+        finally {
+            // A path:none refusal retains its frame; a delivered or unknown attempt
+            // consumes it even if the backend throws.
+            if (dispatchedNothing(result)) {
+                consumeFailure = retireBoundAction(record, binding);
+            }
+            else {
+                consumeFailure = consumeBoundAction(record, binding);
+                if (state.validateLease(lease).ok)
+                    state.reobserveRequired();
+            }
+        }
+        if (consumeFailure && !hasUncertainDeliveredOutcome(result)) {
+            presentation.finish();
+            return { blocked: refusalAfterDispatch(consumeFailure, result, action.type) };
+        }
+        return { result, finish: presentation.finish };
+    }
     const tool = {
         name: 'maka_computer',
         displayName: 'Maka Computer',
@@ -1242,6 +1285,9 @@ export function buildComputerUseTools(deps) {
                         state.screenLocked();
                         return sessionFailure('screen_locked');
                     }
+                    // A new Turn retires the previous frame and advances the session
+                    // generation. Do that before leasing an observe, not after capture.
+                    const observingRecord = input.action === 'observe' ? sessionObservation(sessionId, turnId) : undefined;
                     // Both halves of the wire enum are partitioned in `@maka/core`, so a
                     // new action cannot be added without landing on one side or the
                     // other — and offline consumers read the same partition.
@@ -1355,12 +1401,12 @@ export function buildComputerUseTools(deps) {
                                     stopped = 'capture_failed';
                                     break;
                                 }
-                                current = registerObservation(record, recaptured);
-                                // A frame the host just captured is a live frame. Without this
-                                // the session stays in `reobserve_required` from the previous
-                                // step and the next action is refused — the sequence would take
-                                // exactly one step and stop.
-                                state.freshObservationSucceeded();
+                                current = acceptObservation(state, record, lease.lease, recaptured);
+                                if (!current) {
+                                    const valid = state.validateObservationLease(lease.lease);
+                                    stopped = valid.ok ? 'reobserve_required' : valid.reason;
+                                    break;
+                                }
                             }
                             const wanted = step.label.trim().toLowerCase();
                             const matches = (current?.elements ?? []).filter((element) => (element.label ?? '').trim().toLowerCase() === wanted &&
@@ -1417,27 +1463,28 @@ export function buildComputerUseTools(deps) {
                                 stopped = 'stale_frame';
                                 break;
                             }
-                            const operationContext = { ...runCtx, boundAction: binding };
-                            let stepResult;
-                            let presentation;
-                            try {
-                                presentation = await runWithPresentation(summarySemanticAction(semantic), operationContext, abortSignal, () => deps.backend.runSemantic({ ...semantic, observationId: record.backendObservationId }, abortSignal, operationContext), undefined, invocationGeneration);
-                                if (presentation.blocked)
-                                    return presentation.blocked;
-                                stepResult = presentation.result;
-                            }
-                            finally {
-                                consumeBoundAction(record, binding);
-                                state.reobserveRequired();
+                            const backendAction = { ...semantic, observationId: record.backendObservationId };
+                            const execution = await executeBoundAction({
+                                state,
+                                lease: actionLeaseResult.lease,
+                                record,
+                                binding,
+                                action: summarySemanticAction(semantic),
+                                context: runCtx,
+                                signal: abortSignal,
+                                generation: invocationGeneration,
+                                dispatch: (context) => deps.backend.runSemantic(backendAction, abortSignal, context),
+                            });
+                            if (execution.blocked) {
+                                stopped = execution.blocked.error ?? 'outcome_unknown';
+                                done.push({ step: index + 1, label: step.label, ok: false });
+                                emitProgress?.(done.length, input.steps.length);
+                                break;
                             }
-                            presentation?.finish(stepResult);
-                            if (!stepResult || !stepResult.outcome.ok) {
-                                if (stepResult)
-                                    applyTypedOutcomeState(state, stepResult.outcome);
-                                stopped =
-                                    stepResult && !stepResult.outcome.ok
-                                        ? stepResult.outcome.error
-                                        : 'capture_failed';
+                            const stepResult = execution.result;
+                            execution.finish(stepResult);
+                            if (!stepResult.outcome.ok) {
+                                stopped = stepResult.outcome.error;
                                 done.push({ step: index + 1, label: step.label, ok: false });
                                 emitProgress?.(done.length, input.steps.length);
                                 break;
@@ -1448,6 +1495,7 @@ export function buildComputerUseTools(deps) {
                         // One observation at the end, whatever happened: the model needs a
                         // current frame either to carry on or to work out what went wrong.
                         let final;
+                        let closingBlock;
                         try {
                             const lease = state.beforeObservation();
                             if (lease.ok) {
@@ -1463,7 +1511,14 @@ export function buildComputerUseTools(deps) {
                                     windowId: record.windowId,
                                     includeScreenshot: withPicture,
                                 }, abortSignal, runCtx);
-                                final = registerObservation(record, await capture(true).catch(() => capture(false)));
+                                final = acceptObservation(state, record, lease.lease, await capture(true).catch(() => capture(false)));
+                                if (!final) {
+                                    const valid = state.validateObservationLease(lease.lease);
+                                    closingBlock = valid.ok ? 'reobserve_required' : valid.reason;
+                                }
+                            }
+                            else {
+                                closingBlock = lease.reason;
                             }
                         }
                         catch {
@@ -1471,7 +1526,9 @@ export function buildComputerUseTools(deps) {
                         }
                         const headline = stopped
                             ? `maka_computer.element_sequence stopped at step ${done.length} of ${input.steps.length}: ${stopped}`
-                            : `maka_computer.element_sequence ok (${done.length} of ${input.steps.length} steps)`;
+                            : closingBlock
+                                ? `maka_computer.element_sequence failed after ${done.length} of ${input.steps.length} steps: ${closingBlock} — ${SESSION_BLOCK_RECOVERY[closingBlock]}`
+                                : `maka_computer.element_sequence ok (${done.length} of ${input.steps.length} steps)`;
                         const persistedTail = final
                             ? `\nFresh observation: ${persistedObservationText(final)}`
                             : '';
@@ -1482,7 +1539,11 @@ export function buildComputerUseTools(deps) {
                         return {
                             text: `${headline}${persistedTail}`,
                             modelText: `${headline}\n${stepLines}${modelTail}`,
-                            ...(stopped && isComputerUseErrorCode(stopped) ? { error: stopped } : {}),
+                            ...(stopped && isComputerUseErrorCode(stopped)
+                                ? { error: stopped }
+                                : closingBlock
+                                    ? { error: closingBlock }
+                                    : {}),
                             ...(final?.screenshot
                                 ? {
                                     screenshot: {
@@ -1647,8 +1708,13 @@ export function buildComputerUseTools(deps) {
                                 .filter((part) => typeof part === 'string')
                                 .some((part) => part.toLowerCase().includes(needle)));
                             if (found === wantPresent) {
-                                const observation = registerObservation(record, last);
-                                state.freshObservationSucceeded();
+                                const observation = observationLease?.ok
+                                    ? acceptObservation(state, record, observationLease.lease, last)
+                                    : undefined;
+                                if (!observation) {
+                                    const valid = state.beforeAction();
+                                    return sessionFailure(valid.ok ? 'reobserve_required' : valid.reason, 'wait');
+                                }
                                 const waited = ((Date.now() - (deadline - Math.round((input.duration ?? 5) * 1000))) /
                                     1000).toFixed(1);
                                 const text = `maka_computer.wait ok — ${wantPresent ? 'appeared' : 'gone'} after ${waited}s`;
@@ -1662,8 +1728,13 @@ export function buildComputerUseTools(deps) {
                                 // holds instead is the whole question a model asks next, and
                                 // making it spend another call on that is the round trip this
                                 // action exists to remove.
-                                const observation = registerObservation(record, last);
-                                state.freshObservationSucceeded();
+                                const observation = observationLease?.ok
+                                    ? acceptObservation(state, record, observationLease.lease, last)
+                                    : undefined;
+                                if (!observation) {
+                                    const valid = state.beforeAction();
+                                    return sessionFailure(valid.ok ? 'reobserve_required' : valid.reason, 'wait');
+                                }
                                 const text = `maka_computer.wait failed: timeout — ${JSON.stringify(input.wait_for_text ?? input.wait_for_text_gone)} was still ${wantPresent ? 'absent' : 'present'} after ${(input.duration ?? 5).toFixed(1)}s and ${polls} looks. This is the window as it stands.`;
                                 return {
                                     text: `${text}\n${persistedObservationText(observation)}`,
@@ -1814,13 +1885,13 @@ export function buildComputerUseTools(deps) {
                                 error: code,
                             };
                         }
-                        if (!observationLease?.ok ||
-                            !state.validateObservationLease(observationLease.lease).ok) {
+                        // The observe record was created before taking the lease, so both
+                        // must be present before accepting this capture.
+                        if (!observingRecord || !observationLease?.ok) {
                             const blocked = state.beforeAction();
                             return sessionFailure(blocked.ok ? 'reobserve_required' : blocked.reason, 'observe');
                         }
-                        const record = sessionObservation(sessionId, turnId);
-                        const observation = registerObservation(record, {
+                        const observation = acceptObservation(state, observingRecord, observationLease.lease, {
                             ...withRequestedView(backendObservation, {
                                 ...(input.query ? { query: input.query } : {}),
                                 ...(input.menu ? { menu: input.menu } : {}),
@@ -1836,10 +1907,9 @@ export function buildComputerUseTools(deps) {
                                 ? { appAlias: input.app }
                                 : {}),
                         });
-                        const activated = state.freshObservationSucceeded();
-                        if (activated.status !== 'active') {
-                            invalidateObservation(sessionId);
-                            return sessionFailure(activated.status === 'blocked_url' ? 'blocked_url' : 'user_stopped');
+                        if (!observation) {
+                            const valid = state.beforeAction();
+                            return sessionFailure(valid.ok ? 'reobserve_required' : valid.reason, 'observe');
                         }
                         const screenshot = observation.screenshot;
                         return screenshot
@@ -2008,57 +2078,23 @@ export function buildComputerUseTools(deps) {
                             observationId: record.backendObservationId,
                         };
                         const summaryAction = summarySemanticAction(semanticAction);
-                        let result;
-                        let consumeFailure;
-                        let presentation;
-                        try {
-                            if (!actionLease)
-                                return sessionFailure('no_active_frame', input.action);
-                            const leaseFailure = validateActionLease(state, actionLease);
-                            if (leaseFailure)
-                                return leaseFailure;
-                            const operationContext = { ...runCtx, boundAction: binding };
-                            presentation = await runWithPresentation(summaryAction, operationContext, abortSignal, () => deps.backend.runSemantic(semanticAction, abortSignal, operationContext), () => validateActionLease(state, actionLease), invocationGeneration);
-                            if (presentation.blocked)
-                                return presentation.blocked;
-                            if (!presentation.result)
-                                return bindingFailure('capture_failed', input.action);
-                            result = preservePartialDelivery(presentation.result);
-                            applyTypedOutcomeState(state, result.outcome);
-                            if (result.outcome.ok) {
-                                const postDispatchFailure = validateActionLease(state, actionLease);
-                                if (postDispatchFailure) {
-                                    presentation.finish();
-                                    return postDispatchFailure;
-                                }
-                            }
-                        }
-                        finally {
-                            // A refusal that never reached the window leaves the frame it was
-                            // quoted against exactly as it was, so it keeps its frame and its
-                            // lease. Consuming both is what turned one refusal into three
-                            // calls: the action failed, the frame was thrown away, and the
-                            // code was not one that hands back a fresh one — so the model's
-                            // next call was `reobserve_required` and the one after it was the
-                            // `observe` it should never have had to spend.
-                            if (dispatchedNothing(result)) {
-                                consumeFailure = retireBoundAction(record, binding);
-                            }
-                            else {
-                                consumeFailure = consumeBoundAction(record, binding);
-                                if (actionLease && state.validateLease(actionLease).ok) {
-                                    state.reobserveRequired();
-                                }
-                            }
-                        }
-                        if (consumeFailure && !hasUncertainDeliveredOutcome(result)) {
-                            presentation?.finish();
-                            return refusalAfterDispatch(consumeFailure, result, input.action);
-                        }
-                        if (!result) {
-                            presentation?.finish();
-                            return bindingFailure('capture_failed', input.action);
-                        }
+                        if (!actionLease)
+                            return sessionFailure('no_active_frame', input.action);
+                        const execution = await executeBoundAction({
+                            state,
+                            lease: actionLease,
+                            record,
+                            binding,
+                            action: summaryAction,
+                            context: runCtx,
+                            signal: abortSignal,
+                            generation: invocationGeneration,
+                            dispatch: (context) => deps.backend.runSemantic(semanticAction, abortSignal, context),
+                        });
+                        if (execution.blocked)
+                            return execution.blocked;
+                        const { result } = execution;
+                        const presentation = execution;
                         // One action removes its own target on purpose, and the machinery
                         // below reads a missing target as an uncertain outcome.
                         //
@@ -2119,7 +2155,7 @@ export function buildComputerUseTools(deps) {
                         // `REOBSERVABLE_FAILURES` — `target_missing`, `target_changed`,
                         // `ambiguous_target`, `duplicate_action`, `stale_frame`,
                         // `invalid_coordinate` — takes the fresh observation above, and
-                        // `registerObservation` makes that the current frame. The sentence
+                        // `acceptObservation` makes that the current frame. The sentence
                         // then named a frame the same reply had just superseded: the model
                         // read "observation X is still current, use it rather than
                         // observing again", did exactly that, and collected `stale_frame`

package/node_modules/@maka/runtime/dist/context-budget-helpers.js

@@ -49,6 +49,10 @@ export function turnKey(event) {
 export function sha256(text) {
     return createHash('sha256').update(text).digest('hex');
 }
+/** Accepts whitespace-only strings; trimming would change persisted checkpoint acceptance. */
+export function nonEmpty(value) {
+    return typeof value === 'string' && value.length > 0;
+}
 export function finitePositive(value) {
     return typeof value === 'number' && Number.isFinite(value) && value > 0
         ? Math.floor(value)