@krapht/ork 1.0.0-alpha.13 → 1.0.0-alpha.14

package/dist/{src-D93tHZ5B.mjs → src-C7z_6fhn.mjs}

@@ -1,5 +1,5 @@
-import { $t as serversIn, At as endedWith, Dr as integrationFor, Er as TOOL_PREFIX, Ht as envReadsOf, It as lowerChild, Kt as declaredOutputOf, Lt as startAt, M as sessionRefusals, Mt as stoppedEnd, Nr as AGENT_DRIVERS, Nt as calledWorkflows, Ot as runScope, Pt as slotClock, Qt as mcpNotText, Tr as INTEGRATIONS, Wt as sessionDriver, Zt as MCP_FILE, an as endFor, bn as renderTemplate, br as isToolNode, cr as programsRunBy, fr as markValue, gt as heldTimeout, jt as failedWith, kt as declaredProblem, lt as reportSchemaFor, nn as outcomeEnd, rn as END_DETAIL_LIMIT, rt as planReason, sr as beforeOf, st as planNodeSession, tn as endOf, vn as evaluate, wr as timeoutMs, yn as parseTemplate, yr as isClaudeNode } from "./src-BeR6f70A.mjs";
-import { t as runOnce } from "./run-CQIfq918.mjs";
+import { $t as countedTokens, Cn as MCP_FILE, Dn as endOf, Ft as reportSchemaFor, Gn as parseTemplate, Gr as isToolNode, Ht as heldTimeout, Kn as renderTemplate, Lr as markValue, Mr as beforeOf, Nr as programsRunBy, Nt as planNodeSession, On as outcomeEnd, Qr as integrationFor, Tn as serversIn, Wn as evaluate, Wr as isClaudeNode, Xr as INTEGRATIONS, Yr as timeoutMs, Zr as TOOL_PREFIX, an as stoppedEnd, en as runScope, gn as sessionDriver, ii as AGENT_DRIVERS, in as failedWith, jn as endFor, kn as END_DETAIL_LIMIT, kt as planReason, ln as lowerChild, mn as envReadsOf, nt as sessionRefusals, on as declaredProblem, rn as endedWith, sn as slotClock, tn as calledWorkflows, un as startAt, vn as declaredOutputOf, wn as mcpNotText } from "./src-tsuZRu0H.mjs";
+import { t as runOnce } from "./run-D8divGCs.mjs";
 import path from "node:path";
 import { accessSync, constants, lstatSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { spawn } from "node:child_process";
@@ -538,43 +538,36 @@ const afterLateTurn = (first, later) => {
 		errors: first.errors
 	};
 };
+/** The least of the limits that are set; `undefined` with none. */
+const least = (...limits) => {
+	const known = limits.filter((limit) => limit !== void 0);
+	return known.length === 0 ? void 0 : Math.min(...known);
+};
+/** A cap less what this activation used, beside what a quota says is left. */
+const leftOf = (caps, used, quotaLeft) => least(...caps.map((cap) => cap === void 0 ? void 0 : cap - used), quotaLeft);
 /**
-* What another turn of a session may use. `spent` and `turns` are this
-* activation's, which neither the node's cap nor the run's budget has counted.
-* The quota has: the ledger took it as the session finished, so what it says is
-* left is left. `null` when nothing is, and the turn does not start.
+* What another turn of a session may use. `spent`, `tokens` (counted, RFC-015)
+* and `turns` are this activation's, which neither the node's cap nor the run's
+* budget has counted. The quota has: the ledger took it as the session
+* finished, so what it says is left is left. The run's tokens left have too:
+* only the node's own `budgetTokens` takes `tokens` off. `null` when nothing
+* is, and the turn does not start.
 */
