@nylorun/harness 0.11.1-beta → 0.13.0-beta

package/dist/execution/run.js

@@ -0,0 +1,256 @@
+import { HarnessError, isHarnessError } from "../errors.js";
+import { runStep } from "./step/run.js";
+import { createId } from "../utils/ids.js";
+import { dispatchPlan } from "./dispatch.js";
+import { createInvocation } from "./invocation.js";
+import { openExecution, validateRunOptions } from "./options.js";
+import { applyResume } from "./resume.js";
+/** All mutable progress belongs to this invocation and is discarded when it settles. */
+export async function execute(agent, options) {
+    validateRunOptions(options);
+    const opened = openExecution(agent, options);
+    let { state } = opened;
+    const { input, definitions } = opened;
+    if (state.status === "paused" && !(input.kind === "continue" && options.signal?.aborted)) {
+        state = applyResume(state, input, definitions);
+        if (input.kind === "approve" || input.kind === "respond")
+            state = {
+                ...state,
+                transcript: [
+                    ...state.transcript,
+                    { kind: "input", turnId: state.plan.turnId, event: input },
+                ],
+            };
+    }
+    else if (input.kind === "approve" || input.kind === "respond" || input.kind === "settle") {
+        throw new HarnessError("execution.invalid-input", "There is no matching paused operation for this input");
+    }
+    const invocation = createInvocation({ agent, options, state, definitions });
+    const { signal, observe, record } = invocation;
+    const finish = (result) => finishInvocation(invocation, result);
+    try {
+        signal.throwIfAborted();
+        let turnId;
+        let stepNumber;
+        let arrivals = [];
+        let toolResults = [];
+        if (invocation.state.plan) {
+            turnId = invocation.state.plan.turnId;
+            stepNumber = invocation.state.plan.stepNumber + 1;
+            invocation.state = { ...invocation.state, status: "active" };
+            await record();
+            if ((await dispatchPlan(invocation)) === "paused")
+                return finish({ status: "paused" });
+            toolResults = lastResults(invocation.state);
+        }
+        else {
+            turnId = createId("turn");
+            stepNumber = 1;
+            if (input.kind !== "continue" && input.kind !== "settle")
+                arrivals = [input];
+            invocation.state = {
+                ...invocation.state,
+                status: "active",
+                turnCount: invocation.state.turnCount + 1,
+                transcript: [
+                    ...invocation.state.transcript,
+                    ...arrivals.map((event) => ({ kind: "input", turnId, event })),
+                ],
+            };
+            await record();
+        }
+        for (;; stepNumber++) {
+            signal.throwIfAborted();
+            const stepId = createId("step");
+            const snapshot = {
+                id: invocation.state.executionId,
+                status: "running",
+                revision: invocation.state.revision,
+                turnCount: invocation.state.turnCount,
+                transcript: invocation.state.transcript,
+            };
+            const result = await runStep({
+                agent: {
+                    middleware: agent.middleware,
+                    invoke: options.onModelCall,
+                    registry: agent.registry,
+                },
+                state: snapshot,
+                executionId: invocation.state.executionId,
+                turnId,
+                stepId,
+                turnNumber: invocation.state.turnCount,
+                stepNumber,
+                arrivals,
+                toolResults,
+                signal,
+                info: options.info,
+                observe,
+                output: agent.output,
+            });
+            signal.throwIfAborted();
+            if (result.candidate) {
+                invocation.state = {
+                    ...invocation.state,
+                    transcript: [
+                        ...invocation.state.transcript,
+                        { kind: "candidate", turnId, stepId, candidate: result.candidate },
+                    ],
+                };
+                observe({
+                    type: "model.completed",
+                    turnId,
+                    stepId,
+                    ...(result.modelInvocationId ? { invocationId: result.modelInvocationId } : {}),
+                    ...(result.requestedModelId === undefined
+                        ? {}
+                        : { requestedModelId: result.requestedModelId }),
+                    attributes: result.candidate,
+                });
+            }
+            if (result.output.kind === "tripwire") {
+                observe({
+                    type: "tripwire",
+                    turnId,
+                    stepId,
+                    code: result.output.tripwire.code,
+                    scope: result.output.tripwire.scope ?? "step",
+                    attributes: { message: result.output.tripwire.message },
+                });
+                return finish({ status: "failed", error: result.output.tripwire });
+            }
+            if (result.output.kind === "final") {
+                invocation.state = {
+                    ...invocation.state,
+                    transcript: [
+                        ...invocation.state.transcript,
+                        { kind: "final", turnId, stepId, output: result.output.output },
+                    ],
+                };
+                observe({
+                    type: "turn.completed",
+                    turnId,
+                    stepId,
+                    attributes: { output: result.output.output },
+                });
+                return finish({ status: "completed", output: result.output.output });
+            }
+            const plan = result.output.plan;
+            const calls = plan.executable.map((entry) => {
+                const reference = agent.registry.reference(entry.definition);
+                definitions.set(entry.invocationId, agent.registry.restore(reference));
+                return {
+                    callId: entry.call.callId,
+                    toolName: entry.call.toolName,
+                    args: entry.call.args,
+                    rawArgs: entry.rawArgs,
+                    invocationId: entry.invocationId,
+                    reference,
+                    status: entry.interaction ? "interaction" : "pending",
+                    ...(entry.interaction
+                        ? { interaction: entry.interaction, interactionPhase: "before" }
+                        : {}),
+                };
+            });
+            invocation.state = {
+                ...invocation.state,
+                plan: {
+                    turnId,
+                    stepId,
+                    stepNumber,
+                    order: plan.order,
+                    immediate: plan.immediateResults,
+                    calls,
+                },
+            };
+            observe({
+                type: "tool.sealed",
+                turnId,
+                stepId,
+                attributes: {
+                    executable: plan.executable.map((entry) => ({
+                        callId: entry.call.callId,
+                        toolName: entry.call.toolName,
+                        args: entry.call.args,
+                        rawArgs: entry.rawArgs,
+                        invocationId: entry.invocationId,
+                        owner: entry.owner,
+                        ...(entry.interaction ? { interaction: entry.interaction } : {}),
+                    })),
+                    immediate: plan.immediateResults,
+                },
+            });
+            await record();
+            if ((await dispatchPlan(invocation)) === "paused")
+                return finish({ status: "paused" });
+            toolResults = lastResults(invocation.state);
+            arrivals = [];
+        }
+    }
+    catch (error) {
+        if (isHarnessError(error) && error.code === "execution.record-failed")
+            throw error;
+        if (signal.aborted)
+            return finish({ status: "cancelled" });
+        return finish({
+            status: "failed",
+            error: {
+                code: isHarnessError(error) ? error.code : "execution.failed",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
+}
+async function finishInvocation(invocation, result) {
+    if (result.status === "cancelled" && invocation.state.plan) {
+        const plan = invocation.state.plan;
+        const results = [
+            ...plan.immediate,
+            ...plan.calls.map((call) => call.result ?? {
+                kind: "failed",
+                callId: call.callId,
+                toolName: call.toolName,
+                code: "tool.cancelled",
+                message: "Invocation cancelled; external effects are not automatically retried",
+            }),
+        ];
+        const { plan: _, ...rest } = invocation.state;
+        invocation.state = {
+            ...rest,
+            cancelledCalls: [
+                ...(rest.cancelledCalls ?? []),
+                ...plan.calls.filter((call) => !call.result),
+            ],
+            transcript: [
+                ...invocation.state.transcript,
+                {
+                    kind: "tool-results",
+                    turnId: plan.turnId,
+                    stepId: plan.stepId,
+                    results: plan.order.map((item) => results.find((result) => result.callId === item.callId && result.toolName === item.toolName)),
+                },
+            ],
+        };
+    }
+    invocation.state = { ...invocation.state, status: result.status };
+    await invocation.record();
+    invocation.emit({
+        type: `execution.${result.status}`,
+        ...(result.status === "completed"
+            ? { attributes: { output: result.output } }
+            : result.status === "failed"
+                ? { attributes: { error: result.error } }
+                : {}),
+    });
+    if (result.status === "paused")
+        return {
+            status: "paused",
+            state: invocation.state,
+            pending: invocation.state.plan.calls.filter((call) => call.status === "interaction" || call.status === "deferred"),
+        };
+    return { ...result, state: invocation.state };
+}
+function lastResults(state) {
+    const entry = state.transcript[state.transcript.length - 1];
+    return entry?.kind === "tool-results" ? entry.results : [];
+}

package/dist/execution/state.d.ts

@@ -0,0 +1,8 @@
+import type { BuiltAgent } from "../types/agent.js";
+import type { ExecutionInput, ExecutionState } from "../types/execution.js";
+import type { InputEvent } from "../types/transcript.js";
+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, {
+    kind: "continue" | "settle";
+}>;

package/dist/execution/state.js

@@ -0,0 +1,208 @@
+import { z } from "zod";
+import { HarnessError } from "../errors.js";
+import { assertJson, copyJson } from "../utils/immutable.js";
+import { definitionFor } from "../definition/agent-definition.js";
+import { initializeExecutionState } from "./initial-state.js";
+import { validateTranscript } from "../execution/transcript.js";
+const id = z.string().min(1);
+const json = z.unknown().refine((value) => {
+    try {
+        assertJson(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}, "Expected JSON data");
+const interaction = z
+    .object({
+    id,
+    kind: z.enum(["approval", "response"]),
+    prompt: z.string(),
+    metadata: json.optional(),
+})
+    .strict();
+const outcome = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("completed"), output: json }).strict(),
+    z.object({ kind: z.literal("denied"), reason: z.string() }).strict(),
+    z.object({ kind: z.literal("failed"), code: id, message: z.string() }).strict(),
+]);
+const reference = z
+    .object({
+    capabilityId: id,
+    toolName: id,
+    descriptor: z
+        .object({
+        name: id,
+        description: z.string().optional(),
+        inputSchema: z.record(z.string(), json),
+        outputSchema: z.record(z.string(), json).optional(),
+    })
+        .strict(),
+})
+    .strict();
+const call = z
+    .object({
+    callId: id,
+    invocationId: id,
+    toolName: id,
+    args: json,
+    rawArgs: json,
+    reference,
+    status: z.enum(["pending", "active", "settled", "interaction", "deferred"]),
+    result: json.optional(),
+    interaction: interaction.optional(),
+    interactionPhase: z.enum(["before", "execute"]).optional(),
+    resume: z
+        .discriminatedUnion("kind", [
+        z
+            .object({
+            kind: z.literal("approval"),
+            interactionId: id,
+            approved: z.boolean(),
+            token: json.optional(),
+        })
+            .strict(),
+        z
+            .object({
+            kind: z.literal("response"),
+            interactionId: id,
+            value: json,
+            token: json.optional(),
+        })
+            .strict(),
+    ])
+        .optional(),
+    token: json.optional(),
+})
+    .strict();
+const schema = z
+    .object({
+    version: z.literal(1),
+    agentId: id,
+    executionId: id,
+    outputContract: z.record(z.string(), json).optional(),
+    revision: z.number().int().nonnegative(),
+    turnCount: z.number().int().nonnegative(),
+    transcript: z.array(json),
+    status: z.enum(["ready", "active", "completed", "paused", "cancelled", "failed"]),
+    cancelledCalls: z.array(call).optional(),
+    plan: z
+        .object({
+        turnId: id,
+        stepId: id,
+        stepNumber: z.number().int().positive(),
+        order: z.array(z.object({ callId: id, toolName: id }).strict()),
+        immediate: z.array(json),
+        calls: z.array(call),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+export function createExecutionState(agent) {
+    return initializeExecutionState(definitionFor(agent));
+}
+function omitLegacyExecutionVersion(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return value;
+    if (!("executionVersion" in value))
+        return value;
+    const { executionVersion: _ignored, ...rest } = value;
+    return rest;
+}
+export function validateExecutionState(value) {
+    try {
+        assertJson(value);
+        const parsed = schema.parse(omitLegacyExecutionVersion(value));
+        validateTranscript(parsed.transcript);
+        const plan = parsed.plan;
+        if (parsed.status === "paused" && !plan)
+            throw new HarnessError("execution.invalid-state", "Paused execution requires a pending plan");
+        if (plan) {
+            const ids = new Set();
+            const invocations = new Set();
+            const interactions = new Set();
+            const ordered = new Set(plan.order.map((item) => item.callId));
+            if (ordered.size !== plan.order.length ||
+                plan.order.length !== plan.calls.length + plan.immediate.length)
+                throw new HarnessError("execution.invalid-state", "Plan order must identify every result exactly once");
+            for (const result of plan.immediate) {
+                if (ids.has(result.callId) ||
+                    !plan.order.some((item) => item.callId === result.callId && item.toolName === result.toolName))
+                    throw new HarnessError("execution.invalid-state", "Invalid immediate result identity");
+                ids.add(result.callId);
+            }
+            for (const item of plan.calls) {
+                if (ids.has(item.callId) || invocations.has(item.invocationId))
+                    throw new HarnessError("execution.invalid-state", "Duplicate pending call identity");
+                ids.add(item.callId);
+                invocations.add(item.invocationId);
+                if (!plan.order.some((order) => order.callId === item.callId && order.toolName === item.toolName))
+                    throw new HarnessError("execution.invalid-state", "Pending call missing from plan order");
+                if (item.toolName !== item.reference.descriptor.name)
+                    throw new HarnessError("execution.invalid-state", "Pending tool name differs from its contract");
+                if (item.toolName !== item.reference.toolName)
+                    throw new HarnessError("execution.invalid-state", "Pending tool name differs from its reference");
+                if (item.interaction) {
+                    if (interactions.has(item.interaction.id))
+                        throw new HarnessError("execution.invalid-state", "Duplicate interaction identity");
+                    interactions.add(item.interaction.id);
+                }
+                if (item.status !== "settled" && item.result)
+                    throw new HarnessError("execution.invalid-state", "Unsettled call cannot contain a result");
+                if (item.status === "settled" && !item.result)
+                    throw new HarnessError("execution.invalid-state", "Settled call requires a result");
+                if (item.status === "interaction" && (!item.interaction || !item.interactionPhase))
+                    throw new HarnessError("execution.invalid-state", "Missing interaction state");
+                if (item.result &&
+                    (item.result.callId !== item.callId || item.result.toolName !== item.toolName))
+                    throw new HarnessError("execution.invalid-state", "Result identity mismatch");
+            }
+            validateTranscript([
+                {
+                    kind: "tool-results",
+                    turnId: plan.turnId,
+                    stepId: plan.stepId,
+                    results: [
+                        ...plan.immediate,
+                        ...plan.calls.flatMap((item) => (item.result ? [item.result] : [])),
+                    ],
+                },
+            ]);
+            if (parsed.status === "paused" &&
+                (plan.calls.some((item) => item.status === "active") ||
+                    !plan.calls.some((item) => item.status === "interaction" || item.status === "deferred")))
+                throw new HarnessError("execution.invalid-state", "Invalid paused plan");
+        }
+        return copyJson(parsed);
+    }
+    catch (cause) {
+        throw new HarnessError("execution.invalid-state", `Invalid execution state: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    }
+}
+export function normalizeInput(value) {
+    try {
+        if (typeof value === "string")
+            return { kind: "user-message", text: value };
+        assertJson(value);
+        if ("kind" in value && value.kind === "continue")
+            return z
+                .object({ kind: z.literal("continue") })
+                .strict()
+                .parse(value);
+        if ("kind" in value && value.kind === "settle")
+            return z
+                .object({ kind: z.literal("settle"), invocationId: id, outcome })
+                .strict()
+                .parse(value);
+        const event = "kind" in value ? value : { kind: "user-message", ...value };
+        const validated = validateTranscript([
+            { kind: "input", turnId: "validation", event: event },
+        ]);
+        return validated[0].event;
+    }
+    catch (cause) {
+        throw new HarnessError("execution.invalid-input", `Invalid input: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    }
+}

package/dist/{step → execution/step}/canonicalize.d.ts

@@ -1,5 +1,5 @@
-import type { ModelCandidate, ModelOutputBlock, ModelToolCall } from "../types/model.js";
-import type { JsonObject } from "../types/shared.js";
+import type { ModelCandidate, ModelOutputBlock, ModelToolCall } from "../../types/model.js";
+import type { JsonObject } from "../../types/shared.js";
 export interface CanonicalCall {
     readonly id: string;
     readonly name: string;

package/dist/{step → execution/step}/canonicalize.js

@@ -1,5 +1,5 @@
-import { createId } from "../utils/ids.js";
-import { copyJson } from "../utils/immutable.js";
+import { createId } from "../../utils/ids.js";
+import { copyJson } from "../../utils/immutable.js";
 export function canonicalizeCalls(calls) {
     const idCounts = new Map();
     for (const call of calls) {

package/dist/{step → execution/step}/compose.d.ts

@@ -1,4 +1,5 @@
-import type { BoundMiddleware, StepResponse } from "../types/middleware.js";
-import type { ObserveEmit } from "../utils/observe.js";
+import type { BoundMiddleware } from "../../definition/bound.js";
+import type { StepResponse } from "../../types/middleware.js";
+import type { ObserveEmit } from "../observe.js";
 import { StepContext } from "./step-context.js";
 export declare function runMiddleware(middleware: readonly BoundMiddleware[], context: StepContext, terminal: () => Promise<StepResponse>, observe: ObserveEmit): Promise<StepResponse>;

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

@@ -1,4 +1,4 @@
-import { HarnessError, isHarnessError } from "../errors.js";
+import { HarnessError, isHarnessError } from "../../errors.js";
 import { isBrandedResponse, StepContext } from "./step-context.js";
 export async function runMiddleware(middleware, context, terminal, observe) {
     const dispatch = async (index) => {
@@ -55,7 +55,7 @@ export async function runMiddleware(middleware, context, terminal, observe) {
                     return context.tripwire({
                         code: "middleware.next-called-twice",
                         message: message(handlerError),
-                        scope: "session",
+                        scope: "execution",
                     });
                 }
                 return context.tripwire({
@@ -70,8 +70,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 +80,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/{step → execution/step}/context-draft.d.ts

@@ -1,10 +1,8 @@
-import type { ContextMutationOptions, ContextSnapshot } from "../types/model.js";
-import type { ContextItem, JsonObject } from "../types/shared.js";
-/** Per-step runtime-context draft. Host context is injected fresh for every call. */
+import type { ContextMutationOptions, ContextSnapshot } from "../../types/model.js";
+import type { ContextItem } from "../../types/shared.js";
+/** Per-step model-visible context supplied explicitly by middleware. */
 export declare class ContextDraft {
     #private;
-    private readonly hostContext?;
-    constructor(hostContext?: JsonObject | undefined);
     set(middlewareId: string, middlewareOrder: number, slot: string, items: readonly ContextItem[], options?: ContextMutationOptions): void;
     snapshot(): ContextSnapshot;
 }

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

@@ -1,14 +1,10 @@
-import { HarnessError } from "../errors.js";
-import { copyJson } from "../utils/immutable.js";
+import { HarnessError } from "../../errors.js";
+import { copyJson } from "../../utils/immutable.js";
 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/execution/step/describe.d.ts

@@ -0,0 +1,9 @@
+import type { ModelConfigurationSnapshot } from "../../types/model.js";
+import type { ToolDescriptor } from "../../types/tool.js";
+import type { BoundToolDefinition } from "../../definition/bound.js";
+/** 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/execution/step/describe.js

@@ -0,0 +1,22 @@
+import { copyJson } from "../../utils/immutable.js";
+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/{step → execution/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 "../../types/model.js";
+import type { ToolDefinition } from "../../types/tool.js";
 /** 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 → execution/step}/model-configuration.js

@@ -1,7 +1,7 @@
-import { bindTool } from "../build/bind-tool.js";
-import { HarnessError, isHarnessError } from "../errors.js";
+import { bindTool } from "../../definition/bind-tool.js";
+import { HarnessError, isHarnessError } from "../../errors.js";
 import { normalizeDirective, sameDirective } from "../model/normalize.js";
-import { copyJson } from "../utils/immutable.js";
+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 {