@tangle-network/agent-runtime 0.134.3 → 0.134.5

package/dist/{supervisor-BsniJxSa.js → supervisor-lbWTSscK.js}

@@ -4164,6 +4164,28 @@ function createSandboxLineage(client, capabilities, options = {}) {
 		async fork(parent, prompts, specs, signal) {
 			if (prompts.length === 0) throw new ValidationError("SandboxLineage.fork: prompts must be non-empty");
 			if (signal.aborted) throwAbort();
+			const branched = await branchParent(parent.box, prompts.length, forkConcurrency, signal);
+			if (branched !== void 0) {
+				owned.push(...branched);
+				if (branched.length !== prompts.length) throw new ValidationError(`SandboxLineage.fork: Sandbox returned ${branched.length} of ${prompts.length} requested children`);
+				return mapWithConcurrency(branched, forkConcurrency, async (box, i) => {
+					throwIfAborted(signal);
+					const spec = specs[i % specs.length];
+					if (!spec) throw new ValidationError("SandboxLineage.fork: no AgentRunSpec for branch");
+					await spec.prepareBox?.(box, {
+						signal,
+						recordMount
+					});
+					const sessionId = mintSessionId();
+					return {
+						handle: {
+							box,
+							sessionId
+						},
+						events: promptEvents(streaming, box, prompts[i], sessionId, signal)
+					};
+				});
+			}
 			const checkpointId = capabilities.canFork ? await checkpointForFork(parent.box, signal) : void 0;
 			return mapWithConcurrency(prompts, forkConcurrency, async (prompt, i) => {
 				throwIfAborted(signal);
@@ -4218,10 +4240,28 @@ function mintSessionId() {
 	return `loop-sess-${randomUuid()}`;
 }
 /**
+* Branch a running parent through the current Sandbox SDK, in bounded waves.
+* `undefined` means the box exposes only the legacy checkpoint API (or no
+* branching API), so the caller may try the legacy capability-gated path.
+*/
+async function branchParent(box, count, concurrency, signal) {
+	const branch = box.branch;
+	if (typeof branch !== "function") return void 0;
+	const children = [];
+	for (let offset = 0; offset < count; offset += concurrency) {
+		throwIfAborted(signal);
+		const requested = Math.min(concurrency, count - offset);
+		const batch = await branch.call(box, requested);
+		children.push(...batch);
+		if (batch.length !== requested) return children;
+	}
+	return children;
+}
+/**
 * Checkpoint the parent leaving it running, returning the checkpoint id to fork
-* from, or `undefined` when the box exposes no `checkpoint` (the loop's fakes)
-* or the call produced no id. `undefined` makes the caller degrade to fresh
-* boxes — a fork that can't checkpoint must not pretend to share context.
+* from, or `undefined` when the box exposes no legacy `checkpoint` method or
+* the call produced no id. `undefined` makes the caller use fresh boxes — a
+* fork that cannot preserve context must not pretend to share it.
 */
 async function checkpointForFork(box, signal) {
 	const checkpoint = box.checkpoint;
@@ -4235,10 +4275,9 @@ async function checkpointForFork(box, signal) {
 * platform advertised `canFork`; a missing `fork` here is a contract violation
 * (probe said yes, box says no) and fails loud rather than silently degrading.
 *
-* `signal` gates entry only: the SDK's `fork(checkpointId, options)` takes no
-* abort signal (`ForkOptions` is name/env/resources/metadata), so an in-flight
-* fork cannot be interrupted. The caller (`fork`) checks abort per branch, so
-* cancellation is responsive at branch boundaries, not mid-fork.
+* `signal` gates entry only: the legacy SDK's `fork(checkpointId, options)`
+* takes no abort signal, so an in-flight fork cannot be interrupted. The
+* caller checks abort per branch, so cancellation is responsive at boundaries.
 */
 async function forkFromCheckpoint(box, checkpointId, signal) {
 	const fork = box.fork;
@@ -4460,8 +4499,8 @@ async function runAgentRounds(options) {
 	}
 }
 /**
-* Build the lineage when either lineage flag is set. Probes the platform's fork
-* capability once per run (the lineage degrades gracefully when it's absent).
+* Build the lineage when either lineage flag is set. Probes the legacy fork
+* capability once per run (live branching is detected on each box).
 * Rejects the lineage + `onWorkerBox` combination: both claim the same
 * box-ownership channel, and silently honoring one would leak or double-free.
 */
@@ -4485,9 +4524,9 @@ async function setUpLineage(options, maxConcurrency, recordMount) {
 * Decide, for one round, how each iteration acquires its sandbox stream:
 *   - refine (1 task) + `sessionContinuity` + a live parent handle ⇒ continue
 *     the parent session on its box.
-*   - fanout (N tasks) + `forkFanout` + a live parent handle ⇒ fork the parent
-*     checkpoint once and stream each branch from a child box (degrades to fresh
-*     boxes inside the lineage when the platform can't fork).
+*   - fanout (N tasks) + `forkFanout` + a live parent handle ⇒ branch the parent
+*     box once and stream each branch from a child box (legacy CRIU or fresh-box
+*     fallback is handled inside the lineage).
 *   - otherwise (round 0, no parent, the off flag) ⇒ start a fresh box per
 *     iteration THROUGH the lineage so it's owned + a handle is recorded for a
 *     later round to descend from.
@@ -5988,6 +6027,15 @@ function linkSignals$1(a, b) {
 *
 * @experimental
 */
+/**
+* Materialization contract for one direct Router turn.
+*
+* `resourceFailOnError` is carried: this executor has no workspace, so it inlines resource content
+* into the system prompt and applies the profile's own resource-failure policy while it does so
+* (`renderRouterProfilePrompt`). No value of the field is dropped — a strict profile fails closed
+* on a resource that cannot be inlined, and a best-effort profile is refused because this path has
+* no way to report a skipped resource.
+*/
 const routerTurnProfileMaterialization = defineProfileMaterializationContract({
 	name: "router-profile-turn",
 	axes: [
@@ -6009,6 +6057,7 @@ const routerTurnProfileMaterialization = defineProfileMaterializationContract({
 		"resourceAgents",
 		"commands",
 		"resourceInstructions",
+		"resourceFailOnError",
 		"metadata"
 	]
 });
@@ -7660,7 +7709,10 @@ async function* streamDurableBridgeRun(args) {
 			continue;
 		}
 		if (sawDone) {
-			if (args.run.profileMaterialization === void 0) throw new BackendTransportError("bridge", `bridgeExecutor: run ${args.run.id} completed without ${bridgeProfileMaterializationSchema}`);
+			if (args.run.profileMaterialization === void 0) {
+				if (pendingUpstreamError) throw pendingUpstreamError;
+				throw new BackendTransportError("bridge", `bridgeExecutor: run ${args.run.id} completed without ${bridgeProfileMaterializationSchema}`);
+			}
 			args.run.terminal = true;
 			if (pendingUpstreamError) throw pendingUpstreamError;
 			return;
@@ -8915,10 +8967,19 @@ function exactRouterModel(profile, context) {
 	if (agentHarness(profile.harness) !== void 0) throw new ValidationError(`${context}: AgentProfile.harness ${JSON.stringify(profile.harness)} conflicts with direct Router execution; use "cli-base"`);
 	return concreteProfileModel(profile);
 }
+/**
+* Render the profile prompt plus every resource this executor can inline.
+*
+* The profile's `resources.failOnError` policy decides what happens to a resource that cannot be
+* inlined. Strict (`true` or absent) is the canonical default and fails closed. Best-effort
+* (`false`) asks for the supported subset plus a warning about the rest; this executor has no
+* channel to carry that warning, so it refuses the value instead of silently running strict.
+*/
 function renderRouterProfilePrompt(profile) {
 	const sections = [profile.prompt?.systemPrompt, ...profile.prompt?.instructions ?? []].filter((value) => typeof value === "string" && value.trim().length > 0);
 	const resources = profile.resources;
 	if (!resources) return sections.join("\n");
+	if (resources.failOnError === false) throw new ValidationError("routerInlineExecutor: resources.failOnError: false requests a best-effort resource subset; the direct Router executor always fails closed on a resource it cannot inline and reports no skipped resource, so the best-effort policy is refused rather than applied as strict");
 	if (typeof resources.instructions === "string") {
 		if (resources.instructions.trim()) sections.push(resources.instructions);
 	} else if (resources.instructions) sections.push(renderRouterResource("instructions", resources.instructions));
@@ -12524,4 +12585,4 @@ function isNonEmptySpend(s) {
 //#endregion
 export { createInbox as $, renderProfileMaterializationIssues as $t, createBudgetPool as A, sanitizeKnowledgeReadinessReport as At, WORKER_TRACE_PROPAGATION as B, localHarnessExecutable as Bt, effectiveConcurrency as C, loopEventToOtelSpan as Ct, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as D, createRuntimeEventCollector as Dt, rollingDispatch as E, toOtelAttributes as Et, cliWorktreeExecutor as F, createWorktree as Ft, DEFAULT_SANDBOX_STEERING_MAX_TURNS as G, controlProfileMaterialization as Gt, workerTraceEnv as H, CodexExecutionDiagnosticError as Ht, createExecutor as I, removeWorktree as It, decodeToolPart as J, profileMaterializationAxes$1 as Jt, createSteerableSandboxSession as K, defineProfileMaterializationContract as Kt, createExecutorRegistry as L, DEFAULT_LOCAL_HARNESS as Lt, bindReusableExecutorExecutionId as M, runSettledCommand as Mt, bridgeStopSignalKey as N, runWorktreeHarness as Nt, teardownExecutor as O, createRuntimeStreamEventCollector as Ot, captureReusableExecutorConfig as P, captureWorktreeDiff as Pt, readWorkerProgress as Q, promptResourceProfileMaterialization as Qt, snapshotExecutorConfig as R, LOCAL_HARNESSES as Rt, waitUntil as S, generateSpanId as St, queueOf as T, padTraceId as Tt, workerTraceHeaders as U, AGENT_PROFILE_MATERIALIZATION_AXES as Ut, readWorkerTraceContext as V, parseCodexTokenUsage as Vt, workerTraceSeamKey as W, assertProfileMaterialization as Wt, DEFAULT_STALL_AFTER_MS as X, promptModelProfileMaterialization as Xt, sandboxSessionTraceSource as Y, promptControlProfileMaterialization as Yt, createActivityLog as Z, promptOnlyProfileMaterialization as Zt, createWaitProbes as _, buildRuntimeEventOtelSpans as _t, pickBestDelivered as a, acquireSandbox as at, timerAt as b, exportEvalRuns as bt, driverChild as c, canonicalObservedModel as ct, deriveNodeExecutionIdentity as d, mergeTraceEnv as dt, sandboxActProfileMaterialization as en, createSandboxForSpec as et, meterRuntimeOwnedAccounting as f, readTraceContextFromEnv as ft, settledToIteration as g, buildLoopSpanNodes as gt, scopeOwnerExecutorNodeContext as h, buildLoopOtelSpans as ht, collectDelivered as i, probeSandboxCapabilities as it, spendFromUsageEvents as j, sanitizeRuntimeStreamEvent as jt, assertValidBudget as k, sanitizeAgentRuntimeEvent as kt, withDriverExecutor as l, observedModelMatchesDeclared as lt, recordScopeOwnerMaterialization as m, INTELLIGENCE_WIRE_VERSION as mt, createSupervisor as n, worktreeCliProfileMaterialization as nn, runAgentRounds as nt, runFinalizer as o, routerBrain as ot, meterRuntimeOwnedProviderAttempt as p, traceContextToEnv as pt, createPushTraceSource as q, fullProfileMaterialization as qt, bestDelivered as r, createSandboxLineage as rt, runTree as s, runBrainLoop as st, createRootHandle as t, validateProfileMaterialization as tn, defaultSelectWinner as tt, createScope as u, createPropagatingTraceEmitter as ut, isWaitOutcome as v, createOpenInferenceFileExporter as vt, freeSlots as w, padSpanId as wt, validateWaitSpec as x, flatOtelSpan as xt, pollFor as y, createOtelExporter as yt, createWorktreeCliExecutor as z, harnessSupportsReasoningEffort as zt };
 
-//# sourceMappingURL=supervisor-BsniJxSa.js.map
+//# sourceMappingURL=supervisor-lbWTSscK.js.map