@nylorun/harness 0.12.0-beta → 0.15.0-beta

package/dist/{step → loop/step}/compose.js

@@ -1,4 +1,5 @@
-import { HarnessError, isHarnessError } from "../errors.js";
+import { HostSuspension } from "../host-suspension.js";
+import { HarnessError, isHarnessError } from "@nylorun/core/define";
 import { isBrandedResponse, StepContext } from "./step-context.js";
 export async function runMiddleware(middleware, context, terminal, observe) {
     const dispatch = async (index) => {
@@ -49,13 +50,15 @@ export async function runMiddleware(middleware, context, terminal, observe) {
                     handlerError ??= error;
                 }
             }
+            if (handlerError instanceof HostSuspension)
+                throw handlerError;
             if (handlerError) {
                 if (nextCalledTwice ||
                     (isHarnessError(handlerError) && handlerError.code === "middleware.next-called-twice")) {
                     return context.tripwire({
                         code: "middleware.next-called-twice",
                         message: message(handlerError),
-                        scope: "session",
+                        scope: "execution",
                     });
                 }
                 return context.tripwire({
@@ -70,8 +73,8 @@ export async function runMiddleware(middleware, context, terminal, observe) {
                         message: `Middleware '${item.id}' must return the StepResponse from next()`,
                         // Calling next() completed the step successfully; forgetting to
                         // return that response is isolated to this step. A non-response
-                        // replacement remains a session-level middleware-contract breach.
-                        scope: result === undefined ? "step" : "session",
+                        // replacement remains a execution-level middleware-contract breach.
+                        scope: result === undefined ? "step" : "execution",
                     });
                 }
                 return inner;
@@ -80,7 +83,7 @@ export async function runMiddleware(middleware, context, terminal, observe) {
                 return context.tripwire({
                     code: "middleware.invalid-response",
                     message: `Middleware '${item.id}' must return a branded StepResponse`,
-                    scope: "session",
+                    scope: "execution",
                 });
             }
             return result;

package/dist/loop/step/context-draft.d.ts

@@ -0,0 +1,8 @@
+import type { ContextMutationOptions, ContextSnapshot } from "@nylorun/core/define";
+import type { ContextItem } from "@nylorun/core/define";
+/** Per-step model-visible context supplied explicitly by middleware. */
+export declare class ContextDraft {
+    #private;
+    set(middlewareId: string, middlewareOrder: number, slot: string, items: readonly ContextItem[], options?: ContextMutationOptions): void;
+    snapshot(): ContextSnapshot;
+}

package/dist/{step → loop/step}/context-draft.js

@@ -1,14 +1,10 @@
-import { HarnessError } from "../errors.js";
-import { copyJson } from "../utils/immutable.js";
+import { HarnessError } from "@nylorun/core/define";
+import { copyJson } from "@nylorun/core/define";
 import { SlotDraft } from "./slot-assembly.js";
 const CONTEXT_TYPE = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
-/** Per-step runtime-context draft. Host context is injected fresh for every call. */
+/** Per-step model-visible context supplied explicitly by middleware. */
 export class ContextDraft {
-    hostContext;
     #slots = new SlotDraft();
-    constructor(hostContext) {
-        this.hostContext = hostContext;
-    }
     set(middlewareId, middlewareOrder, slot, items, options) {
         if (!Array.isArray(items))
             throw new HarnessError("context.invalid-item", "Runtime context items must be an array");
@@ -27,14 +23,8 @@ export class ContextDraft {
     }
     snapshot() {
         const slots = this.#slots.values();
-        const host = this.hostContext === undefined
-            ? []
-            : [Object.freeze({ type: "session", value: copyJson(this.hostContext) })];
-        const items = Object.freeze([...host, ...slots.flatMap((slot) => slot.value)]);
-        const contributors = Object.freeze([
-            ...(this.hostContext === undefined ? [] : [hostContributor()]),
-            ...slots.map((slot) => contributor(slot.owner, slot.reason)),
-        ]);
+        const items = Object.freeze(slots.flatMap((slot) => slot.value));
+        const contributors = Object.freeze(slots.map((slot) => contributor(slot.owner, slot.reason)));
         return Object.freeze({ items, contributors });
     }
 }
@@ -48,13 +38,6 @@ function normalizeItem(item) {
         value: copyJson(item.value),
     });
 }
-function hostContributor() {
-    return Object.freeze({
-        middlewareId: "host",
-        slot: "session",
-        order: 0,
-    });
-}
 function contributor(owner, reason) {
     return Object.freeze({
         middlewareId: owner.middlewareId,

package/dist/loop/step/describe.d.ts

@@ -0,0 +1,9 @@
+import type { ModelConfigurationSnapshot } from "@nylorun/core/define";
+import type { ToolDescriptor } from "@nylorun/core/define";
+import type { BoundToolDefinition } from "@nylorun/core/define";
+/** Executable configuration stays inside the invocation. */
+export interface InternalModelConfigurationSnapshot extends Omit<ModelConfigurationSnapshot, "tools"> {
+    readonly tools: readonly BoundToolDefinition[];
+}
+export declare function describeTool(tool: BoundToolDefinition): ToolDescriptor;
+export declare function describeConfiguration(configuration: InternalModelConfigurationSnapshot): ModelConfigurationSnapshot;

package/dist/loop/step/describe.js

@@ -0,0 +1,22 @@
+import { copyJson } from "@nylorun/core/define";
+export function describeTool(tool) {
+    return copyJson({
+        name: tool.name,
+        ...(tool.description === undefined ? {} : { description: tool.description }),
+        owner: tool.owner,
+        inputSchema: { jsonSchema: tool.inputSchema.jsonSchema },
+        ...(tool.outputSchema === undefined
+            ? {}
+            : { outputSchema: { jsonSchema: tool.outputSchema.jsonSchema } }),
+    });
+}
+export function describeConfiguration(configuration) {
+    return copyJson({
+        version: configuration.version,
+        ...(configuration.model === undefined ? {} : { model: configuration.model }),
+        instructions: configuration.instructions,
+        tools: configuration.tools.map(describeTool),
+        toolContracts: configuration.toolContracts,
+        contributors: configuration.contributors,
+    });
+}

package/dist/loop/step/dynamics.d.ts

@@ -0,0 +1,29 @@
+import type { AgentDefinition } from "../../definition/agent-definition.js";
+import type { Decision } from "@nylorun/core/define";
+import type { JsonValue } from "@nylorun/core/define";
+import type { PromptItem } from "@nylorun/core/define";
+import type { InputEvent } from "@nylorun/core/define";
+import type { ModelConfigurationDraft } from "./model-configuration.js";
+export interface DynamicsContext {
+    readonly agent: AgentDefinition;
+    readonly info?: unknown;
+    readonly step: number;
+    readonly arrivals: readonly InputEvent[];
+    readonly messages: readonly PromptItem[];
+    sessionState: Record<string, JsonValue>;
+}
+/** Run all beforeModelCall handlers in capability `.use()` order. */
+export declare function applyBeforeModelCall(ctx: DynamicsContext, configuration: ModelConfigurationDraft): Promise<{
+    readonly blocked?: string;
+}>;
+/** Run all afterModelCall handlers; merge with strictest-wins rules. */
+export declare function applyAfterModelCall(ctx: DynamicsContext, args: {
+    readonly text?: string;
+    readonly toolCalls: readonly {
+        readonly id: string;
+        readonly name: string;
+        readonly args: JsonValue;
+    }[];
+}): Promise<Decision>;
+export declare function mergeDecisions(decisions: readonly Decision[]): Decision;
+export declare function hasDynamics(agent: AgentDefinition): boolean;

package/dist/loop/step/dynamics.js

@@ -0,0 +1,147 @@
+import { HarnessError } from "@nylorun/core/define";
+/** Run all beforeModelCall handlers in capability `.use()` order. */
+export async function applyBeforeModelCall(ctx, configuration) {
+    const patches = [];
+    for (const capability of ctx.agent.manifest.capabilities) {
+        const impl = ctx.agent.implementations[capability.id];
+        if (!impl?.beforeModelCall)
+            continue;
+        const raw = await impl.beforeModelCall({
+            input: projectInput(ctx.arrivals),
+            info: ctx.info,
+            state: { ...ctx.sessionState },
+            messages: ctx.messages,
+            step: ctx.step,
+        });
+        const patch = normalizeCapabilityPatch(capability.id, raw ?? {}, capability.id === "agent");
+        patches.push({ id: capability.id, patch, agentLevel: capability.id === "agent" });
+    }
+    if (!patches.length)
+        return {};
+    let blocked;
+    const capabilitySwitches = new Map();
+    const toolSwitches = new Map();
+    const extraInstructions = [];
+    for (const { id, patch, agentLevel } of patches) {
+        if (patch.block)
+            blocked = patch.block;
+        if (patch.state) {
+            for (const [key, value] of Object.entries(patch.state))
+                ctx.sessionState[key] = value;
+        }
+        if (patch.instructions)
+            extraInstructions.push(...patch.instructions);
+        if (patch.capabilities) {
+            for (const [name, on] of Object.entries(patch.capabilities)) {
+                if (!agentLevel && name !== id)
+                    throw new HarnessError("configuration.invalid", `Capability '${id}' beforeModelCall may only toggle itself, not '${name}'`);
+                if (!ctx.agent.manifest.capabilities.some((item) => item.id === name))
+                    throw new HarnessError("configuration.invalid", `beforeModelCall referenced unknown capability '${name}'`);
+                capabilitySwitches.set(name, on);
+            }
+        }
+        if (patch.tools) {
+            for (const [name, on] of Object.entries(patch.tools)) {
+                const known = ctx.agent.manifest.capabilities.some((cap) => cap.tools?.some((tool) => tool.name === name));
+                if (!known)
+                    throw new HarnessError("configuration.invalid", `beforeModelCall referenced unknown tool '${name}'`);
+                if (!agentLevel) {
+                    const owned = ctx.agent.manifest.capabilities
+                        .find((cap) => cap.id === id)
+                        ?.tools?.some((tool) => tool.name === name);
+                    if (!owned)
+                        throw new HarnessError("configuration.invalid", `Capability '${id}' beforeModelCall may only toggle its own tools`);
+                }
+                toolSwitches.set(name, on);
+            }
+        }
+    }
+    if (blocked)
+        return { blocked };
+    let order = 10_000;
+    for (const [capabilityId, on] of capabilitySwitches) {
+        if (on)
+            continue;
+        configuration.setTools("dynamics", order++, capabilityId, []);
+    }
+    for (const [toolName, on] of toolSwitches) {
+        if (on)
+            continue;
+        for (const capability of ctx.agent.manifest.capabilities) {
+            const tools = ctx.agent.implementations[capability.id]?.tools;
+            if (!tools?.[toolName])
+                continue;
+            const remaining = Object.values(tools).filter((tool) => tool.name !== toolName);
+            configuration.setTools("dynamics", order++, capability.id, remaining);
+        }
+    }
+    if (extraInstructions.length)
+        configuration.setInstructions("dynamics", order++, "dynamics", Object.freeze([...extraInstructions]));
+    return {};
+}
+/** Run all afterModelCall handlers; merge with strictest-wins rules. */
+export async function applyAfterModelCall(ctx, args) {
+    const decisions = [];
+    for (const capability of ctx.agent.manifest.capabilities) {
+        const impl = ctx.agent.implementations[capability.id];
+        if (!impl?.afterModelCall)
+            continue;
+        const decision = await impl.afterModelCall(args, {
+            info: ctx.info,
+            state: { ...ctx.sessionState },
+        });
+        decisions.push(decision ?? {});
+    }
+    return mergeDecisions(decisions);
+}
+export function mergeDecisions(decisions) {
+    let block;
+    let retry;
+    const deny = new Map();
+    const approve = new Map();
+    let text;
+    for (const decision of decisions) {
+        if (decision.block)
+            block = decision.block;
+        if (decision.retry)
+            retry = decision.retry;
+        for (const item of decision.deny ?? [])
+            deny.set(item.id, item.reason);
+        for (const item of decision.approve ?? [])
+            approve.set(item.id, item.prompt);
+        if (decision.text !== undefined)
+            text = decision.text;
+    }
+    if (block)
+        return { block };
+    if (retry)
+        return { retry, ...(text === undefined ? {} : { text }) };
+    return {
+        ...(text === undefined ? {} : { text }),
+        ...(deny.size ? { deny: [...deny.entries()].map(([id, reason]) => ({ id, reason })) } : {}),
+        ...(approve.size
+            ? { approve: [...approve.entries()].map(([id, prompt]) => ({ id, prompt })) }
+            : {}),
+    };
+}
+export function hasDynamics(agent) {
+    return agent.manifest.capabilities.some((capability) => capability.beforeModelCall || capability.afterModelCall);
+}
+function normalizeCapabilityPatch(id, patch, agentLevel) {
+    if (patch.active === undefined)
+        return patch;
+    if (agentLevel)
+        throw new HarnessError("configuration.invalid", "Agent-level beforeModelCall must use capabilities{}, not active");
+    return {
+        ...patch,
+        capabilities: { ...(patch.capabilities ?? {}), [id]: patch.active },
+    };
+}
+function projectInput(arrivals) {
+    const message = arrivals.find((item) => item.kind === "user-message");
+    if (!message)
+        return undefined;
+    if ("text" in message && typeof message.text === "string")
+        return message.text;
+    return undefined;
+}

package/dist/{step → loop/step}/model-configuration.d.ts

@@ -1,5 +1,6 @@
-import type { ModelConfigurationMutationOptions, ModelConfigurationSnapshot, ModelDirective } from "../types/model.js";
-import type { ToolDefinition } from "../types/tool.js";
+import type { InternalModelConfigurationSnapshot } from "./describe.js";
+import type { ModelConfigurationMutationOptions, ModelDirective } from "@nylorun/core/define";
+import type { ToolDefinition } from "@nylorun/core/define";
 /** Per-step, middleware-owned model configuration draft. It never persists past the call. */
 export declare class ModelConfigurationDraft {
     #private;
@@ -9,5 +10,5 @@ export declare class ModelConfigurationDraft {
     select(middlewareId: string, middlewareOrder: number, directive: ModelDirective, options?: Omit<ModelConfigurationMutationOptions, "order">): void;
     replace(middlewareId: string, middlewareOrder: number, directive: ModelDirective, options?: Omit<ModelConfigurationMutationOptions, "order">): void;
     clear(options?: Omit<ModelConfigurationMutationOptions, "order">): void;
-    snapshot(): ModelConfigurationSnapshot;
+    snapshot(): InternalModelConfigurationSnapshot;
 }

package/dist/{step → loop/step}/model-configuration.js

@@ -1,7 +1,7 @@
-import { bindTool } from "../build/bind-tool.js";
-import { HarnessError, isHarnessError } from "../errors.js";
+import { bindTool } from "@nylorun/core/define";
+import { HarnessError, isHarnessError } from "@nylorun/core/define";
 import { normalizeDirective, sameDirective } from "../model/normalize.js";
-import { copyJson } from "../utils/immutable.js";
+import { copyJson } from "@nylorun/core/define";
 import { checkedReason, slotOwner, SlotDraft } from "./slot-assembly.js";
 /** Per-step, middleware-owned model configuration draft. It never persists past the call. */
 export class ModelConfigurationDraft {

package/dist/loop/step/resolve.d.ts

@@ -0,0 +1,11 @@
+import type { TurnOutputContract } from "@nylorun/core/define";
+import type { InputEvent } from "@nylorun/core/define";
+import type { ModelRequest } from "@nylorun/core/define";
+import type { ToolResult } from "@nylorun/core/define";
+import type { StepContext } from "./step-context.js";
+export declare function resolveModelRequest(input: {
+    context: StepContext;
+    arrivals: readonly InputEvent[];
+    toolResults: readonly ToolResult[];
+    output?: TurnOutputContract;
+}): ModelRequest;

package/dist/{step → loop/step}/resolve.js

@@ -1,17 +1,19 @@
+import { describeConfiguration } from "./describe.js";
 export function resolveModelRequest(input) {
     const ctx = input.context;
+    const configuration = describeConfiguration(ctx.configurationSnapshot());
     return Object.freeze({
-        sessionId: ctx.input.sessionId,
+        executionId: ctx.input.executionId,
         turnId: ctx.input.turnId,
         stepId: ctx.input.stepId,
         ...(ctx.selectedDirective === undefined ? {} : { model: ctx.selectedDirective }),
-        configuration: ctx.configurationSnapshot(),
+        configuration,
         instructions: Object.freeze([...ctx.instructions]),
         context: ctx.contextSnapshot(),
         transcript: Object.freeze([...ctx.input.transcript]),
         arrivals: Object.freeze([...input.arrivals]),
         toolResults: Object.freeze([...input.toolResults]),
-        tools: Object.freeze([...ctx.offeredTools]),
+        tools: configuration.tools,
         ...(input.output === undefined ? {} : { outputSchema: input.output.schema.jsonSchema }),
     });
 }

package/dist/loop/step/run.d.ts

@@ -0,0 +1,30 @@
+import type { ExecutionSnapshot, StepRuntime } from "./runtime.js";
+import type { TurnOutputContract } from "@nylorun/core/define";
+import type { ModelCandidate } from "@nylorun/core/define";
+import type { InputEvent } from "@nylorun/core/define";
+import type { ToolResult } from "@nylorun/core/define";
+import type { ObserveEmit } from "../observe.js";
+import { type SealedStepOutput } from "./seal.js";
+export interface StepRunResult {
+    readonly stepId: string;
+    readonly candidate?: ModelCandidate;
+    readonly output: SealedStepOutput;
+    readonly requestedModelId?: string;
+    readonly modelInvocationId?: string;
+    readonly retry?: string;
+}
+export declare function runStep(input: {
+    agent: StepRuntime;
+    observe: ObserveEmit;
+    state: ExecutionSnapshot;
+    executionId: string;
+    turnId: string;
+    stepId: string;
+    turnNumber: number;
+    stepNumber: number;
+    arrivals: readonly InputEvent[];
+    toolResults: readonly ToolResult[];
+    signal: AbortSignal;
+    info?: unknown;
+    output?: TurnOutputContract;
+}): Promise<StepRunResult>;

package/dist/{step → loop/step}/run.js

@@ -1,31 +1,34 @@
+import { HostSuspension } from "../host-suspension.js";
 import { normalizeCandidate } from "../model/normalize.js";
-import { HarnessError, isHarnessError } from "../errors.js";
-import { copyJson } from "../utils/immutable.js";
+import { HarnessError, isHarnessError } from "@nylorun/core/define";
+import { copyJson } from "@nylorun/core/define";
 import { runMiddleware } from "./compose.js";
 import { ContextDraft } from "./context-draft.js";
 import { StepContext } from "./step-context.js";
-import { projectModelCall } from "./project.js";
+import { projectModelCall } from "../model/project.js";
 import { resolveModelRequest } from "./resolve.js";
 import { sealStep } from "./seal.js";
 import { ModelConfigurationDraft } from "./model-configuration.js";
-import { createId } from "../utils/ids.js";
+import { createId } from "../../utils/ids.js";
+import { applyAfterModelCall, applyBeforeModelCall, hasDynamics, } from "./dynamics.js";
 export async function runStep(input) {
-    let state = input.state;
     let requestedModelId;
+    let modelInvocationId;
+    let retryFeedback;
     const stepInput = Object.freeze({
-        sessionId: input.sessionId,
+        executionId: input.executionId,
         turnId: input.turnId,
         stepId: input.stepId,
         turnNumber: input.turnNumber,
         stepNumber: input.stepNumber,
-        session: input.session,
+        info: input.info,
         arrivals: Object.freeze([...input.arrivals]),
         toolResults: Object.freeze([...input.toolResults]),
         transcript: Object.freeze([...input.state.transcript]),
     });
     const configuration = new ModelConfigurationDraft();
-    const runtimeContext = new ContextDraft(input.session.context);
-    const context = new StepContext(stepInput, input.observe, configuration, runtimeContext, input.states);
+    const runtimeContext = new ContextDraft();
+    const context = new StepContext(stepInput, input.observe, configuration, runtimeContext);
     input.observe(() => ({
         type: "step.started",
         turnId: input.turnId,
@@ -35,13 +38,59 @@ export async function runStep(input) {
         attributes: snapshotStepStart(stepInput),
     }));
     await runMiddleware(input.agent.middleware, context, async () => {
+        input.signal.throwIfAborted();
         if (context.currentTripwire)
             return context.tripwire(context.currentTripwire);
+        const definition = input.agent.definition;
+        const dynamicsCtx = definition && hasDynamics(definition)
+            ? {
+                agent: definition,
+                info: input.info,
+                step: input.stepNumber - 1,
+                arrivals: input.arrivals,
+                messages: projectModelCall(resolveModelRequest({
+                    context,
+                    arrivals: input.arrivals,
+                    toolResults: input.toolResults,
+                    output: input.output,
+                })).prompt,
+                sessionState: input.agent.sessionState ?? {},
+            }
+            : undefined;
+        if (dynamicsCtx) {
+            try {
+                const before = await applyBeforeModelCall(dynamicsCtx, configuration);
+                if (input.agent.sessionState) {
+                    Object.assign(input.agent.sessionState, dynamicsCtx.sessionState);
+                }
+                if (input.agent.recordAfterDynamics)
+                    await input.agent.recordAfterDynamics();
+                if (before.blocked) {
+                    return context.tripwire({
+                        code: "dynamics.blocked",
+                        message: before.blocked,
+                    });
+                }
+            }
+            catch (error) {
+                if (error instanceof HostSuspension)
+                    throw error;
+                return context.tripwire({
+                    code: isHarnessError(error) ? error.code : "configuration.invalid",
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
         try {
-            context.sealConfiguration(configuration.snapshot());
+            const selected = configuration.snapshot();
+            for (const tool of selected.tools)
+                input.agent.registry.reference(tool);
+            context.sealConfiguration(selected);
             context.sealContext(runtimeContext.snapshot());
         }
         catch (error) {
+            if (error instanceof HostSuspension)
+                throw error;
             const message = error instanceof Error ? error.message : String(error);
             return context.tripwire({
                 code: isHarnessError(error) ? error.code : "configuration.invalid",
@@ -57,16 +106,10 @@ export async function runStep(input) {
         requestedModelId = request.model?.id;
         const call = projectModelCall(request);
         const invocationId = createId("invocation");
-        const active = Object.freeze({
-            kind: "model",
-            turnId: input.turnId,
-            stepId: input.stepId,
-            invocationId,
-            call,
-        });
-        state = await input.recordModelRequested(state, active);
+        modelInvocationId = invocationId;
         input.observe(() => ({
             type: "model.requested",
+            invocationId,
             turnId: input.turnId,
             stepId: input.stepId,
             ...(request.model?.id === undefined ? {} : { requestedModelId: request.model.id }),
@@ -91,6 +134,7 @@ export async function runStep(input) {
                     const reported = Object.freeze({ adapter: value.adapter, call: copyJson(value.call) });
                     input.observe(() => ({
                         type: "model.prepared",
+                        invocationId,
                         turnId: input.turnId,
                         stepId: input.stepId,
                         ...(request.model?.id === undefined ? {} : { requestedModelId: request.model.id }),
@@ -100,18 +144,52 @@ export async function runStep(input) {
             });
             if (input.signal.aborted)
                 throw input.signal.reason;
-            if (isDeferred(outcome))
-                return context.deferModel(Object.freeze({
-                    ...active,
-                    ...(outcome.token === undefined ? {} : { token: copyJson(outcome.token) }),
-                }));
             const minted = context.mintFromModel(normalizeCandidate(outcome));
             const candidate = context.currentCandidate;
             if (!candidate)
                 throw new HarnessError("model.candidate-missing", "Model candidate missing after mint");
+            if (dynamicsCtx) {
+                const text = candidate.output
+                    ?.filter((block) => block.type === "text")
+                    .map((block) => block.text)
+                    .join("");
+                const toolCalls = (candidate.output ?? [])
+                    .filter((block) => block.type === "tool-call")
+                    .map((block) => {
+                    const call = block;
+                    return { id: call.id, name: call.name, args: call.args };
+                });
+                const decision = await applyAfterModelCall(dynamicsCtx, {
+                    ...(text ? { text } : {}),
+                    toolCalls,
+                });
+                if (input.agent.recordAfterDynamics)
+                    await input.agent.recordAfterDynamics();
+                if (decision.block) {
+                    return context.tripwire({ code: "dynamics.blocked", message: decision.block });
+                }
+                if (decision.retry) {
+                    retryFeedback = decision.retry;
+                    return context.tripwire({ code: "dynamics.retry", message: decision.retry });
+                }
+                if (decision.text !== undefined) {
+                    minted.replace({
+                        output: [{ type: "text", text: decision.text }],
+                    });
+                }
+                for (const item of decision.deny ?? [])
+                    minted.deny(item.id, item.reason);
+                for (const item of decision.approve ?? [])
+                    minted.requireInteraction(item.id, {
+                        kind: "approval",
+                        prompt: item.prompt,
+                    });
+            }
             return minted;
         }
         catch (error) {
+            if (error instanceof HostSuspension)
+                throw error;
             if (input.signal.aborted)
                 throw input.signal.reason;
             return context.tripwire({
@@ -124,47 +202,20 @@ export async function runStep(input) {
     const candidate = output.kind === "tools" ? output.plan.candidate : context.currentCandidate;
     return Object.freeze({
         stepId: input.stepId,
-        state,
         ...(candidate ? { candidate } : {}),
         ...(requestedModelId === undefined ? {} : { requestedModelId }),
         output,
+        ...(modelInvocationId ? { modelInvocationId } : {}),
+        ...(retryFeedback ? { retry: retryFeedback } : {}),
     });
 }
-function isDeferred(value) {
-    return (typeof value === "object" && value !== null && "kind" in value && value.kind === "deferred");
-}
 function snapshotStepStart(input) {
-    const session = Object.freeze({
-        ...(input.session.userId === undefined ? {} : { userId: input.session.userId }),
-        ...(input.session.context === undefined ? {} : { context: copyJson(input.session.context) }),
-    });
     return Object.freeze({
-        ...(Object.keys(session).length === 0 ? {} : { session }),
         arrivals: copyJson(input.arrivals),
         toolResults: copyJson(input.toolResults),
         transcript: input.transcript,
     });
 }
 function snapshotConfiguration(configuration) {
-    return Object.freeze({
-        version: configuration.version,
-        ...(configuration.model === undefined ? {} : { model: copyJson(configuration.model) }),
-        instructions: copyJson(configuration.instructions),
-        tools: snapshotTools(configuration.tools),
-        toolContracts: copyJson(configuration.toolContracts),
-        contributors: copyJson(configuration.contributors),
-    });
-}
-function snapshotTools(tools) {
-    return Object.freeze(tools.map((tool) => Object.freeze({
-        name: tool.name,
-        ...(tool.description === undefined ? {} : { description: tool.description }),
-        owner: tool.owner,
-        inputSchema: Object.freeze({ jsonSchema: copyJson(tool.inputSchema.jsonSchema) }),
-        ...(tool.outputSchema === undefined
-            ? {}
-            : {
-                outputSchema: Object.freeze({ jsonSchema: copyJson(tool.outputSchema.jsonSchema) }),
-            }),
-    })));
+    return copyJson(configuration);
 }