@nylorun/harness 0.13.0-beta → 0.15.0-beta

package/dist/loop/dispatch.js

@@ -0,0 +1,327 @@
+import { HostSuspension } from "./host-suspension.js";
+import { HarnessError, isHarnessError } from "@nylorun/core/define";
+import { isToolError } from "@nylorun/core/define";
+import { createId } from "../utils/ids.js";
+import { copyJson } from "@nylorun/core/define";
+import { createSessionStateBag } from "./initial-state.js";
+import { toolResult } from "./tool-result.js";
+import { isWaitSignal, WaitSignal } from "./waits.js";
+export async function dispatchPlan(invocation) {
+    const { signal, definitions, options, observe, record } = invocation;
+    let plan = invocation.state.plan;
+    if (plan.calls.some((call) => call.status === "interaction" && call.interactionPhase === "before")) {
+        for (const call of plan.calls)
+            if (call.status === "interaction")
+                observe({
+                    type: "interaction.required",
+                    turnId: plan.turnId,
+                    stepId: plan.stepId,
+                    interactionId: call.interaction.id,
+                    kind: call.interaction.kind,
+                    callId: call.callId,
+                    toolName: call.toolName,
+                    phase: "interaction",
+                    attributes: {
+                        prompt: call.interaction.prompt,
+                        ...(call.interaction.metadata ? { metadata: call.interaction.metadata } : {}),
+                    },
+                });
+        return "paused";
+    }
+    signal.throwIfAborted();
+    const pending = plan.calls.filter((call) => call.status === "pending" || call.status === "active");
+    const redelivering = plan.calls.some((call) => call.status === "active");
+    if (pending.length) {
+        invocation.state = {
+            ...invocation.state,
+            plan: {
+                ...plan,
+                calls: plan.calls.map((call) => call.status === "pending" || call.status === "active"
+                    ? { ...call, status: "active" }
+                    : call),
+            },
+        };
+        await record();
+        signal.throwIfAborted();
+        const sessionBag = invocation.sessionBag;
+        const stateApi = createSessionStateBag(sessionBag);
+        const settled = await settleDispatch(pending.map(async (call) => {
+            const definition = definitions.get(call.invocationId);
+            const eventIds = {
+                executionId: invocation.state.executionId,
+                turnId: plan.turnId,
+                stepId: plan.stepId,
+                callId: call.callId,
+                invocationId: call.invocationId,
+                toolName: call.toolName,
+                middlewareId: call.reference.capabilityId,
+                slot: definition.owner.slot,
+            };
+            observe({ type: "tool.started", ...eventIds, attributes: { args: call.args } });
+            let outcome;
+            try {
+                signal.throwIfAborted();
+                if (definition.approval && !call.resume) {
+                    const decision = await definition.approval(call.args);
+                    const prompt = typeof decision === "string"
+                        ? decision
+                        : decision === true
+                            ? `Approve ${call.toolName}?`
+                            : undefined;
+                    if (prompt) {
+                        return copyJson({
+                            ...call,
+                            status: "interaction",
+                            interaction: {
+                                kind: "approval",
+                                prompt,
+                                id: createId("interaction"),
+                            },
+                            interactionPhase: "before",
+                        });
+                    }
+                }
+                const stepMemos = new Map();
+                if (call.token && typeof call.token === "object" && !Array.isArray(call.token)) {
+                    const memos = call.token.steps;
+                    if (memos)
+                        for (const [key, value] of Object.entries(memos))
+                            stepMemos.set(key, value);
+                }
+                const raw = await definition.execute(call.args, {
+                    executionId: invocation.state.executionId,
+                    turnId: plan.turnId,
+                    stepId: plan.stepId,
+                    callId: call.callId,
+                    invocationId: call.invocationId,
+                    signal,
+                    info: options.info,
+                    onModelCall: options.onModelCall,
+                    idempotencyKey: call.callId,
+                    ...(redelivering || call.status === "active" ? { redelivery: true } : {}),
+                    state: stateApi,
+                    session: { id: invocation.state.executionId },
+                    progress(message, data) {
+                        observe({
+                            type: "tool.progress",
+                            ...eventIds,
+                            attributes: {
+                                message,
+                                ...(data === undefined ? {} : { data }),
+                            },
+                        });
+                    },
+                    async ask(prompt, opts) {
+                        if (call.resume?.kind === "response")
+                            return call.resume.value;
+                        throw new WaitSignal({
+                            kind: "interaction-required",
+                            interaction: {
+                                kind: "response",
+                                prompt,
+                                ...(opts ? { metadata: opts } : {}),
+                            },
+                            wait: { kind: "ask", waitId: createId("wait") },
+                            token: { steps: Object.fromEntries(stepMemos) },
+                        });
+                    },
+                    async approve(prompt) {
+                        if (call.resume?.kind === "approval")
+                            return Boolean(call.resume.approved);
+                        throw new WaitSignal({
+                            kind: "interaction-required",
+                            interaction: { kind: "approval", prompt },
+                            wait: { kind: "approve", waitId: createId("wait") },
+                            token: { steps: Object.fromEntries(stepMemos) },
+                        });
+                    },
+                    async sleep(duration) {
+                        throw new WaitSignal({
+                            kind: "deferred",
+                            wait: { kind: "sleep", waitId: createId("wait") },
+                            token: { steps: Object.fromEntries(stepMemos), duration },
+                        });
+                    },
+                    async waitFor(event, opts) {
+                        throw new WaitSignal({
+                            kind: "deferred",
+                            wait: { kind: "waitFor", waitId: createId("wait"), name: event },
+                            token: { steps: Object.fromEntries(stepMemos), event, ...(opts ?? {}) },
+                        });
+                    },
+                    async step(name, fn) {
+                        if (stepMemos.has(name))
+                            return stepMemos.get(name);
+                        const value = await fn();
+                        stepMemos.set(name, value);
+                        return value;
+                    },
+                    ...(call.resume ? { resume: call.resume } : {}),
+                });
+                outcome = normalizeOutcome(raw);
+                if (!outcome || typeof outcome !== "object")
+                    throw new HarnessError("tool.invalid-tool-result", "Tool returned an invalid outcome");
+                if (outcome.kind === "interaction-required") {
+                    if (!["approval", "response"].includes(outcome.interaction.kind) ||
+                        typeof outcome.interaction.prompt !== "string")
+                        throw new HarnessError("tool.invalid-tool-result", "Tool returned an invalid interaction");
+                    return copyJson({
+                        ...call,
+                        status: "interaction",
+                        interaction: {
+                            ...outcome.interaction,
+                            id: outcome.interaction.id ?? createId("interaction"),
+                        },
+                        interactionPhase: "execute",
+                        ...(outcome.token === undefined ? {} : { token: outcome.token }),
+                    });
+                }
+                if (outcome.kind === "deferred") {
+                    observe({
+                        type: "tool.deferred",
+                        ...eventIds,
+                        attributes: outcome.token === undefined ? {} : { token: outcome.token },
+                    });
+                    return copyJson({
+                        ...call,
+                        status: "deferred",
+                        ...(outcome.token === undefined ? {} : { token: outcome.token }),
+                    });
+                }
+                const result = toolResult(call, definition, outcome);
+                observe({
+                    type: "tool.completed",
+                    ...eventIds,
+                    outcome: result.kind,
+                    attributes: result,
+                });
+                return copyJson({ ...call, status: "settled", result });
+            }
+            catch (cause) {
+                if (cause instanceof HostSuspension)
+                    throw cause;
+                if (isWaitSignal(cause)) {
+                    if (cause.outcome.kind === "interaction-required") {
+                        return copyJson({
+                            ...call,
+                            status: "interaction",
+                            interaction: {
+                                ...cause.outcome.interaction,
+                                id: createId("interaction"),
+                            },
+                            interactionPhase: "execute",
+                            wait: cause.outcome.wait,
+                            ...(cause.outcome.token === undefined ? {} : { token: cause.outcome.token }),
+                        });
+                    }
+                    observe({
+                        type: "tool.deferred",
+                        ...eventIds,
+                        attributes: cause.outcome.token === undefined ? {} : { token: cause.outcome.token },
+                    });
+                    return copyJson({
+                        ...call,
+                        status: "deferred",
+                        wait: cause.outcome.wait,
+                        ...(cause.outcome.token === undefined ? {} : { token: cause.outcome.token }),
+                    });
+                }
+                if (isToolError(cause)) {
+                    const result = {
+                        callId: call.callId,
+                        toolName: call.toolName,
+                        kind: "failed",
+                        code: cause.code,
+                        message: cause.message,
+                    };
+                    observe({
+                        type: "tool.completed",
+                        ...eventIds,
+                        outcome: result.kind,
+                        attributes: result,
+                    });
+                    return copyJson({ ...call, status: "settled", result });
+                }
+                const result = {
+                    callId: call.callId,
+                    toolName: call.toolName,
+                    kind: "failed",
+                    code: signal.aborted
+                        ? "tool.cancelled"
+                        : isHarnessError(cause)
+                            ? cause.code
+                            : "tool.execution-failed",
+                    message: cause instanceof Error ? cause.message : String(cause),
+                };
+                observe({
+                    type: "tool.completed",
+                    ...eventIds,
+                    outcome: result.kind,
+                    attributes: result,
+                });
+                return copyJson({ ...call, status: "settled", result });
+            }
+        }));
+        const byId = new Map(settled.map((call) => [call.invocationId, call]));
+        plan = { ...plan, calls: plan.calls.map((call) => byId.get(call.invocationId) ?? call) };
+        invocation.state = {
+            ...invocation.state,
+            plan,
+        };
+        await record();
+    }
+    signal.throwIfAborted();
+    if (plan.calls.some((call) => call.status === "interaction" || call.status === "deferred")) {
+        for (const call of plan.calls)
+            if (call.status === "interaction")
+                observe({
+                    type: "interaction.required",
+                    turnId: plan.turnId,
+                    stepId: plan.stepId,
+                    interactionId: call.interaction.id,
+                    kind: call.interaction.kind,
+                    callId: call.callId,
+                    toolName: call.toolName,
+                    phase: call.interactionPhase === "before" ? "interaction" : "execute",
+                    attributes: {
+                        prompt: call.interaction.prompt,
+                        ...(call.interaction.metadata ? { metadata: call.interaction.metadata } : {}),
+                    },
+                });
+        return "paused";
+    }
+    const results = [
+        ...plan.immediate,
+        ...plan.calls.flatMap((call) => (call.result ? [call.result] : [])),
+    ];
+    const ordered = plan.order.map((item) => results.find((result) => result.callId === item.callId && result.toolName === item.toolName));
+    const { plan: _, ...rest } = invocation.state;
+    invocation.state = {
+        ...rest,
+        transcript: [
+            ...invocation.state.transcript,
+            { kind: "tool-results", turnId: plan.turnId, stepId: plan.stepId, results: ordered },
+        ],
+    };
+    await record();
+}
+function normalizeOutcome(raw) {
+    if (raw && typeof raw === "object" && "kind" in raw) {
+        const kind = raw.kind;
+        if (kind === "completed" ||
+            kind === "denied" ||
+            kind === "failed" ||
+            kind === "interaction-required" ||
+            kind === "deferred")
+            return raw;
+    }
+    return { kind: "completed", output: raw };
+}
+// Persist all parallel action intents before handing control back to a durable host.
+async function settleDispatch(promises) {
+    const results = await Promise.allSettled(promises);
+    const failure = results.find((r) => r.status === "rejected");
+    if (failure)
+        throw failure.reason;
+    return results.map((r) => r.value);
+}

