@nylorun/harness 0.5.0-beta.1 → 0.7.0-beta.1

package/dist/session/seed.js

@@ -0,0 +1,219 @@
+import { HarnessError } from "../errors.js";
+import { normalizeCandidate } from "../model-normalize.js";
+import { assertJson, copyJson, copyJsonObject } from "../utils/immutable.js";
+export function normalizeSessionSeed(seed) {
+    try {
+        return normalizeSeed(seed);
+    }
+    catch (cause) {
+        if (cause instanceof HarnessError && cause.code === "session.invalid-seed")
+            throw cause;
+        throw new HarnessError("session.invalid-seed", "Session seed contains invalid typed JSON", {
+            cause,
+        });
+    }
+}
+function normalizeSeed(seed) {
+    if (!seed || typeof seed !== "object")
+        fail("Session seed must be an object");
+    if (!Array.isArray(seed.transcript))
+        fail("Session seed transcript must be an array");
+    optionalString(seed.id, "Session seed id");
+    optionalString(seed.userId, "Session seed userId");
+    const turnCount = count(seed.turnCount, "turnCount");
+    const revision = count(seed.revision, "revision");
+    const transcript = Object.freeze(seed.transcript.map((entry, index) => entryAt(entry, index)));
+    return Object.freeze({
+        ...(seed.id === undefined ? {} : { id: seed.id }),
+        ...(seed.userId === undefined ? {} : { userId: seed.userId }),
+        ...(seed.context === undefined
+            ? {}
+            : { context: copyJsonObject(seed.context, "session seed context") }),
+        turnCount,
+        revision,
+        transcript,
+    });
+}
+function entryAt(value, index) {
+    if (!value || typeof value !== "object")
+        fail(`Transcript entry ${index} must be an object`);
+    const entry = value;
+    requiredString(entry.kind, `Transcript entry ${index} kind`);
+    requiredString(entry.turnId, `Transcript entry ${index} turnId`);
+    switch (entry.kind) {
+        case "input":
+            exactKeys(entry, ["kind", "turnId", "event"], `Transcript entry ${index}`);
+            return Object.freeze({
+                kind: "input",
+                turnId: entry.turnId,
+                event: inputEvent(entry.event, index),
+            });
+        case "candidate": {
+            exactKeys(entry, ["kind", "turnId", "stepId", "candidate"], `Transcript entry ${index}`);
+            requiredString(entry.stepId, `Transcript entry ${index} stepId`);
+            try {
+                validateSeedCandidate(entry.candidate, index);
+                return Object.freeze({
+                    kind: "candidate",
+                    turnId: entry.turnId,
+                    stepId: entry.stepId,
+                    candidate: normalizeCandidate(entry.candidate),
+                });
+            }
+            catch (cause) {
+                throw new HarnessError("session.invalid-seed", `Invalid candidate at transcript ${index}`, {
+                    cause,
+                });
+            }
+        }
+        case "tool-results": {
+            exactKeys(entry, ["kind", "turnId", "stepId", "results"], `Transcript entry ${index}`);
+            requiredString(entry.stepId, `Transcript entry ${index} stepId`);
+            if (!Array.isArray(entry.results))
+                fail(`Transcript entry ${index} tool results must be an array`);
+            const result = Object.freeze({
+                kind: "tool-results",
+                turnId: entry.turnId,
+                stepId: entry.stepId,
+                results: Object.freeze(entry.results.map((item, resultIndex) => toolResult(item, resultIndex))),
+            });
+            return result;
+        }
+        case "final":
+            exactKeys(entry, ["kind", "turnId", "stepId", "output"], `Transcript entry ${index}`);
+            requiredString(entry.stepId, `Transcript entry ${index} stepId`);
+            if (typeof entry.output !== "string")
+                fail(`Transcript entry ${index} output must be a string`);
+            return Object.freeze({
+                kind: "final",
+                turnId: entry.turnId,
+                stepId: entry.stepId,
+                output: entry.output,
+            });
+        default:
+            fail(`Transcript entry ${index} has unknown kind '${String(entry.kind)}'`);
+    }
+}
+function inputEvent(value, index) {
+    if (!value || typeof value !== "object")
+        fail(`Transcript input ${index} must be an object`);
+    const event = value;
+    switch (event.kind) {
+        case "user-message":
+        case "interrupt":
+            exactKeys(event, ["kind", "text", "metadata"], `Transcript input ${index}`);
+            if (typeof event.text !== "string")
+                fail(`Transcript input ${index} text must be a string`);
+            return Object.freeze({
+                kind: event.kind,
+                text: event.text,
+                ...(event.metadata === undefined
+                    ? {}
+                    : { metadata: copyJsonObject(event.metadata, `transcript input ${index} metadata`) }),
+            });
+        case "approve":
+            exactKeys(event, ["kind", "interactionId", "approved"], `Transcript input ${index}`);
+            requiredString(event.interactionId, `Transcript input ${index} interactionId`);
+            if (typeof event.approved !== "boolean")
+                fail(`Transcript input ${index} approved must be a boolean`);
+            return Object.freeze({
+                kind: "approve",
+                interactionId: event.interactionId,
+                approved: event.approved,
+            });
+        case "respond":
+            exactKeys(event, ["kind", "interactionId", "value"], `Transcript input ${index}`);
+            requiredString(event.interactionId, `Transcript input ${index} interactionId`);
+            assertJson(event.value, `transcript input ${index} value`);
+            return Object.freeze({
+                kind: "respond",
+                interactionId: event.interactionId,
+                value: copyJson(event.value),
+            });
+        default:
+            fail(`Transcript input ${index} has unknown kind '${String(event.kind)}'`);
+    }
+}
+function toolResult(value, index) {
+    if (!value || typeof value !== "object")
+        fail(`Tool result ${index} must be an object`);
+    const result = value;
+    requiredString(result.callId, `Tool result ${index} callId`);
+    requiredString(result.toolName, `Tool result ${index} toolName`);
+    const base = { callId: result.callId, toolName: result.toolName };
+    switch (result.kind) {
+        case "completed":
+            exactKeys(result, ["callId", "toolName", "kind", "output"], `Tool result ${index}`);
+            assertJson(result.output, `tool result ${index} output`);
+            return Object.freeze({ ...base, kind: "completed", output: copyJson(result.output) });
+        case "denied":
+            exactKeys(result, ["callId", "toolName", "kind", "reason"], `Tool result ${index}`);
+            if (typeof result.reason !== "string")
+                fail(`Tool result ${index} reason must be a string`);
+            return Object.freeze({ ...base, kind: "denied", reason: result.reason });
+        case "failed":
+            exactKeys(result, ["callId", "toolName", "kind", "code", "message"], `Tool result ${index}`);
+            if (typeof result.code !== "string" || typeof result.message !== "string")
+                fail(`Tool result ${index} code and message must be strings`);
+            return Object.freeze({
+                ...base,
+                kind: "failed",
+                code: result.code,
+                message: result.message,
+            });
+        default:
+            fail(`Tool result ${index} has unknown kind '${String(result.kind)}'`);
+    }
+}
+function validateSeedCandidate(value, index) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        fail(`Candidate at transcript ${index} must be an object`);
+    const candidate = value;
+    exactKeys(candidate, ["output", "finishReason", "usage", "evidence"], `Candidate at transcript ${index}`);
+    if (!Array.isArray(candidate.output))
+        fail(`Candidate at transcript ${index} output must be an array`);
+    candidate.output.forEach((value, blockIndex) => {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            fail(`Candidate output ${blockIndex} at transcript ${index} must be an object`);
+        const block = value;
+        if (block.type === "text" || block.type === "reasoning") {
+            exactKeys(block, ["type", "text"], `Candidate output ${blockIndex}`);
+            if (typeof block.text !== "string")
+                fail(`Candidate output ${blockIndex} text must be a string`);
+            return;
+        }
+        if (block.type === "tool-call") {
+            exactKeys(block, ["type", "id", "name", "args", "raw"], `Candidate output ${blockIndex}`);
+            requiredString(block.id, `Candidate output ${blockIndex} id`);
+            requiredString(block.name, `Candidate output ${blockIndex} name`);
+            if (block.raw !== undefined && typeof block.raw !== "string")
+                fail(`Candidate output ${blockIndex} raw must be a string`);
+            copyJsonObject(block.args, `candidate output ${blockIndex} args`);
+            return;
+        }
+        fail(`Candidate output ${blockIndex} has unknown kind '${String(block.type)}'`);
+    });
+}
+function exactKeys(value, allowed, label) {
+    for (const key of Object.keys(value))
+        if (!allowed.includes(key))
+            fail(`${label} has unknown field '${key}'`);
+}
+function count(value, label) {
+    if (value === undefined)
+        return 0;
+    if (!Number.isSafeInteger(value) || value < 0)
+        fail(`Session seed ${label} must be a non-negative safe integer`);
+    return value;
+}
+function optionalString(value, label) {
+    if (value !== undefined)
+        requiredString(value, label);
+}
+function requiredString(value, label) {
+    if (typeof value !== "string" || value.length === 0)
+        fail(`${label} must be a non-empty string`);
+}
+function fail(message) {
+    throw new HarnessError("session.invalid-seed", message);
+}

