@tangle-network/agent-runtime 0.217.2 → 0.218.1

package/dist/{supervise-Bl5eBJhb.js → supervise-DV0dlkir.js}

@@ -1,11 +1,11 @@
-import { $ as createExecutor, $r as inheritRuntimeOwnedExecutorAttestation, A as scopeRetainedOwnerPriorSpend, An as zeroSpend, Ar as assertProfileMaterialization, Br as renderUnsupported, Ct as spendFromUsageEvents, D as consumeScopeRetainedOwnerResult, Fr as promptControlProfileMaterialization, Gt as bridgeModelRouteRefusal, Hr as unsupportedProfileDimensions, Ir as promptModelProfileMaterialization, J as teardownExecutor, Ln as registerRetainedExecutorPreparation, Mn as resourceTelemetry, Mr as defineProfileMaterializationContract, Nn as withBudgetResources, Nr as fullProfileMaterialization, Nt as createInbox, O as prepareScopeRetainedOwnerTask, Pr as profileMaterializationAxes$1, Rn as retainedExecutorSeamKey, Wr as worktreeCliProfileMaterialization, Wt as bridgeAdmissionRefusal, X as captureReusableExecutorConfig, Xr as attestRuntimeOwnedScopeOwner, Xt as bridgeRuntimeAttachmentsKey, Y as bindReusableExecutorExecutionId, Zt as bridgeStopSignalKey, _ as recordScopeOwnerMaterialization, _n as addSpend, ai as runtimeOwnedDriveHarnessProviderEvidence, ar as createOtelExporter, bt as contentAddress, c as driverChild, ci as runtimeOwnedExecutorProviderEvidence, cn as routerBrain, cr as generateSpanId, f as beginScopeOwnerAttempt, fr as toOtelAttributes, g as meterRuntimeOwnedProviderAttempt, gi as detachedSnapshot, h as meterRuntimeOwnedAccounting, hn as resolveAgentEnvironmentProvider, ii as recordRuntimeOwnedDriveHarnessProviderEvidence, j as scopeRetainedOwnerResult, jn as addResourceSpend, jr as controlProfileMaterialization, k as scopeRetainedOwnerContext, kn as unmeteredSpend, l as driverExecutorFactory, li as runtimeOwnedPendingExecutorMaterialization, m as deriveNodeExecutionIdentity, n as createSupervisor, o as runFinalizer, oi as runtimeOwnedExecutorExecutionBinding, q as DEFAULT_SUCCESSFUL_SHUTDOWN_MS, r as bestDelivered, ri as providerAttemptEvidence, s as runTree, si as runtimeOwnedExecutorMaterialization, t as createRootHandle, tt as snapshotExecutorConfig, u as isDriverSpec, ui as runtimeOwnedScopeOwnerRuntime, v as restoreScopeOwnerAcceptedExecution, wt as WORKER_TRACE_PROPAGATION, xt as assertValidBudget, y as scopeOwnerExecutorNodeContext, zn as RunCancellationReason } from "./supervisor-CvF_KeLc.js";
+import { $ as createExecutor, A as scopeRetainedOwnerPriorSpend, An as withTimeout, Bn as RunCancellationReason, Ct as spendFromUsageEvents, D as consumeScopeRetainedOwnerResult, Fr as profileMaterializationAxes$1, Gr as worktreeCliProfileMaterialization, Gt as bridgeModelRouteRefusal, Ir as promptControlProfileMaterialization, J as teardownExecutor, Lr as promptModelProfileMaterialization, Mn as addResourceSpend, Mr as controlProfileMaterialization, Nn as resourceTelemetry, Nr as defineProfileMaterializationContract, Nt as createInbox, O as prepareScopeRetainedOwnerTask, Pn as withBudgetResources, Pr as fullProfileMaterialization, Rn as registerRetainedExecutorPreparation, Ur as unsupportedProfileDimensions, Vr as renderUnsupported, Wt as bridgeAdmissionRefusal, X as captureReusableExecutorConfig, Xt as bridgeRuntimeAttachmentsKey, Y as bindReusableExecutorExecutionId, Zr as attestRuntimeOwnedScopeOwner, Zt as bridgeStopSignalKey, _ as recordScopeOwnerMaterialization, _i as detachedSnapshot, _n as addSpend, ai as recordRuntimeOwnedDriveHarnessProviderEvidence, bt as contentAddress, c as driverChild, ci as runtimeOwnedExecutorMaterialization, cn as routerBrain, di as runtimeOwnedScopeOwnerRuntime, ei as inheritRuntimeOwnedExecutorAttestation, f as beginScopeOwnerAttempt, g as meterRuntimeOwnedProviderAttempt, h as meterRuntimeOwnedAccounting, hn as resolveAgentEnvironmentProvider, ii as providerAttemptEvidence, j as scopeRetainedOwnerResult, jn as zeroSpend, jr as assertProfileMaterialization, k as scopeRetainedOwnerContext, kn as unmeteredSpend, l as driverExecutorFactory, li as runtimeOwnedExecutorProviderEvidence, lr as generateSpanId, m as deriveNodeExecutionIdentity, n as createSupervisor, o as runFinalizer, oi as runtimeOwnedDriveHarnessProviderEvidence, or as createOtelExporter, pr as toOtelAttributes, q as DEFAULT_SUCCESSFUL_SHUTDOWN_MS, r as bestDelivered, s as runTree, si as runtimeOwnedExecutorExecutionBinding, t as createRootHandle, tt as snapshotExecutorConfig, u as isDriverSpec, ui as runtimeOwnedPendingExecutorMaterialization, v as restoreScopeOwnerAcceptedExecution, wt as WORKER_TRACE_PROPAGATION, xt as assertValidBudget, y as scopeOwnerExecutorNodeContext, zn as retainedExecutorSeamKey } from "./supervisor-DELeLQRJ.js";
 import { f as RuntimeRunStateError, i as ConfigError, m as ValidationError, r as BackendTransportError, t as AgentEvalError } from "./errors-DodWX-cb.js";
 import { a as concreteProfileModel, c as profileModelExecutionSettings, d as agentHarness, f as harnessRunsAgent, n as assertModelAllowed, o as enforceTokenLimits, r as assertProfileModelsAllowed, s as profileBridgeWireModel, t as assertExecutableAgentProfile } from "./model-policy-DKDyr-fc.js";
 import { t as composeRuntimeHooks } from "./runtime-hooks-tXpAarhW.js";
 import { k as writeRunCancellation, o as readRunCancelRequest, s as readRunCancellation } from "./run-layout-hZREkcfu.js";
