@dogpile/sdk 0.2.1 → 0.3.0

package/dist/browser/index.js

@@ -638,6 +638,10 @@ function firstOf(...conditions) {
 * own normalized inputs so one stop class cannot accidentally satisfy another.
 */
 function evaluateTermination(condition, context) {
+	if (isTerminationFloorBlocked(condition, context)) return {
+		type: "continue",
+		condition
+	};
 	switch (condition.kind) {
 		case "budget": return evaluateBudget(condition, context);
 		case "firstOf": return evaluateFirstOf(condition, context).decision;
@@ -695,6 +699,17 @@ function evaluateTerminationStop(condition, context) {
 	return stopRecord(condition, decision);
 }
 /**
+* Warn when a protocol-level termination floor cannot be satisfied because a
+* lower iteration cap will stop the run first.
+*/
+function warnOnProtocolTerminationMisconfiguration(protocol, terminate, warn = console.warn) {
+	const minTurns = protocolMinTurns(protocol);
+	if (minTurns === void 0 || !terminate) return;
+	const limitingIterationBudget = smallestIterationBudget(terminate);
+	if (limitingIterationBudget === void 0 || limitingIterationBudget >= minTurns) return;
+	warn(`[dogpile] protocol.minTurns (${minTurns}) exceeds terminate budget maxIterations (${limitingIterationBudget}); maxIterations will win.`);
+}
+/**
 * Combine independently evaluated termination decisions with SDK precedence.
 *
 * Budget caps win over judge decisions, and judge decisions win over
@@ -843,6 +858,48 @@ function stopPrecedence(reason) {
 	if (reason.startsWith("judge:")) return 1;
 	return 2;
 }
+function isTerminationFloorBlocked(condition, context) {
+	if (condition.kind !== "convergence" && condition.kind !== "judge") return false;
+	const floor = protocolTerminationFloor(context.protocolConfig);
+	if (floor === void 0 || floor <= 0) return false;
+	return protocolProgress(context) < floor;
+}
+function protocolTerminationFloor(protocol) {
+	if (!protocol) return;
+	switch (protocol.kind) {
+		case "broadcast": return protocol.minRounds;
+		case "coordinator":
+		case "sequential":
+		case "shared": return protocol.minTurns;
+	}
+}
+function protocolProgress(context) {
+	return context.protocolIteration ?? context.iteration ?? context.transcript.length;
+}
+function protocolMinTurns(protocol) {
+	switch (protocol.kind) {
+		case "broadcast": return;
+		case "coordinator":
+		case "sequential":
+		case "shared": return protocol.minTurns;
+	}
+}
+function smallestIterationBudget(condition) {
+	switch (condition.kind) {
+		case "budget": return condition.maxIterations;
+		case "convergence":
+		case "judge": return;
+		case "firstOf": {
+			let smallest;
+			for (const child of condition.conditions) {
+				const budget = smallestIterationBudget(child);
+				if (budget === void 0) continue;
+				smallest = smallest === void 0 ? budget : Math.min(smallest, budget);
+			}
+			return smallest;
+		}
+	}
+}
 function judgeStopDetail(decision, minScore) {
 	return {
 		decision: decision.type,
@@ -921,6 +978,7 @@ function validateDogpileOptions(options) {
 	validateOptionalTemperature(options.temperature, "temperature");
 	validateOptionalBudgetCaps(options.budget, "budget");
 	validateOptionalTerminationCondition(options.terminate, "terminate");
+	validateOptionalWrapUpHint(options.wrapUpHint, "wrapUpHint");
 	validateOptionalFunction(options.evaluate, "evaluate");
 	validateOptionalSeed(options.seed, "seed");
 	validateOptionalAbortSignal(options.signal, "signal");
@@ -941,6 +999,7 @@ function validateEngineOptions(options) {
 	validateOptionalTemperature(options.temperature, "temperature");
 	validateOptionalBudgetCaps(options.budget, "budget");
 	validateOptionalTerminationCondition(options.terminate, "terminate");
+	validateOptionalWrapUpHint(options.wrapUpHint, "wrapUpHint");
 	validateOptionalFunction(options.evaluate, "evaluate");
 	validateOptionalSeed(options.seed, "seed");
 	validateOptionalAbortSignal(options.signal, "signal");
@@ -973,10 +1032,12 @@ function validateProtocolConfig(value, path) {
 		case "sequential":
 		case "shared":
 			validateOptionalPositiveInteger(record.maxTurns, `${path}.maxTurns`);
+			validateOptionalNonNegativeInteger(record.minTurns, `${path}.minTurns`);
 			if (kind === "shared") validateOptionalString(record.organizationalMemory, `${path}.organizationalMemory`);
 			return;
 		case "broadcast":
 			validateOptionalPositiveInteger(record.maxRounds, `${path}.maxRounds`);
+			validateOptionalNonNegativeInteger(record.minRounds, `${path}.minRounds`);
 			return;
 	}
 }
@@ -1144,6 +1205,20 @@ function validateJudgeRubric(value, path) {
 function validateOptionalTemperature(value, path) {
 	validateOptionalNumberInRange(value, path, 0, 2);
 }
+function validateOptionalWrapUpHint(value, path) {
+	if (value === void 0) return;
+	const record = requireRecord(value, path);
+	validateOptionalNonNegativeInteger(record.atIteration, `${path}.atIteration`);
+	validateOptionalNumberInRange(record.atFraction, `${path}.atFraction`, 0, 1);
+	validateOptionalFunction(record.inject, `${path}.inject`);
+	if (record.atIteration === void 0 && record.atFraction === void 0) invalidConfiguration({
+		path,
+		rule: "object",
+		message: "wrapUpHint must configure atIteration or atFraction.",
+		expected: "WrapUpHintConfig with atIteration or atFraction",
+		actual: value
+	});
+}
 function validateOptionalSeed(value, path) {
 	if (value === void 0) return;
 	if (typeof value === "string") return;
@@ -2067,6 +2142,151 @@ function isRuntimeToolAdapterErrorCode(value) {
 	return value === "invalid-input" || value === "permission-denied" || value === "timeout" || value === "aborted" || value === "unavailable" || value === "backend-error" || value === "unknown";
 }
 //#endregion
+//#region src/runtime/wrap-up.ts
+function createWrapUpHintController(options) {
+	const hint = options.wrapUpHint;
+	const effectiveBudget = effectiveWrapUpBudget(options.budget, options.terminate);
+	let emitted = false;
+	return {
+		context(context) {
+			return wrapUpEvaluationContext({
+				...context,
+				tier: options.tier,
+				...effectiveBudget !== void 0 ? { budget: effectiveBudget } : {}
+			});
+		},
+		inject(messages, context) {
+			if (!hint || emitted) return messages;
+			const evaluationContext = wrapUpEvaluationContext({
+				...context,
+				tier: options.tier,
+				...effectiveBudget !== void 0 ? { budget: effectiveBudget } : {}
+			});
+			if (!shouldInjectWrapUpHint(hint, evaluationContext)) return messages;
+			const content = (hint.inject ?? defaultWrapUpHint)(evaluationContext);
+			emitted = true;
+			return [
+				messages[0] ?? {
+					role: "system",
+					content: ""
+				},
+				{
+					role: "system",
+					content
+				},
+				...messages.slice(1)
+			];
+		}
+	};
+}
+function wrapUpEvaluationContext(options) {
+	const iteration = options.iteration ?? options.transcript.length;
+	const elapsedMs = options.elapsedMs;
+	return {
+		runId: options.runId,
+		protocol: options.protocol,
+		tier: options.tier,
+		cost: options.cost,
+		events: options.events,
+		transcript: options.transcript,
+		...options.protocolConfig !== void 0 ? { protocolConfig: options.protocolConfig } : {},
+		...iteration !== void 0 ? { iteration } : {},
+		...options.protocolIteration !== void 0 ? { protocolIteration: options.protocolIteration } : {},
+		...elapsedMs !== void 0 ? { elapsedMs } : {},
+		...options.budget !== void 0 ? { budget: options.budget } : {},
+		...options.budget !== void 0 ? { remainingBudget: remainingBudget(options.budget, {
+			cost: options.cost,
+			iteration,
+			elapsedMs
+		}) } : {},
+		...options.metadata !== void 0 ? { metadata: options.metadata } : {}
+	};
+}
+function shouldInjectWrapUpHint(hint, context) {
+	const iteration = context.iteration ?? context.transcript.length;
+	if (hint.atIteration !== void 0 && iteration >= hint.atIteration) return true;
+	if (hint.atFraction === void 0 || context.budget === void 0) return false;
+	const fraction = hint.atFraction;
+	return capFractionReached(iteration, context.budget.maxIterations, fraction) || capFractionReached(context.elapsedMs, context.budget.timeoutMs, fraction);
+}
+function capFractionReached(current, limit, fraction) {
+	if (current === void 0 || limit === void 0 || limit <= 0) return false;
+	return current / limit >= fraction;
+}
+function remainingBudget(budget, current) {
+	return {
+		...budget.maxIterations !== void 0 && current.iteration !== void 0 ? { iterations: Math.max(0, budget.maxIterations - current.iteration) } : {},
+		...budget.timeoutMs !== void 0 && current.elapsedMs !== void 0 ? { timeoutMs: Math.max(0, budget.timeoutMs - current.elapsedMs) } : {},
+		...budget.maxUsd !== void 0 ? { usd: Math.max(0, budget.maxUsd - current.cost.usd) } : {},
+		...budget.maxTokens !== void 0 ? { tokens: Math.max(0, budget.maxTokens - current.cost.totalTokens) } : {}
+	};
+}
+function defaultWrapUpHint(context) {
+	const parts = [];
+	const remaining = context.remainingBudget;
+	if (remaining?.iterations !== void 0) {
+		const label = remaining.iterations === 1 ? "turn" : "turns";
+		parts.push(`${remaining.iterations} ${label} remaining`);
+	}
+	if (remaining?.timeoutMs !== void 0) parts.push(`${formatRemainingTime(remaining.timeoutMs)} remaining`);
+	return `[wrap-up] ${parts.length === 0 ? "You are approaching a configured hard limit." : `You are approaching a hard limit with ${parts.join(" and ")}.`} If you have enough context, package your work now and return a final-ready answer.`;
+}
+function formatRemainingTime(timeoutMs) {
+	if (timeoutMs >= 1e3) return `${(timeoutMs / 1e3).toFixed(1)}s`;
+	return `${timeoutMs}ms`;
+}
+function effectiveWrapUpBudget(budget, terminate) {
+	const terminationBudget = budgetCapsFromTermination(terminate);
+	if (!budget && !terminationBudget) return;
+	const maxUsd = minCap(budget?.maxUsd, terminationBudget?.maxUsd);
+	const maxTokens = minCap(budget?.maxTokens, terminationBudget?.maxTokens);
+	const maxIterations = minCap(budget?.maxIterations, terminationBudget?.maxIterations);
+	const timeoutMs = minCap(budget?.timeoutMs, terminationBudget?.timeoutMs);
+	return {
+		...maxUsd !== void 0 ? { maxUsd } : {},
+		...maxTokens !== void 0 ? { maxTokens } : {},
+		...maxIterations !== void 0 ? { maxIterations } : {},
+		...timeoutMs !== void 0 ? { timeoutMs } : {}
+	};
+}
+function budgetCapsFromTermination(condition) {
+	if (!condition) return;
+	switch (condition.kind) {
+		case "budget": return {
+			...condition.maxUsd !== void 0 ? { maxUsd: condition.maxUsd } : {},
+			...condition.maxTokens !== void 0 ? { maxTokens: condition.maxTokens } : {},
+			...condition.maxIterations !== void 0 ? { maxIterations: condition.maxIterations } : {},
+			...condition.timeoutMs !== void 0 ? { timeoutMs: condition.timeoutMs } : {}
+		};
+		case "firstOf": {
+			let merged;
+			for (const child of condition.conditions) merged = mergeBudgetCaps(merged, budgetCapsFromTermination(child));
+			return merged;
+		}
+		case "convergence":
+		case "judge": return;
+	}
+}
+function mergeBudgetCaps(left, right) {
+	if (!left) return right;
+	if (!right) return left;
+	const maxUsd = minCap(left.maxUsd, right.maxUsd);
+	const maxTokens = minCap(left.maxTokens, right.maxTokens);
+	const maxIterations = minCap(left.maxIterations, right.maxIterations);
+	const timeoutMs = minCap(left.timeoutMs, right.timeoutMs);
+	return {
+		...maxUsd !== void 0 ? { maxUsd } : {},
+		...maxTokens !== void 0 ? { maxTokens } : {},
+		...maxIterations !== void 0 ? { maxIterations } : {},
+		...timeoutMs !== void 0 ? { timeoutMs } : {}
+	};
+}
+function minCap(left, right) {
+	if (left === void 0) return right;
+	if (right === void 0) return left;
+	return Math.min(left, right);
+}
+//#endregion
 //#region src/runtime/broadcast.ts
 async function runBroadcast(options) {
 	const runId = createRunId$3();
@@ -2081,6 +2301,14 @@ async function runBroadcast(options) {
 	const startedAtMs = nowMs$3();
 	let stopped = false;
 	let termination;
+	const wrapUpHint = createWrapUpHintController({
+		protocol: options.protocol,
+		tier: options.tier,
+		...options.budget ? { budget: options.budget } : {},
+		...options.terminate ? { terminate: options.terminate } : {},
+		...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {}
+	});
+	warnOnProtocolTerminationMisconfiguration(options.protocol, options.terminate);
 	const emit = (event) => {
 		events.push(event);
 		options.emit?.(event);
@@ -2134,13 +2362,21 @@ async function runBroadcast(options) {
 					round,
 					...toolAvailability
 				},
-				messages: [{
+				messages: wrapUpHint.inject([{
 					role: "system",
 					content: buildSystemPrompt$3(agent)
 				}, {
 					role: "user",
 					content: input
-				}]
+				}], {
+					runId,
+					protocol: "broadcast",
+					cost: totalCost,
+					events,
+					transcript,
+					iteration: transcript.length,
+					elapsedMs: elapsedMs$3(startedAtMs)
+				})
 			};
 			const response = await generateModelTurn({
 				model: options.model,
@@ -2305,16 +2541,17 @@ async function runBroadcast(options) {
 	function stopIfNeeded() {
 		throwIfAborted(options.signal, options.model.id);
 		if (stopped || !options.terminate) return stopped;
-		const stopRecord = evaluateTerminationStop(options.terminate, {
+		const stopRecord = evaluateTerminationStop(options.terminate, wrapUpHint.context({
 			runId,
 			protocol: "broadcast",
-			tier: options.tier,
+			protocolConfig: options.protocol,
+			protocolIteration: broadcastRoundsCompleted(events),
 			cost: totalCost,
 			events,
 			transcript,
 			iteration: transcript.length,
 			elapsedMs: elapsedMs$3(startedAtMs)
-		});
+		}));
 		if (!stopRecord) return false;
 		stopped = true;
 		termination = stopRecord;
@@ -2336,6 +2573,9 @@ async function runBroadcast(options) {
 		recordProtocolDecision(event, { transcriptEntryCount: transcript.length });
 	}
 }
+function broadcastRoundsCompleted(events) {
+	return events.filter((event) => event.type === "broadcast").length;
+}
 function buildSystemPrompt$3(agent) {
 	const instruction = agent.instructions ? `\nInstructions: ${agent.instructions}` : "";
 	return `You are ${agent.id}, acting as ${agent.role} in a Broadcast multi-agent protocol.${instruction}`;
@@ -2383,6 +2623,14 @@ async function runCoordinator(options) {
 	const startedAtMs = nowMs$2();
 	let stopped = false;
 	let termination;
+	const wrapUpHint = createWrapUpHintController({
+		protocol: options.protocol,
+		tier: options.tier,
+		...options.budget ? { budget: options.budget } : {},
+		...options.terminate ? { terminate: options.terminate } : {},
+		...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {}
+	});
+	warnOnProtocolTerminationMisconfiguration(options.protocol, options.terminate);
 	const emit = (event) => {
 		events.push(event);
 		options.emit?.(event);
@@ -2432,6 +2680,9 @@ async function runCoordinator(options) {
 				providerCalls,
 				toolExecutor,
 				toolAvailability,
+				events,
+				startedAtMs,
+				wrapUpHint,
 				emit,
 				recordProtocolDecision
 			});
@@ -2453,6 +2704,11 @@ async function runCoordinator(options) {
 				providerCallSlots,
 				toolExecutor,
 				toolAvailability,
+				totalCost,
+				events,
+				transcript: planTranscript,
+				startedAtMs,
+				wrapUpHint,
 				emit
 			})));
 			providerCalls.push(...providerCallSlots.filter((call) => call !== void 0));
@@ -2499,6 +2755,9 @@ async function runCoordinator(options) {
 				providerCalls,
 				toolExecutor,
 				toolAvailability,
+				events,
+				startedAtMs,
+				wrapUpHint,
 				emit,
 				recordProtocolDecision
 			});
@@ -2579,16 +2838,17 @@ async function runCoordinator(options) {
 	function stopIfNeeded() {
 		throwIfAborted(options.signal, options.model.id);
 		if (stopped || !options.terminate) return stopped;
-		const stopRecord = evaluateTerminationStop(options.terminate, {
+		const stopRecord = evaluateTerminationStop(options.terminate, wrapUpHint.context({
 			runId,
 			protocol: "coordinator",
-			tier: options.tier,
+			protocolConfig: options.protocol,
+			protocolIteration: transcript.length,
 			cost: totalCost,
 			events,
 			transcript,
 			iteration: transcript.length,
 			elapsedMs: elapsedMs$2(startedAtMs)
-		});
+		}));
 		if (!stopRecord) return false;
 		stopped = true;
 		termination = stopRecord;
@@ -2625,13 +2885,21 @@ async function runCoordinatorTurn(turn) {
 			phase: turn.phase,
 			...turn.toolAvailability
 		},
-		messages: [{
+		messages: turn.wrapUpHint.inject([{
 			role: "system",
 			content: buildSystemPrompt$2(turn.agent, turn.coordinator)
 		}, {
 			role: "user",
 			content: turn.input
-		}]
+		}], {
+			runId: turn.runId,
+			protocol: "coordinator",
+			cost: turn.totalCost,
+			events: turn.events,
+			transcript: turn.transcript,
+			iteration: turn.transcript.length,
+			elapsedMs: elapsedMs$2(turn.startedAtMs)
+		})
 	};
 	const response = await generateModelTurn({
 		model: turn.options.model,
@@ -2698,13 +2966,21 @@ async function runCoordinatorWorkerTurn(turn) {
 			phase: "worker",
 			...turn.toolAvailability
 		},
-		messages: [{
+		messages: turn.wrapUpHint.inject([{
 			role: "system",
 			content: buildSystemPrompt$2(turn.agent, turn.coordinator)
 		}, {
 			role: "user",
 			content: turn.input
-		}]
+		}], {
+			runId: turn.runId,
+			protocol: "coordinator",
+			cost: turn.totalCost,
+			events: turn.events,
+			transcript: turn.transcript,
+			iteration: turn.turn - 1,
+			elapsedMs: elapsedMs$2(turn.startedAtMs)
+		})
 	};
 	const response = await generateModelTurn({
 		model: turn.options.model,
@@ -2787,6 +3063,14 @@ async function runSequential(options) {
 	const startedAtMs = nowMs$1();
 	let stopped = false;
 	let termination;
+	const wrapUpHint = createWrapUpHintController({
+		protocol: options.protocol,
+		tier: options.tier,
+		...options.budget ? { budget: options.budget } : {},
+		...options.terminate ? { terminate: options.terminate } : {},
+		...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {}
+	});
+	warnOnProtocolTerminationMisconfiguration(options.protocol, options.terminate);
 	const emit = (event) => {
 		events.push(event);
 		options.emit?.(event);
@@ -2838,13 +3122,21 @@ async function runSequential(options) {
 				turn,
 				...toolAvailability
 			},
-			messages: [{
+			messages: wrapUpHint.inject([{
 				role: "system",
 				content: buildSystemPrompt$1(agent)
 			}, {
 				role: "user",
 				content: input
-			}]
+			}], {
+				runId,
+				protocol: "sequential",
+				cost: totalCost,
+				events,
+				transcript,
+				iteration: transcript.length,
+				elapsedMs: elapsedMs$1(startedAtMs)
+			})
 		};
 		const response = await generateModelTurn({
 			model: options.model,
@@ -2969,16 +3261,17 @@ async function runSequential(options) {
 	function stopIfNeeded() {
 		throwIfAborted(options.signal, options.model.id);
 		if (stopped || !options.terminate) return stopped;
-		const stopRecord = evaluateTerminationStop(options.terminate, {
+		const stopRecord = evaluateTerminationStop(options.terminate, wrapUpHint.context({
 			runId,
 			protocol: "sequential",
-			tier: options.tier,
+			protocolConfig: options.protocol,
+			protocolIteration: transcript.length,
 			cost: totalCost,
 			events,
 			transcript,
 			iteration: transcript.length,
 			elapsedMs: elapsedMs$1(startedAtMs)
-		});
+		}));
 		if (!stopRecord) return false;
 		stopped = true;
 		termination = stopRecord;
@@ -3040,6 +3333,14 @@ async function runShared(options) {
 	const startedAtMs = nowMs();
 	let stopped = false;
 	let termination;
+	const wrapUpHint = createWrapUpHintController({
+		protocol: options.protocol,
+		tier: options.tier,
+		...options.budget ? { budget: options.budget } : {},
+		...options.terminate ? { terminate: options.terminate } : {},
+		...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {}
+	});
+	warnOnProtocolTerminationMisconfiguration(options.protocol, options.terminate);
 	const emit = (event) => {
 		events.push(event);
 		options.emit?.(event);
@@ -3092,13 +3393,21 @@ async function runShared(options) {
 					turn,
 					...toolAvailability
 				},
-				messages: [{
+				messages: wrapUpHint.inject([{
 					role: "system",
 					content: buildSystemPrompt(agent)
 				}, {
 					role: "user",
 					content: input
-				}]
+				}], {
+					runId,
+					protocol: "shared",
+					cost: totalCost,
+					events,
+					transcript,
+					iteration: transcript.length,
+					elapsedMs: elapsedMs(startedAtMs)
+				})
 			};
 			const response = await generateModelTurn({
 				model: options.model,
@@ -3235,16 +3544,17 @@ async function runShared(options) {
 	function stopIfNeeded() {
 		throwIfAborted(options.signal, options.model.id);
 		if (stopped || !options.terminate) return stopped;
-		const stopRecord = evaluateTerminationStop(options.terminate, {
+		const stopRecord = evaluateTerminationStop(options.terminate, wrapUpHint.context({
 			runId,
 			protocol: "shared",
-			tier: options.tier,
+			protocolConfig: options.protocol,
+			protocolIteration: transcript.length,
 			cost: totalCost,
 			events,
 			transcript,
 			iteration: transcript.length,
 			elapsedMs: elapsedMs(startedAtMs)
-		});
+		}));
 		if (!stopRecord) return false;
 		stopped = true;
 		termination = stopRecord;
@@ -3333,6 +3643,7 @@ function createEngine(options) {
 				...options.seed !== void 0 ? { seed: options.seed } : {},
 				...options.signal !== void 0 ? { signal: options.signal } : {},
 				...terminate ? { terminate } : {},
+				...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {},
 				...options.evaluate ? { evaluate: options.evaluate } : {}
 			});
 		},
@@ -3715,6 +4026,7 @@ function runProtocol(options) {
 			...options.seed !== void 0 ? { seed: options.seed } : {},
 			...options.signal !== void 0 ? { signal: options.signal } : {},
 			...options.terminate ? { terminate: options.terminate } : {},
+			...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {},
 			...options.emit ? { emit: options.emit } : {}
 		});
 		case "broadcast": return runBroadcast({
@@ -3729,6 +4041,7 @@ function runProtocol(options) {
 			...options.seed !== void 0 ? { seed: options.seed } : {},
 			...options.signal !== void 0 ? { signal: options.signal } : {},
 			...options.terminate ? { terminate: options.terminate } : {},
+			...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {},
 			...options.emit ? { emit: options.emit } : {}
 		});
 		case "coordinator": return runCoordinator({
@@ -3743,6 +4056,7 @@ function runProtocol(options) {
 			...options.seed !== void 0 ? { seed: options.seed } : {},
 			...options.signal !== void 0 ? { signal: options.signal } : {},
 			...options.terminate ? { terminate: options.terminate } : {},
+			...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {},
 			...options.emit ? { emit: options.emit } : {}
 		});
 		case "shared": return runShared({
@@ -3757,6 +4071,7 @@ function runProtocol(options) {
 			...options.seed !== void 0 ? { seed: options.seed } : {},
 			...options.signal !== void 0 ? { signal: options.signal } : {},
 			...options.terminate ? { terminate: options.terminate } : {},
+			...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {},
 			...options.emit ? { emit: options.emit } : {}
 		});
 	}