package/dist/loop/host-suspension.d.ts

@@ -0,0 +1,6 @@
+/** Control transfer to a durable host, never a model/tool failure. */
+export declare class HostSuspension extends Error {
+    readonly effectId: string;
+    readonly status: "pending" | "uncertain";
+    constructor(effectId: string, status: "pending" | "uncertain");
+}

package/dist/loop/host-suspension.js

@@ -0,0 +1,10 @@
+/** Control transfer to a durable host, never a model/tool failure. */
+export class HostSuspension extends Error {
+    effectId;
+    status;
+    constructor(effectId, status) {
+        super(`Host suspended at ${effectId}`);
+        this.effectId = effectId;
+        this.status = status;
+    }
+}

package/dist/loop/initial-state.d.ts

@@ -0,0 +1,13 @@
+import type { AgentDefinition } from "../definition/agent-definition.js";
+import type { ExecutionState } from "../types/execution.js";
+import type { JsonObject, JsonValue } from "@nylorun/core/define";
+export declare function initializeExecutionState(agent: AgentDefinition, options?: {
+    readonly executionId?: string;
+    readonly state?: JsonObject;
+}): ExecutionState;
+/** Mutable session-memory bag backed by Invocation / ExecutionState.state. */
+export declare function createSessionStateBag(bag: Record<string, JsonValue>): {
+    get(key: string): JsonValue | undefined;
+    set(key: string, value: JsonValue): void;
+    entries(): Readonly<Record<string, JsonValue>>;
+};

