@arnilo/prism 0.0.8 → 0.0.11

package/CHANGELOG.md

@@ -1,11 +1,52 @@
 # Changelog
 
-All notable changes to this project will be documented in this file.
-
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## Unreleased
+All notable changes to this project will be documented in this file.
+
+## [Unreleased]
+
+## [0.0.11] - 2026-07-22
+
+### Added
+
+- Coding harness fundamentals for 0.0.11 (Plan 074): bounded `SessionIndex`/`searchSessions` (SQLite/Postgres FTS migration 004; memory linear|unsupported; JSONL unsupported), assembler `contextBudget` + omission reports, `@arnilo/prism-provider-anthropic` + `@arnilo/prism-provider-google`, mid-run `AgentSession.steer` / RPC steer, coding-agent `runCodingGoalVerify` and opt-in `ask_user_decision` (multi/free-text/durable suspend glue).
+- Opt-in `structuredOutputTiming: "final-turn-only"` on `generate-validate-revise` (default `"every-turn"`): tool-eligible turns omit native schema so models can call tools; artifact/revision turns attach schema and withdraw tools.
+
+### Changed
+
+- Versioned all 34 first-party manifests and exact internal ranges to `0.0.11` (adds `@arnilo/prism-provider-anthropic` + `@arnilo/prism-provider-google` to the publishable graph and `@arnilo/prism-providers` umbrella).
+- Network-free search/budget evidence: `scripts/benchmark-0.0.11.mjs`.
+
+## [0.0.10] - 2026-07-21
+
+### Changed
+
+- Coding harness workspace modes (Phase 5): required `workspaceMode` on `@arnilo/prism-coding-security` composition; sandbox mode unifies shell/FS on one disposable tree; host mode never claims containment; fail-closed mixed wiring + `allowMixedWorkspaceWiring` escape hatch; import/export tree identity; `scripts/benchmark-0.0.10.mjs` evidence.
+- Versioned all 32 first-party manifests and exact internal ranges from the post-ship `0.0.96` graph to `0.0.10` for the roadmap Phase 5 release line.
+
+## [0.0.96] - 2026-07-21
+
+### Changed
+
+- Package graph and runtime version pins bumped from 0.0.9 to 0.0.96 for a clean publish tag after the mistaken `v0.0.95` tag and TypeScript 7 / workspace-order CI fixes.
+
+## [0.0.9] - 2026-07-21
+
+### Added
+
+- Production coding and browser execution for Release 0.0.9: disposable Docker sandbox, bounded native repository list/search, structured Git/named checks/PR handoff, durable coding-plan/checkpoint composition, and optional `@arnilo/prism-browser` with egress/side-effect/upload/download/screenshot policy.
+- Versioned all 32 first-party manifests and exact internal ranges to 0.0.9 (adds `@arnilo/prism-browser` to the publishable graph; browser stays out of `@arnilo/prism-code` and activates only through explicit install or `@arnilo/prism-all`).
+- Added network-free coding/browser adversarial evaluation fixtures, `scripts/benchmark-0.0.9.mjs`, and protected Docker/Playwright gates via `.github/workflows/sandbox-browser.yml`.
+- Office execution remains outside Prism packaging by product decision (host-selected skills/instructions only).
+- `tryParseJsonObjectArguments` and `toolCallFromArgumentsText` for recoverable streamed tool-call argument parsing.
+
+### Fixed
+
+- Malformed streamed tool-call arguments (id+name present) become failed/`tool_execution_blocked` tool results (`invalid_arguments` / `invalid_json_arguments`) instead of terminal `ProviderTransportError`, so models can self-correct within existing turn budgets.
+- Incomplete tool-call deltas (missing id/name) fail with typed `ProviderTransportError` / `ErrorInfo.code: "incomplete_delta"` instead of a bare `Error("Incomplete tool call delta...")`; openai-compatible streams no longer emit `done` alongside leftover incomplete deltas.
+- Empty/whitespace-only call-free artifact candidates (including thinking-only output) are `parse_error` through the revision budget; `generate-validate-revise` session runs no longer resolve `succeeded` without `artifact_finished`.
 
 ## [0.0.8] - 2026-07-20
 

package/dist/agent-loops.d.ts

