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

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

@@ -1,4 +1,4 @@
-import { Ar as AGENT_DRIVERS, Bt as lowerChild, En as maskSecrets, Vt as startAt, an as FEEDBACK_SEVERITIES, en as outcomeEnd, ft as parseReport, in as FEEDBACK_KINDS, nn as END_KINDS, on as FEEDBACK_TARGETS, rn as endFor, wn as MASK } from "./src-CdDTQLdQ.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;
@@ -969,7 +1019,7 @@ const permissionTool = defineTool({
 *   kept as the session's report, and the session runner ends the session with
 *   it instead of what the tool's last line says.
 */
-const REPORT_TOOL = "report";
+const REPORT_TOOL$1 = "report";
 /** Whether the driver holds a session's final answer to its schema itself. */
 const checksItsReport = (driver) => AGENT_DRIVERS.find((d) => d.id === driver)?.capabilities.reportSchema ?? true;
 /**
@@ -985,13 +1035,13 @@ const reportValidator = (schema) => {
 	}
 };
 const failed = (why) => ({
-	...text(`The report was not accepted; fix it and call ${REPORT_TOOL} again.\n${why}`),
+	...text(`The report was not accepted; fix it and call ${REPORT_TOOL$1} again.\n${why}`),
 	isError: true
 });
 const bound = (report) => {
 	const schema = reportValidator(report.schema);
 	return {
-		name: REPORT_TOOL,
+		name: REPORT_TOOL$1,
 		description: "Hand in your final report: call this once your work is done, as your last step, with the report the task asks for. A report that does not fit comes back with what to fix; call again with the fixed report. The last report accepted is the one your owner gets.",
 		shape: schema instanceof z.ZodObject ? schema.shape : {},
 		schema,
@@ -1025,7 +1075,7 @@ const ORK_TOOLS = [
 	releaseTool,
 	feedbackTool,
 	{
-		name: REPORT_TOOL,
+		name: REPORT_TOOL$1,
 		bind: (context) => context.report === void 0 || checksItsReport(context.driver) ? null : bound(context.report)
 	}
 ];
@@ -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,
@@ -1135,7 +1158,7 @@ const createSessionRuntime = (adapter, options = {}) => ({
 					}
 				}
 			});
-			const byTool = tools.some((tool) => tool.name === REPORT_TOOL);
+			const byTool = tools.some((tool) => tool.name === REPORT_TOOL$1);
 			const mcp = await startOrkMcpHttp(tools, hold === void 0 || hook === void 0 ? void 0 : toolHook({
 				hold,
 				heavy,
@@ -1243,7 +1266,8 @@ const createSessionRuntime = (adapter, options = {}) => ({
 /**
 * @file The `claude-code` adapter's `EventDecoder` and `UsageReader`: maps the
 *   `claude` CLI's `stream-json` lines to Ork's runtime events, marks the
-*   result of a turn the hold hook deferred, and adds up a session's legs.
+*   result of a turn the hold hook deferred, and adds up a session's legs. Its
+*   leg decoder keeps a report the session handed in and then wrote past.
 */
 const isObject$2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 const get$1 = (value, key) => isObject$2(value) ? value[key] : void 0;
@@ -1378,6 +1402,56 @@ const decodeClaudeLine = (line) => {
 		deferred: isDeferredResult(message)
 	};
 };
+/** The tool `claude` hands a `--json-schema` report in with. */
+const REPORT_TOOL = "StructuredOutput";
+/**
+* A leg's decoder that keeps the last report `claude` accepted (a
+* `StructuredOutput` call whose result was not an error). When the session
+* writes on after it, `claude`'s result can come without `structured_output`;
+* the kept report is then the result's, so a session that reported is not read
+* as one that didn't.
+*/
+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"]);
+				if (block["type"] === "tool_result" && calls.has(id)) {
+					if (block["is_error"] !== true) accepted = calls.get(id);
+					calls.delete(id);
+				}
+			}
+			const kept = isObject$2(message) && message["type"] === "result" && (message["structured_output"] ?? null) === null && accepted !== void 0 ? {
+				...message,
+				structured_output: accepted
+			} : message;
+			return {
+				events: normalize(kept),
+				deferred: isDeferredResult(message),
+				...usage === void 0 ? {} : { usage }
+			};
+		},
+		exit: () => []
+	};
+};
 /**
 * Two legs of one session, as one: the tokens of both, and the later leg's
 * cost, which is already the session's total (ADR-046).
@@ -1540,6 +1614,7 @@ const claudeCodeAdapter = {
 		input: userLine
 	},
 	decode: decodeClaudeLine,
+	legDecoder: claudeDecoder,
 	mcp: {
 		kind: "flag",
 		wire: () => Promise.resolve({
@@ -1904,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"]);
@@ -1980,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)];
@@ -2547,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"]);