package/dist/loop/initial-state.js

@@ -0,0 +1,30 @@
+import { copyJson } from "@nylorun/core/define";
+import { createId } from "../utils/ids.js";
+export function initializeExecutionState(agent, options = {}) {
+    return copyJson({
+        version: 1,
+        agentId: agent.id,
+        manifestHash: agent.hash,
+        executionId: options.executionId ?? createId("execution"),
+        revision: 0,
+        turnCount: 0,
+        transcript: [],
+        status: "ready",
+        state: options.state ?? {},
+        ...(agent.output ? { outputContract: agent.output.schema.jsonSchema } : {}),
+    });
+}
+/** Mutable session-memory bag backed by Invocation / ExecutionState.state. */
+export function createSessionStateBag(bag) {
+    return {
+        get(key) {
+            return bag[key];
+        },
+        set(key, value) {
+            bag[key] = value;
+        },
+        entries() {
+            return { ...bag };
+        },
+    };
+}

package/dist/{execution → loop}/invocation.d.ts

@@ -1,7 +1,8 @@
 import type { AgentDefinition } from "../definition/agent-definition.js";
-import type { BoundToolDefinition } from "../definition/bound.js";
+import type { BoundToolDefinition } from "@nylorun/core/define";
 import type { ExecutionState, RunOptions } from "../types/execution.js";