-const lateLimits = (spec, { spent, turns }, runLeft, quotaLeft) => {
-	const budgets = [...[spec.budgetUsd, runLeft].flatMap((limit) => limit === void 0 ? [] : [limit - spent]), ...quotaLeft === void 0 ? [] : [quotaLeft]];
-	const budgetUsd = budgets.length === 0 ? void 0 : Math.min(...budgets);
-	if (budgetUsd !== void 0 && budgetUsd <= 0) return null;
-	const maxTurns = spec.maxTurns === void 0 ? void 0 : spec.maxTurns - turns;
-	if (maxTurns !== void 0 && maxTurns <= 0) return null;
+const lateLimits = (spec, used, runLeft, quotaLeft, tokensLeft = {}) => {
+	const budgetUsd = leftOf([spec.budgetUsd, runLeft], used.spent, quotaLeft);
+	const budgetTokens = leftOf([spec.budgetTokens], used.tokens ?? 0, least(tokensLeft.run, tokensLeft.quota));
+	const maxTurns = spec.maxTurns === void 0 ? void 0 : spec.maxTurns - used.turns;
+	if ([
+		budgetUsd,
+		budgetTokens,
+		maxTurns
+	].some((left) => (left ?? 1) <= 0)) return null;
 	return {
 		...budgetUsd === void 0 ? {} : { budgetUsd },
+		...budgetTokens === void 0 ? {} : { budgetTokens },
 		...maxTurns === void 0 ? {} : { maxTurns }
 	};
 };
-/** What a session may spend as it starts: the least of the budget and any quota. */
-const budgetNow = (context) => {
-	if (context.budgetLeftNow === void 0) return context.budgetLeftUsd;
-	const known = [context.budgetLeftNow(), context.quota?.().leftUsd].flatMap((left) => left === void 0 ? [] : [left]);
-	return known.length === 0 ? void 0 : Math.min(...known);
-};
-/**
-* What a node's first session may spend, set aside from the run's budget in the
-* same step that reads it (ADR-077), so a node starting beside it is never
-* offered the same part: the least of what is left and the node's own
-* `budgetUsd`. With nothing left, it waits for a worker running beside it to
-* finish, as long as one may.
-*/
-const budgetToStart = async (context) => {
-	const left = budgetNow(context);
-	if (left !== void 0 && left <= 0) return await context.budgetFreed?.(context.signal) === true ? budgetToStart(context) : left;
-	const own = isClaudeNode(context.node) ? context.node.budgetUsd ?? context.workflow.defaults?.budgetUsd : void 0;
-	context.reserveBudget?.(own === void 0 || left === void 0 ? left : Math.min(own, left));
-	return left;
-};
 /**
 * Whether a limit across runs, rather than the node's work, ended a node: a
 * session whose cap was a quota's and that ran into it, or one its plan refused
@@ -587,7 +580,7 @@ const limitWatch = (context) => {
 			why = reason;
 		},
 		session: (asked) => {
-			const left = context.quota?.().leftUsd;
+			const { leftUsd: left, leftTokens } = context.quota?.() ?? {};
 			let refused;
 			return {
 				saw: (event) => {
@@ -595,7 +588,7 @@ const limitWatch = (context) => {
 				},
 				ended: (outcome) => {
 					if (refused !== void 0 && (outcome?.report ?? null) === null) why = refused;
-					const capped = left !== void 0 && asked.budgetUsd !== void 0 && asked.budgetUsd >= left;
+					const capped = left !== void 0 && asked.budgetUsd !== void 0 && asked.budgetUsd >= left || leftTokens !== void 0 && asked.budgetTokens !== void 0 && asked.budgetTokens >= leftTokens;
 					const spent = outcome !== null && outcomeEnd(outcome).kind === "budget_limit";
 					if (capped && spent) why = context.quota?.().blocked ?? "a session reached what was left of a quota";
 				}
@@ -657,6 +650,61 @@ const sessionDriverOf = (context, plan, options) => {
 	const unfit = plan.pinned === void 0 ? void 0 : refusalOn(context, driver, options.drivers ?? AGENT_DRIVERS);
 	return unfit === void 0 ? driver : notStarted("invalid_node", unfit);
 };
+// ../nodes/src/start-budgets.ts
+/** What a session may spend as it starts: the least of the budget and any quota. */
+const budgetNow = (context) => context.budgetLeftNow === void 0 ? context.budgetLeftUsd : least(context.budgetLeftNow(), context.quota?.().leftUsd);
+/** The counted tokens a session may use as it starts: the run's and a quota's. */
+const tokensNow = (context) => least(context.tokensLeftNow?.(), context.quota?.().leftTokens);
+/**
+* What is `left` now, with `own` (the node's cap) set aside through `reserve`
+* in the same step; with nothing left, it waits for a worker's reserve to
+* free.
+*/
+const startWith = async (context, left, own, reserve) => {
+	const now = left();
+	if (now !== void 0 && now <= 0) {
+		context.reserveBudget?.(0);
+		context.reserveTokens?.(0);
+		return await context.budgetFreed?.(context.signal) === true ? startWith(context, left, own, reserve) : now;
+	}
+	reserve?.(own === void 0 || now === void 0 ? now : Math.min(own, now));
+	return now;
+};
+/**
+* What a node's first session may spend, set aside from the run's budget in the
+* same step that reads it (ADR-077), so a node starting beside it is never
+* offered the same part: the least of what is left and the node's own
+* `budgetUsd`. With nothing left, it waits for a worker running beside it to
+* finish, as long as one may.
+*/
+const budgetToStart = (context) => startWith(context, () => budgetNow(context), isClaudeNode(context.node) ? context.node.budgetUsd ?? context.workflow.defaults?.budgetUsd : void 0, context.reserveBudget);
+/** `budgetToStart` in counted tokens: the run's `budgetTokens` and a quota's. */
+const tokensToStart = (context) => startWith(context, () => tokensNow(context), isClaudeNode(context.node) ? context.node.budgetTokens ?? context.workflow.defaults?.budgetTokens : void 0, context.reserveTokens);
+/**
+* What a node's first session may spend, in dollars and in counted tokens, set
+* into `planOptions`; the node's result instead when nothing is left of
+* either.
+*/
+const startBudgets = async (context, planOptions) => {
+	const usd = await budgetToStart(context);
+	if (usd !== void 0 && usd <= 0) return notStarted("budget_limit", "nothing is left of the run's budget");
+	if (usd !== void 0) planOptions.budgetLeftUsd = usd;
+	const waited = { done: false };
+	const tokens = await tokensToStart({
+		...context,
+		budgetFreed: async (signal) => {
+			waited.done = true;
+			return await context.budgetFreed?.(signal) ?? false;
+		}
+	});
+	if (tokens !== void 0 && tokens <= 0) return notStarted("budget_limit", "nothing is left of the run's tokens");
+	if (waited.done) {
+		context.reserveTokens?.(0);
+		return startBudgets(context, planOptions);
+	}
+	if (tokens !== void 0) planOptions.budgetLeftTokens = tokens;
+	return null;
+};
 // ../nodes/src/tool-output.ts
 /**
 * @file A tool node's structured result (`output: { format: json }`): the file
@@ -1742,9 +1790,8 @@ const claudeExecutor = (options) => async (context) => {
 	}
 	const blocked = context.quota?.().blocked;
 	if (blocked !== void 0) return notStarted("plan_limit", blocked, blocked);
-	const budget = await budgetToStart(context);
-	if (budget !== void 0 && budget <= 0) return notStarted("budget_limit", "nothing is left of the run's budget");
-	if (budget !== void 0) planOptions.budgetLeftUsd = budget;
+	const refused = await startBudgets(context, planOptions);
+	if (refused !== null) return refused;
 	const plan = planNodeSession(context.workflow, context.id, planOptions);
 	if (!plan.ok) return notStarted("invalid_node", plan.error);
 	const servers = namedMcpEntries(context.projectRoot, plan.mcp);
@@ -1775,6 +1822,7 @@ const claudeExecutor = (options) => async (context) => {
 	const run = async (asked) => {
 		const watching = watch.session(asked);
 		context.reserveBudget?.(asked.budgetUsd);
+		context.reserveTokens?.(asked.budgetTokens);
 		const session = runtime.start(asked, ports);
 		const stop = () => {
 			session.interrupt();
@@ -1793,6 +1841,7 @@ const claudeExecutor = (options) => async (context) => {
 			}
 		} finally {
 			context.reserveBudget?.(0);
+			context.reserveTokens?.(0);
 			disconnect?.();
 			context.signal.removeEventListener("abort", stop);
 		}
@@ -1808,8 +1857,12 @@ const claudeExecutor = (options) => async (context) => {
 		}
 		return lateLimits(spec, {
 			spent: context.ownSpend?.(sessionId, usage.costUsd) ?? usage.costUsd,
-			turns: usage.turns
-		}, context.budgetLeftNow?.(), quota?.leftUsd);
+			turns: usage.turns,
+			tokens: countedTokens(usage)
+		}, context.budgetLeftNow?.(), quota?.leftUsd, {
+			run: context.tokensLeftNow?.(),
+			quota: quota?.leftTokens
+		});
 	};
 	const resumeWith = (outcome, prompt, limits) => run({
 		...spec,

package/dist/{src-CqRqsb2t.mjs → src-njdtejgZ.mjs}

@@ -1,4 +1,4 @@
-import { En as MASK, It as lowerChild, Lt as startAt, Nr as AGENT_DRIVERS, On as maskSecrets, an as endFor, cn as FEEDBACK_TARGETS, ct as parseReport, in as END_KINDS, nn as outcomeEnd, on as FEEDBACK_KINDS, sn as FEEDBACK_SEVERITIES } from "./src-BeR6f70A.mjs";
+import { $n as maskSecrets, $t as countedTokens, An as END_KINDS, Mn as FEEDBACK_KINDS, Nn as FEEDBACK_SEVERITIES, On as outcomeEnd, Pn as FEEDBACK_TARGETS, Pt as parseReport, Zn as MASK, ii as AGENT_DRIVERS, jn as endFor, ln as lowerChild, un as startAt } from "./src-tsuZRu0H.mjs";
 import path from "node:path";
 import { z } from "zod";
 import { existsSync, linkSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
@@ -448,7 +448,8 @@ const classifyProviderError = (text, status) => {
 *   it can see (a turn cap, an exit code, a provider's error), and the report
 *   the session handed in decides the rest. The runner then writes the end in
 *   the node's numbers, its detail scrubbed with the feedback redactor. A
-*   session the driver could not run ends as `driverFailure` says.
+*   session the driver could not run ends as `driverFailure` says, and one that
+*   reached its token cap as `tokenCapOutcome` says.
 */
 /** The end a report gives: done, a reported failure, or none handed in. */
 const reportEnd = (report) => {
@@ -479,6 +480,36 @@ const settleEnd = (outcome, facts, scrub) => {
 	};
 };
 /**
+* What a session's end is written with: the node's limits and program, and its
+* folder and the home folder taken out of the detail.
+*/
+const scopeOf = (spec, bin, env) => ({
+	facts: {
+		...spec.maxTurns === void 0 ? {} : { maxTurns: spec.maxTurns },
+		...spec.budgetUsd === void 0 ? {} : { budgetUsd: spec.budgetUsd },
+		...spec.budgetTokens === void 0 ? {} : { budgetTokens: spec.budgetTokens },
+		program: path.basename(bin)
+	},
+	scrub: {
+		roots: [spec.cwd],
+		home: env["HOME"] ?? homedir()
+	}
+});
+/**
+* The outcome of a session stopped once its counted tokens (RFC-015) reach
+* `budgetTokens`: `budget_limit`, with what it used so far; `undefined` under
+* the cap, or with none.
+*/
+const tokenCapOutcome = ({ budgetTokens }, usage, sessionId) => budgetTokens === void 0 || usage === void 0 || countedTokens(usage) < budgetTokens ? void 0 : {
+	subtype: "error_max_budget_tokens",
+	end: endFor("budget_limit"),
+	sessionId,
+	report: null,
+	text: "",
+	usage,
+	errors: [`Reached the token budget (${String(budgetTokens)})`]
+};
+/**
 * The kind of a failure to run the driver: its program missing, else what a
 * provider's words in it say, else a crash.
 */
@@ -534,6 +565,15 @@ const settled = (outcome, input) => settleEnd(input.reported === void 0 ? outcom
 	...outcome,
 	report: input.reported()
 }, input.scope.facts, input.scope.scrub);