-import { C as createCoordinationTools, F as watchRunCancellation, M as createInMemoryRunContext, P as applyRunCancellation, S as coordinationVerbNames, c as createProgressTracker, d as progressStop, j as createFileRunContext, r as driverAgent } from "./coordination-driver-yaK8G6xJ.js";
+import { C as createCoordinationTools, F as watchRunCancellation, M as createInMemoryRunContext, P as applyRunCancellation, S as coordinationVerbNames, c as createProgressTracker, d as progressStop, j as createFileRunContext, r as driverAgent, y as DEFAULT_AWAIT_EVENT_TIMEOUT_MS } from "./coordination-driver-rlM6lqtZ.js";
 import { t as createStdioToolServer } from "./tool-server-BJbCPhoW.js";
-import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
+import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, canonicalCandidateJson, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
 import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { resolve } from "node:path";
 import { isMaterializerHarness } from "@tangle-network/agent-profile-materialize";
@@ -577,7 +577,7 @@ function coordinationHttpHandler(input) {
 			requests = 0;
 			controlRequests = 0;
 		}
-		controlAdmission = active >= limits.maxConcurrentRequests || requests >= limits.requestsPerMinute;
+		controlAdmission = active + input.backgroundActions() >= limits.maxConcurrentRequests || requests >= limits.requestsPerMinute;
 		if (controlAdmission) {
 			if (controlActive >= 2 || controlRequests >= 60) {
 				reject(429);
@@ -656,6 +656,106 @@ function coordinationHttpHandler(input) {
 	};
 }
 //#endregion
+//#region src/runtime/supervise/single-flight-tools.ts
+/**
+* Serve method-supplied supervisor tools on the coordination MCP as single-flight, fenced calls.
+*
+* A method tool can run for hours: a literature graph spawns and joins its own children inside one
+* call. The coordination transport answers 504 at `requestTimeoutMs`, so an unwrapped long call
+* reaches the caller as a hard tool error while its handler keeps running. A caller that retries
+* starts a second full run. Run mech-interp-foundations-glm2-20260911d spawned the same enumerate
+* and extract children twice this way.
+*
+* Two rules close that failure:
+* - Identity. A call joins an existing invocation when its tool name and its RFC 8785 canonical
+*   arguments match, and that invocation has not yet returned its outcome to a caller. The handler
+*   is not invoked again. Key order does not matter: the observed retry reordered every key.
+* - Fence. A call waits at most `fenceMs` for the outcome. If the handler is still running, the call
+*   returns a non-error pending result. A later identical call keeps waiting, then returns the value
+*   or throws the handler's error once the handler settles.
+*
+* An invocation's identity ends when a call returns its outcome. The next identical call is a fresh
+* run, because equal arguments do not make a call a replay. Code mode's `execute` and Knowledge's
+* `knowledge_search` read live state, so their callers repeat identical arguments to get a current
+* answer. A handler that finishes within the fence therefore behaves exactly as it did unwrapped.
+* No escape hatch is needed: the only calls this absorbs are ones whose caller could not have seen
+* the outcome.
+*/
+function singleFlightTools(tools, options) {
+	const { fenceMs } = options;
+	if (!Number.isSafeInteger(fenceMs) || fenceMs <= 0) throw new ValidationError("singleFlightTools: fenceMs must be a positive safe integer");
+	const now = options.now ?? Date.now;
+	const invocations = /* @__PURE__ */ new Map();
+	const start = (tool, raw) => {
+		const invocation = {
+			startedAt: now(),
+			settled: (async () => tool.handler(raw))().then((value) => {
+				invocation.outcome = {
+					ok: true,
+					value
+				};
+				return invocation.outcome;
+			}, (error) => {
+				invocation.outcome = {
+					ok: false,
+					error
+				};
+				return invocation.outcome;
+			}),
+			outcome: void 0,
+			waiting: 0
+		};
+		return invocation;
+	};
+	const wrap = (tool) => Object.freeze({
+		...tool,
+		handler: async (raw) => {
+			const key = invocationKey(tool.name, raw);
+			let invocation = invocations.get(key);
+			if (invocation === void 0) {
+				invocation = start(tool, raw);
+				invocations.set(key, invocation);
+			}
+			if (invocation.outcome === void 0) {
+				invocation.waiting++;
+				try {
+					await withTimeout(invocation.settled, fenceMs);
+				} finally {
+					invocation.waiting--;
+				}
+			}
+			const outcome = invocation.outcome;
+			if (outcome === void 0) return pendingToolCall(tool.name, now() - invocation.startedAt);
+			if (invocations.get(key) === invocation) invocations.delete(key);
+			if (outcome.ok) return outcome.value;
+			throw outcome.error;
+		}
+	});
+	return {
+		tools: Object.freeze(tools.map(wrap)),
+		background() {
+			let count = 0;
+			for (const invocation of invocations.values()) if (invocation.outcome === void 0 && invocation.waiting === 0) count++;
+			return count;
+		}
+	};
+}
+function invocationKey(name, raw) {
+	try {
+		return canonicalCandidateJson([name, raw]);
+	} catch (error) {
+		throw new ValidationError(`${name}: arguments must be finite JSON so a repeated call can join its earlier run`, { cause: error });
+	}
+}
+function pendingToolCall(tool, elapsedMs) {
+	return {
+		pending: true,
+		tool,
+		elapsedMs,
+		instruction: `${tool} is still running; nothing failed. Call ${tool} again with the same arguments to keep waiting. That call joins this run and returns its result, or its error, once it finishes. Different arguments start a separate run.`
+	};
+}
+//#endregion
 //#region src/runtime/supervise/coordination-mcp.ts
 /**
 *
@@ -700,10 +800,25 @@ function assertCoordinationTransport(options) {
 	}
 	coordinationHttpLimits(options);
 }
+/**
+* The longest one coordination call holds its HTTP response before it answers with a re-pollable
+* pending result instead: `await_event` by default, and every method-supplied node tool always.
+*
+* It is half of `requestTimeoutMs`, so the answer leaves before the transport's own 504 at
+* `requestTimeoutMs`, with the other half left for body transfer, admission, and serialization.
+* Deriving it here means a configured request timeout moves both fences with it. It is capped at
+* {@link DEFAULT_AWAIT_EVENT_TIMEOUT_MS} so a long request timeout does not lengthen each wait; at
+* the default 30 s request timeout both values are 15 s.
+*/
+function coordinationResponseFenceMs(requestTimeoutMs) {
+	return Math.max(1, Math.min(DEFAULT_AWAIT_EVENT_TIMEOUT_MS, Math.floor(requestTimeoutMs / 2)));
+}
 /** Stand up the existing coordination tools with bounded HTTP access over one live scope. */
 async function serveCoordinationMcp(opts) {
 	const host = opts.host ?? "127.0.0.1";
 	assertCoordinationTransport(opts);
+	const requestTimeoutMs = coordinationHttpLimits(opts).requestTimeoutMs;
+	const responseFenceMs = coordinationResponseFenceMs(requestTimeoutMs);
 	if (opts.peerMail && (!isLoopbackHost(host) || opts.publicUrl)) throw new ConfigError("remote peer mail requires a separate reachable capability transport; coordination authentication does not authorize the peer listener");
 	const identity = Object.freeze({ ...opts.identity ?? {
 		runId: opts.scope.view?.root ?? "",
@@ -773,7 +888,7 @@ async function serveCoordinationMcp(opts) {
 		...opts.deliverable ? { deliverable: opts.deliverable } : {},
 		...opts.onStop ? { onStop: opts.onStop } : {},
 		...opts.maxLiveWorkers !== void 0 ? { maxLiveWorkers: opts.maxLiveWorkers } : {},
-		awaitTimeoutMs: opts.awaitTimeoutMs ?? 15e3,
+		awaitTimeoutMs: opts.awaitTimeoutMs ?? responseFenceMs,
 		...opts.analysts ? { analysts: opts.analysts } : {},
 		...opts.analyzeOnSettle ? { analyzeOnSettle: opts.analyzeOnSettle } : {},
 		...opts.watchWorkers ? { watchWorkers: opts.watchWorkers } : {},
@@ -797,7 +912,8 @@ async function serveCoordinationMcp(opts) {
 		if (reservedNames.has(tool.name)) throw new ValidationError(`serveCoordinationMcp: node tool ${JSON.stringify(tool.name)} shadows a coordination verb or another node tool`);
 		reservedNames.add(tool.name);
 	}
-	const availableTools = [...coord.tools, ...opts.nodeTools ?? []];
+	const nodeTools = singleFlightTools(opts.nodeTools ?? [], { fenceMs: responseFenceMs });
+	const availableTools = [...coord.tools, ...nodeTools.tools];
 	const availableByName = new Map(availableTools.map((tool) => [tool.name, tool]));
 	if (!Array.isArray(opts.toolNames)) throw new ValidationError("serveCoordinationMcp: toolNames must name every granted tool explicitly");
 	const selectedNames = opts.toolNames;
@@ -818,6 +934,7 @@ async function serveCoordinationMcp(opts) {
 		identity,
 		toolNames: new Set(servedTools.map((tool) => tool.name)),
 		handle: (message) => mcp.handle(message),
+		backgroundActions: nodeTools.background,
 		authorize: (req) => {
 			if (!paths.has(req.url ?? "")) return 404;
 			if (!audiences.has(req.headers.host ?? "")) return 403;
@@ -828,7 +945,6 @@ async function serveCoordinationMcp(opts) {
 			if (!validCredential(supplied)) return 401;
 		}
 	}));
-	const requestTimeoutMs = coordinationHttpLimits(opts).requestTimeoutMs;
 	server.requestTimeout = requestTimeoutMs;
 	server.headersTimeout = requestTimeoutMs;
 	const port = await new Promise((resolve, reject) => {
@@ -3539,4 +3655,4 @@ function rootProviderModelEvidenceFromExecution(evidence) {
 //#endregion
 export { serveCoordinationMcp as _, isPreSpawnExecutorFailure as a, mapExecutorResult as b, withWorkerSpawnRetry as c, resolveSupervisorProfile as d, supervisorAgent as f, defaultUnmetContractSteer as g, classifyDriverFailure as h, workerFromBackend as i, assertCoordinationBinding as l, DriverAttemptsExhaustedError as m, supervise as n, resolveWorkerSpawnRetry as o, supervisorAgentWithTestBrain as p, superviseWithTestBrain as r, retryPreSpawnRefusals as s, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as t, coordinationProfileToolPrefix as u, createSupervisorSpanRecorder as v, gateOnDeliverable as y };
 
-//# sourceMappingURL=supervise-Bl5eBJhb.js.map
+//# sourceMappingURL=supervise-DV0dlkir.js.map