omk-agent-core 0.99.0 → 1.2.0

package/dist/agent-loop.js

@@ -7,8 +7,10 @@ import { bindToolIdentity } from "./builtin-tool-resource-claims.js";
 import { partitionToolBatchWaves } from "./parallel-tool-batch.js";
 import { pinProviderConfig, requestAssistantResponse } from "./provider-request.js";
 export { getVisionRouteModel, isVisionRouteModel, VISION_ROUTE_MODEL } from "./vision-route.js";
-import { applyConcurrencyCap, scheduleDagLevels, } from "./tool-dag-scheduler.js";
+import { scheduleDagLevelsMemo as scheduleDagLevelsMemoFromModule } from "./tool-dag-memo.js";
+import { applyConcurrencyCap, assignDagDependencies, conflictsWithUnsettledClaim } from "./tool-dag-scheduler.js";
 import { awaitWithAbort, createErrorToolResult, createImmutableJsonSnapshot, createImmutableSnapshot, finalizeExecutedToolCall, parseJsonValue, stampToolResultEnvelope, } from "./tool-execution-boundary.js";
+import { resolveToolClaimsForCall } from "./tool-resource-claims.js";
 import { resolveToolTimeoutMs, runToolCallWithTimeout } from "./tool-timeout.js";
 import { hasUnsettledTimeout } from "./tool-timeout-settlement.js";
 import { createSyntheticToolResult, inspectTranscriptIntegrity, repairTranscriptIntegrity, } from "./tool-transcript-integrity.js";
@@ -536,62 +538,6 @@ async function executeToolCallsInWaves(currentContext, assistantMessage, toolCal
     }
     return { messages, terminate: terminated, stopRun };
 }
