@arnilo/prism 0.0.10 → 0.0.12

package/CHANGELOG.md

@@ -5,6 +5,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 All notable changes to this project will be documented in this file.
 
+## [Unreleased]
+
+## [0.0.12] - 2026-07-22
+
+### Added
+
+- Optional `@arnilo/prism-ag-ui` package with bounded AG-UI mapper/authorized handler/replay and stable `./acp` sibling, built over shared durable resume streams.
+- `createCodingCompactionStrategy()` preset for bounded coding-session handoff.
+
+### Changed
+
+- Versioned all 35 first-party manifests and exact internal ranges to `0.0.12`; `@arnilo/prism-all` includes AG-UI while `@arnilo/prism-code` and `@arnilo/prism-sdk` remain free of UI protocol dependencies.
+- Added network-free interoperability/compaction evidence: `scripts/benchmark-0.0.12.mjs`.
+
+
+## [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

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,
@@ -214,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/agent-run-lifecycle.d.ts

@@ -1,4 +1,4 @@
-import type { Agent, AgentRunRef, AgentRunResult, AgentRunResume, AgentRunStatusResult, OwnershipScope } from "./contracts.js";
+import type { Agent, AgentEvent, AgentRunRef, AgentRunResult, AgentRunResume, AgentRunStatusResult, OwnershipScope, SubscribeOptions } from "./contracts.js";
 import type { CheckpointStore } from "./contracts.js";
 export interface AgentRunLifecycleAgent {
     readonly agent: Agent;
@@ -20,9 +20,13 @@ export interface AgentRunLifecycleRequest {
     /** Adapter-selected capability; stored runs for another agent are non-enumerable. */
     readonly agentId?: string;
 }
+/** Bounded live-event options for a durable lifecycle resume. */
+export interface AgentRunLifecycleStreamRequest extends AgentRunLifecycleRequest, SubscribeOptions {
+}
 export interface AgentRunLifecycle {
     status(ref: AgentRunRef, options?: AgentRunLifecycleRequest): Promise<AgentRunStatusResult>;
     resume(ref: AgentRunRef, resume: AgentRunResume, options?: AgentRunLifecycleRequest): Promise<AgentRunResult>;
+    resumeStream(ref: AgentRunRef, resume: AgentRunResume, options?: AgentRunLifecycleStreamRequest): AsyncIterable<AgentEvent>;
 }
 /** Host capability for durable agent status/resume. Adapters supply authorized ownership only. */
 export declare function createAgentRunLifecycle(options: AgentRunLifecycleOptions): AgentRunLifecycle;

package/dist/agent-run-lifecycle.js

@@ -1,6 +1,6 @@
 import { AgentRunStateError } from "./contracts.js";
 import { loadAgentRunState, publicState } from "./agent-run-state.js";
-import { resumeAgentRun } from "./agents.js";
+import { resumeAgentRun, resumeAgentRunStream } from "./agents.js";
 function assertAgentId(actual, expected) {
     if (expected !== undefined && actual !== expected)
         throw new AgentRunStateError("Agent run capability mismatch");
@@ -28,6 +28,22 @@ export function createAgentRunLifecycle(options) {
                 definitionRevision: resolved.definitionRevision,
             });
         },
+        async *resumeStream(ref, resume, request = {}) {
+            request.signal?.throwIfAborted();
+            const { state } = await loadAgentRunState(options.checkpoints, ref, request.ownership);
+            assertAgentId(state.agentId, request.agentId);
+            const resolved = await options.resolveAgent({ agentId: state.agentId, ownership: request.ownership, signal: request.signal });
+            request.signal?.throwIfAborted();
+            yield* resumeAgentRunStream(resolved.agent, ref, resume, {
+                checkpoints: options.checkpoints,
+                ownership: request.ownership,
+                fencingToken: options.fencingToken,
+                definitionRevision: resolved.definitionRevision,
+                signal: request.signal,
+                maxQueuedEvents: request.maxQueuedEvents,
+                overflow: request.overflow,
+            });
+        },
     };
 }
 //# sourceMappingURL=agent-run-lifecycle.js.map

package/dist/agents.d.ts

