maka-agent 0.2.0-dev.76.20261009 → 0.2.0-dev.78.20261010

package/node_modules/@maka/runtime/dist/stream-graph-schedule-reconcile.js

@@ -22,6 +22,15 @@ import { projectAgentGraphSchedule, } from './stream-graph-supervisor-tools.js';
 import { stableHash } from './request-shape.js';
 const MAX_RECONCILIATION_ATTEMPTS = 8;
 const SCHEDULE_INTENT_SCHEMA_VERSION = 1;
+// A failed control pass can park the wave it is stopping, and nothing else may
+// wake it. Retry with a capped backoff while that wave is still running.
+const CONTROL_RETRY_INITIAL_DELAY_MS = 100;
+const CONTROL_RETRY_MAX_DELAY_MS = 5_000;
+// The eighth consecutive failure of a stop or a control read lands about 11 s
+// after the first, once the backoff has reached its cap: a fault that clears
+// during the ramp is never reported as stuck, while a persistent one is
+// surfaced instead of leaving the graph parked behind a single failure record.
+const CONTROL_STUCK_FAILURES = 8;
 /**
  * Applies durable supervisor schedule intent to existing and newly
  * materialized graph operators.
@@ -35,6 +44,39 @@ export async function reconcileAgentGraphSchedule(input) {
     if (!Number.isSafeInteger(input.maxNewActivations) || input.maxNewActivations < 0) {
         throw new Error('Agent graph maxNewActivations must be a non-negative safe integer');
     }
+    const wake = createReconciliationWake();
+    // Install before reading the durable schedule: a commit during any await
+    // remains pending until this reconciliation consumes it.
+    const unsubscribe = input.subscribeToScheduleChanges?.(wake.notify);
+    try {
+        return await reconcileSchedule(input, wake);
+    }
+    finally {
+        unsubscribe?.();
+    }
+}
+function createReconciliationWake() {
+    let pending = false;
+    let resolve;
+    let next = new Promise((done) => {
+        resolve = done;
+    });
+    return {
+        notify() {
+            pending = true;
+            resolve();
+        },
+        async wait() {
+            if (!pending)
+                await next;
+            pending = false;
+            next = new Promise((done) => {
+                resolve = done;
+            });
+        },
+    };
+}
+async function reconcileSchedule(input, wake) {
     const processedIntentIds = new Set();
     const dispatches = [];
     const stops = [];
@@ -43,6 +85,11 @@ export async function reconcileAgentGraphSchedule(input) {
     // reconciliation; cache them per source graph so repeated snapshot reads do
     // not replay the full committed projection of a closed epoch.
     const selectedResultCache = new Map();
+    // Exact stops that already succeeded in this reconciliation; later passes
+    // and wakes do not stop the same activation again.
+    const resolvedStops = new Set();
+    // Consecutive stop failures per target, reset when the target resolves.
+    const stopFailureStreaks = new Map();
     let newActivationCount = 0;
     let observedExistingActivationCount = 0;
     let snapshot = await readScheduleSnapshot(input, selectedResultCache);
@@ -50,10 +97,8 @@ export async function reconcileAgentGraphSchedule(input) {
         if (input.abortSignal?.aborted) {
             return reconciliationResult('cancelled', newActivationCount, observedExistingActivationCount, dispatches, stops, [], failures, snapshot);
         }
-        const stopWave = await applyScheduleStops(input, snapshot);
-        stops.push(...stopWave.stops);
-        for (const failure of stopWave.failures)
-            recordReconciliationFailure(input, failures, failure);
+        const stopWave = await applyScheduleStops(input, snapshot, resolvedStops);
+        recordScheduleStops(input, stops, failures, stopFailureStreaks, stopWave);
         if (failures.length > 0) {
             snapshot = await readScheduleSnapshot(input, selectedResultCache);
             return reconciliationResult(input.abortSignal?.aborted ? 'cancelled' : 'failed', newActivationCount, observedExistingActivationCount, dispatches, stops, [], failures, snapshot);
@@ -196,13 +241,81 @@ export async function reconcileAgentGraphSchedule(input) {
             snapshot = await readScheduleSnapshot(input, selectedResultCache);
             return reconciliationResult('failed', newActivationCount, observedExistingActivationCount, dispatches, stops, deferredWork, failures, snapshot);
         }
-        const outcomes = await Promise.all(prepared.map(async (work) => {
+        let waveSettled = false;
+        const wave = Promise.all(prepared.map(async (work) => {
             const outcome = await dispatchScheduledWork(input, work, snapshot.schedule.revision);
             if (outcome.status === 'rejected') {
                 notifySupervisor(input.supervisor?.onReconciliationFailure, outcome.failure);
             }
             return outcome;
-        }));
+        })).finally(() => {
+            waveSettled = true;
+            wake.notify();
+        });
+        let controlReadFailure;
+        let controlReadFailureStreak = 0;
+        let retryTimer;
+        let retryDelay = CONTROL_RETRY_INITIAL_DELAY_MS;
+        try {
+            // A driver abort does not end this loop: the wave still owns its
+            // dispatches, and a child parked behind a failed stop settles only
+            // after a retry succeeds.
+            while (!waveSettled) {
+                await wake.wait();
+                clearTimeout(retryTimer);
+                retryTimer = undefined;
+                if (waveSettled)
+                    break;
+                let retry;
+                try {
+                    const latest = await readScheduleSnapshot(input, selectedResultCache);
+                    const controls = await applyScheduleStops(input, latest, resolvedStops);
+                    recordScheduleStops(input, stops, failures, stopFailureStreaks, controls);
+                    if (controlReadFailure) {
+                        failures.splice(failures.indexOf(controlReadFailure), 1);
+                        controlReadFailure = undefined;
+                    }
+                    controlReadFailureStreak = 0;
+                    retry = controls.failures.length > 0;
+                }
+                catch (error) {
+                    if (controlReadFailure)
+                        failures.splice(failures.indexOf(controlReadFailure), 1);
+                    controlReadFailureStreak += 1;
+                    // Like a stop, a read failure notifies on its first occurrence and,
+                    // once, when it has persisted long enough to be stuck.
+                    controlReadFailure =
+                        controlReadFailureStreak < CONTROL_STUCK_FAILURES
+                            ? { phase: 'schedule', error }
+                            : {
+                                phase: 'schedule',
+                                error: new Error(`Reading graph schedule controls is stuck after ${controlReadFailureStreak} consecutive failures and is still retrying`, { cause: error }),
+                            };
+                    failures.push(controlReadFailure);
+                    if (controlReadFailureStreak === 1 ||
+                        controlReadFailureStreak === CONTROL_STUCK_FAILURES) {
+                        notifySupervisor(input.supervisor?.onReconciliationFailure, controlReadFailure);
+                    }
+                    retry = true;
+                }
+                // A failed stop can keep its child, and so this wave, parked until a
+                // retry succeeds. Back off instead of waiting for another commit.
+                if (retry) {
+                    retryTimer = setTimeout(wake.notify, retryDelay);
+                    retryDelay = Math.min(retryDelay * 2, CONTROL_RETRY_MAX_DELAY_MS);
+                }
+                else {
+                    retryDelay = CONTROL_RETRY_INITIAL_DELAY_MS;
+                }
+            }
+        }
+        finally {
+            clearTimeout(retryTimer);
+            // This wave remains the sole owner of all dispatched executions, even
+            // if a control-store read fails while processing a schedule wake.
+            await wave;
+        }
+        const outcomes = await wave;
         let stale = false;
         for (const outcome of outcomes) {
             if (outcome.status === 'stale') {
@@ -259,6 +372,7 @@ async function readScheduleSnapshot(input, selectedResultCache) {
     assertGraphObservation(input.topology.graphId, observation);
     notifySupervisor(input.supervisor?.onObservation, observation);
     const schedule = projectAgentGraphSchedule(input.topology.graphId, updates);
+    notifySupervisor(input.onScheduleObserved, schedule);
     const selectedInputs = schedule.work
         .filter((work) => work.status === 'requested')
         .flatMap((work) => work.selectedResultInputs ?? []);
@@ -359,7 +473,43 @@ async function resolveSelectedResultRecords(input, selectedInputs, cache) {
 function selectedResultKey(selected) {
     return `${selected.sourceGraphId}\u0000${selected.resultId}`;
 }
-async function applyScheduleStops(input, snapshot) {
+function recordScheduleStops(input, stops, failures, streaks, controls) {
+    stops.push(...controls.stops);
+    const resolvedTargets = new Set(controls.stops.map((stop) => stop.targetId));
+    for (const targetId of resolvedTargets)
+        streaks.delete(targetId);
+    for (let index = failures.length - 1; index >= 0; index -= 1) {
+        const failure = failures[index];
+        if (failure.phase === 'stop' && failure.targetId && resolvedTargets.has(failure.targetId)) {
+            failures.splice(index, 1);
+        }
+    }
+    for (const failure of controls.failures) {
+        const targetId = failure.targetId ?? '';
+        const streak = (streaks.get(targetId) ?? 0) + 1;
+        streaks.set(targetId, streak);
+        // The stuck state travels in the message: supervisor notifications are
+        // structured clones and the durable client failure keeps only the reason.
+        const recorded = streak < CONTROL_STUCK_FAILURES
+            ? failure
+            : {
+                ...failure,
+                error: new Error(`Stop for graph target ${targetId} is stuck after ${streak} consecutive failures and is still retrying`, { cause: failure.error }),
+            };
+        // A retried stop that fails again replaces its earlier failure. The
+        // supervisor hears about the first failure and, once, about a stuck stop,
+        // not about every backoff attempt.
+        const previous = failures.findIndex((existing) => existing.phase === 'stop' && existing.targetId === failure.targetId);
+        if (previous >= 0)
+            failures[previous] = recorded;
+        else
+            failures.push(recorded);
+        if (streak === 1 || streak === CONTROL_STUCK_FAILURES) {
+            notifySupervisor(input.supervisor?.onReconciliationFailure, recorded);
+        }
+    }
+}
+async function applyScheduleStops(input, snapshot, resolvedStops) {
     const requests = new Map();
     for (const stopped of snapshot.schedule.stoppedTargets) {
         requests.set(stopped.targetId, stopped.reason);
@@ -375,7 +525,7 @@ async function applyScheduleStops(input, snapshot) {
     const claimsByIntent = new Map(snapshot.claims.map((claim) => [claim.intentId, claim]));
     const activationTargets = graphActivationTargets(snapshot.observation);
     const immediate = [];
-    const targetsBySession = new Map();
+    const targets = [];
     const failures = [];
     for (const [targetId, reason] of requests) {
         const work = workById.get(targetId);
@@ -386,13 +536,26 @@ async function applyScheduleStops(input, snapshot) {
             ? activationTargets.get(claim.targetRunId)
             : activationTargets.get(targetId);
         if (activation && isTerminalActivationStatus(activation.status)) {
-            immediate.push({
-                targetId,
-                reason,
-                status: 'already_terminal',
+            const identity = {
                 sessionId: activation.sessionId,
-                activationId: activation.activationId,
-            });
+                runId: activation.activationId,
+                turnId: activation.turnId,
+            };
+            // A durable terminal does not prove that backend cleanup succeeded.
+            // Retry the exact stop only while a failed stop retains cleanup for this
+            // Run; a settled historical target resolves without a runtime call.
+            if (resolvedStops.has(stopTargetKey(targetId, identity)) ||
+                !input.stopController.hasPendingAgentGraphActivationStop?.(identity)) {
+                immediate.push({
+                    targetId,
+                    reason,
+                    status: 'already_terminal',
+                    sessionId: activation.sessionId,
+                    activationId: activation.activationId,
+                });
+                continue;
+            }
+            targets.push({ targetId, reason, status: 'already_terminal', identity });
             continue;
         }
         if (work && claim) {
@@ -424,36 +587,37 @@ async function applyScheduleStops(input, snapshot) {
         }
         const sessionId = activation?.sessionId ?? claim.targetSessionId;
         const activationId = activation?.activationId ?? claim.targetRunId;
-        const sessionTargets = targetsBySession.get(sessionId) ?? [];
-        sessionTargets.push({
-            targetId,
-            reason,
-            activationId,
-        });
-        targetsBySession.set(sessionId, sessionTargets);
+        const turnId = activation?.turnId ?? claim.targetTurnId;
+        const identity = { sessionId, runId: activationId, turnId };
+        if (resolvedStops.has(stopTargetKey(targetId, identity))) {
+            immediate.push({ targetId, reason, status: 'stopped', sessionId, activationId });
+            continue;
+        }
+        targets.push({ targetId, reason, status: 'stopped', identity });
     }
-    const settled = await Promise.allSettled([...targetsBySession].map(async ([sessionId, targets]) => {
-        await input.stopController.stopSession(sessionId, { source: 'graph_supervisor' });
-        return targets.map((target) => ({
+    const settled = await Promise.allSettled(targets.map(async (target) => {
+        await input.stopController.stopAgentGraphActivation(target.identity, {
+            source: 'graph_supervisor',
+        });
+        return {
             targetId: target.targetId,
             reason: target.reason,
-            status: 'stopped',
-            sessionId,
-            activationId: target.activationId,
-        }));
+            status: target.status,
+            sessionId: target.identity.sessionId,
+            activationId: target.identity.runId,
+        };
     }));
     settled.forEach((result, index) => {
+        const target = targets[index];
         if (result.status === 'fulfilled') {
-            immediate.push(...result.value);
+            resolvedStops.add(stopTargetKey(target.targetId, target.identity));
+            immediate.push(result.value);
             return;
         }
-        const [sessionId, targets] = [...targetsBySession][index];
-        targets.forEach((target) => {
-            failures.push({
-                phase: 'stop',
-                targetId: target.targetId,
-                error: new Error(`Failed to stop graph supervisor target ${target.targetId} in ${sessionId}`, { cause: result.reason }),
-            });
+        failures.push({
+            phase: 'stop',
+            targetId: target.targetId,
+            error: new Error(`Failed to stop graph supervisor target ${target.targetId} in ${target.identity.sessionId}`, { cause: result.reason }),
         });
     });
     return {
@@ -461,6 +625,9 @@ async function applyScheduleStops(input, snapshot) {
         failures,
     };
 }
+function stopTargetKey(targetId, identity) {
+    return [targetId, identity.sessionId, identity.runId, identity.turnId].join('\u0000');
+}
 async function dispatchScheduledWork(input, prepared, expectedRevision) {
     let admission;
     try {
@@ -593,7 +760,7 @@ function scheduledWorkIntent(topology, observation, work, provision) {
         ],
     };
 }
-function scheduledWorkIntentId(graphId, workId) {
+export function scheduledWorkIntentId(graphId, workId) {
     const hash = stableHash({
         schemaVersion: SCHEDULE_INTENT_SCHEMA_VERSION,
         graphId,
@@ -712,15 +879,20 @@ function orderedRequestedWork(schedule) {
 }
 function graphActivationTargets(observation) {
     const targets = new Map();
+    const sourceByActivation = new Map(observation.projection.records.map((record) => [record.activationId, record.source]));
     for (const binding of observation.projection.operators) {
         const state = observation.projection.state.operators[binding.operatorId];
         for (const activation of Object.values(state?.activations ?? {})) {
             if (targets.has(activation.activationId)) {
                 throw new Error(`Graph activation ${activation.activationId} belongs to multiple operators`);
             }
+            const source = sourceByActivation.get(activation.activationId);
+            if (!source)
+                throw new Error(`Graph activation ${activation.activationId} has no source`);
             targets.set(activation.activationId, {
                 sessionId: binding.sessionId,
                 activationId: activation.activationId,
+                turnId: source.turnId,
                 status: activation.status,
             });
         }

package/node_modules/@maka/runtime/dist/tool-availability.js

@@ -106,9 +106,9 @@ export function toolAvailabilityConnectorNames(tools, config) {
 /**
  * Immutable, backend-scoped bound-tool inventory and MiniSearch index.
  *
- * Mutable activation belongs to the per-send TurnScope and is passed to
- * prepare(). Constructing one AiSdkBackend therefore constructs one index; all
- * turns on that backend reuse it without sharing activation state.
+ * Mutable activation is passed into prepare(). One AiSdkBackend constructs one
+ * index; Turns on that backend share the Session activation map so later
+ * Turns keep previously activated schemas.
  */
 export class ToolAvailabilityRuntime {
     invalidTool;
@@ -249,7 +249,11 @@ export class ToolAvailabilityRuntime {
                 diagnostics: () => undefined,
             };
         }
