@tangle-network/agent-runtime 0.113.1 → 0.114.0

package/dist/{supervisor-DS278ICs.js → supervisor-DKqolBGI.js}

@@ -1,6 +1,6 @@
 import { c as RuntimeRunStateError, u as ValidationError } from "./errors-DEAvWQPy.js";
 import { n as addTokenUsage, p as zeroTokenUsage } from "./util-Cc9g9Y-o.js";
-import { a as contentAddress, c as replaySpawnTree, o as materializeTreeView, s as pendingWaits } from "./spawn-journal-DLhnom3e.js";
+import { a as contentAddress, c as replaySpawnTree, o as materializeTreeView, s as pendingWaits } from "./spawn-journal-DCPbicXB.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-C7iJOWm3.js";
 import { estimateCost, isModelPriced } from "@tangle-network/agent-eval";
 import { createHash, randomUUID } from "node:crypto";
@@ -1917,14 +1917,7 @@ function splitReasoning(rawContent, fieldReasoning) {
 * `routerChatWithUsage`. `tool_choice: 'auto'` lets the model decide; the driver loops on the result.
 */
 async function routerChatWithTools(cfg, messages, tools, opts) {
-	const body = {
-		model: cfg.model,
-		messages,
-		tools,
-		tool_choice: opts?.toolChoice ?? "auto",
-		temperature: opts?.temperature ?? .3,
-		...opts?.maxTokens ? { max_tokens: opts.maxTokens } : {}
-	};
+	const body = toolCompletionBody(cfg, messages, tools, opts);
 	const data = cfg.complete ? await cfg.complete(body) : await (async () => {
 		const res = await fetch(`${cfg.routerBaseUrl.replace(/\/$/, "")}/chat/completions`, {
 			method: "POST",
@@ -1944,12 +1937,7 @@ async function routerChatWithTools(cfg, messages, tools, opts) {
 		name: tc.function?.name ?? "",
 		arguments: tc.function?.arguments ?? "{}"
 	}));
-	const u = data.usage;
-	const usage = u && typeof u.prompt_tokens === "number" && typeof u.completion_tokens === "number" ? {
-		input: u.prompt_tokens,
-		output: u.completion_tokens
-	} : void 0;
-	const costUsd = usage && isModelPriced(cfg.model) ? estimateCost(usage.input, usage.output, cfg.model) : void 0;
+	const { usage, costUsd } = meterTurn(data.usage, cfg.model);
 	return {
 		content: msg?.content ?? null,
 		toolCalls,
@@ -1957,6 +1945,204 @@ async function routerChatWithTools(cfg, messages, tools, opts) {
 		...costUsd !== void 0 ? { costUsd } : {}
 	};
 }
+/** The OpenAI-shape request body both tool-calling transports send. One builder so the streamed
+*  turn cannot drift from the buffered one on model, temperature, tool_choice, or the ceiling. */
+function toolCompletionBody(cfg, messages, tools, opts) {
+	return {
+		model: cfg.model,
+		messages,
+		tools,
+		tool_choice: opts?.toolChoice ?? "auto",
+		temperature: opts?.temperature ?? .3,
+		...opts?.maxTokens ? { max_tokens: opts.maxTokens } : {}
+	};
+}
+/**
+* REAL usage → the metered pair, or `undefined` when the provider reported none. Never a
+* fabricated 0: a phantom 0 reads as a free call to the conserved budget pool, which would then
+* over-spend. Shared by the buffered and streamed transports so both meter identically.
+*/
+function meterTurn(raw, model) {
+	const usage = raw && typeof raw.prompt_tokens === "number" && typeof raw.completion_tokens === "number" ? {
+		input: raw.prompt_tokens,
+		output: raw.completion_tokens
+	} : void 0;
+	if (!usage) return {};
+	const costUsd = isModelPriced(model) ? estimateCost(usage.input, usage.output, model) : void 0;
+	return {
+		usage,
+		...costUsd !== void 0 ? { costUsd } : {}
+	};
+}
+/**
+* The SAME completion as `routerChatWithTools`, taken over SSE (`stream: true`) and reassembled
+* into the identical `RouterChatToolsResult`. Opt in with `RouterConfig.stream` — the buffered
+* function is untouched and stays the default for every existing caller.
+*
+* What it buys: a buffered POST holds one connection idle for the whole completion, and that idle
+* window is what an intermediary gateway kills (524/503). Streaming puts bytes on the wire from the
+* first generated token, so the connection is only idle through prefill.
+*
+* Usage accounting is preserved exactly: `stream_options.include_usage` asks the provider for a
+* terminal usage chunk, and those tokens run through the same `meterTurn` the buffered path uses.
+*
+* When NO chunk reported usage, `usage`/`costUsd` stay undefined (never a fabricated 0) AND
+* `usageUnknown: true` is set. A stream that finishes with no usage chunk means the
+* `include_usage` request was not honored upstream, and returning a quiet `undefined` for it is
+* indistinguishable from a free turn — the marker is what lets a metering caller record an UNKNOWN
+* turn instead. Streaming raises the odds of this (one dropped terminal frame is enough), which is
+* why the streamed transport says so explicitly and the buffered one has no equivalent claim to make.
+*/
+async function streamRouterChatWithTools(cfg, messages, tools, opts) {
+	if (cfg.complete) throw new ValidationError("streamRouterChatWithTools: RouterConfig.complete is a BUFFERED transport (it returns one parsed completion body) and cannot serve a stream. Drop `stream` to use the injected transport, or drop `complete` to stream from the router.");
+	const body = {
+		...toolCompletionBody(cfg, messages, tools, opts),
+		stream: true,
+		stream_options: { include_usage: true }
+	};
+	const res = await fetch(`${cfg.routerBaseUrl.replace(/\/$/, "")}/chat/completions`, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			authorization: `Bearer ${cfg.routerKey}`,
+			accept: "text/event-stream"
+		},
+		body: JSON.stringify(body),
+		...opts?.signal ? { signal: opts.signal } : {}
+	});
+	if (!res.ok) throw new Error(`router ${res.status}: ${(await res.text()).slice(0, 200)}`);
+	if (!res.body) throw new ValidationError(`router ${res.status}: streamed completion returned no response body to read`);
+	let content = "";
+	let sawContent = false;
+	let fieldReasoning = "";
+	let finishReason;
+	let rawUsage;
+	const calls = /* @__PURE__ */ new Map();
+	let lastCallIndex = -1;
+	for await (const chunk of readChatCompletionChunks(res.body)) {
+		if (chunk.error) throw new ValidationError(`router stream error: ${chunk.error.message ?? chunk.error.type ?? "unknown"}`);
+		if (chunk.usage) rawUsage = chunk.usage;
+		const choice = chunk.choices?.[0];
+		if (!choice) continue;
+		if (typeof choice.finish_reason === "string") finishReason = choice.finish_reason;
+		const delta = choice.delta;
+		if (!delta) continue;
+		if (typeof delta.content === "string") {
+			content += delta.content;
+			sawContent = true;
+		}
+		const reasoningDelta = delta.reasoning_content ?? delta.reasoning;
+		if (typeof reasoningDelta === "string") fieldReasoning += reasoningDelta;
+		for (const tc of delta.tool_calls ?? []) {
+			const index = typeof tc.index === "number" ? tc.index : tc.id && !idAlreadyOpen(calls, tc.id) ? lastCallIndex + 1 : Math.max(lastCallIndex, 0);
+			lastCallIndex = Math.max(lastCallIndex, index);
+			const acc = calls.get(index) ?? { arguments: "" };
+			if (tc.id) acc.id = tc.id;
+			if (tc.function?.name) acc.name = tc.function.name;
+			if (tc.function?.arguments) acc.arguments += tc.function.arguments;
+			calls.set(index, acc);
+		}
+	}
+	const split = splitReasoning(content, fieldReasoning.length > 0 ? fieldReasoning : void 0);
+	const toolCalls = [...calls.entries()].sort((a, b) => a[0] - b[0]).map(([index, call]) => ({
+		id: call.id ?? `call_${index}`,
+		name: call.name ?? "",
+		arguments: call.arguments || "{}"
+	}));
+	const { usage, costUsd } = meterTurn(rawUsage, cfg.model);
+	return {
+		content: sawContent ? split.content : null,
+		toolCalls,
+		...split.reasoning ? { reasoning: split.reasoning } : {},
+		...finishReason !== void 0 ? { finishReason } : {},
+		...usage ? { usage } : {},
+		...costUsd !== void 0 ? { costUsd } : {},
+		...usage ? {} : { usageUnknown: true }
+	};
+}
+function idAlreadyOpen(calls, id) {
+	for (const call of calls.values()) if (call.id === id) return true;
+	return false;
+}
+/**
+* Decode an SSE body into chat-completion chunks. Frames are blank-line separated; `data:` lines
+* concatenate; `:` comments are keepalives; `[DONE]` ends the stream. The unterminated tail is
+* parsed too — an upstream that dies mid-response routinely sends a last frame with no trailing
+* blank line, and dropping it would turn a real upstream error into a silent empty turn.
+*
+* All three SSE line terminators (CRLF, LF, lone CR) are normalized, and the boundary scan runs
+* over the ACCUMULATED buffer — never over a single read in isolation, because a read may split a
+* CRLF. See `normalizeSseLineEndings`; the split is exercised byte-by-byte by the tests.
+*
+* The generator OWNS the body for its lifetime and releases it on every exit. Stopping early —
+* at `[DONE]`, or because the consumer threw — leaves the HTTP response only partly read, so the
+* body is CANCELLED rather than merely unlocked: releasing the lock alone leaves the connection
+* held open until the socket times out, which under a connection pool starves later turns.
+*/
+async function* readChatCompletionChunks(body) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buf = "";
+	let drained = false;
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			buf = normalizeSseLineEndings(done ? buf : buf + decoder.decode(value, { stream: true }), !done);
+			let sep = buf.indexOf("\n\n");
+			while (sep !== -1) {
+				const frame = parseChunkFrame(buf.slice(0, sep));
+				buf = buf.slice(sep + 2);
+				if (frame === "done") return;
+				if (frame) yield frame;
+				sep = buf.indexOf("\n\n");
+			}
+			if (done) break;
+		}
+		drained = true;
+		const tail = parseChunkFrame(buf);
+		if (tail && tail !== "done") yield tail;
+	} finally {
+		if (!drained) await reader.cancel().catch(() => void 0);
+		reader.releaseLock();
+	}
+}
+/**
+* Normalize an SSE body's line terminators to `\n`. The SSE grammar accepts CRLF, LF, AND a lone
+* CR, so a `\r`-separated body is legal — and left unnormalized it decodes to zero frames, which
+* this transport would report as a turn with no content, no tool calls, and `usageUnknown: true`
+* and no error at all. Losing a whole turn in silence is the one outcome it may not produce.
+*
+* `holdTrailingCr` keeps an ambiguous FINAL `\r` out of the conversion while more bytes may still
+* arrive: rewriting it to `\n` before the next byte is seen turns a read-split CRLF into a FALSE
+* frame boundary, splitting one frame into two unparseable halves. At EOF nothing can follow it,
+* so it is converted. Re-running this over the accumulated buffer is idempotent.
+*/
+function normalizeSseLineEndings(buf, holdTrailingCr) {
+	if (holdTrailingCr && buf.endsWith("\r")) return `${buf.slice(0, -1).replace(/\r\n?/g, "\n")}\r`;
+	return buf.replace(/\r\n?/g, "\n");
+}
+/** One SSE frame → a chunk, `'done'`, or undefined for a comment/keepalive/unparseable payload. */
+function parseChunkFrame(frame) {
+	const dataLines = [];
+	for (const line of frame.split("\n")) {
+		if (!line || line.startsWith(":")) continue;
+		if (line.startsWith("data:")) dataLines.push(line.slice(5).trimStart());
+	}
+	if (dataLines.length === 0) return void 0;
+	const data = dataLines.join("\n");
+	if (data === "[DONE]") return "done";
+	try {
+		return JSON.parse(data);
+	} catch {
+		return;
+	}
+}
+/** Pick the tool-calling transport the config asked for. `routerChatWithTools` itself never
+*  streams; this is the one place `RouterConfig.stream` is honored, so every router-client entry
+*  point (`routerBrain`, `routerToolLoop`) obeys the same switch. */
+function chatWithTools(cfg, messages, tools, opts) {
+	return cfg.stream === true ? streamRouterChatWithTools(cfg, messages, tools, opts) : routerChatWithTools(cfg, messages, tools, opts);
+}
 /**
 * The tool-using router backend: a real agentic loop OVER the Tangle router (which
 * supports tool-calling), off-box — no sandbox. Each turn is one router completion
@@ -1970,7 +2156,7 @@ async function routerChatWithTools(cfg, messages, tools, opts) {
 */
 async function routerToolLoop(cfg, system, user, tools, execute, opts) {
 	return runBrainLoop({
-		chat: (messages, toolSpecs) => routerChatWithTools(cfg, messages, toolSpecs, {
+		chat: (messages, toolSpecs) => chatWithTools(cfg, messages, toolSpecs, {
 			...opts?.temperature !== void 0 ? { temperature: opts.temperature } : {},
 			...opts?.maxTokens ? { maxTokens: opts.maxTokens } : {},
 			...opts?.signal ? { signal: opts.signal } : {}
@@ -1992,10 +2178,13 @@ async function routerToolLoop(cfg, system, user, tools, execute, opts) {
 * tool-calling. The driver's spawn/observe/steer/await/stop turns become real router tool-calls.
 * The turnkey production brain — tests script a mock `ToolLoopChat`; production passes
 * `routerBrain(cfg)`. No message translation: the loop already speaks the router's OpenAI shape.
+*
+* Transport follows `cfg.stream`: buffered by default, SSE when the caller opts in. A supervisor
+* turn is the longest completion in the system, so it is the call site streaming exists for.
 */
 function routerBrain(cfg, opts = {}) {
 	const temperature = opts.temperature ?? .4;
-	return (messages, tools) => routerChatWithTools(cfg, messages, tools, {
+	return (messages, tools) => chatWithTools(cfg, messages, tools, {
 		temperature,
 		toolChoice: "auto",
 		...cfg.maxTokens !== void 0 ? { maxTokens: cfg.maxTokens } : {}
@@ -2041,10 +2230,12 @@ function readWorkerProgress(scope, executor, now, stallAfterMs = DEFAULT_STALL_A
 		stallAfterMs,
 		turns: executor?.turns ?? scope.turns,
 		tokens: scope.tokens,
+		...scope.tokensKnown === false ? { tokensKnown: false } : {},
 		usd: scope.usd,
 		...scope.usdKnown === false ? { usdKnown: false } : {},
 		pendingMessages: executor?.pendingMessages ?? 0,
 		recentActivity: executor?.recentActivity ?? [],
+		...executor?.derived?.length ? { derived: executor.derived } : {},
 		...note ? { note } : {}
 	};
 }
@@ -2645,6 +2836,7 @@ function createScope(args) {
 			lastActivityAt: child.lastActivityAt,
 			turns: child.spent.iterations,
 			tokens: child.spent.tokens,
+			...child.spent.tokensKnown === false ? { tokensKnown: false } : {},
 			usd: child.spent.usd,
 			...child.spent.usdKnown === false ? { usdKnown: false } : {}
 		}, fromExecutor, opts.now ?? now(), opts.stallAfterMs ?? 18e4);
@@ -3040,6 +3232,7 @@ function clampSpend(spend, budget) {
 			output: Math.floor(spend.tokens.output * ratio)
 		} : spend.tokens,
 		usd: budget.maxUsd === void 0 ? spend.usd : Math.min(spend.usd, budget.maxUsd),
+		...spend.tokensKnown === false ? { tokensKnown: false } : {},
 		...spend.usdKnown === false ? { usdKnown: false } : {},
 		ms: spend.ms
 	};
@@ -3263,6 +3456,7 @@ function sumSpend(settled) {
 		total.tokens.input += ev.spent.tokens.input;
 		total.tokens.output += ev.spent.tokens.output;
 		total.usd += ev.spent.usd;
+		if (ev.spent.tokensKnown === false) total.tokensKnown = false;
 		if (ev.spent.usdKnown === false) total.usdKnown = false;
 		total.ms += ev.spent.ms;
 	}
@@ -3287,13 +3481,17 @@ function sumMetered(events) {
 		total.tokens.input += ev.spend.tokens.input;
 		total.tokens.output += ev.spend.tokens.output;
 		total.usd += ev.spend.usd;
+		if (ev.spend.tokensKnown === false) total.tokensKnown = false;
 		if (ev.spend.usdKnown === false) total.usdKnown = false;
 		total.ms += ev.spend.ms;
 	}
 	return total;
 }
+/** An all-zero spend that carries an UNKNOWN marker counts as non-zero: a sub-driver whose turns
+*  went unmeasured did real work, and dropping its `metered` event here would re-hide upstream the
+*  very turn the driver refused to skip. */
 function isNonZeroSpend(s) {
-	return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0;
+	return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0 || s.tokensKnown === false || s.usdKnown === false;
 }
 /** A spend, or `undefined` when it is all-zero — so `metered()` returns undefined for a driver
 *  whose sub-tree did no inference (and the parent journals no empty `metered` event). */
@@ -3365,6 +3563,10 @@ function isAgent(value) {
 * unknown reconcile) so a child can never refund twice. If dollar cost is unknowable under a
 * dollar limit, reconciliation closes the known token/iteration work, marks the dollar channel
 * unusable, and refuses later reservations; inventing a numeric dollar total would be worse.
+* If a TOKEN count is unknowable (a provider that reported no usage for work that ran), the pool
+* records the work, debits what it knows, and marks `readout().tokensKnown` false — the balance is
+* then a ceiling, not a measurement. It does not close admission the way the dollar channel does:
+* tokens are always capped, so one unreported turn must not end the run.
 *
 * @experimental
 */
@@ -3427,6 +3629,7 @@ function createBudgetPool(root, now = Date.now) {
 	let freeTokens = root.maxTokens;
 	let reservedTokens = 0;
 	let committedTokens = 0;
+	let tokensTainted = false;
 	const usdCapped = root.maxUsd !== void 0;
 	let freeUsd = root.maxUsd ?? 0;
 	let reservedUsd = 0;
@@ -3493,6 +3696,7 @@ function createBudgetPool(root, now = Date.now) {
 		if (spent.iterations > rIterations) throw new Error(`budget pool: ticket ${ticket.id} spent ${spent.iterations} iterations > reserved ${rIterations}`);
 		if (usdCapped && spent.usd > rUsd) throw new Error(`budget pool: ticket ${ticket.id} spent $${spent.usd} > reserved $${rUsd}`);
 		open.delete(ticket.id);
+		if (spent.tokensKnown === false) tokensTainted = true;
 		reservedTokens -= rTokens;
 		committedTokens += spentTokens;
 		freeTokens += rTokens - spentTokens;
@@ -3511,6 +3715,7 @@ function createBudgetPool(root, now = Date.now) {
 	}
 	function observe(spend) {
 		if (usdCapped && spend.usdKnown === false) throw new Error("budget pool: cannot observe unknown dollar cost under a dollar-capped budget");
+		if (spend.tokensKnown === false) tokensTainted = true;
 		const tokens = totalTokens(spend.tokens);
 		freeTokens -= tokens;
 		committedTokens += tokens;
@@ -3522,6 +3727,7 @@ function createBudgetPool(root, now = Date.now) {
 	function readout() {
 		return {
 			tokensLeft: freeTokens,
+			tokensKnown: !tokensTainted,
 			usdLeft: usdCapped ? usdTainted ? 0 : freeUsd : 0,
 			usdCapped,
 			deadlineMs: absoluteDeadlineMs,
@@ -4012,6 +4218,7 @@ function accumulate(a, b) {
 	a.tokens.input += b.tokens.input;
 	a.tokens.output += b.tokens.output;
 	a.usd += b.usd;
+	if (b.tokensKnown === false) a.tokensKnown = false;
 	if (b.usdKnown === false) a.usdKnown = false;
 	a.ms += b.ms;
 }
@@ -4025,17 +4232,20 @@ function addSpend(a, b) {
 			output: a.tokens.output + b.tokens.output
 		},
 		usd: a.usd + b.usd,
+		...a.tokensKnown === false || b.tokensKnown === false ? { tokensKnown: false } : {},
 		...a.usdKnown === false || b.usdKnown === false ? { usdKnown: false } : {},
 		ms: a.ms + b.ms
 	};
 }
 /** True when any driver metered inference this run (so the winner carries a `spentBreakdown`).
 *  Checks every channel `addSpend` sums — including `ms` — so the gate stays consistent with the
-*  total even though the coordination driver currently stamps `ms: 0`. */
+*  total even though the coordination driver currently stamps `ms: 0`. An all-zero spend that
+*  carries an UNKNOWN marker is non-empty: work happened and went unmeasured, which is exactly the
+*  fact a breakdown must not hide by looking like no work at all. */
 function isNonEmptySpend(s) {
-	return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0;
+	return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0 || s.tokensKnown === false || s.usdKnown === false;
 }
 //#endregion
-export { createWorktree as A, routerChatWithUsage as C, runWorktreeChecks as D, runSettledCommand as E, CodexExecutionDiagnosticError as F, harnessInvocation as M, parseCodexTokenUsage as N, runWorktreeHarness as O, runLocalHarness as P, routerChatWithTools as S, runBrainLoop as T, waitUntil as _, runFinalizer as a, readWorkerProgress as b, spendFromUsageEvents as c, settledToIteration as d, createWaitProbes as f, validateWaitSpec as g, timerAt as h, pickBestDelivered as i, removeWorktree as j, captureWorktreeDiff as k, withDriverExecutor as l, pollFor as m, bestDelivered as n, runTree as o, isWaitOutcome as p, collectDelivered as r, createBudgetPool as s, createSupervisor as t, createScope as u, DEFAULT_STALL_AFTER_MS as v, routerToolLoop as w, routerBrain as x, createActivityLog as y };
+export { captureWorktreeDiff as A, routerChatWithUsage as C, runSettledCommand as D, runBrainLoop as E, runLocalHarness as F, CodexExecutionDiagnosticError as I, removeWorktree as M, harnessInvocation as N, runWorktreeChecks as O, parseCodexTokenUsage as P, routerChatWithTools as S, streamRouterChatWithTools as T, waitUntil as _, runFinalizer as a, readWorkerProgress as b, spendFromUsageEvents as c, settledToIteration as d, createWaitProbes as f, validateWaitSpec as g, timerAt as h, pickBestDelivered as i, createWorktree as j, runWorktreeHarness as k, withDriverExecutor as l, pollFor as m, bestDelivered as n, runTree as o, isWaitOutcome as p, collectDelivered as r, createBudgetPool as s, createSupervisor as t, createScope as u, DEFAULT_STALL_AFTER_MS as v, routerToolLoop as w, routerBrain as x, createActivityLog as y };
 
-//# sourceMappingURL=supervisor-DS278ICs.js.map
+//# sourceMappingURL=supervisor-DKqolBGI.js.map