@@ -1,7 +1,9 @@
-import type { Agent, AgentConfig, AgentRunResult, AgentRunResume, AgentRunResumeOptions, AgentRunRef, AgentSession, AgentSessionConfig } from "./contracts.js";
+import type { Agent, AgentConfig, AgentEvent, AgentRunResult, AgentRunResume, AgentRunResumeOptions, AgentRunResumeStreamOptions, AgentRunRef, AgentSession, AgentSessionConfig } from "./contracts.js";
 export declare function createAgent(config: AgentConfig): Agent;
 export declare function createAgentSession(config: AgentSessionConfig & {
     readonly agent: Agent;
 }): AgentSession;
 /** Resume a persisted built-in run. A claimed/dispatched tool is never replayed automatically. */
 export declare function resumeAgentRun(agent: Agent, ref: AgentRunRef, resume: AgentRunResume, options: AgentRunResumeOptions): Promise<AgentRunResult>;
+/** Subscribe before resuming one durable run. Early consumer return aborts that resumed execution. */
+export declare function resumeAgentRunStream(agent: Agent, ref: AgentRunRef, resume: AgentRunResume, options: AgentRunResumeStreamOptions): AsyncGenerator<AgentEvent>;

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";
@@ -30,6 +30,32 @@ export function createAgentSession(config) {
 }
 /** Resume a persisted built-in run. A claimed/dispatched tool is never replayed automatically. */
 export async function resumeAgentRun(agent, ref, resume, options) {
+    return executePreparedAgentRunResume(await prepareAgentRunResume(agent, ref, resume, options));
+}
+/** Subscribe before resuming one durable run. Early consumer return aborts that resumed execution. */
+export async function* resumeAgentRunStream(agent, ref, resume, options) {
+    throwIfAbortedSignal(options.signal);
+    const prepared = await prepareAgentRunResume(agent, ref, resume, options, options.signal);
+    const subscription = prepared.session.subscribe(options);
+    let settled = false;
+    const runPromise = executePreparedAgentRunResume(prepared, options.signal).finally(() => { settled = true; });
+    try {
+        for await (const event of subscription) {
+            if ("runId" in event && event.runId !== ref.runId)
+                continue;
+            yield event;
+        }
+        await runPromise;
+    }
+    finally {
+        if (!settled) {
+            prepared.session.abort(new Error("resume stream consumer closed"));
+            await runPromise.catch(() => undefined);
+        }
+    }
+}
+async function prepareAgentRunResume(agent, ref, resume, options, signal) {
+    throwIfAbortedSignal(signal);
     const { record, state } = await loadAgentRunState(options.checkpoints, ref, options.ownership);
     if (state.definitionRevision !== options.definitionRevision || state.agentId !== (agent.config.id ?? agent.config.name) || state.fingerprint !== agentFingerprint(agent, options.definitionRevision)) {
         throw new AgentRunStateError("Agent definition revision or fingerprint mismatch on resume");
@@ -37,7 +63,9 @@ export async function resumeAgentRun(agent, ref, resume, options) {
     if (record.version !== resume.expectedVersion || state.status !== "suspended") {
         throw new AgentRunStateError("Stale or non-suspended agent run resume");
     }
+    const session = new RuntimeAgentSession({ agent, id: state.sessionId, leafId: state.leafId });
     if (resume.decision === "deny") {
+        throwIfAbortedSignal(signal);
         const denied = await saveAgentRunState({
             checkpoints: options.checkpoints,
             state: { ...state, status: "denied" },
@@ -45,10 +73,23 @@ export async function resumeAgentRun(agent, ref, resume, options) {
             ownership: options.ownership,
             fencingToken: options.fencingToken,
         });
-        const session = new RuntimeAgentSession({ agent, id: state.sessionId, leafId: state.leafId });
-        await session.recordDurableDenial(state.runId, state.interruption, denied.record.version, options.ownership);
-        const runState = publicState(denied.state);
-        return { sessionId: state.sessionId, runId: state.runId, status: "denied", leafId: state.leafId, text: "", content: [], runState, interruption: state.interruption };
+        return {
+            kind: "deny",
+            session,
+            interruption: state.interruption,
+            version: denied.record.version,
+            ownership: options.ownership,
+            result: {
+                sessionId: state.sessionId,
+                runId: state.runId,
+                status: "denied",
+                leafId: state.leafId,
+                text: "",
+                content: [],
+                runState: publicState(denied.state),
+                interruption: state.interruption,
+            },
+        };
     }
     if (state.pending?.status === "dispatched")
         throw new AgentRunStateError("Ambiguous dispatched tool requires operator resolution");
@@ -56,6 +97,7 @@ export async function resumeAgentRun(agent, ref, resume, options) {
     if (configured && (configured.checkpoints !== options.checkpoints || configured.definitionRevision !== options.definitionRevision)) {
         throw new AgentRunStateError("Agent durable run-state configuration mismatch on resume");
     }
+    throwIfAbortedSignal(signal);
     const claimed = await saveAgentRunState({
         checkpoints: options.checkpoints,
         state: { ...state, status: "running", interruption: undefined },
@@ -63,13 +105,25 @@ export async function resumeAgentRun(agent, ref, resume, options) {
         ownership: options.ownership,
         fencingToken: options.fencingToken,
     });
-    const session = new RuntimeAgentSession({ agent, id: state.sessionId, leafId: state.leafId });
-    return session.resumeDurable(claimed.state, configured ?? {
-        checkpoints: options.checkpoints,
-        definitionRevision: options.definitionRevision,
-        interruptBeforeTool: state.interruptBeforeTool,
-        fencingToken: options.fencingToken,
-    }, options.ownership);
+    return {
+        kind: "approve",
+        session,
+        state: claimed.state,
+        ownership: options.ownership,
+        runState: configured ?? {
+            checkpoints: options.checkpoints,
+            definitionRevision: options.definitionRevision,
+            interruptBeforeTool: state.interruptBeforeTool,
+            fencingToken: options.fencingToken,
+        },
+    };
+}
+async function executePreparedAgentRunResume(prepared, signal) {
+    if (prepared.kind === "deny") {
+        await prepared.session.recordDurableDenial(prepared.result.runId, prepared.interruption, prepared.version, prepared.ownership);
+        return prepared.result;
+    }
+    return prepared.session.resumeDurable(prepared.state, prepared.runState, prepared.ownership, signal);
 }
 class AgentRunSuspended extends Error {
     state;
@@ -91,6 +145,11 @@ class RuntimeAgentSession {
     currentLeafId;
     history = [];
     activeRun;
+    activeRunId;
+    activeProviderTurnAbort;
+    pendingSoftInterrupt = false;
+    pendingSteers = [];
+    pendingSteerBytes = 0;
     activeRedactor;
     activeProvider;
     activeLedger;
@@ -124,18 +183,48 @@ class RuntimeAgentSession {
     async run(input, options = {}) {
         return this.runInternal(input, options, randomId("run"));
     }
-    async resumeDurable(state, runState, ownership) {
-        return this.runInternal(state.input ?? [], { runState, ownership }, state.runId, { options: runState, state, version: state.version });
+    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, signal) {
+        return this.runInternal(state.input ?? [], { runState, ownership, signal }, state.runId, { options: runState, state, version: state.version });
     }
     async recordDurableDenial(runId, interruption, version, ownership) {
         this.activeLedger = this.agent.config.runLedger;
         this.activeOwnership = ownership ?? this.agent.config.ownership;
         this.activeRedactor = this.agent.config.redactor;
-        this.emit({ type: "agent_denied", sessionId: this.id, runId, interruption, version });
-        await this.drainLedger();
-        this.activeLedger = undefined;
-        this.activeOwnership = undefined;
-        this.activeRedactor = undefined;
+        try {
+            this.emit({ type: "agent_denied", sessionId: this.id, runId, interruption, version });
+            await this.drainLedger();
+        }
+        finally {
+            this.activeLedger = undefined;
+            this.activeOwnership = undefined;
+            this.activeRedactor = undefined;
+            this.closeSubscribers();
+        }
     }
     async runInternal(input, options, runId, resumed) {
         if (this.agent.config.secure && (options.redactor !== undefined || options.ownership !== undefined || options.validate !== undefined || options.runState !== undefined)) {
@@ -165,6 +254,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;
@@ -327,7 +420,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({
@@ -367,6 +468,8 @@ 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;
@@ -443,6 +546,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) {
@@ -693,7 +801,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);
@@ -745,9 +853,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);
@@ -791,7 +908,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),
                 }));
@@ -811,6 +928,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();
@@ -827,6 +957,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)];
@@ -987,6 +1144,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];

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;
+};