@dougbots/avenor-core 0.5.0 → 0.5.2

package/README.md

@@ -67,7 +67,7 @@ Status values: `running`, `done`, `failed`, `timeout`, `killed`. If a permission
 
 ### `resultTool`
 
-Waits for one run to finish and returns its bounded final output without transcript or event details.
+Waits for one run to finish and returns its complete final output without transcript or event details.
 
 ```ts
 import { resultTool } from '@dougbots/avenor-core'
@@ -138,7 +138,7 @@ const { run_id } = await spawnTool({
   label: 'security-review',
 })
 
-// 3. Wait for the bounded final output
+// 3. Wait for the complete final output
 const result = await resultTool({ runId: run_id })
 console.log(result) // { run_id, label, status: 'done', ready: true, output: '...' }
 
@@ -156,7 +156,7 @@ await shutdownTool()
 | `findAvenorBinary` | function | Discover the avenor binary path |
 | `spawnTool` | function | Start a new agent run |
 | `statusTool` | function | Query run lifecycle status (single or all) |
-| `resultTool` | function | Wait for and retrieve one run's bounded final output |
+| `resultTool` | function | Wait for and retrieve one run's complete final output |
 | `answerPermissionTool` | function | Answer a pending permission request |
 | `followUpTool` | function | Resume a session with a follow-up prompt |
 | `eventsTool` | function | Read recent events from a run's event log |

package/dist/index.d.ts

@@ -62,6 +62,7 @@ declare class Client {
   events(options?: SubscribeOptions): AsyncIterableIterator<Event>;
   history(options: HistoryOptions): Promise<HistoryResult>;
   status(runtimeId?: string): Promise<Record<string, unknown>>;
+  result(runtimeId?: string): Promise<Record<string, unknown>>;
   list(): Promise<Array<Record<string, unknown>>>;
   spawn(params: SpawnParams): Promise<Record<string, unknown>>;
   shutdown(mode: string): Promise<void>;
@@ -232,6 +233,9 @@ interface RunInfo {
   eventLogPath: string;
   runtimeId?: string;
   sessionId?: string;
+  agent?: string;
+  backend?: string;
+  dir?: string;
   brokerUrl?: string;
   parentToken?: string;
 }
@@ -318,6 +322,7 @@ interface StatusResult {
   usage?: Record<string, unknown>;
   latest_seq?: number;
   final_output?: string;
+  final_output_truncated?: boolean;
 }
 declare function statusTool(args: {
   runId?: string;
@@ -356,6 +361,8 @@ interface ResultResult {
   stop_reason?: string;
   pending_permission?: StatusResult['pending_permission'];
   output?: string;
+  output_truncated?: boolean;
+  output_event_path?: string;
   timed_out?: boolean;
 }
 interface ResultToolArgs {

package/dist/index.js

@@ -233,6 +233,10 @@ var Client = class {
 		const params = runtimeId ? { runtime_id: runtimeId } : void 0;
 		return this.call("status", params);
 	}
+	async result(runtimeId) {
+		const params = runtimeId ? { runtime_id: runtimeId } : void 0;
+		return this.call("result", params);
+	}
 	async list() {
 		return this.call("list");
 	}
@@ -1257,6 +1261,9 @@ var Supervisor = class Supervisor {
 			eventLogPath: result.on_event ?? eventLogPath,
 			runtimeId: result.runtime_id,
 			sessionId: result.session_id,
+			agent: spawnParams.agent ?? params.agent,
+			backend: spawnParams.backend,
+			dir: spawnParams.dir,
 			brokerUrl: result.broker_url,
 			parentToken: result.parent_token
 		};
@@ -1497,7 +1504,8 @@ function buildBaseStatus(source, fallback, translatedStatus) {
 		event_path: stringField(source, "event_path", "on_event"),
 		usage: asRecord(source.usage) ?? void 0,
 		latest_seq: numberField(source, "latest_seq"),
-		final_output: stringField(source, "final_output", "finalOutput")
+		final_output: stringField(source, "final_output", "finalOutput"),
+		...source.final_output_truncated === true && { final_output_truncated: true }
 	};
 }
 function shapeStatusResult(result, view = "full") {
@@ -1874,9 +1882,23 @@ function sleep(ms, signal) {
 		signal?.addEventListener("abort", onAbort, { once: true });
 	});
 }
+async function fullOutput(runtimeId, supervisorId) {
+	if (supervisorId) {
+		const { client, isSingleton } = await getSupervisorClient(supervisorId);
+		try {
+			const result = await client.result(runtimeId);
+			return typeof result.final_output === "string" ? result.final_output : void 0;
+		} finally {
+			if (!isSingleton) client.close();
+		}
+	}
+	const result = await (await Supervisor.get()).getClient().result(runtimeId);
+	return typeof result.final_output === "string" ? result.final_output : void 0;
+}
 const defaultDeps = {
 	status: statusTool,
 	inspect: inspectTool,
+	fullOutput,
 	sleep,
 	now: Date.now,
 	pollIntervalMs: DEFAULT_POLL_INTERVAL_MS
@@ -1893,6 +1915,8 @@ function toResult(status, timedOut = false) {
 		stop_reason: status.stop_reason,
 		pending_permission: status.pending_permission,
 		output: ready ? status.final_output : void 0,
+		output_truncated: ready && status.final_output_truncated ? true : void 0,
+		output_event_path: ready && status.final_output_truncated ? status.event_path : void 0,
 		timed_out: timedOut || void 0
 	};
 }
@@ -1911,13 +1935,23 @@ async function executeResultTool(args, deps) {
 		const status = Array.isArray(raw) ? raw[0] : raw;
 		if (!status) throw new Error(`run not found: ${args.runId}`);
 		if (TERMINAL_STATUSES.has(status.status)) {
-			if (!status.final_output) try {
+			let exactOutputRetrieved = false;
+			try {
+				const output = await deps.fullOutput?.(status.runtime_id, args.supervisorId);
+				if (output !== void 0) {
+					status.final_output = output;
+					status.final_output_truncated = false;
+					exactOutputRetrieved = true;
+				}
+			} catch {}
+			if (status.final_output === void 0) try {
 				const inspected = await deps.inspect({
 					runId: args.runId,
 					supervisorId: args.supervisorId
 				});
 				status.final_output = inspected.final_output ?? inspected.snapshot.final_output ?? inspected.snapshot.assistant_text;
 			} catch {}
+			if (!exactOutputRetrieved && status.final_output !== void 0) status.final_output_truncated = true;
 			return toResult(status);
 		}
 		if (status.status === "waiting" || !wait) return toResult(status);
@@ -1970,6 +2004,10 @@ function findRunByLabel(sup, runId) {
 	if (byKey) return byKey;
 	for (const info of runs.values()) if (info.label === runId) return info;
 }
+function requireResumableAgent(agent) {
+	if (agent === void 0) throw new Error("run has no agent to resume");
+	return agent;
+}
 async function parseSentinel(filePath) {
 	try {
 		const content = (await fs.promises.readFile(filePath, "utf-8")).trim();
@@ -1990,28 +2028,36 @@ async function parseSentinel(filePath) {
 }
 async function followUpTool(args) {
 	if (args.supervisorId) {
-		const { client, isSingleton } = await getSupervisorClient(args.supervisorId);
+		const { client, isSingleton, sup } = await getSupervisorClient(args.supervisorId);
 		try {
 			validateRunId(args.runId);
+			let runInfo;
+			if (isSingleton && sup) runInfo = findRunByLabel(sup, args.runId);
+			const fallbackSessionId = runInfo?.sessionId;
 			let liveStatus = null;
 			try {
 				liveStatus = await client.status(args.runId);
 			} catch {}
-			const sentinel = await parseSentinel(liveStatus?.sentinel_file ?? path.join(runsRoot(), args.runId, "sentinel.done"));
-			if (!sentinel?.SESSION) throw new Error("run has no session to resume");
-			const agent = liveStatus?.agent ?? "codex";
+			const sessionId = (await parseSentinel(liveStatus?.sentinel_file ?? path.join(runsRoot(), args.runId, "sentinel.done")))?.SESSION ?? liveStatus?.session_id ?? fallbackSessionId;
+			if (!sessionId) throw new Error("run has no session to resume");
+			const agent = requireResumableAgent(liveStatus?.agent ?? runInfo?.agent);
+			const backend = liveStatus?.backend ?? runInfo?.backend;
+			const dir = liveStatus?.dir ?? runInfo?.dir;
 			const followUpRunId = crypto.randomUUID();
 			const followUpLabel = args.label ?? `${args.runId}-followup`;
 			const { sentinelPath: followUpSentinelPath, eventLogPath } = ensureRunPaths(followUpRunId);
+			const spawnParams = {
+				agent,
+				prompt: args.message,
+				label: followUpLabel,
+				session_id: sessionId,
+				sentinel_file: followUpSentinelPath,
+				on_event: eventLogPath
+			};
+			if (backend) spawnParams.backend = backend;
+			if (dir) spawnParams.dir = dir;
 			return {
-				run_id: (await client.spawn({
-					agent,
-					prompt: args.message,
-					label: followUpLabel,
-					session_id: sentinel.SESSION,
-					sentinel_file: followUpSentinelPath,
-					on_event: eventLogPath
-				})).runtime_id ?? followUpRunId,
+				run_id: (await client.spawn(spawnParams)).runtime_id ?? followUpRunId,
 				label: followUpLabel
 			};
 		} finally {
@@ -2021,18 +2067,23 @@ async function followUpTool(args) {
 	const sup = await Supervisor.get();
 	const runInfo = findRunByLabel(sup, args.runId);
 	if (!runInfo) throw new Error(`run not found: ${args.runId}`);
-	const sentinel = await parseSentinel(runInfo.sentinelPath);
-	if (!sentinel?.SESSION) throw new Error("run has no session to resume");
+	const sessionId = (await parseSentinel(runInfo.sentinelPath))?.SESSION ?? runInfo.sessionId;
+	if (!sessionId) throw new Error("run has no session to resume");
 	const client = sup.getClient();
-	let agent = "codex";
+	let liveStatus = null;
 	if (runInfo.runtimeId) try {
-		agent = (await client.status(runInfo.runtimeId))?.agent ?? "codex";
+		liveStatus = await client.status(runInfo.runtimeId);
 	} catch {}
+	const agent = requireResumableAgent(liveStatus?.agent ?? runInfo.agent);
+	const backend = liveStatus?.backend ?? runInfo.backend;
+	const dir = liveStatus?.dir ?? runInfo.dir;
 	const followUpLabel = args.label ?? `${runInfo.label}-followup`;
 	const followUpRun = await sup.spawn({
 		agent,
+		backend,
+		dir,
 		prompt: args.message,
-		session_id: sentinel.SESSION,
+		session_id: sessionId,
 		label: followUpLabel
 	});
 	return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dougbots/avenor-core",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "type": "module",
   "repository": {
     "type": "git",