@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/runtime/request/handler.js

@@ -1,8 +1,13 @@
+import { hasSuperContextContract } from "../context/super-context-policy.js";
+import { TerminalResponseAppend } from "../session/terminal-response.js";
+import { boundedSuperFailureCode } from "../steps/degraded-finalization/super.js";
+import { composeSuperFailureMessage } from "./super-failure-message.js";
 import { randomUUID } from "node:crypto";
 import { isRequestCancelled, REQUEST_CANCELLED } from "./cancellation.js";
 import { isRequestInterrupted, REQUEST_INTERRUPTED } from "./interruption.js";
 import { RequestToolResources } from "../capabilities/request-tool-resources.js";
 import { traceDebug } from "../observability/debug-logger.js";
+import { traceRequestControl } from "../observability/request-control-diagnostics.js";
 import { RequestLifecycle } from "../orchestration/lifecycle/request-lifecycle.js";
 import { ROLE_CALL_RESPONSE_MAX_LENGTH } from "../orchestration/role-calls/index.js";
 import { runModelAuthoredDegradedFinalization } from "../steps/degraded-finalization/model-authored.js";
@@ -18,6 +23,15 @@ import { prepareRequestExecution } from "./prepared-execution.js";
 import { parkRequestApproval } from "./approval-wait/park.js";
 import { classifyRequestTerminalCause, createRequestFailureMessage, } from "./approval-wait/failure.js";
 export async function handleRunRequest(ws, msg, options = {}) {
+    const outcome = await handleRunRequestWithOutcome(ws, msg, options);
+    if (!outcome)
+        return;
+    const hasPendingApproval = outcome.kind === "awaiting_approval";
+    if (hasPendingApproval)
+        return outcome;
+}
+/** In-process terminal metadata; the ordinary handler preserves its public return shape. */
+export async function handleRunRequestWithOutcome(ws, msg, options = {}) {
     return new RequestHandlingSession(ws, msg, options).run();
 }
 /** One active invocation. A saved approval boundary retires this entire object. */