+/** The session's end at its token cap, its earlier legs' usage included. */
+const tokenCapEnd = (input, used, sessionId) => {
+	const usage = used === void 0 || input.carried === void 0 ? used : input.adapter.usage.combine(input.carried, used);
+	const capped = tokenCapOutcome(input.scope.facts, usage, sessionId);
+	return capped === void 0 ? void 0 : {
+		type: "session.finished",
+		outcome: settled(capped, input)
+	};
+};
 /** The kinds of a session that ended well, so a queued message continues it. */
 const wentWell = (kind) => kind === "done" || kind === "reported_failure" || kind === "no_report";
 /**
@@ -639,16 +679,26 @@ const runLeg = async function* (input) {
 	for (const line of input.pending.splice(0)) write(line);
 	if (input.adapter.command.input === void 0) child.stdin.end();
 	let outcome;
+	let sessionId = "";
 	const { decoder } = input;
 	const decode = decoder?.decode ?? input.adapter.decode;
 	try {
 		for await (const line of createInterface({ input: child.stdout })) {
-			const { events, ended } = legStep(decode(line), input);
+			const decoded = decode(line);
+			const { events, ended } = legStep(decoded, input);
+			for (const event of decoded.events) if (event.type === "session.started") sessionId = event.sessionId;
 			yield* events;
 			if (ended !== void 0) {
 				child.stdin.end();
 				outcome = ended;
 			}
+			const capped = outcome === void 0 ? tokenCapEnd(input, decoded.usage, sessionId) : void 0;
+			if (capped !== void 0) {
+				stopped = true;
+				child.kill("SIGINT");
+				yield capped;
+				return { kind: "finished" };
+			}
 		}
 		const end = await Promise.race([exited, spawnError.then((error) => error)]);
 		if (outcome !== void 0) return outcome;
@@ -1034,33 +1084,6 @@ const orkTools = (context) => ORK_TOOLS.flatMap((tool) => tool.bind(context) ??
 /** Their Claude Code names, for the session's allowed tools. */
 const preapprovedTools = (tools) => tools.filter((t) => t.preapproved).map((t) => toolId(t.name));
 // ../runtime/src/session-runner.ts