@@ -7,6 +7,7 @@ export declare function generateValidateReviseLoop(opts: {
     readonly repairer?: ArtifactRepairer<unknown>;
     readonly maxRevisions?: number;
     readonly toolCalls?: "disabled" | "bounded";
+    readonly structuredOutputTiming?: "every-turn" | "final-turn-only";
 }): AgentLoopStrategy;
 export declare function resolveToolConcurrency(options: {
     loop?: AgentLoopStrategy | AgentLoopOptions;

package/dist/agent-loops.js

@@ -1,5 +1,6 @@
 import { inputMessages } from "./input.js";
 import { createId } from "./ids.js";
+import { artifactStructuredOutputRequest, withoutStructuredOutput } from "./structured-output.js";
 function throwIfAborted(signal) {
     if (signal.aborted)
         throw signal.reason instanceof Error ? signal.reason : new Error("Agent run aborted");
@@ -23,6 +24,7 @@ export const singleShotLoop = {
         let nextInput = ctx.input;
         for (let turn = 1;; turn += 1) {
             throwIfAborted(ctx.signal);
+            await ctx.applyPendingSteers?.();
             ctx.emit({ type: "turn_started", sessionId: ctx.sessionId, runId: ctx.runId, turn });
             const request = await ctx.assemble(nextInput, undefined, turn);
             throwIfAborted(ctx.signal);
@@ -37,8 +39,14 @@ export const singleShotLoop = {
                 ctx.emit({ type: "message_finished", sessionId: ctx.sessionId, runId: ctx.runId, message });
             }
             ctx.emit({ type: "turn_finished", sessionId: ctx.sessionId, runId: ctx.runId, turn });
-            if (calls.length === 0 || toolRounds >= ctx.maxToolRounds)
+            if (calls.length === 0 || toolRounds >= ctx.maxToolRounds) {
+                // Soft-interrupt / late steer: keep same run going when queue still has text.
+                if (await ctx.applyPendingSteers?.()) {
+                    nextInput = [];
+                    continue;
+                }
                 break;
+            }
             toolRounds += 1;
             await dispatchToolCallsInOrder(calls, ctx);
             nextInput = [];
@@ -61,6 +69,7 @@ function defaultRepairer() {
 export function generateValidateReviseLoop(opts) {
     const max = opts.maxRevisions ?? 3;
     const repairer = opts.repairer ?? defaultRepairer();
+    const finalOnly = opts.structuredOutputTiming === "final-turn-only" && opts.toolCalls === "bounded";
     return {
         name: "generate-validate-revise",
         async run(ctx) {
@@ -69,10 +78,24 @@ export function generateValidateReviseLoop(opts) {
             let pendingHistory = [];
             let toolRounds = 0;
             let attempts = 0;
+            let artifactPhase = !finalOnly;
+            let savedSchema;
             for (let turn = 1; attempts <= max; turn += 1) {
                 throwIfAborted(ctx.signal);
+                await ctx.applyPendingSteers?.();
                 ctx.emit({ type: "turn_started", sessionId: ctx.sessionId, runId: ctx.runId, turn });
-                const request = await ctx.assemble(nextInput, undefined, turn);
+                let request = await ctx.assemble(nextInput, undefined, turn);
+                if (request.options?.structuredOutput)
+                    savedSchema ??= request.options.structuredOutput;
+                if (finalOnly) {
+                    if (!artifactPhase && toolRounds < ctx.maxToolRounds) {
+                        request = withoutStructuredOutput(request);
+                    }
+                    else {
+                        artifactPhase = true;
+                        request = artifactStructuredOutputRequest(request, savedSchema);
+                    }
+                }
                 throwIfAborted(ctx.signal);
                 const { content, calls, messageId, started, usage: turnUsage } = await ctx.generate(request);
                 usage = turnUsage ?? usage;
@@ -100,6 +123,17 @@ export function generateValidateReviseLoop(opts) {
                     nextInput = [];
                     continue;
                 }
+                // Soft-interrupt / late steer before treating empty/final output as artifact work.
+                if (await ctx.applyPendingSteers?.()) {
+                    nextInput = [];
+                    continue;
+                }
+                // Call-free during tool phase → one more turn with schema on / tools off.
+                if (finalOnly && !artifactPhase) {
+                    artifactPhase = true;
+                    nextInput = [];
+                    continue;
+                }
                 const artifactCtx = {
                     sessionId: ctx.sessionId,
                     runId: ctx.runId,
@@ -111,9 +145,13 @@ export function generateValidateReviseLoop(opts) {
                     .filter((b) => b.type === "text")
                     .map((b) => b.text)
                     .join("");
-                const parsed = opts.parser
-                    ? await opts.parser(text, artifactCtx)
-                    : { ok: true, value: text };
+                // Empty/whitespace-only call-free output is a parse failure (thinking-only
+                // models must not succeed with an empty artifact via the identity parser).
+                const parsed = text.trim() === ""
+                    ? { ok: false, error: "no artifact text in model output" }
+                    : opts.parser
+                        ? await opts.parser(text, artifactCtx)
+                        : { ok: true, value: text };
                 // Parse failure consumes revision budget like a validation failure; the
                 // repairer receives `undefined` value plus a synthetic parse issue.
                 const parseFailure = !parsed.ok || parsed.value === undefined
@@ -210,6 +248,7 @@ export function resolveLoop(options, config) {
                 repairer: loop.repairer,
                 maxRevisions: loop.maxRevisions,
                 toolCalls: loop.toolCalls,
+                structuredOutputTiming: loop.structuredOutputTiming,
             });
         }
         throw new Error(`Unknown agent loop strategy: ${strategy}`);

package/dist/agents.js

@@ -1,4 +1,4 @@
-import { AgentRunError, AgentRunStateError } from "./contracts.js";
+import { AgentRunError, AgentRunStateError, DEFAULT_MAX_PENDING_STEER_BYTES, DEFAULT_MAX_PENDING_STEERS, } from "./contracts.js";
 import { resolveLoop, resolveToolConcurrency } from "./agent-loops.js";
 import { createId } from "./ids.js";
 import { assertGuardrailsAllowed, GuardrailError, runGuardrails } from "./guardrails.js";
@@ -91,6 +91,11 @@ class RuntimeAgentSession {
     currentLeafId;
     history = [];
     activeRun;
+    activeRunId;
+    activeProviderTurnAbort;
+    pendingSoftInterrupt = false;
+    pendingSteers = [];
+    pendingSteerBytes = 0;
     activeRedactor;
     activeProvider;
     activeLedger;
@@ -124,6 +129,31 @@ class RuntimeAgentSession {
     async run(input, options = {}) {
         return this.runInternal(input, options, randomId("run"));
     }
+    steer(input, options = {}) {
+        if (!this.activeRun || !this.activeRunId)
+            throw new Error("Agent session has no active run to steer");
+        const messages = inputToMessages(input).map((message) => this.redact(message));
+        if (messages.length === 0)
+            throw new Error("steer requires non-empty input");
+        let addBytes = 0;
+        for (const message of messages)
+            addBytes += messageTextBytes(message);
+        if (this.pendingSteers.length + messages.length > DEFAULT_MAX_PENDING_STEERS) {
+            throw new Error(`steer queue exceeds max pending messages (${DEFAULT_MAX_PENDING_STEERS})`);
+        }
+        if (this.pendingSteerBytes + addBytes > DEFAULT_MAX_PENDING_STEER_BYTES) {
+            throw new Error(`steer queue exceeds max pending bytes (${DEFAULT_MAX_PENDING_STEER_BYTES})`);
+        }
+        this.pendingSteers.push(...messages);
+        this.pendingSteerBytes += addBytes;
+        this.emit({ type: "queue_updated", sessionId: this.id, runId: this.activeRunId, size: this.pendingSteers.length });
+        if (options.softInterrupt) {
+            if (this.activeProviderTurnAbort)
+                this.activeProviderTurnAbort.abort(new SteerSoftInterrupt());
+            else
+                this.pendingSoftInterrupt = true;
+        }
+    }
     async resumeDurable(state, runState, ownership) {
         return this.runInternal(state.input ?? [], { runState, ownership }, state.runId, { options: runState, state, version: state.version });
     }
@@ -165,6 +195,10 @@ class RuntimeAgentSession {
         const controller = new AbortController();
         const cleanupSignal = bridgeAbort(options.signal, controller);
         this.activeRun = controller;
+        this.activeRunId = runId;
+        this.pendingSteers = [];
+        this.pendingSteerBytes = 0;
+        this.pendingSoftInterrupt = false;
         this.activeRedactor = options.redactor ?? this.agent.config.redactor;
         this.activeLedger = options.runLedger ?? this.agent.config.runLedger;
         this.activeOwnership = options.ownership ?? this.agent.config.ownership;
@@ -274,6 +308,8 @@ class RuntimeAgentSession {
             };
             // ponytail: LoopContext binds existing private helpers; loop orchestrates only.
             let assembledTurn = false;
+            let artifactFinished = false;
+            let artifactFailedInfo;
             const ctx = {
                 sessionId: this.id,
                 runId,
@@ -325,7 +361,15 @@ class RuntimeAgentSession {
                     assembledTurn = false;
                     const policyResult = await this.applyProviderRequestPolicies(request, runId, options, metadata, controller.signal);
                     const middlewareRequest = await this.agent.config.middleware?.run("provider_request", policyResult.request) ?? policyResult.request;
-                    return this.generateWithRetry(this.redactProviderRequest(middlewareRequest), runId, options, controller.signal, policyResult.secrets, this.activeLoopTurn, recordProviderUsage);
+                    try {
+                        return await this.generateWithRetry(this.redactProviderRequest(middlewareRequest), runId, options, controller.signal, policyResult.secrets, this.activeLoopTurn, recordProviderUsage);
+                    }
+                    catch (error) {
+                        if (isSteerSoftInterrupt(error)) {
+                            return { content: [], calls: [], started: false, usage: undefined };
+                        }
+                        throw error;
+                    }
                 },
                 isToolCallExclusive: (call) => registry.get(call.name)?.exclusive === true,
                 dispatchToolCall: (call) => dispatchToolCall({
@@ -365,9 +409,21 @@ class RuntimeAgentSession {
                     validate,
                 }),
                 appendMessage: (message) => this.appendMessage(message, runId),
+                hasPendingSteers: () => this.pendingSteers.length > 0,
+                applyPendingSteers: () => this.applyPendingSteers(runId, metadata, controller.signal),
                 emit: (event) => {
                     if (event.type === "turn_started")
                         this.activeLoopTurn = event.turn;
+                    if (event.type === "artifact_finished")
+                        artifactFinished = true;
+                    if (event.type === "artifact_failed") {
+                        const first = event.result.errors?.[0];
+                        const reason = event.result.metadata?.reason;
+                        artifactFailedInfo = {
+                            message: first?.message ?? "artifact failed",
+                            code: typeof reason === "string" || typeof reason === "number" ? reason : "artifact_failed",
+                        };
+                    }
                     this.emit(event);
                 },
             };
@@ -380,6 +436,9 @@ class RuntimeAgentSession {
                 });
             }
             const loopUsage = await loop.run(ctx);
+            if (loop.name === "generate-validate-revise" && !artifactFinished) {
+                throw Object.assign(new Error(artifactFailedInfo?.message ?? "artifact loop ended without a validated artifact"), { name: "ArtifactFailed", code: artifactFailedInfo?.code ?? "artifact_failed" });
+            }
             usage = runUsage.value() ?? loopUsage;
             if (usage && this.activeLedger) {
                 const usageRecord = {
@@ -428,6 +487,11 @@ class RuntimeAgentSession {
         finally {
             if (this.activeRun === controller)
                 this.activeRun = undefined;
+            this.activeRunId = undefined;
+            this.activeProviderTurnAbort = undefined;
+            this.pendingSoftInterrupt = false;
+            this.pendingSteers = [];
+            this.pendingSteerBytes = 0;
             try {
                 await this.drainLedger();
                 if (this.activeLedger) {
@@ -678,7 +742,7 @@ class RuntimeAgentSession {
                 return await this.generateProviderTurn(request, runId, signal, secrets, turn, attempt, recordUsage);
             }
             catch (error) {
-                if (error instanceof GuardrailError)
+                if (error instanceof GuardrailError || isSteerSoftInterrupt(error))
                     throw error;
                 const failure = error instanceof ProviderTurnFailure ? error : undefined;
                 const info = failure ? redactSecrets(failure.info, secrets) : errorToErrorInfo(error, secrets);
@@ -730,9 +794,18 @@ class RuntimeAgentSession {
             usageRecorded = true;
             await recordUsage?.(usage, turn, attempt);
         };
+        const turnAbort = new AbortController();
+        const cleanupTurn = bridgeAbort(signal, turnAbort);
+        this.activeProviderTurnAbort = turnAbort;
+        if (this.pendingSoftInterrupt) {
+            this.pendingSoftInterrupt = false;
+            turnAbort.abort(new SteerSoftInterrupt());
+        }
+        const turnRequest = { ...request, signal: turnAbort.signal };
         try {
-            for await (const event of this.activeProvider.generate(request)) {
-                throwIfAborted(signal);
+            throwIfAborted(turnAbort.signal);
+            for await (const event of this.activeProvider.generate(turnRequest)) {
+                throwIfAborted(turnAbort.signal);
                 this.activeLimits.charge("maxResponseBytes", jsonBytes(event));
                 if (event.type === "error")
                     throw new ProviderTurnFailure(event.error, started);
@@ -776,7 +849,7 @@ class RuntimeAgentSession {
                     stage: "output",
                     guardrails: this.activeGuardrails,
                     value: { content, calls, messageId, started, usage },
-                    context: { sessionId: this.id, runId, metadata: this.activeMetadata ?? {}, signal },
+                    context: { sessionId: this.id, runId, metadata: this.activeMetadata ?? {}, signal: turnAbort.signal },
                     redactor: this.activeRedactor,
                     emit: (event) => this.emit(event),
                 }));
@@ -796,6 +869,19 @@ class RuntimeAgentSession {
             return { content, calls, messageId, started, usage };
         }
         catch (error) {
+            if (isSteerSoftInterrupt(error) || isSteerSoftInterrupt(turnAbort.signal.reason)) {
+                await recordTurnUsage();
+                const latencyMs = Math.round(performance.now() - startedAt);
+                this.emit({
+                    type: "provider_turn_finished",
+                    sessionId: this.id,
+                    runId,
+                    turn,
+                    metadata: buildMetadata({ latencyMs }),
+                    usage,
+                });
+                throw new SteerSoftInterrupt();
+            }
             const latencyMs = Math.round(performance.now() - startedAt);
             const info = error instanceof ProviderTurnFailure ? redactSecrets(error.info, secrets) : errorToErrorInfo(error, secrets);
             await recordTurnUsage();
@@ -812,6 +898,33 @@ class RuntimeAgentSession {
                 throw error;
             throw new ProviderTurnFailure(info, started);
         }
+        finally {
+            cleanupTurn();
+            if (this.activeProviderTurnAbort === turnAbort)
+                this.activeProviderTurnAbort = undefined;
+        }
+    }
+    async applyPendingSteers(runId, metadata, signal) {
+        if (this.pendingSteers.length === 0)
+            return false;
+        const drained = this.pendingSteers.splice(0);
+        this.pendingSteerBytes = 0;
+        this.emit({ type: "queue_updated", sessionId: this.id, runId, size: 0 });
+        for (const message of drained) {
+            throwIfAborted(signal);
+            const inputGuardrails = await runGuardrails({
+                stage: "input",
+                guardrails: this.activeGuardrails,
+                value: [message],
+                context: { sessionId: this.id, runId, metadata, signal },
+                redactor: this.activeRedactor,
+                emit: (event) => this.emit(event),
+            });
+            assertGuardrailsAllowed(inputGuardrails);
+            this.history.push(message);
+            await this.appendMessage(message, runId);
+        }
+        return true;
     }
     async applyProviderRequestPolicies(request, runId, options, metadata, signal) {
         const policies = [...policyList(this.agent.config.providerRequestPolicies), ...policyList(options.providerRequestPolicies)];
@@ -972,6 +1085,27 @@ function inputToMessages(input) {
         return [input];
     return [...input];
 }
+const steerTextEncoder = new TextEncoder();
+function messageTextBytes(message) {
+    let total = 0;
+    for (const block of message.content) {
+        if (block.type === "text")
+            total += steerTextEncoder.encode(block.text).byteLength;
+    }
+    return total;
+}
+const STEER_SOFT_INTERRUPT_CODE = "steer_soft_interrupt";
+class SteerSoftInterrupt extends Error {
+    code = STEER_SOFT_INTERRUPT_CODE;
+    constructor() {
+        super("Provider turn soft-interrupted by steer");
+        this.name = "SteerSoftInterrupt";
+    }
+}
+function isSteerSoftInterrupt(error) {
+    return error instanceof SteerSoftInterrupt
+        || (typeof error === "object" && error !== null && error.code === STEER_SOFT_INTERRUPT_CODE);
+}
 function finalAssistantMessage(history) {
     for (let index = history.length - 1; index >= 0; index -= 1) {
         const message = history[index];
@@ -999,7 +1133,7 @@ function policyList(policies) {
     return "apply" in policies ? [policies] : policies;
 }
 function errorFromInfo(error) {
-    return Object.assign(new Error(error.message), { name: error.name ?? "Error", cause: error.cause });
+    return Object.assign(new Error(error.message), { name: error.name ?? "Error", cause: error.cause, code: error.code });
 }
 class ProviderTurnFailure extends Error {
     info;

package/dist/context-budget.d.ts

@@ -0,0 +1,63 @@
+import type { ContextBlock, InputAssemblyLayout, Message, ProviderRequest, Skill, ToolDefinition } from "./contracts.js";
+/** Assembler-time input budget. At least one max required when present. */
+export interface ContextBudget {
+    readonly maxInputTokens?: number;
+    readonly maxInputBytes?: number;
+    readonly reportOmissions?: boolean;
+}
+export type ContextBudgetOmissionKind = "skills" | "context" | "history" | "tool_results" | "summaries" | "attachments" | "tools";
+export interface ContextBudgetOmission {
+    readonly kind: ContextBudgetOmissionKind;
+    readonly id?: string;
+    readonly tokenEstimate: number;
+    readonly byteLength: number;
+}
+export interface ContextBudgetReport {
+    readonly omitted: readonly ContextBudgetOmission[];
+    readonly keptTokens: number;
+    readonly keptBytes: number;
+    readonly maxInputTokens?: number;
+    readonly maxInputBytes?: number;
+    readonly truncated: boolean;
+}
+export interface ContextBudgetMessageGroups {
+    readonly instructions: readonly Message[];
+    readonly summaries: readonly Message[];
+    readonly history: readonly Message[];
+    readonly input: readonly Message[];
+    readonly attachments: readonly Message[];
+    readonly toolResults: readonly Message[];
+}
+export declare const CONTEXT_BUDGET_REPORT_METADATA_KEY: "contextBudgetReport";
+export declare const HARD_MAX_CONTEXT_BUDGET_TOKENS = 2000000;
+export declare const HARD_MAX_CONTEXT_BUDGET_BYTES: number;
+export declare const DEFAULT_MAX_CONTEXT_BUDGET_OMISSIONS = 256;
+export declare const HARD_MAX_CONTEXT_BUDGET_OMISSIONS = 1024;
+export declare const CONTEXT_BUDGET_ERROR_CODE: "context_budget_exceeded";
+export declare class ContextBudgetError extends Error {
+    readonly code: "context_budget_exceeded";
+    constructor(message?: string);
+}
+export declare function isContextBudgetError(error: unknown): error is ContextBudgetError;
+/** UTF-16 code units / 4. Estimate only — not billing. */
+export declare function estimateTextTokens(text: string): number;
+export declare function estimateTextBytes(text: string): number;
+export declare function estimateMessageTokens(message: Message): number;
+export declare function estimateMessageBytes(message: Message): number;
+export declare function estimateAssemblyTokens(messages: readonly Message[]): number;
+export declare function resolveContextBudget(budget: ContextBudget): Required<Pick<ContextBudget, "reportOmissions">> & ContextBudget;
+export declare function getContextBudgetReport(request: ProviderRequest): ContextBudgetReport | undefined;
+export declare function applyContextBudget(options: {
+    readonly groups: ContextBudgetMessageGroups;
+    readonly context?: readonly ContextBlock[];
+    readonly skills?: readonly Skill[];
+    readonly tools?: readonly ToolDefinition[];
+    readonly budget: ContextBudget;
+    readonly layout?: InputAssemblyLayout;
+}): {
+    readonly groups: ContextBudgetMessageGroups;
+    readonly context: readonly ContextBlock[];
+    readonly skills: readonly Skill[];
+    readonly tools: readonly ToolDefinition[] | undefined;
+    readonly report: ContextBudgetReport;
+};