@@ -35,6 +49,9 @@ class RequestHandlingSession {
     durable;
     steeringPersistenceError;
     finalized = false;
+    superFailurePolicy = false;
+    superFailureFinalization;
+    terminalResponse;
     constructor(ws, msg, options) {
         this.ws = ws;
         this.options = options;
@@ -71,13 +88,33 @@ class RequestHandlingSession {
             return await this.execute();
         }
         catch (error) {
-            return await this.fail(error);
+            try {
+                return await this.fail(error);
+            }
+            catch (secondary) {
+                if (this.terminalResponse?.failureOutcome(secondary) === "session_deleted")
+                    return this.fail(secondary);
+                if (this.superFailurePolicy)
+                    traceDebug("runtime.request", "super.failure_delivery_rejected", {
+                        requestId: this.input.requestId,
+                        primaryCode: boundedSuperFailureCode(this.superFailureFinalization?.primaryError() ?? error),
+                        secondaryCode: boundedSuperFailureCode(secondary),
+                    });
+                throw secondary;
+            }
         }
         finally {
             await this.dispose();
         }
     }
     async execute() {
+        traceRequestControl("runtime.request_control", "request.entered", {
+            requestId: this.input.requestId,
+            sessionId: this.input.sessionId,
+            environmentId: this.options.runtimeConfig?.runtimeId,
+            toolPermissionMode: this.input.toolPermissionMode,
+            resumed: Boolean(this.options.approvalExecution?.resume),
+        });
         const prepared = await prepareRequestExecution({
             ws: this.ws,
             options: this.options,
@@ -88,6 +125,22 @@ class RequestHandlingSession {
             steering: this.requestSteering,
             temporalContext: this.temporalContext,
             initialEvents: this.events,
+            onFailurePolicyReady: (policy) => {
+                this.superFailurePolicy = hasSuperContextContract(policy.authority, policy.rootContract.contractId);
+            },
+            onSessionAdmitted: (agentMode) => {
+                if (!this.superFailurePolicy || this.durable)
+                    return;
+                this.terminalResponse = new TerminalResponseAppend({
+                    store: this.dependencies.sessionStore,
+                    sessionId: this.input.sessionId,
+                    requestId: this.input.requestId,
+                    agentMode,
+                });
+            },
+            onFailureFinalizationReady: (finalization) => {
+                this.superFailureFinalization = finalization;
+            },
             onEventsReady: (events, callbacks, durable) => {
                 this.events = events;
                 this.callbacks = callbacks;
@@ -157,24 +210,64 @@ class RequestHandlingSession {
             finalObservation: result.finalObservation,
             memoryCandidates: result.memoryCandidates,
             longTermMemory: this.dependencies.longTermMemory,
-            ...(this.durable
-                ? {
-                    persistResponse: (message) => this.commitTerminal(message, "completed"),
-                }
-                : {}),
-            composeInvalidFinalOutput: () => runModelAuthoredDegradedFinalization({
-                request: prepared.request,
-                input: {
-                    problem: {
-                        code: "invalid_final_output",
-                        stage: "chat_finalization",
+            ...this.terminalResponsePersister(),
+            composeInvalidFinalOutput: () => this.superFailureFinalization
+                ? this.superFailureFinalization
+                    .explain({
+                    error: new Error("invalid_final_output"),
+                    input: {
+                        problem: {
+                            code: "invalid_final_output",
+                            stage: "chat_finalization",
+                        },
+                        progress: null,
+                    },
+                    maxResponseChars: ROLE_CALL_RESPONSE_MAX_LENGTH,
+                })
+                    .then(({ output }) => output)
+                : runModelAuthoredDegradedFinalization({
+                    request: prepared.request,
+                    input: {
+                        problem: {
+                            code: "invalid_final_output",
+                            stage: "chat_finalization",
+                        },
+                        progress: null,
                     },
-                    progress: null,
-                },
-                maxResponseChars: ROLE_CALL_RESPONSE_MAX_LENGTH,
-            }),
+                    maxResponseChars: ROLE_CALL_RESPONSE_MAX_LENGTH,
+                }),
         });
         this.finalized = true;
+        return {
+            kind: "completed",
+            disposition: result.disposition ?? "responded",
+        };
+    }
+    terminalResponsePersister() {
+        if (this.durable)
+            return {
+                persistResponse: (message) => this.commitTerminal(message, "completed"),
+            };
+        if (this.terminalResponse)
+            return {
+                persistResponse: (message) => this.appendTerminalResponse(message),
+            };
+        return {};
+    }
+    async appendTerminalResponse(message) {
+        try {
+            await this.terminalResponse.append(message);
+        }
+        catch (error) {
+            traceDebug("runtime.request", "super.terminal_append_failed", {
+                requestId: this.input.requestId,
+                primaryCode: boundedSuperFailureCode(this.superFailureFinalization?.primaryError() ?? error),
+                secondaryCode: boundedSuperFailureCode(error),
+                persisted: false,
+                persistence: this.terminalResponse.failureOutcome(error),
+            });
+            throw error;
+        }
     }
     bindSteeringPersistence() {
         const persistedPrefix = this.options.approvalExecution?.resume?.snapshot.steering.version ?? 0;
@@ -209,33 +302,51 @@ class RequestHandlingSession {
     async fail(error) {
         if (this.finalized)
             return;
-        const cancelled = isRequestCancelled(this.lifecycle.signal);
-        const interrupted = isRequestInterrupted(this.lifecycle.signal);
-        let message = error instanceof Error ? error.message : "unknown error";
-        if (this.lifecycle.timedOutReason)
-            message = this.lifecycle.timedOutReason;
-        if (cancelled)
-            message = REQUEST_CANCELLED;
-        if (interrupted)
-            message = REQUEST_INTERRUPTED;
+        const append = this.terminalResponse?.snapshot();
+        if (append?.attempted) {
+            traceDebug("runtime.request", "super.terminal_delivery_failed", {
+                requestId: this.input.requestId,
+                primaryCode: boundedSuperFailureCode(this.superFailureFinalization?.primaryError() ?? error),
+                secondaryCode: boundedSuperFailureCode(error),
+                persisted: append.persisted,
+            });
+            const outcome = this.terminalResponse.failureOutcome(error);
+            if (outcome === "uncertain")
+                throw error;
+            this.finalized = true;
+            if (outcome === "session_deleted")
+                failRequest({ events: this.events, error: this.failureCode(error) });
+            return;
+        }
+        const primary = this.superFailureFinalization?.primaryError() ?? error;
+        const message = this.failureCode(primary);
         traceDebug("runtime.request", "request.failed", {
             requestId: this.input.requestId,
             sessionId: this.input.sessionId,
             error: message,
+            ...(primary !== error
+                ? { secondaryCode: boundedSuperFailureCode(error) }
+                : {}),
         });
         if (this.durable) {
-            await this.requestSteering.close();
-            const cause = classifyRequestTerminalCause(this.lifecycle.signal);
+            if (!this.superFailurePolicy)
+                await this.requestSteering.close();
             const current = await this.durable.finalizeFailure({
                 commandId: randomUUID(),
-                cause,
+                cause: classifyRequestTerminalCause(this.lifecycle.signal),
                 error: message,
-                message: createRequestFailureMessage({
-                    cause,
-                    partialAnswer: this.callbacks?.getAnswerText() ?? "",
-                    thinkingTrace: this.callbacks?.getThinkingTrace(),
-                }),
+                message: this.ordinaryFailureMessage(),
+                ...(this.superFailurePolicy
+                    ? {
+                        prepareFailure: async () => ({
+                            message: await this.prepareSuperFailureMessage(primary),
+                            cause: classifyRequestTerminalCause(this.lifecycle.signal),
+                            error: this.failureCode(primary),
+                        }),
+                    }
+                    : {}),
             });
+            await this.requestSteering.close();
             this.finalized = true;
             if (current?.status === "awaiting_approval")
                 return { kind: "awaiting_approval", lifecycle: current };
@@ -244,7 +355,21 @@ class RequestHandlingSession {
         const details = {};
         if (this.lifecycle.timedOutReason)
             details.stage = "timeout";
-        if (cancelled && this.callbacks) {
+        if (this.canPersistSuperFailure()) {
+            const terminalMessage = await this.prepareSuperFailureMessage(primary);
+            if (this.canPersistSuperFailure()) {
+                this.options.claimFinalization?.();
+                await this.appendTerminalResponse(terminalMessage);
+                this.finalized = true;
+                failRequest({
+                    events: this.events,
+                    error: this.failureCode(primary),
+                    details: { ...details, stoppedResponse: terminalMessage.content },
+                });
+                return;
+            }
+        }
+        if (isRequestCancelled(this.lifecycle.signal) && this.callbacks) {
             await this.requestSteering.close();
             Object.assign(details, await persistCancelledResponse({
                 sessionStore: this.dependencies.sessionStore,
@@ -254,9 +379,53 @@ class RequestHandlingSession {
                 thinkingTrace: this.callbacks.getThinkingTrace(),
             }));
         }
-        failRequest({ events: this.events, error: message, details });
+        failRequest({
+            events: this.events,
+            error: this.failureCode(primary),
+            details,
+        });
         this.finalized = true;
     }
+    canPersistSuperFailure() {
+        if (!this.superFailurePolicy)
+            return false;
+        if (!this.durable && !this.terminalResponse)
+            return false;
+        if (isRequestCancelled(this.lifecycle.signal))
+            return false;
+        return !isRequestInterrupted(this.lifecycle.signal);
+    }
+    failureCode(error) {
+        if (isRequestCancelled(this.lifecycle.signal))
+            return REQUEST_CANCELLED;
+        if (isRequestInterrupted(this.lifecycle.signal))
+            return REQUEST_INTERRUPTED;
+        if (this.lifecycle.timedOutReason)
+            return this.lifecycle.timedOutReason;
+        return error instanceof Error ? error.message : "unknown error";
+    }
+    ordinaryFailureMessage() {
+        return createRequestFailureMessage({
+            cause: classifyRequestTerminalCause(this.lifecycle.signal),
+            partialAnswer: this.callbacks?.getAnswerText() ?? "",
+            thinkingTrace: this.callbacks?.getThinkingTrace(),
+        });
+    }
+    async prepareSuperFailureMessage(error) {
+        if (!this.canPersistSuperFailure()) {
+            await this.requestSteering.close();
+            return this.ordinaryFailureMessage();
+        }
+        const message = await composeSuperFailureMessage({
+            requestId: this.input.requestId,
+            error,
+            finalization: this.superFailureFinalization,
+            steering: this.requestSteering,
+        });
+        if (!this.canPersistSuperFailure())
+            return this.ordinaryFailureMessage();
+        return message;
+    }
     async dispose() {
         try {
             await this.toolResources.dispose();

package/dist/src/runtime/request/locked-request-steering.d.ts

@@ -0,0 +1,3 @@
+import { type RequestSteeringInbox } from "./request-steering.js";
+/** Internal automation nodes cannot accept user steering at any transport. */
+export declare function createLockedRequestSteeringInbox(requestId: string): RequestSteeringInbox;

package/dist/src/runtime/request/locked-request-steering.js

@@ -0,0 +1,12 @@
+import { createRequestSteeringInbox, } from "./request-steering.js";
+/** Internal automation nodes cannot accept user steering at any transport. */
+export function createLockedRequestSteeringInbox(requestId) {
+    const inbox = createRequestSteeringInbox({ requestId });
+    return Object.freeze({
+        ...inbox,
+        append: () => Object.freeze({
+            ok: false,
+            reason: "automation_session_locked",
+        }),
+    });
+}

package/dist/src/runtime/request/policy-degraded-finalization.d.ts

@@ -0,0 +1,10 @@
+import type { DegradedFinalizationInput } from "../steps/degraded-finalization/contract.js";
+import type { RequestExecutionScope } from "./execution-scope.js";
+import type { RequestRunnerResult } from "./result.js";
+/** Existing policy gate; EA retains its original single-step supervision path. */
+export declare function runPolicyDegradedFinalization(params: {
+    request: RequestExecutionScope;
+    input: DegradedFinalizationInput;
+    maxResponseChars: number;
+}): Promise<string>;
+export declare function projectPolicyDegradedResult(request: RequestExecutionScope, output: string): RequestRunnerResult;

package/dist/src/runtime/request/policy-degraded-finalization.js

@@ -0,0 +1,27 @@
+import { runDegradedFinalization } from "../steps/degraded-finalization/run.js";
+import { fitsSuperFailureResponse } from "../steps/degraded-finalization/super.js";
+/** Existing policy gate; EA retains its original single-step supervision path. */
+export async function runPolicyDegradedFinalization(params) {
+    const finalization = params.request.superFailureFinalization;
+    if (!finalization)
+        return runDegradedFinalization(params);
+    const error = new Error(params.input.problem.code);
+    const result = await finalization.explain({
+        error,
+        input: params.input,
+        maxResponseChars: params.maxResponseChars,
+    });
+    if (!fitsSuperFailureResponse(result.output, params.maxResponseChars))
+        throw error;
+    return result.output;
+}
+export function projectPolicyDegradedResult(request, output) {
+    if (request.superFailureFinalization)
+        return { output, disposition: "blocked" };
+    return {
+        output,
+        ...(request.executionPolicy.authority.terminalTextMode === "exact"
+            ? { outputTextMode: "exact" }
+            : {}),
+    };
+}

package/dist/src/runtime/request/prepared-execution.d.ts

@@ -1,3 +1,5 @@
+import type { AgentMode } from "../../shared/types.js";
+import { type SuperFailureFinalization } from "./super-failure-explanation.js";
 import type WebSocket from "ws";
 import type { EventSink } from "../ports.js";
 import type { RequestHandlerOptions } from "./contracts.js";
@@ -8,6 +10,7 @@ import type { RequestLifecycle } from "../orchestration/lifecycle/request-lifecy
 import type { RequestSteeringInbox } from "./request-steering.js";
 import type { RequestTemporalContext } from "../context/request-temporal-context.js";
 import { createRequestCallbacks } from "../streaming/request-callbacks.js";
+import { type CompiledRequestExecutionPolicy } from "./execution-scope.js";
 import { RequestActivationEvents } from "./approval-wait/activation-events.js";
 export type RequestPreparationInput = Readonly<{
     ws: WebSocket;
@@ -19,6 +22,9 @@ export type RequestPreparationInput = Readonly<{
     steering: RequestSteeringInbox;
     temporalContext: RequestTemporalContext;
     initialEvents: EventSink;
+    onFailurePolicyReady?(policy: CompiledRequestExecutionPolicy): void;
+    onSessionAdmitted?(agentMode: AgentMode): void;
+    onFailureFinalizationReady?(finalization: SuperFailureFinalization): void;
     onEventsReady(events: EventSink, callbacks: ReturnType<typeof createRequestCallbacks>, durable: RequestActivationEvents | undefined): void;
 }>;
 export declare function prepareRequestExecution(params: RequestPreparationInput): Promise<{
@@ -32,13 +38,14 @@ export declare function prepareRequestExecution(params: RequestPreparationInput)
         prompt: string;
         temporalContext?: RequestTemporalContext;
         scheduledExecution?: import("../../sessions/schedule-metadata.js").ScheduleMessageReference;
+        sessionKind?: "spark";
         historyMessages: readonly import("../context/request-context-contracts.js").RequestHistoryMessage[];
         sessionArtifactPaths?: readonly string[];
         shouldGenerateSessionTitle: boolean;
         runnerConfig: import("../config/runner/contracts.js").RequestRunnerConfig;
         executionPolicySelection?: import("../config/model-execution-policy.js").RequestExecutionPolicySelection;
         attachments?: import("../../model-gateway/types.js").ModelGatewayAttachment[];
-        agentMode: import("../../shared/types.js").AgentMode;
+        agentMode: AgentMode;
         modelPreference?: import("../../model-gateway/types.js").ModelPreference;
         modelPolicy?: import("../../model-gateway/types.js").ModelGatewayPolicyConfig;
         modelGatewayClient: Pick<import("../ports.js").ModelGatewayClient, "invoke" | "invokeRaw" | "countInputTokens">;
@@ -47,6 +54,8 @@ export declare function prepareRequestExecution(params: RequestPreparationInput)
         longTermMemory?: import("../index.js").LongTermMemoryService;
         memoryRecallLimit?: number;
         requestSteering?: RequestSteeringInbox;
+        effectPersistence?: import("../adapters/registered-tool-normal-invocations/shared/contracts.js").RegisteredToolEffectPersistence;
+        automationOutputContract?: import("../../capabilities/tool-types.js").ToolNormalInvocationInput;
         toolPermissionMode: import("../ports.js").ToolPermissionMode;
         toolApprovalController?: import("../ports.js").ToolApprovalController;
         abortSignal: AbortSignal;

package/dist/src/runtime/request/prepared-execution.js

@@ -1,3 +1,5 @@
+import { isSparkSession } from "../../sessions/spark-session.js";
+import { createSuperFailureFinalization, } from "./super-failure-explanation.js";
 import { resolveSessionWorkingDirectory } from "../projects/session-paths.js";
 import { resolveModelSelection } from "../model/model-selection.js";
 import { resolveScheduledExecution } from "./scheduled-execution.js";
@@ -7,11 +9,11 @@ import { snapshotRequestHistory } from "../session/request-history.js";
 import { createRequestSessionTitleUpdater, shouldGenerateSessionTitle, } from "../session/session-title.js";
 import { createPersistentRequestEvents, createRequestCallbacks, } from "../streaming/request-callbacks.js";
 import { createRequestContextCompactionStore } from "../context/semantic-compaction/index.js";
-import { restoreRequestContextCompaction } from "../context/semantic-compaction/snapshot.js";
+import { restoreApprovalCompaction } from "./approval-wait/super-compaction-restore.js";
 import { createRequestSessionMemory } from "../context/session-memory/index.js";
 import { restoreRequestSessionMemory } from "../context/session-memory/snapshot.js";
 import { snapshotSessionArtifactPathTargets } from "./session-artifact-path-persistence.js";
-import { createRequestExecutionScope } from "./execution-scope.js";
+import { createRequestExecutionScope, } from "./execution-scope.js";
 import { createRequestWorkerCapabilityProvider } from "./worker-capability-composition.js";
 import { withToolApprovalWait } from "./tool-approval-wait.js";
 import { RequestActivationEvents } from "./approval-wait/activation-events.js";
@@ -33,6 +35,7 @@ export async function prepareRequestExecution(params) {
     });
     const executionPolicy = resolveRequestExecutionPolicy(resume?.snapshot.seed.executionPolicySelection?.policy ??
         selection.execution.policy);
+    params.onFailurePolicyReady?.(executionPolicy);
     const opened = resume
         ? undefined
         : await openRequestSession({
@@ -88,13 +91,18 @@ export async function prepareRequestExecution(params) {
             sessionStore,
             attachmentStore: dependencies.attachmentStore,
             events,
+            onUserMessagePersisted: () => params.onSessionAdmitted?.(selection.agentMode),
             ...(schedule ? { schedule } : {}),
         });
     const requestWorkingDirectory = resume?.snapshot.requestWorkingDirectory ??
         resolveSessionWorkingDirectory(opened.session) ??
         options.runtimeConfig?.paths.agentWorkDir ??
         process.cwd();
-    const toolAttachments = resume?.snapshot.toolAttachments ?? initialized.toolAttachments;
+    const toolAttachments = resume?.snapshot
+        .toolAttachments ?? [
+        ...initialized.toolAttachments,
+        ...(options.automationInputAttachments ?? []),
+    ];
     if (resume)
         resources.restore(resume.snapshot.resources);
     let controller = dependencies.toolApprovalController;
@@ -108,6 +116,9 @@ export async function prepareRequestExecution(params) {
         sessionId,
         prompt: initialized.prompt,
         temporalContext: params.temporalContext,
+        ...(isSparkSession(opened.session)
+            ? { sessionKind: "spark" }
+            : {}),
         historyMessages,
         shouldGenerateSessionTitle: generateSessionTitle,
         runnerConfig: loaded.runnerConfig,
@@ -119,10 +130,16 @@ export async function prepareRequestExecution(params) {
             : {}),
         ...(selection.modelPolicy ? { modelPolicy: selection.modelPolicy } : {}),
         toolPermissionMode: input.toolPermissionMode,
+        ...(options.effectPersistence
+            ? { effectPersistence: options.effectPersistence }
+            : {}),
+        ...(options.automationOutputContract
+            ? { automationOutputContract: options.automationOutputContract }
+            : {}),
         sessionArtifactPaths: snapshotSessionArtifactPathTargets(opened.session.artifactPaths),
         ...(memoryRecallLimit !== undefined ? { memoryRecallLimit } : {}),
     };
-    const seed = {
+    const preparedSeed = {
         ...baseSeed,
         ...(schedule ? { scheduledExecution: schedule } : {}),
         toolResources: resources,
@@ -130,9 +147,7 @@ export async function prepareRequestExecution(params) {
         longTermMemory,
         requestSteering: steering,
         sessionMemory,
-        contextCompactionStore: resume
-            ? restoreRequestContextCompaction(resume.snapshot.compaction)
-            : createRequestContextCompactionStore(),
+        contextCompactionStore: createRequestContextCompactionStore(),
         ...(controller ? { toolApprovalController: controller } : {}),
         ...(options.approvalExecution
             ? {
@@ -164,6 +179,25 @@ export async function prepareRequestExecution(params) {
             events.event(name, extra);
         },
     };
+    const superFailureFinalization = createSuperFailureFinalization({
+        request: preparedSeed,
+        executionPolicy,
+        readBudgets: () => lifecycle.snapshotBudgets(),
+    });
+    if (superFailureFinalization)
+        params.onFailureFinalizationReady?.(superFailureFinalization);
+    const seed = resume
+        ? {
+            ...preparedSeed,
+            contextCompactionStore: restoreApprovalCompaction({
+                snapshot: resume.snapshot.compaction,
+                ledgerCheckpoint: resume.snapshot.runner.ledger,
+                requestId,
+                prompt: baseSeed.prompt,
+                executionPolicy,
+            }),
+        }
+        : preparedSeed;
     const toolRegistry = options.toolRegistry?.prepareRequest
         ? await options.toolRegistry.prepareRequest({
             requestState: resources.state,
@@ -174,11 +208,17 @@ export async function prepareRequestExecution(params) {
     resources.assertRestoredStateClaimed();
     const request = createRequestExecutionScope({
         seed,
+        requestWorkingDirectory,
         executionPolicy,
-        createWorkerCapabilities: (view) => createRequestWorkerCapabilityProvider({
+        ...(superFailureFinalization ? { superFailureFinalization } : {}),
+        createWorkerCapabilities: (view, filesystemScope) => createRequestWorkerCapabilityProvider({
             request: view,
             requestWorkingDirectory,
+            ...(filesystemScope ? { filesystemScope } : {}),
             executionPolicyAuthority: executionPolicy.authority,
+            ...(seed.executionPolicySelection?.plugins
+                ? { modelPlugins: seed.executionPolicySelection.plugins }
+                : {}),
             requestAttachments: toolAttachments,
             ...(options.runtimeConfig
                 ? { runtimeConfig: options.runtimeConfig }

package/dist/src/runtime/request/request-steering.d.ts

@@ -15,7 +15,7 @@ export type RequestSteeringAppendResult = Readonly<{
     update: RequestSteeringUpdate;
 }> | Readonly<{
     ok: false;
-    reason: "invalid_steer_request" | "request_not_active" | "steer_id_conflict";
+    reason: "invalid_steer_request" | "request_not_active" | "automation_session_locked" | "steer_id_conflict";
 }>;
 export type RequestSteeringInbox = Readonly<{
     append(input: Readonly<{
@@ -33,4 +33,8 @@ export declare function resolveRequestSteeringInbox(inbox: RequestSteeringInbox
 export declare function projectRequestSteeringSnapshot(inbox: RequestSteeringInbox | undefined, version: number): RequestSteeringSnapshot;
 export declare function createRequestSteeringInbox(params: {
     requestId: string;
+    diagnostics?: Readonly<{
+        inboxId?: string;
+        origin?: string;
+    }>;
 }): RequestSteeringInbox;