package/dist/session/session.d.ts

@@ -1,13 +1,14 @@
-import type { InputHandle, InputOptions, MessageInput, Session, SessionEvent, SessionOptions, SessionSnapshot, SessionInput } from "../types/session.js";
+import type { InputHandle, InputOptions, MessageInput, Session, SessionEvent, SessionRunOptions, SessionSnapshot, SessionInput } from "../types/session.js";
 import type { Observer } from "../types/shared.js";
 import type { LoopAgent } from "../build/agent.js";
 export declare class LiveSession implements Session {
     readonly id: string;
     private readonly scheduler;
-    constructor(id: string, agent: LoopAgent, options: SessionOptions);
+    constructor(id: string, agent: LoopAgent, options: SessionRunOptions);
     get state(): SessionSnapshot;
     input(event: SessionInput, options?: InputOptions): InputHandle;
     interrupt(event: MessageInput, options?: InputOptions): InputHandle;
+    continue(options?: InputOptions): InputHandle;
     stream(): AsyncIterable<SessionEvent>;
     observe(listener: Observer): () => void;
     stop(reason?: string): Promise<void>;

package/dist/session/session.js

@@ -1,15 +1,24 @@
 import { SessionScheduler } from "./scheduler.js";
 import { copyJsonObject } from "../utils/immutable.js";
+import { normalizeSessionSeed } from "./seed.js";
 export class LiveSession {
     id;
     scheduler;
     constructor(id, agent, options) {
         this.id = id;
+        const seed = "seed" in options && options.seed ? normalizeSessionSeed(options.seed) : undefined;
+        const userId = seed?.userId ?? ("userId" in options ? options.userId : undefined);
+        const suppliedContext = seed?.context ?? ("context" in options ? options.context : undefined);
         const session = Object.freeze({
-            ...(options.userId ? { userId: options.userId } : {}),
-            ...(options.context ? { context: copyJsonObject(options.context, "session context") } : {}),
+            ...(userId === undefined ? {} : { userId }),
+            ...(suppliedContext === undefined
+                ? {}
+                : { context: copyJsonObject(suppliedContext, "session context") }),
+        });
+        this.scheduler = new SessionScheduler(id, agent, session, {
+            ...(seed === undefined ? {} : { seed }),
+            ...(options.recorder === undefined ? {} : { recorder: options.recorder }),
         });
-        this.scheduler = new SessionScheduler(id, agent, session);
     }
     get state() {
         return this.scheduler.snapshot;
@@ -20,6 +29,9 @@ export class LiveSession {
     interrupt(event, options) {
         return this.scheduler.submit(normalizeMessage("interrupt", event), options);
     }
+    continue(options) {
+        return this.scheduler.continue(options);
+    }
     stream() {
         return this.scheduler.events;
     }

package/dist/session/state.d.ts

@@ -1,8 +1,13 @@
-import type { InputEvent, SessionSnapshot } from "../types/session.js";
+import type { ActiveExecutionRecord, InputEvent, SessionSnapshot, TranscriptEntry } from "../types/session.js";
 import type { ModelCandidate } from "../types/model.js";
 import type { RequiredInteraction, ToolResult } from "../types/tool.js";
-export declare function initialState(id: string): SessionSnapshot;
-export declare function withStatus(state: SessionSnapshot, status: SessionSnapshot["status"], pendingInteraction?: RequiredInteraction): SessionSnapshot;
+export declare function initialState(id: string, input?: {
+    readonly turnCount?: number;
+    readonly revision?: number;
+    readonly transcript?: readonly TranscriptEntry[];
+}): SessionSnapshot;
+export declare function withStatus(state: SessionSnapshot, status: SessionSnapshot["status"], pendingInteraction?: RequiredInteraction, active?: ActiveExecutionRecord): SessionSnapshot;
+export declare function withRevision(state: SessionSnapshot, revision: number): SessionSnapshot;
 export declare function beginTurn(state: SessionSnapshot, turnId: string, event?: InputEvent): SessionSnapshot;
 export declare const commitInput: (state: SessionSnapshot, turnId: string, event: InputEvent) => SessionSnapshot;
 export declare const commitCandidate: (state: SessionSnapshot, turnId: string, stepId: string, candidate: ModelCandidate) => SessionSnapshot;

package/dist/session/state.js

@@ -1,15 +1,26 @@
-export function initialState(id) {
-    return Object.freeze({ id, status: "idle", turnCount: 0, transcript: Object.freeze([]) });
+export function initialState(id, input = {}) {
+    return Object.freeze({
+        id,
+        status: "idle",
+        turnCount: input.turnCount ?? 0,
+        revision: input.revision ?? 0,
+        transcript: Object.freeze([...(input.transcript ?? [])]),
+    });
 }
-export function withStatus(state, status, pendingInteraction) {
+export function withStatus(state, status, pendingInteraction, active) {
     return Object.freeze({
         id: state.id,
         status,
         turnCount: state.turnCount,
+        revision: state.revision,
         transcript: state.transcript,
         ...(pendingInteraction ? { pendingInteraction } : {}),
+        ...(active ? { active } : {}),
     });
 }
+export function withRevision(state, revision) {
+    return Object.freeze({ ...state, revision });
+}
 export function beginTurn(state, turnId, event) {
     const transcript = event
         ? [
@@ -20,7 +31,8 @@ export function beginTurn(state, turnId, event) {
     return Object.freeze({
         id: state.id,
         status: "running",
-        turnCount: state.turnCount + (event ? 1 : 0),
+        turnCount: state.turnCount + 1,
+        revision: state.revision,
         transcript: Object.freeze(transcript),
     });
 }

package/dist/session/submission-stream.d.ts

@@ -3,11 +3,13 @@ export declare class SubmissionStream implements InputHandle {
     readonly inputId: string;
     readonly completed: Promise<InputCompletion>;
     private resolveCompletion;
+    private rejectCompletion;
     private readonly events;
     private readonly cleanups;
     private done;
     constructor(inputId: string);
     emit(event: SessionEvent): void;
     finish(status: InputCompletion["status"]): void;
+    fail(error: unknown): void;
     onFinish(cleanup: () => void): void;
 }

package/dist/session/submission-stream.js

@@ -2,13 +2,15 @@ export class SubmissionStream {
     inputId;
     completed;
     resolveCompletion;
+    rejectCompletion;
     events = [];
     cleanups = [];
     done = false;
     constructor(inputId) {
         this.inputId = inputId;
-        this.completed = new Promise((resolve) => {
+        this.completed = new Promise((resolve, reject) => {
             this.resolveCompletion = resolve;
+            this.rejectCompletion = reject;
         });
     }
     emit(event) {
@@ -27,6 +29,14 @@ export class SubmissionStream {
             events: Object.freeze([...this.events]),
         }));
     }
+    fail(error) {
+        if (this.done)
+            return;
+        this.done = true;
+        while (this.cleanups.length)
+            this.cleanups.pop()();
+        this.rejectCompletion(error);
+    }
     onFinish(cleanup) {
         if (this.done)
             cleanup();

package/dist/step/model-configuration.d.ts

@@ -1,11 +1,9 @@
 import type { ModelConfigurationMutationOptions, ModelConfigurationSnapshot, ModelDirective } from "../types/model.js";
 import type { ToolDefinition } from "../types/tool.js";
-import type { AdapterRegistry } from "../build/adapters.js";
 /** Per-step, middleware-owned model configuration draft. It never persists past the call. */
 export declare class ModelConfigurationDraft {
     #private;
-    private readonly adapters;
-    constructor(adapters: AdapterRegistry, directive?: ModelDirective);
+    constructor(directive?: ModelDirective);
     setInstructions(middlewareId: string, middlewareOrder: number, slot: string, items: readonly string[], options?: ModelConfigurationMutationOptions): void;
     setTools(middlewareId: string, middlewareOrder: number, slot: string, tools: readonly ToolDefinition[], options?: ModelConfigurationMutationOptions): void;
     select(middlewareId: string, middlewareOrder: number, directive: ModelDirective, options?: Omit<ModelConfigurationMutationOptions, "order">): void;

package/dist/step/model-configuration.js

@@ -6,12 +6,10 @@ import { copyJson } from "../utils/immutable.js";
 import { checkedReason, slotOwner, SlotDraft } from "./slot-assembly.js";
 /** Per-step, middleware-owned model configuration draft. It never persists past the call. */
 export class ModelConfigurationDraft {
-    adapters;
     #instructions = new SlotDraft();
     #tools = new SlotDraft();
     #model;
-    constructor(adapters, directive) {
-        this.adapters = adapters;
+    constructor(directive) {
         if (directive !== undefined)
             this.#model = Object.freeze({ directive: checkedDirective(directive) });
     }
@@ -38,7 +36,7 @@ export class ModelConfigurationDraft {
             middlewareId,
             middlewareOrder,
             slot,
-            value: Object.freeze(tools.map((tool) => bindTool(tool, this.adapters))),
+            value: Object.freeze(tools.map((tool) => bindTool(tool, { middlewareId, slot }))),
             order: options?.order,
             reason: options?.reason,
             invalidSlot: "configuration.invalid-slot",

package/dist/step/project.js

@@ -81,8 +81,10 @@ function projectToolResult(result) {
 }
 function toolResultPayload(result) {
     if (result.kind === "completed")
-        return result.output ?? null;
-    return { kind: result.kind, reason: result.reason ?? result.message ?? result.code ?? "failed" };
+        return result.output;
+    if (result.kind === "denied")
+        return { kind: result.kind, reason: result.reason };
+    return { kind: result.kind, code: result.code, message: result.message };
 }
 function textPart(text) {
     return Object.freeze({ type: "text", text });

package/dist/step/run.d.ts

@@ -1,12 +1,15 @@
 import type { ModelCandidate } from "../types/model.js";
-import type { InputEvent, SessionSnapshot } from "../types/session.js";
+import type { ActiveModelExecutionRecord, InputEvent, SessionSnapshot } from "../types/session.js";
 import type { LoopAgent } from "../build/agent.js";
 import type { ObserveEmit } from "../utils/observe.js";
 import { type SealedStepOutput } from "./seal.js";
+import type { CapabilityStateRegistry } from "../session/capability-state.js";
 export interface StepRunResult {
     readonly stepId: string;
+    readonly state: SessionSnapshot;
     readonly candidate?: ModelCandidate;
     readonly output: SealedStepOutput;
+    readonly requestedModelId?: string;
 }
 export declare function runStep(input: {
     agent: LoopAgent;
@@ -24,4 +27,6 @@ export declare function runStep(input: {
         readonly userId?: string;
         readonly context?: import("../types/shared.js").JsonObject;
     }>;
+    states: CapabilityStateRegistry;
+    recordModelRequested(state: SessionSnapshot, active: ActiveModelExecutionRecord): Promise<SessionSnapshot>;
 }): Promise<StepRunResult>;

package/dist/step/run.js

@@ -8,7 +8,10 @@ import { projectModelCall } from "./project.js";
 import { resolveModelRequest } from "./resolve.js";
 import { sealStep } from "./seal.js";
 import { ModelConfigurationDraft } from "./model-configuration.js";
+import { createId } from "../utils/ids.js";
 export async function runStep(input) {
+    let state = input.state;
+    let requestedModelId;
     const stepInput = Object.freeze({
         sessionId: input.sessionId,
         turnId: input.turnId,
@@ -20,9 +23,9 @@ export async function runStep(input) {
         toolResults: Object.freeze([...input.toolResults]),
         transcript: Object.freeze([...input.state.transcript]),
     });
-    const configuration = new ModelConfigurationDraft(input.agent.adapters, input.agent.directive);
+    const configuration = new ModelConfigurationDraft();
     const runtimeContext = new ContextDraft(input.session.context);
-    const context = new StepContext(stepInput, input.observe, configuration, runtimeContext);
+    const context = new StepContext(stepInput, input.observe, configuration, runtimeContext, input.states);
     input.observe(() => ({
         type: "step.started",
         turnId: input.turnId,
@@ -50,7 +53,17 @@ export async function runStep(input) {
             arrivals: input.arrivals,
             toolResults: input.toolResults,
         });
+        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);
         input.observe(() => ({
             type: "model.requested",
             turnId: input.turnId,
@@ -63,22 +76,22 @@ export async function runStep(input) {
             }),
         }));
         try {
-            const minted = context.mintFromModel(normalizeCandidate(await input.agent.invoke(call, {
+            const outcome = await input.agent.invoke(call, {
                 request,
+                invocationId,
                 signal: input.signal,
-            })));
+            });
             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");
-            input.observe(() => ({
-                type: "model.completed",
-                turnId: input.turnId,
-                stepId: input.stepId,
-                ...(request.model?.id === undefined ? {} : { requestedModelId: request.model.id }),
-                attributes: candidate,
-            }));
             return minted;
         }
         catch (error) {
@@ -92,7 +105,16 @@ export async function runStep(input) {
     }, input.observe);
     const output = sealStep(context);
     const candidate = output.kind === "tools" ? output.plan.candidate : context.currentCandidate;
-    return Object.freeze({ stepId: input.stepId, ...(candidate ? { candidate } : {}), output });
+    return Object.freeze({
+        stepId: input.stepId,
+        state,
+        ...(candidate ? { candidate } : {}),
+        ...(requestedModelId === undefined ? {} : { requestedModelId }),
+        output,
+    });
+}
+function isDeferred(value) {
+    return (typeof value === "object" && value !== null && "kind" in value && value.kind === "deferred");
 }
 function snapshotStepStart(input) {
     const session = Object.freeze({
@@ -121,7 +143,7 @@ function snapshotTools(tools) {
     return Object.freeze(tools.map((tool) => Object.freeze({
         name: tool.name,
         ...(tool.description === undefined ? {} : { description: tool.description }),
-        executeWith: tool.executeWith,
+        owner: tool.owner,
         parameters: Object.freeze({ jsonSchema: copyJson(tool.parameters.jsonSchema) }),
     })));
 }

package/dist/step/seal.d.ts

@@ -1,12 +1,13 @@
 import type { ModelCandidate } from "../types/model.js";
 import type { Tripwire } from "../types/shared.js";
-import type { RequiredInteraction, SealedToolCall, ToolResult } from "../types/tool.js";
+import type { BoundToolDefinition, RequiredInteraction, SealedToolCall, ToolOwner, ToolResult } from "../types/tool.js";
 import type { StepContext } from "./step-context.js";
 export interface ExecutablePlanEntry {
     readonly call: SealedToolCall;
     readonly invocationId: string;
+    readonly owner: ToolOwner;
+    readonly execute: BoundToolDefinition["execute"];
     readonly interaction?: RequiredInteraction;
-    readonly preflight?: "sandbox" | "validation";
 }
 export interface InternalToolPlan {
     readonly candidate: ModelCandidate;
@@ -23,6 +24,9 @@ export type SealedStepOutput = {
 } | {
     readonly kind: "final";
     readonly output: string;
+} | {
+    readonly kind: "deferred-model";
+    readonly active: import("../types/session.js").ActiveModelExecutionRecord;
 } | {
     readonly kind: "tools";
     readonly plan: InternalToolPlan;

package/dist/step/seal.js

@@ -7,6 +7,8 @@ const failed = (callId, toolName, code, message) => Object.freeze({ kind: "faile
 export function sealStep(context) {
     if (context.currentTripwire)
         return Object.freeze({ kind: "tripwire", tripwire: context.currentTripwire });
+    if (context.currentModelDeferred)
+        return Object.freeze({ kind: "deferred-model", active: context.currentModelDeferred });
     const calls = context.canonicalCalls();
     if (!calls.length)
         return Object.freeze({
@@ -75,7 +77,6 @@ function sealCall(context, catalog, candidate) {
     const interaction = requested
         ? Object.freeze({ ...requested, id: requested.id ?? createId("interaction") })
         : undefined;
-    const preflight = context.preflightFor(candidate.id);
     return {
         order,
         canonical,
@@ -84,11 +85,11 @@ function sealCall(context, catalog, candidate) {
                 callId: candidate.id,
                 toolName: candidate.name,
                 args,
-                executeWith: tool.executeWith,
             }),
             invocationId: createId("invocation"),
+            owner: tool.owner,
+            execute: tool.execute,
             ...(interaction ? { interaction } : {}),
-            ...(preflight ? { preflight } : {}),
         }),
     };
 }

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

@@ -1,19 +1,22 @@
 import type { ContextSnapshot, ModelCandidate, ModelDirective, ModelConfigurationSnapshot } from "../types/model.js";
 import type { StepInput, StepRequest, StepResponse } from "../types/middleware.js";
 import type { Tripwire } from "../types/shared.js";
+import type { ActiveModelExecutionRecord } from "../types/session.js";
 import type { ObserveEmit } from "../utils/observe.js";
 import type { BoundToolDefinition, Interaction } from "../types/tool.js";
 import { type CanonicalCall } from "./canonicalize.js";
 import { ContextDraft } from "./context-draft.js";
 import { ModelConfigurationDraft } from "./model-configuration.js";
+import type { CapabilityStateRegistry } from "../session/capability-state.js";
 export declare function isBrandedResponse(value: unknown): value is StepResponse;
 /** Mutable Step state. Middleware receives leased request views and one branded response. */
 export declare class StepContext {
     #private;
     readonly input: Readonly<StepInput>;
-    constructor(input: Readonly<StepInput>, observe: ObserveEmit, configuration: ModelConfigurationDraft, context: ContextDraft);
+    constructor(input: Readonly<StepInput>, observe: ObserveEmit, configuration: ModelConfigurationDraft, context: ContextDraft, states?: CapabilityStateRegistry);
     get currentTripwire(): Tripwire | undefined;
     get currentCandidate(): Readonly<ModelCandidate> | undefined;
+    get currentModelDeferred(): ActiveModelExecutionRecord | undefined;
     get selectedDirective(): ModelDirective | undefined;
     get instructions(): readonly string[];
     contextSnapshot(): ContextSnapshot;
@@ -24,9 +27,9 @@ export declare class StepContext {
     sealContext(snapshot: ContextSnapshot): void;
     denialFor(callId: string): string | undefined;
     interactionFor(callId: string): Interaction | undefined;
-    preflightFor(callId: string): "sandbox" | "validation" | undefined;
     canonicalCalls(): readonly CanonicalCall[];
     mintFromModel(candidate: Readonly<ModelCandidate>): StepResponse;
+    deferModel(active: ActiveModelExecutionRecord): StepResponse;
     tripwire(error: Tripwire): StepResponse;
     seal(): void;
     requestFacade(middlewareId: string, middlewareOrder: number): {