-/**
-* @file The session runner: one agent CLI session, driven through an adapter's
-*   strategies (`adapter.ts`), written once for every driver. It serves Ork's
-*   tools on a local MCP endpoint, wires the session to it, and runs the tool
-*   as one or more processes (legs). A paused node's tool call is held, and
-*   past the hold window deferred; the next leg resumes the session once the
-*   node continues (ADR-041). A tool that takes no message mid-session gets one
-*   at the next leg, which resumes the session with it. A driver that cannot
-*   hold the final answer to the report schema gets Ork's `report` tool, and
-*   the session ends with the report it accepted. Interrupting stops the
-*   running process.
-*/
-/**
-* What a session's end is written with: the node's limits and program, and its
-* folder and the home folder taken out of the detail.
-*/
-const scopeOf = (spec, bin, env) => ({
-	facts: {
-		...spec.maxTurns === void 0 ? {} : { maxTurns: spec.maxTurns },
-		...spec.budgetUsd === void 0 ? {} : { budgetUsd: spec.budgetUsd },
-		program: path.basename(bin)
-	},
-	scrub: {
-		roots: [spec.cwd],
-		home: env["HOME"] ?? homedir()
-	}
-});
 /** A spec that resumes `sessionId`; a fork's later legs continue the fork. */
 const resumed = (spec, sessionId) => ({
 	...spec,
@@ -1391,9 +1414,23 @@ const REPORT_TOOL = "StructuredOutput";
 const claudeDecoder = () => {
 	const calls = /* @__PURE__ */ new Map();
 	let accepted;
+	/** Each model response's usage, by message id: its blocks repeat it. */
+	const responses = /* @__PURE__ */ new Map();
+	/** The leg's usage so far, when `message` is a model response. */
+	const usageSoFar = (message) => {
+		const inner = get$1(message, "message");
+		const id = get$1(inner, "id");
+		if (get$1(message, "type") !== "assistant" || typeof id !== "string") return;
+		responses.set(id, {
+			...usageOf({ usage: get$1(inner, "usage") }),
+			turns: 1
+		});
+		return [...responses.values()].reduce((a, b) => addUsage(a, b));
+	};
 	return {
 		decode: (line) => {
 			const message = parseLine$2(line);
+			const usage = usageSoFar(message);
 			for (const block of blocks(message)) {
 				if (block["type"] === "tool_use" && block["name"] === REPORT_TOOL) calls.set(str$2(block["id"]), block["input"]);
 				const id = str$2(block["tool_use_id"]);
@@ -1408,7 +1445,8 @@ const claudeDecoder = () => {
 			} : message;
 			return {
 				events: normalize(kept),
-				deferred: isDeferredResult(message)
+				deferred: isDeferredResult(message),
+				...usage === void 0 ? {} : { usage }
 			};
 		},
 		exit: () => []
@@ -1941,6 +1979,26 @@ const commandCodeDecoder = () => {
 	let sessionId = "";
 	let turns = 0;
 	let held;
+	/** The leg's tokens so far, from each `model_request_end` frame. */
+	let used;
+	/** A model request's usage, added to the leg's so far. */
+	const requestEnded = (usage) => {
+		const said = isObject$1(usage) ? usage : {};
+		const own = {
+			costUsd: 0,
+			inputTokens: num$1(said["inputTokens"]),
+			outputTokens: num$1(said["outputTokens"]),
+			cacheReadTokens: num$1(said["cacheReadTokens"]),
+			cacheWriteTokens: num$1(said["cacheWriteTokens"]),
+			turns,
+			durationMs: 0
+		};
+		used = used === void 0 ? own : {
+			...addUsage(used, own),
+			turns
+		};
+		return used;
+	};
 	const frame = (event) => {
 		const type = event["type"];
 		const id = str$1(event["toolCallId"]);
@@ -2017,7 +2075,11 @@ const commandCodeDecoder = () => {
 				return { events: [] };
 			}
 			const event = message["event"];
-			return { events: message["type"] === "event" && isObject$1(event) ? frame(event) : [] };
+			if (message["type"] !== "event" || !isObject$1(event)) return { events: [] };
+			return {
+				events: frame(event),
+				...event["type"] === "model_request_end" ? { usage: requestEnded(event["usage"]) } : {}
+			};
 		},
 		exit: (code) => {
 			if (held !== void 0) return [result(held, code)];
@@ -2584,7 +2646,10 @@ const openCodeDecoder = (spec) => {
 			switch (message["type"]) {
 				case "step_finish":
 					usage = sumUsage(usage, stepUsage(message["part"]));
-					break;
+					return {
+						events,
+						usage
+					};
 				case "error":
 					errors.push(errorText(message["error"]));
 					failed ??= errorLineEnd(message["error"]);