@orkestrel/agent 0.0.7 → 0.0.9

package/dist/src/core/index.cjs

@@ -74,6 +74,24 @@ var THINK_CLOSE = "</think>";
 */
 var WORKSPACE_SECTION_HEADER = "## Workspace";
 /**
+* The estimated per-message role/framing overhead {@link import('./helpers.js').estimateMessages}
+* adds on top of a message's content estimate — accounts for the fixed wire framing every
+* conversation turn carries (its role tag, delimiters) that {@link import('./helpers.js').estimateTokens}'s
+* content-only heuristic does not otherwise capture.
+*/
+var MESSAGE_TOKEN_OVERHEAD = 4;
+/**
+* The coarse, deliberately-approximate per-image token cost {@link import('./helpers.js').estimateMessages}
+* charges for each attached image.
+*
+* @remarks
+* A base64 image payload's LENGTH is NOT a reliable token proxy (a vision model's actual image
+* token cost depends on resolution / tiling, not byte size), so this is a fixed, coarse
+* per-image estimate rather than a derivation from `image.length` — a planning heuristic, not an
+* exact count.
+*/
+var IMAGE_TOKEN_ESTIMATE = 512;
+/**
 * The extension→language table {@link import('./helpers.js').inferLanguage} reads to
 * map a file path's extension to a fenced-code language tag. Covers the common source /
 * markup / data extensions; an unlisted extension falls back to `'text'`.
@@ -202,18 +220,21 @@ function isAgentJobError(value) {
 }
 /**
 * Thrown by a {@link ConversationInterface}'s `compact()` when the conversation has no
-* {@link ConversationSummarizer} to fold its messages with — carries a machine-readable
-* `code`.
+* {@link ConversationSummarizer} to fold its messages with, or when its `sections` cap is
+* structurally invalid — carries a machine-readable `code`.
 *
 * @remarks
 * Compaction REQUIRES a summarizer (it digests the folded slice into a section summary and
 * regenerates the rollup); a conversation created without one can still store + `view()` its
-* live tail, but a `compact()` is a programmer error (§12) and throws this. `code` is
-* `'SUMMARIZER'` (the only condition so far). Narrow a caught value with
+* live tail, but a `compact()` is a programmer error (§12) and throws this with `'SUMMARIZER'`.
+* A `sections` cap (§F2, on {@link import('./types.js').ConversationOptions} /
+* {@link import('./types.js').ConversationManagerOptions} /
+* {@link import('./types.js').CompactOptions}) must be `>= 1` — a sub-1 cap is a programmer
+* error and throws this with `'SECTIONS'`. Narrow a caught value with
 * {@link isConversationError} and branch on `error.code`.
 */
 var ConversationError = class extends Error {
-	/** The machine-readable condition — `'SUMMARIZER'`: a `compact()` with no summarizer. */
+	/** The machine-readable condition — `'SUMMARIZER'`: a `compact()` with no summarizer; `'SECTIONS'`: a sub-1 `sections` cap. */
 	code;
 	constructor(code, message) {
 		super(message);
@@ -257,7 +278,7 @@ var WorkspaceError = class extends Error {
 		super(message);
 		this.name = "WorkspaceError";
 		this.code = code;
-		this.context = context;
+		if (context !== void 0) this.context = context;
 	}
 };
 /**
@@ -278,6 +299,45 @@ var WorkspaceError = class extends Error {
 function isWorkspaceError(value) {
 	return value instanceof WorkspaceError;
 }
+/**
+* Thrown synchronously by an {@link AgentInterface}'s `stream()` when a concurrent run would
+* corrupt SHARED per-agent accounting — carries a machine-readable `code`.
+*
+* @remarks
+* A run already in flight on the same agent, PLUS a construction-level `window` (a shared
+* context budget) or a construction-level `budget` with no per-run override (a shared cost
+* budget), means a second concurrent `stream()` would race its charges against the same
+* shared instance — corrupting the accounting. `code` is `'CONCURRENCY'` (the only condition
+* so far). Use separate agents, or per-run `budget` overrides with no `window`, for genuinely
+* concurrent runs. Narrow a caught value with {@link isAgentError} and branch on `error.code`.
+*/
+var AgentError = class extends Error {
+	/** The machine-readable condition — `'CONCURRENCY'`: a concurrent run on a shared accounting agent. */
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "AgentError";
+		this.code = code;
+	}
+};
+/**
+* Narrow an unknown caught value to an {@link AgentError}.
+*
+* @param value - The value to test (typically a `catch` binding)
+* @returns `true` when `value` is an {@link AgentError}
+*
+* @example
+* ```ts
+* try {
+* 	agent.stream()
+* } catch (error) {
+* 	if (isAgentError(error) && error.code === 'CONCURRENCY') useSeparateAgents()
+* }
+* ```
+*/
+function isAgentError(value) {
+	return value instanceof AgentError;
+}
 //#endregion
 //#region src/core/conversations/Conversation.ts
 /**
@@ -331,17 +391,20 @@ var Conversation = class {
 	#emitter;
 	#summarize;
 	#keep;
+	#cap;
 	#sections = [];
 	#summary;
 	#messages = /* @__PURE__ */ new Map();
 	constructor(options, seed) {
 		this.#id = seed?.id ?? options?.id ?? crypto.randomUUID();
 		this.#emitter = new _orkestrel_emitter.Emitter({
-			on: options?.on,
-			error: options?.error
+			...options?.on === void 0 ? {} : { on: options.on },
+			...options?.error === void 0 ? {} : { error: options.error }
 		});
 		this.#summarize = options?.summarize;
 		this.#keep = options?.keep ?? 0;