-        const connector = this.buildSearchConnector(activeTools);
+        const requiredNames = [...requiredToolNames].filter((name) => this.toolsByName.has(name));
+        const requiredNameSet = new Set(requiredNames);
+        // Required names are already on the provider list. Omit them from the
+        // search inventory so an exact-name search does not "activate" them again.
+        const connector = this.buildSearchConnector(activeTools, requiredNameSet);
         const allTools = [...this.tools, connector];
         const canonical = canonicalizeToolSet(allTools, this.invalidTool);
         const knownNames = new Set(canonical.providerTools.map((tool) => tool.name));
@@ -260,7 +264,6 @@ export class ToolAvailabilityRuntime {
             if (this.activationKeysByName.get(name) !== activatedKey)
                 activeTools.delete(name);
         }
-        const requiredNames = [...requiredToolNames].filter((name) => knownNames.has(name));
         const step = { active: new Set() };
         const computeActive = () => {
             const names = new Set([...this.directNames, TOOL_SEARCH_NAME]);
@@ -284,12 +287,16 @@ export class ToolAvailabilityRuntime {
             diagnostics: (active, chars) => this.buildDiagnostic(allTools, active, chars),
         };
     }
-    buildSearchConnector(activeTools) {
+    buildSearchConnector(activeTools, requiredToolNames) {
         return {
             name: TOOL_SEARCH_NAME,
-            description: renderInventory(this.groups),
+            description: renderInventory(this.groups, requiredToolNames),
             parameters: z.object({
-                query: z.string().trim().min(1).describe('Search query describing the needed capability.'),
+                query: z
+                    .string()
+                    .trim()
+                    .min(1)
+                    .describe('Search query describing the needed capability. An exact catalog tool name activates only that tool.'),
                 limit: z
                     .number()
                     .int()
@@ -300,11 +307,7 @@ export class ToolAvailabilityRuntime {
             }),
             impl: ({ query, limit = TOOL_SEARCH_DEFAULT_LIMIT }, context) => {
                 const normalizedQuery = query.trim();
-                const ranked = this.searchIndex.search(normalizedQuery)
-                    .map((result) => String(result.id))
-                    .filter((name) => !activeTools.has(name))
-                    .slice(0, TOOL_SEARCH_MAX_LIMIT)
-                    .filter((name) => this.searchableNames.has(name));
+                const ranked = this.rankDeferredSearchHits(normalizedQuery, activeTools, requiredToolNames);
                 const activated = [];
                 let blocked;
                 let schemaChars = 0;
@@ -355,6 +358,38 @@ export class ToolAvailabilityRuntime {
             },
         };
     }
+    /**
+     * Rank deferred tools for one search. An exact catalog name (case-sensitive,
+     * then unique case-insensitive) never expands into MiniSearch neighbors, so
+     * naming one tool cannot invalidate the prompt-cache prefix with up to
+     * `TOOL_SEARCH_DEFAULT_LIMIT` extra schemas.
+     */
+    rankDeferredSearchHits(query, activeTools, requiredToolNames) {
+        const withheld = (name) => activeTools.has(name) || requiredToolNames.has(name);
+        const exactName = this.resolveExactCatalogName(query);
+        if (exactName !== undefined) {
+            return this.searchableNames.has(exactName) && !withheld(exactName) ? [exactName] : [];
+        }
+        return this.searchIndex.search(query)
+            .map((result) => String(result.id))
+            .filter((name) => !withheld(name))
+            .slice(0, TOOL_SEARCH_MAX_LIMIT)
+            .filter((name) => this.searchableNames.has(name));
+    }
+    resolveExactCatalogName(query) {
+        if (this.toolsByName.has(query))
+            return query;
+        const lowered = query.toLowerCase();
+        let match;
+        for (const name of this.toolsByName.keys()) {
+            if (name.toLowerCase() !== lowered)
+                continue;
+            if (match !== undefined)
+                return undefined;
+            match = name;
+        }
+        return match;
+    }
     buildDiagnostic(allTools, active, visibleToolSchemaChars) {
         const activeSet = new Set(active);
         const enabledSourceIds = this.groups
@@ -384,11 +419,13 @@ export class ToolAvailabilityRuntime {
         };
     }
 }
-function renderInventory(groups) {
-    const lines = groups.flatMap((group) => [
-        `${group.id}:`,
-        ...group.toolNames.map((name) => `- ${name}`),
-    ]);
+function renderInventory(groups, omitNames = new Set()) {
+    const lines = groups.flatMap((group) => {
+        const names = group.toolNames.filter((name) => !omitNames.has(name));
+        if (names.length === 0)
+            return [];
+        return [`${group.id}:`, ...names.map((name) => `- ${name}`)];
+    });
     return [
         'Search the deferred tools bound to this run. A successful search activates the',
         'bounded top matches; their complete callable definitions become visible on the',

package/node_modules/@maka/runtime/dist/tool-call-snapshot.js

@@ -0,0 +1,142 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * The call-data boundary for one tool execution: the argument views a call
+ * produces.
+ *
+ * Extracted from `executeTool()` so the ownership of each rule is named
+ * instead of living inline in a thousand-line method. This module owns
+ * *construction only* — admission, dispatch identity, publication timing and
+ * persistence stay in `executeTool()`.
+ */
+import { computerUseModelCallArgs } from '@maka/core/computer-use';
+/** The recursively frozen, cycle-rejecting argument snapshot. */
+export function snapshotToolArgs(value) {
+    return snapshotJsonValue(value, new WeakSet());
+}
+function snapshotJsonValue(value, seen) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (seen.has(value))
+        throw new Error('Tool arguments must not contain cycles');
+    seen.add(value);
+    if (Array.isArray(value)) {
+        return Object.freeze(value.map((entry) => snapshotJsonValue(entry, seen)));
+    }
+    const output = {};
+    for (const key of Object.keys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor || !('value' in descriptor)) {
+            throw new Error(`Tool argument ${key} must be a plain data property`);
+        }
+        output[key] = snapshotJsonValue(descriptor.value, seen);
+    }
+    return Object.freeze(output);
+}
+/**
+ * Validates call arguments against the tool's declared schema, accepting the
+ * schema shapes the runtime already supports (zod `safeParseAsync`/`safeParse`,
+ * a `validate` callable, or a standard-schema `~standard.validate`). A tool
+ * without a usable schema declares nothing and validates nothing.
+ */
+export async function validateDeclaredToolArgs(parameters, args) {
+    if (!parameters || (typeof parameters !== 'object' && typeof parameters !== 'function')) {
+        return;
+    }
+    const schema = parameters;
+    if (typeof schema.safeParseAsync === 'function') {
+        const parsed = await schema.safeParseAsync(args);
+        if (parsed.success)
+            return;
+        throw parsed.error;
+    }
+    if (typeof schema.safeParse === 'function') {
+        const parsed = schema.safeParse(args);
+        if (parsed.success)
+            return;
+        throw parsed.error;
+    }
+    if (typeof schema.validate === 'function') {
+        const parsed = await schema.validate(args);
+        if (parsed.success)
+            return;
+        throw parsed.error;
+    }
+    if (typeof schema['~standard']?.validate === 'function') {
+        const parsed = await schema['~standard'].validate(args);
+        if ('value' in parsed)
+            return;
+        throw new Error('Tool arguments failed declared schema validation', { cause: parsed.issues });
+    }
+}
+/**
+ * The named argument-view construction operation: validation, permission
+ * projection, and the persisted view, in the order and with the guards the
+ * inline region in `executeTool()` established.
+ *
+ * The args written into the `tool_start` event and the durable ledger are the
+ * record of the call the model reads back on its next turn
+ * (`model-history.ts` replays `event.content.args`).
+ *
+ * Computer Use used the host's approval summary there. That projection exists
+ * to decide and display a permission: it renames `window_id` to `windowId`,
+ * adds `approvalClass` and `rememberForTurnAllowed`, and drops every argument
+ * it does not need. On the real ToolRuntime a model that sent
+ * {action:'press_key', app, window_id, observation_id, element_id,
+ * text:'cmd+s'} read back {action, approvalClass, rememberForTurnAllowed,
+ * app, windowId, observationId} — a key the tool rejects, two fields it never
+ * sent, no element, and a press_key with no key. It then went on calling it
+ * that way.
+ *
+ * The permission prompt still reads the permission view, and the approval
+ * scope key is still computed from the raw call, so the projection only
+ * changes what is written down. `computerUseModelCallArgs` keeps the same
+ * privacy rule — screen-derived and user-typed values are reduced to a shape
+ * — and speaks the tool's own argument names.
+ */
+export async function buildToolCallArgs(input) {
+    let permissionArgs = input.executionArgs;
+    let permissionArgsError;
+    if (!input.directOnlyRejected) {
+        try {
+            if (!input.validationDeferred) {
+                await validateDeclaredToolArgs(input.parameters, input.executionArgs);
+            }
+            permissionArgs = input.permissionArgs
+                ? snapshotToolArgs(input.permissionArgs(structuredClone(input.executionArgs), {
+                    sessionId: input.sessionId,
+                    turnId: input.turnId,
+                    toolCallId: input.toolCallId,
+                }))
+                : input.executionArgs;
+        }
+        catch (error) {
+            permissionArgsError = error;
+        }
+    }
+    const persistedArgs = input.categoryHint === 'computer_use'
+        ? snapshotToolArgs(computerUseModelCallArgs(permissionArgs))
+        : permissionArgs;
+    return {
+        executionArgs: input.executionArgs,
+        permissionArgs,
+        permissionArgsError,
+        persistedArgs,
+    };
+}