-import type { ObserveEvent } from "../types/observe.js";
+import type { ObserveEvent } from "@nylorun/core/define";
+import type { JsonValue } from "@nylorun/core/define";
 import { type ExecutionOutcomeEvent, type ObserveEmit } from "./observe.js";
 export interface Invocation {
     readonly agent: AgentDefinition;
@@ -9,6 +10,8 @@ export interface Invocation {
     readonly signal: AbortSignal;
     readonly definitions: Map<string, BoundToolDefinition>;
     state: ExecutionState;
+    /** Mutable durable session memory for this invocation. */
+    sessionBag: Record<string, JsonValue>;
     observe: ObserveEmit;
     emit(event: ObserveEvent | ExecutionOutcomeEvent): void;
     record(): Promise<void>;

package/dist/{execution → loop}/invocation.js

@@ -1,5 +1,5 @@
-import { HarnessError } from "../errors.js";
-import { copyJson } from "../utils/immutable.js";
+import { HarnessError } from "@nylorun/core/define";
+import { copyJson } from "@nylorun/core/define";
 import { createId } from "../utils/ids.js";
 import { createObservationSink } from "./observe.js";
 export function createInvocation(input) {
@@ -9,6 +9,7 @@ export function createInvocation(input) {
         signal: input.options.signal ?? new AbortController().signal,
         definitions: input.definitions,
         state: input.state,
+        sessionBag: { ...(input.state.state ?? {}) },
     };
     const sink = createObservationSink({
         listener: input.options.onEvent,
@@ -18,7 +19,11 @@ export function createInvocation(input) {
     invocation.observe = sink.observe;
     invocation.emit = sink.emit;
     invocation.record = async () => {
-        invocation.state = copyJson({ ...invocation.state, revision: invocation.state.revision + 1 });
+        invocation.state = copyJson({
+            ...invocation.state,
+            state: { ...invocation.sessionBag },
+            revision: invocation.state.revision + 1,
+        });
         if (!input.options.record)
             return;
         try {

package/dist/{execution → loop}/model/adapters.d.ts

@@ -1,5 +1,7 @@
-import type { ModelAdapter, ModelAdapterContext, ModelCall, ModelCandidate } from "../../types/model.js";
-import type { JsonObject } from "../../types/shared.js";
+import type { ModelAdapter, ModelAdapterContext, ModelCall, ModelCandidate } from "@nylorun/core/define";
+import type { JsonObject } from "@nylorun/core/define";
+import { preparedModel } from "./prepared.js";
+export { preparedModel };
 export type ChatCompletionsMessage = {
     readonly role: "system";
     readonly content: string;

package/dist/{execution → loop}/model/adapters.js

@@ -1,6 +1,7 @@
-import { HarnessError } from "../../errors.js";
-import { copyJsonObject } from "../../utils/immutable.js";
+import { HarnessError } from "@nylorun/core/define";
+import { copyJsonObject } from "@nylorun/core/define";
 import { preparedModel } from "./prepared.js";
+export { preparedModel };
 /** Translate a Harness call to the OpenAI Chat Completions request shape. */
 export function toChatCompletions(call) {
     const messages = withoutProviderReasoning(call.prompt).map((item) => {

package/dist/{execution → loop}/model/normalize.d.ts

@@ -1,5 +1,5 @@
-import { HarnessError } from "../../errors.js";
-import type { ModelCandidate, ModelDirective, ModelOutputBlock } from "../../types/model.js";
+import { HarnessError } from "@nylorun/core/define";
+import type { ModelCandidate, ModelDirective, ModelOutputBlock } from "@nylorun/core/define";
 export declare function normalizeDirective(value: unknown): ModelDirective | HarnessError;
 export declare function sameDirective(left: ModelDirective, right: ModelDirective): boolean;
 export declare function textFromOutput(output: readonly ModelOutputBlock[]): string;

package/dist/{execution → loop}/model/normalize.js

@@ -1,5 +1,5 @@
-import { HarnessError, isHarnessError } from "../../errors.js";
-import { assertJson, copyJson, copyJsonObject } from "../../utils/immutable.js";
+import { HarnessError, isHarnessError } from "@nylorun/core/define";
+import { assertJson, copyJson, copyJsonObject } from "@nylorun/core/define";
 const FINISH_REASONS = new Set([
     "stop",
     "length",

package/dist/{execution → loop}/model/prepared.d.ts

@@ -1,5 +1,5 @@
-import type { ModelAdapter, ModelAdapterContext, ModelCandidate, ModelCall } from "../../types/model.js";
-import type { JsonValue } from "../../types/shared.js";
+import type { ModelAdapter, ModelAdapterContext, ModelCandidate, ModelCall } from "@nylorun/core/define";
+import type { JsonValue } from "@nylorun/core/define";
 export interface PreparedModelOptions<Wire> {
     readonly adapter: string;
     prepare(call: ModelCall, context: ModelAdapterContext): Promise<{

package/dist/{execution → loop}/model/project.d.ts

@@ -1,2 +1,2 @@
-import type { ModelCall, ModelRequest } from "../../types/model.js";
+import type { ModelCall, ModelRequest } from "@nylorun/core/define";
 export declare function projectModelCall(request: ModelRequest): ModelCall;

package/dist/{execution → loop}/model/project.js

@@ -1,4 +1,4 @@
-import { copyJson, freezeGraph } from "../../utils/immutable.js";
+import { copyJson, freezeGraph } from "@nylorun/core/define";
 export function projectModelCall(request) {
     return freezeGraph({
         prompt: Object.freeze([

package/dist/{execution → loop}/observe.d.ts

@@ -1,6 +1,6 @@
 import type { ExecutionEvent } from "../types/execution.js";
-import type { ObserveEvent, Observer } from "../types/observe.js";
-import type { JsonValue } from "../types/shared.js";
+import type { ObserveEvent, Observer } from "@nylorun/core/define";
+import type { JsonValue } from "@nylorun/core/define";
 export type ObserveEmit = (event: ObserveEvent | (() => ObserveEvent)) => void;
 export type ExecutionOutcomeEvent = {
     type: "execution.completed" | "execution.paused" | "execution.cancelled" | "execution.failed" | "observation.failed";

package/dist/{execution → loop}/observe.js

@@ -1,4 +1,4 @@
-import { copyJson } from "../utils/immutable.js";
+import { copyJson } from "@nylorun/core/define";
 export function createObservationSink(input) {
     let sequence = 0;
     let reportingFailure = false;

package/dist/{execution → loop}/options.d.ts

@@ -1,5 +1,5 @@
 import type { AgentDefinition } from "../definition/agent-definition.js";
-import type { BoundToolDefinition } from "../definition/bound.js";
+import type { BoundToolDefinition } from "@nylorun/core/define";
 import type { ExecutionState, RunOptions } from "../types/execution.js";
 import { normalizeInput } from "./state.js";
 export declare function validateRunOptions(options: RunOptions<any>): void;
@@ -7,4 +7,5 @@ export declare function openExecution(agent: AgentDefinition, options: RunOption
     readonly state: ExecutionState;
     readonly input: ReturnType<typeof normalizeInput>;
     readonly definitions: Map<string, BoundToolDefinition>;
+    readonly redelivery: boolean;
 };

package/dist/{execution → loop}/options.js

@@ -1,6 +1,7 @@
+import { checkCompatibility } from "../definition/compatibility.js";
 import { initializeExecutionState } from "./initial-state.js";
-import { canonical } from "../utils/canonical.js";
-import { HarnessError } from "../errors.js";
+import { canonical } from "@nylorun/core/define";
+import { HarnessError } from "@nylorun/core/define";
 import { normalizeInput, validateExecutionState } from "./state.js";
 const acceptedOptions = new Set([
     "state",
@@ -30,12 +31,26 @@ export function openExecution(agent, options) {
     const state = options.state === undefined
         ? initializeExecutionState(agent)
         : validateExecutionState(options.state);
-    if (state.agentId !== agent.id ||
-        canonical(state.outputContract) !== canonical(agent.output?.schema.jsonSchema))
+    if (state.agentId !== agent.id)
         throw new HarnessError("execution.incompatible", "Saved state requires the original compatible agent and outputSchema");
-    if ((state.status !== "paused" && state.plan !== undefined) ||
-        state.status === "active" ||
-        state.plan?.calls.some((call) => call.status === "active"))
+    if (canonical(state.outputContract) !== canonical(agent.output?.schema.jsonSchema))
+        throw new HarnessError("execution.incompatible", "Saved state requires the original compatible agent and outputSchema");
+    if (state.manifestHash) {
+        const compatibility = checkCompatibility(agent.manifest, state);
+        if (!compatibility.ok)
+            throw compatibility.error;
+    }
+    const hasActive = state.status === "active" || state.plan?.calls.some((call) => call.status === "active");
+    // Crash-continue: allow resume when a prior run left active work; mark redelivery.
+    if (hasActive && options.input && typeof options.input === "object" && "kind" in options.input) {
+        const kind = options.input.kind;
+        if (kind !== "continue" && kind !== "settle" && kind !== "approve" && kind !== "respond")
+            throw new HarnessError("execution.invalid-state", "Execution was interrupted with possibly active effects. Resume with continue/settle/approve/respond; automatic replay is not supported.");
+    }
+    else if (hasActive) {
+        throw new HarnessError("execution.invalid-state", "Execution was interrupted with possibly active effects. Reconcile it before starting another run; automatic replay is not supported.");
+    }
+    if (state.status !== "paused" && state.plan !== undefined && !hasActive)
         throw new HarnessError("execution.invalid-state", "Execution was interrupted with possibly active effects. Reconcile it before starting another run; automatic replay is not supported.");
     const definitions = new Map();
     for (const call of state.plan?.calls ?? []) {
@@ -45,5 +60,10 @@ export function openExecution(agent, options) {
             throw new HarnessError("execution.incompatible", "Saved tool arguments differ from their accepted contract");
         definitions.set(call.invocationId, definition);
     }
-    return { state, input: normalizeInput(options.input), definitions };
+    return {
+        state,
+        input: normalizeInput(options.input),
+        definitions,
+        redelivery: Boolean(hasActive),
+    };
 }

package/dist/{execution → loop}/resume.d.ts

@@ -1,4 +1,4 @@
-import type { BoundToolDefinition } from "../definition/bound.js";
+import type { BoundToolDefinition } from "@nylorun/core/define";
 import type { ExecutionState } from "../types/execution.js";
 import type { normalizeInput } from "./state.js";
 export declare function applyResume(state: ExecutionState, input: ReturnType<typeof normalizeInput>, definitions: Map<string, BoundToolDefinition>): ExecutionState;

package/dist/{execution → loop}/resume.js

@@ -1,5 +1,5 @@
-import { HarnessError } from "../errors.js";
-import { copyJson } from "../utils/immutable.js";
+import { HarnessError } from "@nylorun/core/define";
+import { copyJson } from "@nylorun/core/define";
 import { toolResult } from "./tool-result.js";
 export function applyResume(state, input, definitions) {
     const plan = state.plan;

package/dist/{execution → loop}/run.d.ts

@@ -1,5 +1,5 @@
 import type { AgentDefinition } from "../definition/agent-definition.js";
 import type { RunOptions, RunResult } from "../types/execution.js";
-import type { JsonValue } from "../types/shared.js";
+import type { JsonValue } from "@nylorun/core/define";
 /** All mutable progress belongs to this invocation and is discarded when it settles. */
 export declare function execute(agent: AgentDefinition, options: RunOptions<any>): Promise<RunResult<JsonValue>>;

package/dist/{execution → loop}/run.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 { runStep } from "./step/run.js";
 import { createId } from "../utils/ids.js";
 import { dispatchPlan } from "./dispatch.js";
@@ -74,6 +75,11 @@ export async function execute(agent, options) {
                     middleware: agent.middleware,
                     invoke: options.onModelCall,
                     registry: agent.registry,
+                    definition: agent,
+                    sessionState: invocation.sessionBag,
+                    recordAfterDynamics: async () => {
+                        await record();
+                    },
                 },
                 state: snapshot,
                 executionId: invocation.state.executionId,
@@ -188,6 +194,8 @@ export async function execute(agent, options) {
         }
     }
     catch (error) {
+        if (error instanceof HostSuspension)
+            throw error;
         if (isHarnessError(error) && error.code === "execution.record-failed")
             throw error;
         if (signal.aborted)

package/dist/{execution → loop}/state.d.ts

@@ -1,6 +1,6 @@
-import type { BuiltAgent } from "../types/agent.js";
+import type { BuiltAgent } from "@nylorun/core/define";
 import type { ExecutionInput, ExecutionState } from "../types/execution.js";
-import type { InputEvent } from "../types/transcript.js";
+import type { InputEvent } from "@nylorun/core/define";
 export declare function createExecutionState<Info, Output>(agent: BuiltAgent<Info, Output>): ExecutionState;
 export declare function validateExecutionState(value: unknown): ExecutionState;
 export declare function normalizeInput(value: ExecutionInput): InputEvent | Extract<ExecutionInput, {