+		if (options?.sections !== void 0 && options.sections < 1) throw new ConversationError("SECTIONS", "a sections cap must be >= 1");
+		this.#cap = options?.sections;
 		if (seed) {
 			this.#summary = seed.summary;
 			for (const section of seed.sections) this.#sections.push(section);
@@ -393,6 +456,8 @@ var Conversation = class {
 	async compact(options) {
 		const summarize = this.#summarize;
 		if (summarize === void 0) throw new ConversationError("SUMMARIZER", "cannot compact a conversation without a summarizer");
+		const cap = options?.sections ?? this.#cap;
+		if (cap !== void 0 && cap < 1) throw new ConversationError("SECTIONS", "a sections cap must be >= 1");
 		const keep = options?.keep ?? this.#keep;
 		const live = [...this.#messages.values()];
 		const fold = keep <= 0 ? live.length : live.length - keep;
@@ -406,6 +471,23 @@ var Conversation = class {
 		};
 		for (const message of slice) this.#messages.delete(message.id);
 		this.#sections.push(section);
+		if (cap !== void 0 && this.#sections.length > cap) {
+			const overflow = this.#sections.length - cap + 1;
+			const folded = this.#sections.slice(0, overflow);
+			try {
+				const merged = {
+					id: crypto.randomUUID(),
+					summary: await summarize(folded.map((one) => this.#summaryMessage(one))),
+					messages: folded.flatMap((one) => one.messages)
+				};
+				this.#sections.splice(0, overflow, merged);
+				this.#emitter.emit("collapse", merged);
+			} catch (error) {
+				this.#summary = await summarize(this.#sections.map((one) => this.#summaryMessage(one)));
+				this.#emitter.emit("summary", this.#summary);
+				throw error;
+			}
+		}
 		this.#summary = await summarize(this.#sections.map((one) => this.#summaryMessage(one)));
 		this.#emitter.emit("summary", this.#summary);
 		this.#emitter.emit("compact", section);
@@ -505,10 +587,12 @@ var ConversationManager = class {
 	#active;
 	#summarize;
 	#keep;
+	#sections;
 	#store;
 	constructor(options) {
 		this.#summarize = options?.summarize;
 		this.#keep = options?.keep ?? 0;
+		this.#sections = options?.sections;
 		this.#store = options?.store;
 	}
 	get count() {
@@ -524,11 +608,14 @@ var ConversationManager = class {
 		return [...this.#conversations.values()];
 	}
 	add(input) {
+		const sections = input?.sections ?? this.#sections;
+		const summarize = input?.summarize ?? this.#summarize;
 		const conversation = new Conversation({
 			...input?.id === void 0 ? {} : { id: input.id },
 			...input?.on === void 0 ? {} : { on: input.on },
-			summarize: input?.summarize ?? this.#summarize,
-			keep: input?.keep ?? this.#keep
+			...summarize === void 0 ? {} : { summarize },
+			keep: input?.keep ?? this.#keep,
+			...sections === void 0 ? {} : { sections }
 		}, input?.snapshot);
 		this.#conversations.set(conversation.id, conversation);
 		if (this.#active === void 0) this.#active = conversation.id;
@@ -669,23 +756,40 @@ function estimateTokens(text) {
 * (the {@link import('./types.js').AgentOptions} `window`).
 *
 * @remarks
-* Sums {@link estimateTokens} over each message's `content` (the `ceil(length / 4)` char
-* heuristic), so it is deterministic and provider-free — the same messages always yield the
-* same estimate, with an empty batch `0`. It is the fully-swappable default an agent's
-* auto-compaction context budget charges each turn's new messages through; a caller wanting a
-* sharper count supplies its own `consume` to `createBudget` instead. Total — never throws.
+* Sums, per message, {@link estimateTokens} over its `content` (the `ceil(length / 4)` char
+* heuristic) PLUS {@link import('./constants.js').MESSAGE_TOKEN_OVERHEAD} (a fixed per-message
+* role/framing overhead) PLUS, when present, {@link estimateTokens} over its JSON-stringified
+* `calls` PLUS `images.length * `{@link import('./constants.js').IMAGE_TOKEN_ESTIMATE} (a coarse,
+* deliberately-approximate per-image cost — a base64 length is NOT a token proxy). Deterministic
+* and provider-free — the same messages always yield the same estimate, with an empty batch `0`.
+* It is the fully-swappable default an agent's auto-compaction context budget charges each
+* turn's new messages through; a caller wanting a sharper count supplies its own `consume` to
+* `createBudget` instead. Total — never throws: a `calls` `JSON.stringify` that throws (a
+* circular `ToolCall.arguments`) is caught and replaced with a conservative fixed contribution of
+* {@link import('./constants.js').MESSAGE_TOKEN_OVERHEAD} (the same per-message overhead scale)
+* instead of estimating the (unreachable) serialized length.
 *
 * @param messages - The messages to estimate (a turn's appended assistant + tool messages)
-* @returns The summed estimated token count (`Σ estimateTokens(m.content)`; `0` when empty)
+* @returns The summed estimated token count (`0` when empty)
 *
 * @example
 * ```ts
 * estimateMessages([]) // 0
-* estimateMessages([{ id: '1', role: 'user', content: 'hello' }]) // 2
+* estimateMessages([{ id: '1', role: 'user', content: 'hello' }]) // 6  (2 content + 4 overhead)
 * ```
 */
 function estimateMessages(messages) {
-	return messages.reduce((sum, message) => sum + estimateTokens(message.content), 0);
+	return messages.reduce((sum, message) => {
+		const content = estimateTokens(message.content) + 4;
+		let calls = 0;
+		if (message.calls?.length) try {
+			calls = estimateTokens(JSON.stringify(message.calls));
+		} catch {
+			calls = 4;
+		}
+		const images = (message.images?.length ?? 0) * 512;
+		return sum + content + calls + images;
+	}, 0);
 }
 /**
 * Run one rehydrated agent and apply the partial-as-configurable-failure policy — the
@@ -715,6 +819,38 @@ async function settleAgentJob(agent, allowPartial) {
 	return result;
 }
 /**
+* Handle one queued agent job by rehydrating it through a registry with the queue
+* attempt's signal, then applying the shared partial-result policy.
+*
+* @param registry - The registry that rehydrates the serializable job
+* @param allowPartial - Whether a partial result resolves instead of throwing
+* @param input - The serializable agent job
+* @param execution - The queue attempt whose signal bounds the agent
+* @returns The settled agent result
+*/
+function handleAgentQueueJob(registry, allowPartial, input, execution) {
+	return settleAgentJob(registry.build(input, execution.signal), allowPartial);
+}
+/**
+* Handle one runner agent job by fanning out its declared children, rehydrating the
+* parent through a registry with the controller signal, and applying the shared
+* partial-result policy.
+*
+* @remarks
+* Children are fired and tracked through the runner controller without awaiting them
+* inline, preserving bounded-runner progress.
+*
+* @param registry - The registry that rehydrates serializable jobs
+* @param allowPartial - Whether a partial result resolves instead of throwing
+* @param controller - The runner controller for this parent job
+* @returns The settled parent agent result
+*/
+function handleAgentRunnerJob(registry, allowPartial, controller) {
+	const children = controller.input.children;
+	if (children !== void 0) for (const child of children) controller.spawn(child);
+	return settleAgentJob(registry.build(controller.input, controller.signal), allowPartial);
+}
+/**
 * Whether a {@link FileContent} is the TEXT arm — the narrowing guard for the text-vs-binary
 * union (AGENTS §14: narrow an untyped arm via a guard, never an `as`).
 *
@@ -1311,6 +1447,40 @@ function fencedFile(path, language, content) {
 function escapeRegExp(value) {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+/**
+* Sanitize one reported token count into a safe non-negative integer.
+*
+* @param value - The token count to sanitize
+* @returns The floored count, or `0` when the value is non-finite or non-positive
+*/
+function sanitizeToken(value) {
+	return Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+/**
+* Sanitize a {@link TokenUsage} into safe, non-negative integers — the guard an agent's
+* abort-usage path applies to a provider's partial usage before it is charged against a
+* budget or folded into the run total.
+*
+* @remarks
+* Per field (`prompt` / `completion` / `total`): a non-finite value (`NaN`, `+Infinity`,
+* `-Infinity`) or a negative value floors to `0`; a fractional value floors to its
+* non-negative integer part. No upper cap is applied. Total — never throws.
+*
+* @param usage - The token usage to sanitize (e.g. a provider's abort-partial usage)
+* @returns A new {@link TokenUsage} with every field a safe non-negative integer
+*
+* @example
+* ```ts
+* sanitizeUsage({ prompt: -5, completion: NaN, total: 12.7 }) // { prompt: 0, completion: 0, total: 12 }
+* ```
+*/
+function sanitizeUsage(usage) {
+	return {
+		prompt: sanitizeToken(usage.prompt),
+		completion: sanitizeToken(usage.completion),
+		total: sanitizeToken(usage.total)
+	};
+}
 //#endregion
 //#region src/core/instructions/Instruction.ts
 /**
@@ -1392,8 +1562,8 @@ var InstructionManager = class {
 	#format;
 	constructor(options) {
 		this.#emitter = new _orkestrel_emitter.Emitter({
-			on: options?.on,
-			error: options?.error
+			...options?.on === void 0 ? {} : { on: options.on },
+			...options?.error === void 0 ? {} : { error: options.error }
 		});
 		this.#format = options?.format;
 	}
@@ -1595,8 +1765,8 @@ var Workspace = class {
 	constructor(options, seed) {
 		this.#id = options?.id ?? crypto.randomUUID();
 		this.#emitter = new _orkestrel_emitter.Emitter({
-			on: options?.on,
-			error: options?.error
+			...options?.on === void 0 ? {} : { on: options.on },
+			...options?.error === void 0 ? {} : { error: options.error }
 		});
 		if (seed) for (const [path, file] of seed) this.#files.set(path, file);
 	}
@@ -1889,10 +2059,12 @@ var WorkspaceManager = class {
 		return [...this.#workspaces.values()];
 	}
 	add(input) {
+		const on = input?.on ?? this.#on;
+		const error = input?.error ?? this.#error;
 		const workspace = new Workspace({
 			...input?.id === void 0 ? {} : { id: input.id },
-			on: input?.on ?? this.#on,
-			error: input?.error ?? this.#error
+			...on === void 0 ? {} : { on },
+			...error === void 0 ? {} : { error }
 		}, input?.seed);
 		this.#workspaces.set(workspace.id, workspace);
 		if (this.#active === void 0) this.#active = workspace.id;
@@ -2236,6 +2408,7 @@ var Agent = class {
 	#signal;
 	#authority;
 	#window;
+	#strict;
 	#emitter;
 	id = crypto.randomUUID();
 	#status = "idle";
@@ -2243,9 +2416,12 @@ var Agent = class {
 	constructor(provider, options) {
 		this.#provider = provider;
 		this.#context = new AgentContext({
-			system: options?.system,
-			tools: options?.tools,
-			conversations: options?.conversations
+			...options?.system === void 0 ? {} : { system: options.system },
+			...options?.tools === void 0 ? {} : { tools: options.tools },
+			...options?.instructions === void 0 ? {} : { instructions: options.instructions },
+			...options?.workspaces === void 0 ? {} : { workspaces: options.workspaces },
+			...options?.scope === void 0 ? {} : { scope: options.scope },
+			...options?.conversations === void 0 ? {} : { conversations: options.conversations }
 		});
 		this.#limit = options?.limit ?? 10;
 		this.#timeoutMs = options?.timeout;
@@ -2254,9 +2430,10 @@ var Agent = class {
 		this.#signal = options?.signal;
 		this.#authority = options?.authority;
 		this.#window = options?.window;
+		this.#strict = options?.strict ?? false;
 		this.#emitter = new _orkestrel_emitter.Emitter({
-			on: options?.on,
-			error: options?.error
+			...options?.on === void 0 ? {} : { on: options.on },
+			...options?.error === void 0 ? {} : { error: options.error }
 		});
 	}
 	get emitter() {
@@ -2272,48 +2449,49 @@ var Agent = class {
 		return this.stream(options).result;
 	}
 	stream(options) {
+		if (this.#runs.size > 0 && (this.#window !== void 0 || this.#budget !== void 0 && options?.budget === void 0)) throw new AgentError("CONCURRENCY", "concurrent runs on one agent with a shared construction window/budget corrupt accounting; use separate agents or per-run budgets");
 		const timeoutMs = options?.timeout ?? this.#timeoutMs;
 		const timeout = timeoutMs === void 0 ? void 0 : (0, _orkestrel_timeout.createTimeout)({ ms: timeoutMs });
 		timeout?.start();
 		const budget = options?.budget ?? this.#budget;
 		budget?.start();
 		const limit = options?.limit ?? this.#limit;
-		const abort = (0, _orkestrel_abort.createAbort)({ signal: this.#parents(timeout, budget, options?.signal) });
+		const signal = this.#parents(timeout, budget, options?.signal);
+		const abort = (0, _orkestrel_abort.createAbort)(signal === void 0 ? {} : { signal });
 		this.#runs.add(abort);
 		this.#status = "running";
 		this.#emitter.emit("start", this.id);
-		const outcome = {
+		const state = { outcome: {
 			content: "",
 			thinking: void 0,
 			usage: void 0,
 			partial: false,
 			exhausted: false
-		};
+		} };
 		const channel = new Channel();
 		const settled = (0, _orkestrel_workflow.createDeferred)();
-		this.#pump(abort, outcome, timeout, channel, settled, options?.think, options?.schema, limit, budget);
+		this.#pump(abort, state, timeout, channel, settled, options?.think, options?.schema, limit, budget);
 		settled.promise.catch(() => {});
 		return {
 			events: this.#events(channel, abort),
 			result: settled.promise,
-			abort: (reason) => {
-				abort.abort(reason);
-			}
+			abort: abort.abort.bind(abort)
 		};
 	}
 	abort(reason) {
 		for (const abort of [...this.#runs]) abort.abort(reason);
 	}
-	async #pump(abort, outcome, timeout, channel, settled, think, schema, limit, budget) {
+	async #pump(abort, state, timeout, channel, settled, think, schema, limit, budget) {
 		let failure;
 		try {
-			for await (const chunk of this.#run(abort, outcome, think, schema, limit, budget)) channel.push(chunk);
+			for await (const chunk of this.#run(abort, state, think, schema, limit, budget)) channel.push(chunk);
 		} catch (error) {
 			failure = { error };
 		} finally {
 			timeout?.clear();
 			this.#runs.delete(abort);
 			if (failure === void 0) {
+				const outcome = state.outcome;
 				this.#status = "done";
 				channel.close();
 				const result = this.#result(outcome);
@@ -2336,7 +2514,7 @@ var Agent = class {
 			abort.abort();
 		}
 	}
-	async *#run(abort, outcome, think, schema, limit, budget) {
+	async *#run(abort, state, think, schema, limit, budget) {
 		const messages = [...this.#context.build(this.#provider.format)];
 		const tools = this.#context.tools;
 		let content = "";
@@ -2344,7 +2522,7 @@ var Agent = class {
 		let usage;
 		let pending = false;
 		let broke = false;
-		const compaction = { futile: false };
+		const compaction = { state: { futile: false } };
 		const compacting = this.#window !== void 0 && this.#context.conversations.active?.summarizable === true;
 		if (compacting) {
 			this.#window?.clear();
@@ -2356,14 +2534,20 @@ var Agent = class {
 				await this.#scheduler?.yield({ signal: abort.signal });
 			} catch (error) {
 				if (abort.signal.aborted) {
-					outcome.partial = true;
+					state.outcome = {
+						...state.outcome,
+						partial: true
+					};
 					broke = true;
 					break;
 				}
 				throw error;
 			}
 			if (abort.signal.aborted) {
-				outcome.partial = true;
+				state.outcome = {
+					...state.outcome,
+					partial: true
+				};
 				broke = true;
 				break;
 			}
@@ -2391,7 +2575,7 @@ var Agent = class {
 					if (isProviderAbortError(error)) {
 						if (error.partial.thinking !== void 0) thinking = this.#thought(thinking, error.partial.thinking);
 						if (error.partial.usage !== void 0) {
-							const abortUsage = error.partial.usage;
+							const abortUsage = sanitizeUsage(error.partial.usage);
 							budget?.consume({
 								prompt: abortUsage.prompt,
 								completion: Math.max(0, abortUsage.completion - charged),
@@ -2400,7 +2584,10 @@ var Agent = class {
 							usage = this.#sum(usage, abortUsage);
 						}
 					}
-					outcome.partial = true;
+					state.outcome = {
+						...state.outcome,
+						partial: true
+					};
 					broke = true;
 					break;
 				}
@@ -2408,16 +2595,17 @@ var Agent = class {
 			}
 			if (result.thinking !== void 0 && result.thinking.length > 0) thinking = this.#thought(thinking, result.thinking);
 			if (result.usage !== void 0) {
+				const resultUsage = sanitizeUsage(result.usage);
 				budget?.consume({
-					prompt: result.usage.prompt,
-					completion: Math.max(0, result.usage.completion - charged),
-					total: Math.max(0, result.usage.total - charged)
+					prompt: resultUsage.prompt,
+					completion: Math.max(0, resultUsage.completion - charged),
+					total: Math.max(0, resultUsage.total - charged)
 				});
-				usage = this.#sum(usage, result.usage);
-				this.#emitter.emit("usage", result.usage);
+				usage = this.#sum(usage, resultUsage);
+				this.#emitter.emit("usage", resultUsage);
 				yield {
 					type: "usage",
-					usage: result.usage
+					usage: resultUsage
 				};
 			}
 			if (result.tools !== void 0 && result.tools.length > 0) {
@@ -2457,17 +2645,21 @@ var Agent = class {
 			broke = true;
 			break;
 		}
-		if (!broke && pending) {
-			outcome.partial = true;
-			outcome.exhausted = !abort.signal.aborted;
-		}
-		outcome.content = content;
-		outcome.thinking = thinking;
-		outcome.usage = usage;
+		if (!broke && pending) state.outcome = {
+			...state.outcome,
+			partial: true,
+			exhausted: !abort.signal.aborted
+		};
+		state.outcome = {
+			...state.outcome,
+			content,
+			thinking,
+			usage
+		};
 	}
 	async #trim(messages, compaction, latchFutile) {
 		const conversation = this.#context.conversations.active;
-		if (this.#window === void 0 || conversation?.summarizable !== true || compaction.futile) return;
+		if (this.#window === void 0 || conversation?.summarizable !== true || compaction.state.futile) return;
 		this.#window.clear();
 		this.#window.consume(messages);
 		if (!this.#window.exhausted) return;
@@ -2476,10 +2668,11 @@ var Agent = class {
 			section = await conversation.compact();
 		} catch (error) {
 			this.#emitter.emit("compactError", error);
+			if (this.#strict) throw error;
 			return;
 		}
 		if (section === void 0) {
-			if (latchFutile) compaction.futile = true;
+			if (latchFutile) compaction.state = { futile: true };
 			return;
 		}
 		messages.splice(0, messages.length, ...this.#context.build(this.#provider.format));
@@ -2641,16 +2834,17 @@ var AgentRegistry = class {
 		return agent;
 	}
 	#options(input, signal) {
+		const budget = this.#budget(input.budget);
 		return {
-			system: input.system,
 			tools: this.#manager(input.tools),
-			limit: input.limit,
-			timeout: input.timeout,
-			budget: this.#budget(input.budget),
-			authority: input.authority === void 0 ? void 0 : this.authority(input.authority),
-			scheduler: input.scheduler === void 0 ? void 0 : this.scheduler(input.scheduler),
-			conversations: this.#store === void 0 ? void 0 : new ConversationManager({ store: this.#store }),
-			signal
+			...input.system === void 0 ? {} : { system: input.system },
+			...input.limit === void 0 ? {} : { limit: input.limit },
+			...input.timeout === void 0 ? {} : { timeout: input.timeout },
+			...budget === void 0 ? {} : { budget },
+			...input.authority === void 0 ? {} : { authority: this.authority(input.authority) },
+			...input.scheduler === void 0 ? {} : { scheduler: this.scheduler(input.scheduler) },
+			...this.#store === void 0 ? {} : { conversations: new ConversationManager({ store: this.#store }) },
+			...signal === void 0 ? {} : { signal }
 		};
 	}
 	#manager(names) {
@@ -2716,7 +2910,7 @@ var Authority = class {
 		for (const rule of this.#rules) if (rule.match(context)) return {
 			zone: rule.zone,
 			allowed: rule.allowed ?? true,
-			reason: rule.reason
+			...rule.reason === void 0 ? {} : { reason: rule.reason }
 		};
 		return this.#fallback;
 	}
@@ -2895,16 +3089,19 @@ var Scope = class Scope {
 	files;
 	constructor(input) {
 		this.name = input.name;
-		this.instructions = input.instructions === void 0 ? void 0 : [...input.instructions];
-		this.tools = input.tools === void 0 ? void 0 : [...input.tools];
-		this.files = input.files === void 0 ? void 0 : [...input.files];
+		if (input.instructions !== void 0) this.instructions = [...input.instructions];
+		if (input.tools !== void 0) this.tools = [...input.tools];
+		if (input.files !== void 0) this.files = [...input.files];
 	}
 	narrow(config) {
+		const instructions = Scope.#intersect(this.instructions, config.instructions);
+		const tools = Scope.#intersect(this.tools, config.tools);
+		const files = Scope.#intersect(this.files, config.files);
 		return new Scope({
 			name: this.name,
-			instructions: Scope.#intersect(this.instructions, config.instructions),
-			tools: Scope.#intersect(this.tools, config.tools),
-			files: Scope.#intersect(this.files, config.files)
+			...instructions === void 0 ? {} : { instructions },
+			...tools === void 0 ? {} : { tools },
+			...files === void 0 ? {} : { files }
 		});
 	}
 	static #intersect(parent, child) {
@@ -2948,8 +3145,8 @@ var ScopeManager = class {
 	#emitter;
 	constructor(on, error) {
 		this.#emitter = new _orkestrel_emitter.Emitter({
-			on,
-			error
+			...on === void 0 ? {} : { on },
+			...error === void 0 ? {} : { error }
 		});
 	}
 	get emitter() {
@@ -3139,9 +3336,9 @@ var Tool = class {
 	#execute;
 	constructor(options) {
 		this.name = options.name;
-		this.description = options.description;
-		this.summary = options.summary;
-		this.parameters = options.parameters;
+		if (options.description !== void 0) this.description = options.description;
+		if (options.summary !== void 0) this.summary = options.summary;
+		if (options.parameters !== void 0) this.parameters = options.parameters;
 		this.#execute = options.execute;
 	}
 	execute(args) {
@@ -3799,11 +3996,11 @@ function createAgentRegistry(options) {
 function createAgentQueue(options) {
 	const { registry, allowPartial = false, concurrency, retries, timeout, store } = options;
 	return (0, _orkestrel_queue.createQueue)({
-		concurrency,
-		retries,
-		timeout,
-		store,
-		handler: (input, execution) => settleAgentJob(registry.build(input, execution.signal), allowPartial)
+		...concurrency === void 0 ? {} : { concurrency },
+		...retries === void 0 ? {} : { retries },
+		...timeout === void 0 ? {} : { timeout },
+		...store === void 0 ? {} : { store },
+		handler: handleAgentQueueJob.bind(void 0, registry, allowPartial)
 	});
 }
 /**
@@ -3845,14 +4042,10 @@ function createAgentQueue(options) {
 function createAgentRunner(options) {
 	const { registry, allowPartial = false, concurrency, retries, timeout } = options;
 	return (0, _orkestrel_workflow.createRunner)({
-		concurrency,
-		retries,
-		timeout,
-		handler: (controller) => {
-			const children = controller.input.children;
-			if (children !== void 0) for (const child of children) controller.spawn(child);
-			return settleAgentJob(registry.build(controller.input, controller.signal), allowPartial);
-		}
+		...concurrency === void 0 ? {} : { concurrency },
+		...retries === void 0 ? {} : { retries },
+		...timeout === void 0 ? {} : { timeout },
+		handler: handleAgentRunnerJob.bind(void 0, registry, allowPartial)
 	});
 }
 /**
@@ -4064,6 +4257,7 @@ function createWorkspaceManager(options) {
 //#endregion
 exports.Agent = Agent;
 exports.AgentContext = AgentContext;
+exports.AgentError = AgentError;
 exports.AgentJobError = AgentJobError;
 exports.AgentRegistry = AgentRegistry;
 exports.Authority = Authority;
@@ -4078,8 +4272,10 @@ exports.DEFAULT_CONVERSATION_KEEP = DEFAULT_CONVERSATION_KEEP;
 exports.DatabaseConversationStore = DatabaseConversationStore;
 exports.DatabaseWorkspaceStore = DatabaseWorkspaceStore;
 exports.EXTENSION_TO_LANGUAGE = EXTENSION_TO_LANGUAGE;
+exports.IMAGE_TOKEN_ESTIMATE = IMAGE_TOKEN_ESTIMATE;
 exports.Instruction = Instruction;
 exports.InstructionManager = InstructionManager;
+exports.MESSAGE_TOKEN_OVERHEAD = MESSAGE_TOKEN_OVERHEAD;
 exports.MemoryConversationStore = MemoryConversationStore;
 exports.MemoryWorkspaceStore = MemoryWorkspaceStore;
 exports.ProviderAbortError = ProviderAbortError;
@@ -4129,7 +4325,10 @@ exports.estimateMessages = estimateMessages;
 exports.estimateTokens = estimateTokens;
 exports.fencedFile = fencedFile;
 exports.filterAllowList = filterAllowList;
+exports.handleAgentQueueJob = handleAgentQueueJob;
+exports.handleAgentRunnerJob = handleAgentRunnerJob;
 exports.inferLanguage = inferLanguage;
+exports.isAgentError = isAgentError;
 exports.isAgentJobError = isAgentJobError;
 exports.isBinary = isBinary;
 exports.isConversationError = isConversationError;
@@ -4146,6 +4345,8 @@ exports.isWorkspaceError = isWorkspaceError;
 exports.isWorkspaceSnapshot = isWorkspaceSnapshot;
 exports.offsetAt = offsetAt;
 exports.rangeOf = rangeOf;
+exports.sanitizeToken = sanitizeToken;
+exports.sanitizeUsage = sanitizeUsage;
 exports.settleAgentJob = settleAgentJob;
 exports.sliceRange = sliceRange;
 exports.spliceRange = spliceRange;