-const DAG_SCHEDULE_CACHE_LIMIT = 64;
-/**
- * Canonical key covering every input claim resolution depends on. A custom
- * `resourceKeyResolver` function cannot be fingerprinted, so callers skip the
- * memo entirely when one is configured. Within a run, tool definitions (and
- * their `resourceClaims` closures) are stable, so name/mode/claims-presence
- * fingerprints are sufficient.
- */
-function dagScheduleCacheKey(toolCalls, options) {
-    const policies = [...(options.toolPolicies?.entries() ?? [])].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
-    const registered = (options.registeredTools ?? []).map((tool) => [
-        tool.name,
-        tool.executionMode ?? "",
-        typeof tool.resourceClaims === "function" ? "1" : "0",
-    ]);
-    return JSON.stringify([
-        toolCalls.map((call) => [call.name, call.arguments ?? null]),
-        options.cwd,
-        options.strictExtensionClaims === true,
-        options.maxConcurrency ?? null,
-        policies,
-        registered,
-    ]);
-}
-/**
- * Schedule with a per-run memo. Identical batches (provider retries, stubborn
- * re-emissions) re-resolve path identities and custom claims; the plan is a
- * pure function of the canonical inputs, so replaying it is safe. Returns
- * `null` when the underlying schedule was aborted. Cached levels are handed
- * out as copies because callers append to and reorder them.
- */
-export async function scheduleDagLevelsMemo(toolCalls, options, signal, cache) {
-    if (options.resourceKeyResolver) {
-        const scheduled = await awaitWithAbort(() => scheduleDagLevels(toolCalls, options), signal);
-        return scheduled.kind === "aborted" ? null : scheduled.value;
-    }
-    const key = dagScheduleCacheKey(toolCalls, options);
-    const cached = cache.get(key);
-    if (cached) {
-        cache.delete(key);
-        cache.set(key, cached);
-        return { levels: cached.levels.map((level) => level.slice()), planKey: cached.planKey };
-    }
-    const scheduled = await awaitWithAbort(() => scheduleDagLevels(toolCalls, options), signal);
-    if (scheduled.kind === "aborted") {
-        return null;
-    }
-    if (cache.size >= DAG_SCHEDULE_CACHE_LIMIT) {
-        const oldest = cache.keys().next();
-        if (!oldest.done) {
-            cache.delete(oldest.value);
-        }
-    }
-    cache.set(key, { levels: scheduled.value.levels.map((level) => level.slice()), planKey: scheduled.value.planKey });
-    return scheduled.value;
-}
 /**
  * Schedule planned calls into candidate DAG levels. Immediate plans fail
  * before any tool executes, so they carry no claims and fold into the first
@@ -612,7 +558,7 @@ async function schedulePlannedDagLevels(plans, toolPolicies, boundTools, config,
             immediateSourceIndices.push(sourceIndex);
         }
     });
-    const scheduled = await scheduleDagLevelsMemo(claimableCalls, {
+    const scheduled = await scheduleDagLevelsMemoFromModule(claimableCalls, {
         cwd: config.cwd ?? process.cwd(),
         toolPolicies,
         registeredTools: boundTools,
@@ -621,17 +567,29 @@ async function schedulePlannedDagLevels(plans, toolPolicies, boundTools, config,
         resourceKeyResolver: config.resourceKeyResolver,
     }, signal, dagScheduleCache);
     if (scheduled === null) {
-        return [];
+        return { levels: [], resolutions: new Map(), dependencies: new Map() };
     }
+    const resolutions = new Map();
+    scheduled.entries.forEach((entry, position) => {
+        resolutions.set(schedulableSourceIndices[position], entry.resolution);
+    });
+    // Precedence graph in source-index space. Immediate plans carry no claims and
+    // therefore no predecessors; they already fail before any tool executes.
+    const dependencies = new Map();
+    for (const sourceIndex of immediateSourceIndices)
+        dependencies.set(sourceIndex, []);
+    assignDagDependencies(scheduled.entries).forEach((blockers, position) => {
+        dependencies.set(schedulableSourceIndices[position], blockers.map((blocker) => schedulableSourceIndices[blocker]));
+    });
     const levels = scheduled.levels.map((level) => level.map((position) => schedulableSourceIndices[position]));
     if (immediateSourceIndices.length === 0) {
-        return levels;
+        return { levels, resolutions, dependencies };
     }
     if (levels.length === 0) {
-        return [[...immediateSourceIndices]];
+        return { levels: [[...immediateSourceIndices]], resolutions, dependencies };
     }
     levels[0] = [...levels[0], ...immediateSourceIndices].sort((left, right) => left - right);
-    return levels;
+    return { levels, resolutions, dependencies };
 }
 /**
  * Execute a tool-call batch using the dag-v2 scheduler.
@@ -654,27 +612,25 @@ async function executeToolCallsDagLevels(currentContext, assistantMessage, toolC
         if (mode && !toolPolicies.has(tool.name))
             toolPolicies.set(tool.name, mode);
     }
-    const levels = await schedulePlannedDagLevels(plans, toolPolicies, boundTools, config, signal, dagScheduleCache);
+    const schedule = await schedulePlannedDagLevels(plans, toolPolicies, boundTools, config, signal, dagScheduleCache);
+    const levels = schedule.levels;
+    const batchState = {
+        resolutions: schedule.resolutions,
+        deferred: new Map(),
+        settled: new Set(),
+    };
     const finalizedByIndex = new Array(toolCalls.length).fill(undefined);
     let skippedReason;
     let stoppedByUnsettledTimeout = false;
-    for (const level of levels) {
-        if (signal?.aborted)
-            break;
-        const executedLevel = await runDagLevelCalls(currentContext, assistantMessage, level, toolCalls, plans, toolPolicies, config, signal, emit, dagScheduleCache);
-        for (const outcome of executedLevel.outcomes)
-            finalizedByIndex[outcome.sourceIndex] = outcome.finalized;
-        if (signal?.aborted)
-            break;
-        if (executedLevel.stoppedByUnsettledTimeout) {
-            skippedReason = "Skipped because a preceding DAG tool timed out before its execution promise settled";
-            stoppedByUnsettledTimeout = true;
-            break;
-        }
-        if (shouldTerminateToolBatch(executedLevel.outcomes.map((outcome) => outcome.finalized))) {
-            skippedReason = "Skipped because the preceding DAG level requested termination";
-            break;
-        }
+    const frontier = await runDagFrontier(currentContext, assistantMessage, levels.flat(), schedule.dependencies, toolCalls, plans, toolPolicies, config, signal, emit, batchState);
+    for (const outcome of frontier.outcomes)
+        finalizedByIndex[outcome.sourceIndex] = outcome.finalized;
+    if (frontier.stoppedByUnsettledTimeout) {
+        skippedReason = "Skipped because a preceding DAG tool timed out before its execution promise settled";
+        stoppedByUnsettledTimeout = true;
+    }
+    else if (frontier.terminated) {
+        skippedReason = "Skipped because the preceding DAG level requested termination";
     }
     const messages = [];
     const finalizedCalls = [];
@@ -710,85 +666,236 @@ async function executeToolCallsDagLevels(currentContext, assistantMessage, toolC
         stopRun: stoppedByUnsettledTimeout,
     };
 }
-/** Re-plan final claims for a runnable candidate level from exact post-hook arguments. */
-async function rescheduleRunnableLevels(runnable, toolPolicies, config, signal, dagScheduleCache) {
-    const finalClaimableCalls = runnable.map(({ preparation }) => ({
-        id: preparation.toolCall.id,
-        name: preparation.toolCall.name,
-        arguments: preparation.args,
-    }));
-    const scheduled = await scheduleDagLevelsMemo(finalClaimableCalls, {
+// Re-resolve claims for a prepared call from its exact post-hook arguments.
+// Resolution failures fail closed as an immediate error rather than guessing
+// at a safe scope.
+//
+// The wait is bound to the run's abort signal exactly like the initial
+// scheduling pass (tool-dag-memo): an extension `resourceClaims()` that never
+// settles must not pin a cancelled run. Abandoning the wait does not stop the
+// callback — a plain Promise cannot be killed — but the aborted outcome settles
+// this call before any late value could admit it, and the frontier loop exits
+// on the same signal, so a late fulfilment or rejection lands in a finished
+// batch and admits nothing.
+async function resolveFinalResolution(preparation, toolPolicies, config, signal) {
+    // awaitWithAbort short-circuits an already-aborted signal before invoking the callback.
+    const call = { id: preparation.toolCall.id, name: preparation.toolCall.name, arguments: preparation.args };
+    const options = {
         cwd: config.cwd ?? process.cwd(),
         toolPolicies,
-        registeredTools: runnable.map(({ preparation }) => preparation.tool),
+        registeredTools: [preparation.tool],
         strictExtensionClaims: config.strictExtensionClaims,
-        maxConcurrency: config.maxToolConcurrency,
         resourceKeyResolver: config.resourceKeyResolver,
-    }, signal, dagScheduleCache);
-    return scheduled === null ? null : scheduled.levels;
+    };
+    try {
+        const bounded = await awaitWithAbort(() => resolveToolClaimsForCall(call, options), signal);
+        if (bounded.kind === "aborted" || signal?.aborted)
+            return immediateOutcome("aborted", "Operation aborted");
+        return bounded.value;
+    }
+    catch (error) {
+        return immediateOutcome("failed", error instanceof Error ? error.message : String(error));
+    }
 }
-/** Authorize one candidate DAG level, re-plan final claims, and run its safe sublevels. */
-async function runDagLevelCalls(currentContext, assistantMessage, levelIndices, toolCalls, plans, toolPolicies, config, signal, emit, dagScheduleCache) {
+/** No call in the ready queue is pre-ordered against another, so drift checks see no exempt peers. */
+const NO_READY_PEERS = new Set();
+/**
+ * Execute a planned batch as a dependency ready queue.
+ *
+ * States are `pending -> ready -> running -> settled`. A call is admitted once
+ * every call it actually conflicts with has settled, rather than once its whole
+ * barrier level has, so one slow unrelated call no longer delays independent
+ * work queued behind it.
+ *
+ * Admission — authorize, re-resolve claims from exact post-hook arguments, and
+ * enforce the final-claims contract — runs one call at a time in source order.
+ * That keeps hook ordering and the conflict contract identical to the barrier
+ * executor and leaves the shared batch state free of concurrent mutation; only
+ * tool execution overlaps. Simultaneously-ready calls are admitted by source
+ * index, so admission order stays deterministic even though completion order
+ * is not.
+ *
+ * A call whose post-hook claims newly conflict with an earlier unsettled call
+ * yields its turn and is retried after the next settle, which preserves the
+ * source-order conflict contract without a separate drain pass.
+ */
+async function runDagFrontier(currentContext, assistantMessage, order, dependencies, toolCalls, plans, toolPolicies, config, signal, emit, state) {
     const outcomes = [];
-    const runnable = [];
-    for (const sourceIndex of levelIndices) {
-        const toolCall = toolCalls[sourceIndex];
-        const plan = plans[sourceIndex];
-        const preparation = plan.kind === "immediate"
-            ? plan
-            : await authorizePlannedToolCall(currentContext, assistantMessage, plan, config, signal);
-        if (preparation.kind === "immediate") {
-            outcomes.push({
-                sourceIndex,
-                finalized: {
-                    toolCall,
-                    result: preparation.result,
-                    isError: preparation.isError,
-                    envelope: preparation.envelope,
-                },
-            });
-        }
-        else {
-            runnable.push({ sourceIndex, preparation });
+    const pending = [...order].sort((left, right) => left - right);
+    const running = new Map();
+    // Mirrors applyConcurrencyCap: absent, non-finite, or non-positive is unbounded.
+    const cap = typeof config.maxToolConcurrency === "number" &&
+        Number.isFinite(config.maxToolConcurrency) &&
+        config.maxToolConcurrency > 0
+        ? Math.max(1, Math.floor(config.maxToolConcurrency))
+        : Number.POSITIVE_INFINITY;
+    let stoppedByUnsettledTimeout = false;
+    let terminated = false;
+    // Readiness bookkeeping: each pending call tracks how many of its
+    // predecessors are still unsettled, and each settle decrements only its
+    // successors — the per-settle cost is proportional to the out-degree of the
+    // finished call, not to a full rescan of every pending dependency list.
+    const remainingPredecessors = new Map();
+    const successors = new Map();
+    for (const sourceIndex of pending) {
+        const blockers = dependencies.get(sourceIndex) ?? [];
+        remainingPredecessors.set(sourceIndex, blockers.filter((blocker) => !state.settled.has(blocker)).length);
+        for (const blocker of blockers) {
+            const followers = successors.get(blocker);
+            if (followers)
+                followers.push(sourceIndex);
+            else
+                successors.set(blocker, [sourceIndex]);
         }
-        if (signal?.aborted)
-            return { outcomes, stoppedByUnsettledTimeout: false };
     }
-    // Re-plan final claims from the exact post-hook arguments. Non-plain
-    // payloads stay in the schedule and fail closed into exclusive barriers
-    // inside claim resolution rather than degrading the level to sequential
-    // singletons.
-    const executionLevels = await rescheduleRunnableLevels(runnable, toolPolicies, config, signal, dagScheduleCache);
-    if (executionLevels === null)
-        return { outcomes, stoppedByUnsettledTimeout: false };
-    for (const executionLevel of executionLevels) {
-        if (signal?.aborted)
-            break;
-        for (const entryIndex of executionLevel) {
-            await emitToolExecutionStart(runnable[entryIndex].preparation, emit);
+    const settle = async (outcome) => {
+        outcomes.push(outcome);
+        state.settled.add(outcome.sourceIndex);
+        for (const follower of successors.get(outcome.sourceIndex) ?? []) {
+            const remaining = (remainingPredecessors.get(follower) ?? 0) - 1;
+            remainingPredecessors.set(follower, Math.max(0, remaining));
         }
-        const finalizedLevel = await Promise.all(executionLevel.map(async (entryIndex) => {
-            const entry = runnable[entryIndex];
-            const executed = await executePreparedToolCall(entry.preparation, config, signal, emit);
-            const finalized = await finalizeExecutedToolCall({
-                currentContext,
-                assistantMessage,
-                prepared: entry.preparation,
-                executed,
-                afterToolCall: config.afterToolCall,
-                signal,
-            });
-            await emitToolExecutionEnd(finalized, emit);
-            return { sourceIndex: entry.sourceIndex, finalized };
-        }));
-        outcomes.push(...finalizedLevel);
-        if (signal?.aborted)
-            break;
-        if (await hasUnsettledTimeout(finalizedLevel.map(({ finalized }) => finalized))) {
-            return { outcomes, stoppedByUnsettledTimeout: true };
+        if (await hasUnsettledTimeout([outcome.finalized]))
+            stoppedByUnsettledTimeout = true;
+    };
+    try {
+        while (!signal?.aborted && !stoppedByUnsettledTimeout && !terminated) {
+            // Termination is a property of a settled group, not of one call:
+            // shouldTerminateToolBatch requires every member to terminate. Evaluating it
+            // only when nothing is in flight keeps the barrier executor's semantics,
+            // where a call sharing a level with a non-terminating peer did not end the
+            // batch. Judging a single outcome would terminate on the first terminating
+            // call and strand its concurrent peers.
+            if (running.size === 0 && shouldTerminateToolBatch(outcomes.map((outcome) => outcome.finalized))) {
+                terminated = true;
+                break;
+            }
+            let admitted = false;
+            for (let position = 0; position < pending.length && running.size < cap;) {
+                if (signal?.aborted || stoppedByUnsettledTimeout)
+                    break;
+                const sourceIndex = pending[position];
+                if ((remainingPredecessors.get(sourceIndex) ?? 0) > 0) {
+                    position++;
+                    continue;
+                }
+                const cached = state.deferred.get(sourceIndex);
+                let preparation;
+                let resolved;
+                if (cached) {
+                    preparation = cached.preparation;
+                    resolved = cached.resolution;
+                }
+                else {
+                    const plan = plans[sourceIndex];
+                    const preparedOutcome = plan.kind === "immediate"
+                        ? plan
+                        : await authorizePlannedToolCall(currentContext, assistantMessage, plan, config, signal);
+                    if (preparedOutcome.kind === "immediate") {
+                        pending.splice(position, 1);
+                        admitted = true;
+                        await settle({
+                            sourceIndex,
+                            finalized: {
+                                toolCall: toolCalls[sourceIndex],
+                                result: preparedOutcome.result,
+                                isError: preparedOutcome.isError,
+                                envelope: preparedOutcome.envelope,
+                            },
+                        });
+                        continue;
+                    }
+                    preparation = preparedOutcome;
+                    const resolution = await resolveFinalResolution(preparation, toolPolicies, config, signal);
+                    if (resolution.kind === "immediate") {
+                        pending.splice(position, 1);
+                        admitted = true;
+                        await settle({
+                            sourceIndex,
+                            finalized: {
+                                toolCall: preparation.toolCall,
+                                result: resolution.result,
+                                isError: resolution.isError,
+                                envelope: resolution.envelope,
+                            },
+                        });
+                        continue;
+                    }
+                    resolved = resolution;
+                }
+                state.resolutions.set(sourceIndex, resolved);
+                if (conflictsWithUnsettledClaim(sourceIndex, resolved, NO_READY_PEERS, state.settled, new Set(running.keys()), state.resolutions)) {
+                    // Defer without losing the prepared call: a later scan retries
+                    // admission from this cache instead of re-invoking authorization.
+                    if (!cached)
+                        state.deferred.set(sourceIndex, { preparation, resolution: resolved });
+                    position++;
+                    continue;
+                }
+                state.deferred.delete(sourceIndex);
+                pending.splice(position, 1);
+                admitted = true;
+                await emitToolExecutionStart(preparation, emit);
+                running.set(sourceIndex, (async () => {
+                    const executed = await executePreparedToolCall(preparation, config, signal, emit);
+                    const finalized = await finalizeExecutedToolCall({
+                        currentContext,
+                        assistantMessage,
+                        prepared: preparation,
+                        executed,
+                        afterToolCall: config.afterToolCall,
+                        signal,
+                    });
+                    await emitToolExecutionEnd(finalized, emit);
+                    return { sourceIndex, finalized };
+                })());
+            }
+            if (running.size === 0) {
+                // Nothing is in flight: either every call settled, or the remainder is
+                // blocked with nothing left that could unblock it. A pending call that
+                // can never become ready still gets an explicit terminal outcome rather
+                // than vanishing from the batch.
+                if (!admitted) {
+                    for (const sourceIndex of pending.splice(0)) {
+                        await settle({
+                            sourceIndex,
+                            finalized: {
+                                toolCall: toolCalls[sourceIndex],
+                                result: createErrorToolResult("DAG dependency deadlock: call could not become ready and nothing is running to unblock it"),
+                                isError: true,
+                                envelope: createToolResultEnvelope({
+                                    disposition: "failed",
+                                    synthetic: true,
+                                    executionStarted: false,
+                                    reason: "DAG dependency deadlock",
+                                }),
+                            },
+                        });
+                    }
+                    break;
+                }
+                continue;
+            }
+            const finished = await Promise.race([...running.values()]);
+            running.delete(finished.sourceIndex);
+            await settle(finished);
+        }
+    }
+    finally {
+        // Join work already in flight: cancellation, termination, and propagation
+        // of preparation/event errors all preserve ownership of started
+        // executions rather than abandoning them mid-flight.
+        while (running.size > 0) {
+            const entries = [...running.entries()];
+            const drained = await Promise.allSettled(entries.map(([, task]) => task));
+            for (const [index, drainedResult] of drained.entries()) {
+                running.delete(entries[index][0]);
+                if (drainedResult.status === "fulfilled")
+                    await settle(drainedResult.value);
+            }
         }
     }
-    return { outcomes, stoppedByUnsettledTimeout: false };
+    return { outcomes, stoppedByUnsettledTimeout, terminated };
 }
 async function executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit) {
     const finalizedCalls = [];