@nylorun/harness 0.11.1-beta → 0.13.0-beta

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

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

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

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

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

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

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

@@ -1,31 +1,31 @@
 import { normalizeCandidate } from "../model/normalize.js";
-import { HarnessError, isHarnessError } from "../errors.js";
-import { copyJson } from "../utils/immutable.js";
+import { HarnessError, isHarnessError } from "../../errors.js";
+import { copyJson } from "../../utils/immutable.js";
 import { runMiddleware } from "./compose.js";
 import { ContextDraft } from "./context-draft.js";
 import { StepContext } from "./step-context.js";
-import { projectModelCall } from "./project.js";
+import { projectModelCall } from "../model/project.js";
 import { resolveModelRequest } from "./resolve.js";
 import { sealStep } from "./seal.js";
 import { ModelConfigurationDraft } from "./model-configuration.js";
-import { createId } from "../utils/ids.js";
+import { createId } from "../../utils/ids.js";
 export async function runStep(input) {
-    let state = input.state;
     let requestedModelId;
+    let modelInvocationId;
     const stepInput = Object.freeze({
-        sessionId: input.sessionId,
+        executionId: input.executionId,
         turnId: input.turnId,
         stepId: input.stepId,
         turnNumber: input.turnNumber,
         stepNumber: input.stepNumber,
-        session: input.session,
+        info: input.info,
         arrivals: Object.freeze([...input.arrivals]),
         toolResults: Object.freeze([...input.toolResults]),
         transcript: Object.freeze([...input.state.transcript]),
     });
     const configuration = new ModelConfigurationDraft();
-    const runtimeContext = new ContextDraft(input.session.context);
-    const context = new StepContext(stepInput, input.observe, configuration, runtimeContext, input.states);
+    const runtimeContext = new ContextDraft();
+    const context = new StepContext(stepInput, input.observe, configuration, runtimeContext);
     input.observe(() => ({
         type: "step.started",
         turnId: input.turnId,
@@ -35,10 +35,14 @@ export async function runStep(input) {
         attributes: snapshotStepStart(stepInput),
     }));
     await runMiddleware(input.agent.middleware, context, async () => {
+        input.signal.throwIfAborted();
         if (context.currentTripwire)
             return context.tripwire(context.currentTripwire);
         try {
-            context.sealConfiguration(configuration.snapshot());
+            const selected = configuration.snapshot();
+            for (const tool of selected.tools)
+                input.agent.registry.reference(tool);
+            context.sealConfiguration(selected);
             context.sealContext(runtimeContext.snapshot());
         }
         catch (error) {
@@ -57,16 +61,10 @@ export async function runStep(input) {
         requestedModelId = request.model?.id;
         const call = projectModelCall(request);
         const invocationId = createId("invocation");
-        const active = Object.freeze({
-            kind: "model",
-            turnId: input.turnId,
-            stepId: input.stepId,
-            invocationId,
-            call,
-        });
-        state = await input.recordModelRequested(state, active);
+        modelInvocationId = invocationId;
         input.observe(() => ({
             type: "model.requested",
+            invocationId,
             turnId: input.turnId,
             stepId: input.stepId,
             ...(request.model?.id === undefined ? {} : { requestedModelId: request.model.id }),
@@ -91,6 +89,7 @@ export async function runStep(input) {
                     const reported = Object.freeze({ adapter: value.adapter, call: copyJson(value.call) });
                     input.observe(() => ({
                         type: "model.prepared",
+                        invocationId,
                         turnId: input.turnId,
                         stepId: input.stepId,
                         ...(request.model?.id === undefined ? {} : { requestedModelId: request.model.id }),
@@ -100,11 +99,6 @@ export async function runStep(input) {
             });
             if (input.signal.aborted)
                 throw input.signal.reason;
-            if (isDeferred(outcome))
-                return context.deferModel(Object.freeze({
-                    ...active,
-                    ...(outcome.token === undefined ? {} : { token: copyJson(outcome.token) }),
-                }));
             const minted = context.mintFromModel(normalizeCandidate(outcome));
             const candidate = context.currentCandidate;
             if (!candidate)
@@ -124,47 +118,19 @@ export async function runStep(input) {
     const candidate = output.kind === "tools" ? output.plan.candidate : context.currentCandidate;
     return Object.freeze({
         stepId: input.stepId,
-        state,
         ...(candidate ? { candidate } : {}),
         ...(requestedModelId === undefined ? {} : { requestedModelId }),
         output,
+        ...(modelInvocationId ? { modelInvocationId } : {}),
     });
 }
-function isDeferred(value) {
-    return (typeof value === "object" && value !== null && "kind" in value && value.kind === "deferred");
-}
 function snapshotStepStart(input) {
-    const session = Object.freeze({
-        ...(input.session.userId === undefined ? {} : { userId: input.session.userId }),
-        ...(input.session.context === undefined ? {} : { context: copyJson(input.session.context) }),
-    });
     return Object.freeze({
-        ...(Object.keys(session).length === 0 ? {} : { session }),
         arrivals: copyJson(input.arrivals),
         toolResults: copyJson(input.toolResults),
         transcript: input.transcript,
     });
 }
 function snapshotConfiguration(configuration) {
-    return Object.freeze({
-        version: configuration.version,
-        ...(configuration.model === undefined ? {} : { model: copyJson(configuration.model) }),
-        instructions: copyJson(configuration.instructions),
-        tools: snapshotTools(configuration.tools),
-        toolContracts: copyJson(configuration.toolContracts),
-        contributors: copyJson(configuration.contributors),
-    });
-}
-function snapshotTools(tools) {
-    return Object.freeze(tools.map((tool) => Object.freeze({
-        name: tool.name,
-        ...(tool.description === undefined ? {} : { description: tool.description }),
-        owner: tool.owner,
-        inputSchema: Object.freeze({ jsonSchema: copyJson(tool.inputSchema.jsonSchema) }),
-        ...(tool.outputSchema === undefined
-            ? {}
-            : {
-                outputSchema: Object.freeze({ jsonSchema: copyJson(tool.outputSchema.jsonSchema) }),
-            }),
-    })));
+    return copyJson(configuration);
 }

package/dist/execution/step/runtime.d.ts

@@ -0,0 +1,32 @@
+import type { ToolRegistry } from "../../definition/registry.js";
+import type { ModelAdapter } from "../../types/model.js";
+import type { InputEvent, TranscriptEntry } from "../../types/transcript.js";
+import type { ToolResult } from "../../types/tool.js";
+import type { BoundMiddleware } from "../../definition/bound.js";
+/** Compiled definition pieces plus the per-run model adapter for one step. */
+export interface StepRuntime {
+    readonly middleware: readonly BoundMiddleware[];
+    readonly invoke: ModelAdapter;
+    readonly registry: ToolRegistry;
+}
+export interface StepInput {
+    readonly executionId: string;
+    readonly turnId: string;
+    readonly stepId: string;
+    /** One-based position of this turn within the execution. */
+    readonly turnNumber: number;
+    /** One-based position of this Model Step within the Turn. */
+    readonly stepNumber: number;
+    readonly info?: unknown;
+    readonly arrivals: readonly InputEvent[];
+    readonly toolResults: readonly ToolResult[];
+    readonly transcript: readonly TranscriptEntry[];
+}
+/** Internal view consumed by a single model step. */
+export interface ExecutionSnapshot {
+    readonly id: string;
+    readonly status: "running";
+    readonly turnCount: number;
+    readonly revision: number;
+    readonly transcript: readonly TranscriptEntry[];
+}

package/dist/execution/step/runtime.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,9 +1,17 @@
-import type { ModelCandidate } from "../types/model.js";
-import type { Tripwire } from "../types/shared.js";
-import type { BoundToolDefinition, RequiredInteraction, SealedToolCall, ToolOwner, ToolResult } from "../types/tool.js";
+import type { BoundToolDefinition } from "../../definition/bound.js";
+import type { ModelCandidate } from "../../types/model.js";
+import type { JsonValue, Tripwire } from "../../types/shared.js";
+import type { RequiredInteraction, ToolOwner, ToolResult } from "../../types/tool.js";
 import type { StepContext } from "./step-context.js";
-import type { TurnOutputContract } from "../session/output-contract.js";
+import type { TurnOutputContract } from "../../definition/output-contract.js";
+export interface SealedToolCall {
+    readonly callId: string;
+    readonly toolName: string;
+    readonly args: JsonValue;
+}
 export interface ExecutablePlanEntry {
+    readonly definition: BoundToolDefinition;
+    readonly rawArgs: JsonValue;
     readonly call: SealedToolCall;
     readonly invocationId: string;
     readonly owner: ToolOwner;
@@ -25,10 +33,7 @@ export type SealedStepOutput = {
     readonly tripwire: Tripwire;
 } | {
     readonly kind: "final";
-    readonly output: import("../types/shared.js").JsonValue;
-} | {
-    readonly kind: "deferred-model";
-    readonly active: import("../types/session.js").ActiveModelExecutionRecord;
+    readonly output: JsonValue;
 } | {
     readonly kind: "tools";
     readonly plan: InternalToolPlan;

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

@@ -1,7 +1,7 @@
 import { textFromOutput } from "../model/normalize.js";
-import { createId } from "../utils/ids.js";
-import { HarnessError, isHarnessError } from "../errors.js";
-import { assertJson, copyJson } from "../utils/immutable.js";
+import { createId } from "../../utils/ids.js";
+import { HarnessError, isHarnessError } from "../../errors.js";
+import { assertJson, copyJson } from "../../utils/immutable.js";
 const failed = (callId, toolName, code, message, details) => Object.freeze({
     kind: "failed",
     callId,
@@ -14,8 +14,6 @@ const failed = (callId, toolName, code, message, details) => Object.freeze({
 export function sealStep(context, outputContract) {
     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) {
         if (outputContract)
@@ -45,7 +43,9 @@ function sealStructuredOutput(context, contract) {
         return invalidOutput("Structured terminal output must contain exactly one JSON block and no text blocks");
     const validation = contract.schema.validate(json[0].value);
     if (!validation.ok)
-        return invalidOutput(`Structured terminal output failed validation: ${validation.issues.map(renderIssue).join("; ")}`);
+        return invalidOutput(`Structured terminal output failed validation: ${validation.issues
+            .map(renderIssue)
+            .join("; ")}`);
     try {
         assertJson(validation.value, "structured terminal output");
         return Object.freeze({ kind: "final", output: copyJson(validation.value) });
@@ -113,6 +113,8 @@ function sealCall(context, catalog, candidate) {
         order,
         canonical,
         executable: Object.freeze({
+            definition: tool,
+            rawArgs: copyJson(candidate.args),
             call: Object.freeze({
                 callId: candidate.id,
                 toolName: candidate.name,

package/dist/{step → execution/step}/slot-assembly.d.ts

@@ -1,4 +1,4 @@
-import { type HarnessErrorCode } from "../errors.js";
+import { type HarnessErrorCode } from "../../errors.js";
 export interface SlotOwner {
     readonly middlewareId: string;
     readonly middlewareOrder: number;
@@ -11,9 +11,9 @@ export interface SlotDeclaration<Value> {
     readonly reason?: string;
 }
 /**
- * Shared per-step slot store. It has no session lifetime: declarations are discarded with the
- * draft that owns this instance. Configuration and context supply their typed values and snapshot
- * them after this assembler has applied ownership, replacement, and canonical ordering.
+ * Shared per-step slot store. Declarations are discarded with the draft that owns this instance.
+ * Configuration and context supply their typed values and snapshot them after this assembler has
+ * applied ownership, replacement, and canonical ordering.
  */
 export declare class SlotDraft<Value> {
     #private;

package/dist/{step → execution/step}/slot-assembly.js

@@ -1,8 +1,8 @@
-import { HarnessError } from "../errors.js";
+import { HarnessError } from "../../errors.js";
 /**
- * Shared per-step slot store. It has no session lifetime: declarations are discarded with the
- * draft that owns this instance. Configuration and context supply their typed values and snapshot
- * them after this assembler has applied ownership, replacement, and canonical ordering.
+ * Shared per-step slot store. Declarations are discarded with the draft that owns this instance.
+ * Configuration and context supply their typed values and snapshot them after this assembler has
+ * applied ownership, replacement, and canonical ordering.
  */
 export class SlotDraft {
     #slots = new Map();

package/dist/{step → execution/step}/step-context.d.ts

@@ -1,35 +1,34 @@
-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 { BoundToolDefinition } from "../../definition/bound.js";
+import type { StepInput } from "./runtime.js";
+import type { InternalModelConfigurationSnapshot } from "./describe.js";
+import type { ContextSnapshot, ModelCandidate, ModelDirective } from "../../types/model.js";
+import type { StepRequest, StepResponse } from "../../types/middleware.js";
+import type { Tripwire } from "../../types/shared.js";
+import type { ObserveEmit } from "../observe.js";
+import type { 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, states?: CapabilityStateRegistry);
+    constructor(input: Readonly<StepInput>, observe: ObserveEmit, configuration: ModelConfigurationDraft, context: ContextDraft);
     get currentTripwire(): Tripwire | undefined;
     get currentCandidate(): Readonly<ModelCandidate> | undefined;
-    get currentModelDeferred(): ActiveModelExecutionRecord | undefined;
     get selectedDirective(): ModelDirective | undefined;
     get instructions(): readonly string[];
     contextSnapshot(): ContextSnapshot;
     get offeredTools(): readonly BoundToolDefinition[];
     get catalogByName(): ReadonlyMap<string, BoundToolDefinition>;
-    configurationSnapshot(): ModelConfigurationSnapshot;
-    sealConfiguration(snapshot: ModelConfigurationSnapshot): void;
+    configurationSnapshot(): InternalModelConfigurationSnapshot;
+    sealConfiguration(snapshot: InternalModelConfigurationSnapshot): void;
     sealContext(snapshot: ContextSnapshot): void;
     denialFor(callId: string): string | undefined;
     interactionFor(callId: string): Interaction | undefined;
     canonicalCalls(): readonly CanonicalCall[];
     mintFromModel(candidate: Readonly<ModelCandidate>): StepResponse;
-    deferModel(active: ActiveModelExecutionRecord): StepResponse;
     tripwire(error: Tripwire): StepResponse;
     seal(): void;
     requestFacade(middlewareId: string, middlewareOrder: number): {

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

@@ -1,4 +1,5 @@
-import { HarnessError, isHarnessError } from "../errors.js";
+import { HarnessError, isHarnessError } from "../../errors.js";
+import { freezeGraph } from "../../utils/immutable.js";
 import { callsFromCanonical, candidateFromCanonical, canonicalizeOutput, identityKey, } from "./canonicalize.js";
 import { normalizeCandidate } from "../model/normalize.js";
 import { ContextDraft } from "./context-draft.js";
@@ -13,24 +14,21 @@ export class StepContext {
     #observe;
     #context;
     #configuration;
-    #states;
     #denials = new Map();
     #interactions = new Map();
     #identities = new Map();
     #canonical = Object.freeze([]);
     #candidate;
     #tripwire;
-    #modelDeferred;
     #response;
     #sealed = false;
     #configurationSnapshot;
     #contextSnapshot;
-    constructor(input, observe, configuration, context, states) {
+    constructor(input, observe, configuration, context) {
         this.input = input;
         this.#observe = observe;
         this.#configuration = configuration;
         this.#context = context;
-        this.#states = states;
     }
     get currentTripwire() {
         return this.#tripwire;
@@ -38,9 +36,6 @@ export class StepContext {
     get currentCandidate() {
         return this.#candidate;
     }
-    get currentModelDeferred() {
-        return this.#modelDeferred;
-    }
     get selectedDirective() {
         return this.configurationSnapshot().model;
     }
@@ -83,10 +78,6 @@ export class StepContext {
             this.#identities.set(call.id, identityKey(call.name, call.args));
         return this.#ensureResponse();
     }
-    deferModel(active) {
-        this.#modelDeferred = active;
-        return this.#ensureResponse();
-    }
     tripwire(error) {
         this.#tripwire ??= Object.freeze({ ...error });
         return this.#ensureResponse();
@@ -138,10 +129,10 @@ export class StepContext {
             }
         });
         const request = {
-            sessionId: this.input.sessionId,
+            executionId: this.input.executionId,
             turnId: this.input.turnId,
             stepId: this.input.stepId,
-            session: this.input.session,
+            info: this.input.info,
             turnNumber: this.input.turnNumber,
             stepNumber: this.input.stepNumber,
             arrivals: this.input.arrivals,
@@ -171,11 +162,6 @@ export class StepContext {
                 return minted;
             },
         };
-        if (this.#states?.has(middlewareId))
-            Object.defineProperty(request, "state", {
-                enumerable: true,
-                get: () => this.#states.get(middlewareId),
-            });
         const value = Object.freeze(request);
         return Object.freeze({
             value,
@@ -253,11 +239,3 @@ function pickSidecar(key, replacement, normalized, current) {
     const value = source?.[key];
     return value === undefined ? {} : { [key]: value };
 }
-function freezeGraph(value, seen = new WeakSet()) {
-    if (!value || typeof value !== "object" || seen.has(value))
-        return value;
-    seen.add(value);
-    for (const item of Object.values(value))
-        freezeGraph(item, seen);
-    return Object.freeze(value);
-}

package/dist/execution/tool-result.d.ts

@@ -0,0 +1,4 @@
+import type { BoundToolDefinition } from "../definition/bound.js";
+import type { SavedToolCall } from "../types/execution.js";
+import type { ToolOutcome, ToolResult } from "../types/tool.js";
+export declare function toolResult(call: SavedToolCall, definition: BoundToolDefinition, outcome: ToolOutcome): ToolResult;

package/dist/execution/tool-result.js

@@ -0,0 +1,30 @@
+import { HarnessError } from "../errors.js";
+import { copyJson } from "../utils/immutable.js";
+export function toolResult(call, definition, outcome) {
+    const identity = { callId: call.callId, toolName: call.toolName };
+    if (outcome.kind === "completed") {
+        const checked = definition.outputSchema?.validate(outcome.output);
+        if (checked && !checked.ok)
+            return {
+                ...identity,
+                kind: "failed",
+                code: "tool.invalid-output",
+                message: checked.issues.map((issue) => issue.message).join("; "),
+                details: { phase: "output", issues: checked.issues },
+            };
+        return copyJson({
+            ...identity,
+            kind: "completed",
+            output: checked?.ok ? checked.value : outcome.output,
+        });
+    }
+    if (outcome.kind === "failed" &&
+        typeof outcome.code === "string" &&
+        typeof outcome.message === "string")
+        return copyJson({ ...identity, kind: "failed", code: outcome.code, message: outcome.message });
+    if (outcome.kind === "denied" && typeof outcome.reason !== "string")
+        throw new HarnessError("tool.invalid-tool-result", "Tool denial reason must be a string");
+    if (outcome.kind === "denied" && typeof outcome.reason === "string")
+        return copyJson({ ...identity, kind: "denied", reason: outcome.reason });
+    throw new HarnessError("tool.invalid-tool-result", "Expected a completed, failed, or denied tool result");
+}

package/dist/execution/transcript.d.ts

@@ -0,0 +1,2 @@
+import type { TranscriptEntry } from "../types/transcript.js";
+export declare function validateTranscript(value: readonly TranscriptEntry[]): readonly TranscriptEntry[];

package/dist/{session/seed.js → execution/transcript.js}

@@ -1,39 +1,20 @@
 import { HarnessError } from "../errors.js";
-import { normalizeCandidate } from "../model/normalize.js";
+import { normalizeCandidate } from "./model/normalize.js";
 import { assertJson, copyJson, copyJsonObject } from "../utils/immutable.js";
-export function normalizeSessionSeed(seed) {
+export function validateTranscript(value) {
     try {
-        return normalizeSeed(seed);
+        if (!Array.isArray(value))
+            fail("Transcript must be an array");
+        return Object.freeze(value.map((entry, index) => entryAt(entry, index)));
     }
     catch (cause) {
-        if (cause instanceof HarnessError && cause.code === "session.invalid-seed")
+        if (cause instanceof HarnessError && cause.code === "execution.invalid-state")
             throw cause;
-        throw new HarnessError("session.invalid-seed", "Session seed contains invalid typed JSON", {
+        throw new HarnessError("execution.invalid-state", "Transcript 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`);
@@ -61,7 +42,7 @@ function entryAt(value, index) {
                 });
             }
             catch (cause) {
-                throw new HarnessError("session.invalid-seed", `Invalid candidate at transcript ${index}`, {
+                throw new HarnessError("execution.invalid-state", `Invalid candidate at transcript ${index}`, {
                     cause,
                 });
             }
@@ -273,21 +254,10 @@ function exactKeys(value, allowed, label) {
         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);
+    throw new HarnessError("execution.invalid-state", message);
 }

package/dist/index.d.ts

@@ -1,15 +1,18 @@
-export { Agent, AgentBuilder, AgentBuildError, AgentLifecycleError, BoundAgentBuilder, } from "./build/builder.js";
-export type { AgentOptions } from "./build/builder.js";
+export { Agent, AgentBuilder, AgentBuildError, AgentLifecycleError } from "./definition/builder.js";
+export type { AgentOptions } from "./definition/builder.js";
 export { HarnessError, isHarnessError } from "./errors.js";
 export type { HarnessErrorCode, HarnessErrorDetails, HarnessErrorOptions } from "./errors.js";
-export { BuiltAgent } from "./build/agent.js";
-export { middleware, model, tool } from "./build/helpers.js";
-export { defineSchema } from "./build/schema.js";
-export { preparedModel } from "./model/prepared.js";
-export type { PreparedModelOptions } from "./model/prepared.js";
-export type { AgentManifest, MiddlewareManifest } from "./types/manifest.js";
-export type { BoundMiddleware, CapabilityDeclaration, CapabilityItems, CapabilityState, MiddlewareContributions, StepInput, StepMiddleware, StepRequest, StepResponse, } from "./types/middleware.js";
+export type { BuiltAgent } from "./types/agent.js";
+export { middleware, model, tool } from "./definition/helpers.js";
+export { defineSchema } from "./definition/schema.js";
+export { preparedModel } from "./execution/model/prepared.js";
+export type { PreparedModelOptions } from "./execution/model/prepared.js";
+export type { AgentManifest, CapabilityManifest, ManifestTool } from "./types/manifest.js";
+export type { CapabilityDeclaration, CapabilityItems, MiddlewareContributions, StepMiddleware, StepRequest, StepResponse, } from "./types/middleware.js";
 export type { ModelCandidate, ModelControls, ModelDirective, ModelEvidence, ModelFinishReason, ModelAdapter, ModelAdapterContext, ModelPreparedCall, ContextContributor, ContextMutationOptions, ContextSnapshot, ModelCall, ModelCallTool, ModelOutputBlock, PromptContentPart, PromptItem, ModelConfigurationContributor, ModelConfigurationInstruction, ModelConfigurationMutationOptions, ModelConfigurationSnapshot, ModelConfigurationTool, ModelRequest, ModelToolCall, ModelUsage, } from "./types/model.js";
-export type { BuildDiagnostic, ContextItem, DeferredOutcome, JsonObject, JsonPrimitive, JsonValue, ObserveEvent, ObserveModelConfigurationSnapshot, ObserveModelRequested, ObserveSealedCall, ObserveToolSnapshot, Observer, Tripwire, } from "./types/shared.js";
-export type { ActiveExecutionRecord, ActiveInteractionExecutionRecord, ActiveModelExecutionRecord, ActiveToolCallRecord, ActiveToolsExecutionRecord, InteractionReply, InputCompletion, InputEvent, InputHandle, InputOptions, OutputInputOptions, MessageInput, Session, SessionInput, SessionIdentity, SessionEvent, SessionOptions, SessionRecord, SessionRecorder, SessionRunOptions, SessionSeed, SeededSessionOptions, SessionSnapshot, TranscriptEntry, UserContentPart, } from "./types/session.js";
-export type { BoundToolSchema, BoundToolDefinition, Interaction, RequiredInteraction, SealedToolCall, ToolContent, ToolDefinition, ToolExecutionContext, ToolExecutionResume, ToolInputSchema, ToolOutputSchema, ToolSchema, ToolSchemaSource, StandardToolSchema, StandardSchemaIssue, SchemaIssue, SchemaValidation, SchemaOutput, ToolOwner, ToolOutcome, ToolResult, ToolValidationFailureDetails, } from "./types/tool.js";
+export type { BuildDiagnostic, ContextItem, DeferredOutcome, JsonObject, JsonPrimitive, JsonValue, Tripwire, } from "./types/shared.js";
+export type { ObserveEvent, ObserveModelConfigurationSnapshot, ObserveModelRequested, ObserveSealedCall, ObserveToolSnapshot, Observer, } from "./types/observe.js";
+export type { InputEvent, MessageInput, InteractionReply, TranscriptEntry, UserContentPart, } from "./types/transcript.js";
+export type { ExecutionInput, ExecutionState, ExecutionEvent, RunOptions, RunResult, SavedToolCall, ExecutionPlan, ToolReference, } from "./types/execution.js";
+export { createExecutionState, validateExecutionState } from "./execution/state.js";
+export type { Interaction, RequiredInteraction, ToolContent, ToolDefinition, ToolDescriptor, ToolExecutionContext, ToolExecutionResume, ToolInputSchema, ToolOutputSchema, ToolSchema, ToolSchemaSource, StandardToolSchema, StandardSchemaIssue, SchemaIssue, SchemaValidation, SchemaOutput, ToolOwner, ToolOutcome, ToolResult, ToolValidationFailureDetails, } from "./types/tool.js";