@nylorun/harness 0.13.0-beta → 0.16.0-beta

package/dist/loop/waits.d.ts

@@ -0,0 +1,50 @@
+import type { JsonObject, JsonValue } from "@nylorun/core/define";
+/** Internal signal thrown by durable wait helpers; caught by the tool dispatcher. */
+export declare class WaitSignal {
+    readonly outcome: {
+        readonly kind: "interaction-required";
+        readonly interaction: {
+            readonly kind: "approval" | "response";
+            readonly prompt: string;
+            readonly metadata?: JsonObject;
+        };
+        readonly token?: JsonValue;
+        readonly wait: {
+            readonly kind: "ask" | "approve" | "sleep" | "waitFor";
+            readonly waitId: string;
+            readonly name?: string;
+        };
+    } | {
+        readonly kind: "deferred";
+        readonly token?: JsonValue;
+        readonly wait: {
+            readonly kind: "ask" | "approve" | "sleep" | "waitFor";
+            readonly waitId: string;
+            readonly name?: string;
+        };
+    };
+    readonly name = "WaitSignal";
+    constructor(outcome: {
+        readonly kind: "interaction-required";
+        readonly interaction: {
+            readonly kind: "approval" | "response";
+            readonly prompt: string;
+            readonly metadata?: JsonObject;
+        };
+        readonly token?: JsonValue;
+        readonly wait: {
+            readonly kind: "ask" | "approve" | "sleep" | "waitFor";
+            readonly waitId: string;
+            readonly name?: string;
+        };
+    } | {
+        readonly kind: "deferred";
+        readonly token?: JsonValue;
+        readonly wait: {
+            readonly kind: "ask" | "approve" | "sleep" | "waitFor";
+            readonly waitId: string;
+            readonly name?: string;
+        };
+    });
+}
+export declare function isWaitSignal(value: unknown): value is WaitSignal;

package/dist/loop/waits.js

@@ -0,0 +1,11 @@
+/** Internal signal thrown by durable wait helpers; caught by the tool dispatcher. */
+export class WaitSignal {
+    outcome;
+    name = "WaitSignal";
+    constructor(outcome) {
+        this.outcome = outcome;
+    }
+}
+export function isWaitSignal(value) {
+    return value instanceof WaitSignal;
+}

package/dist/run/durable.d.ts

@@ -0,0 +1,80 @@
+import type { AgentManifest } from "@nylorun/core/define";
+import type { ExecutionInput, ExecutionState, RunResult } from "../types/execution.js";
+import type { JsonObject } from "@nylorun/core/define";
+import type { ActionOutcome } from "@nylorun/core/contracts";
+import { ENGINE_VERSION } from "../compatibility.js";
+/** Private persistence contract for hosts; this is not a session wire type. */
+export interface DurableCheckpoint {
+    readonly version: 1;
+    readonly engineVersion: typeof ENGINE_VERSION;
+    readonly manifestHash: string;
+    readonly sessionId: string;
+    readonly turnId: string;
+    /** Increment for each human/event continuation, not for an action result. */
+    readonly segment: number;
+    readonly input: ExecutionInput;
+    readonly state?: ExecutionState;
+    readonly info?: JsonObject;
+}
+export interface HostEffect {
+    readonly effectId: string;
+    readonly sessionId: string;
+    readonly turnId: string;
+    readonly agentId: string;
+    readonly manifestHash: string;
+    readonly kind: "model" | "tool" | "beforeModelCall" | "afterModelCall";
+    readonly capabilityId?: string;
+    readonly toolName?: string;
+    readonly input: unknown;
+    readonly context: Record<string, unknown>;
+}
+export type EffectResolution = {
+    readonly status: "completed";
+    readonly outcome: ActionOutcome;
+} | {
+    readonly status: "pending" | "uncertain";
+};
+export interface DurableHost {
+    /** Atomically load-or-create by effectId; validate identical request on replay.
+     * Return recorded outcomes. Record intent BEFORE invoking a provider or exposing
+     * customer work. Uncertain effects must never be automatically executed again.
+     */
+    resolveEffect(effect: HostEffect): Promise<EffectResolution>;
+}
+export type DurableResult = {
+    readonly status: "waiting" | "uncertain";
+    readonly checkpoint: DurableCheckpoint;
+    readonly effectIds: readonly string[];
+} | {
+    readonly status: "completed" | "paused" | "cancelled" | "failed";
+    readonly checkpoint: DurableCheckpoint;
+    readonly result: RunResult<unknown>;
+};
+/** Discovered tool advertised for this execution. It is not part of the hashed manifest. */
+export interface DurableSessionTool {
+    readonly capabilityId: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly inputSchema: JsonObject;
+    readonly outputSchema?: JsonObject;
+}
+export declare function createDurableCheckpoint(input: {
+    manifest: AgentManifest;
+    sessionId: string;
+    turnId: string;
+    input: ExecutionInput;
+    state?: ExecutionState;
+    info?: JsonObject;
+    segment?: number;
+}): DurableCheckpoint;
+/** Deterministic reconstruction uses individually journaled effects, never a replayable whole loop.
+ * A suspended checkpoint is the immutable segment start plus the host's durable effect journal.
+ * Returning waiting releases all execution stacks; no process-local continuation survives.
+ */
+export declare function runDurable(options: {
+    manifest: AgentManifest;
+    checkpoint: DurableCheckpoint;
+    host: DurableHost;
+    signal?: AbortSignal;
+    sessionTools?: readonly DurableSessionTool[];
+}): Promise<DurableResult>;

package/dist/run/durable.js

@@ -0,0 +1,176 @@
+import { HarnessError } from "@nylorun/core/define";
+import { AgentManifestSchema } from "@nylorun/core/contracts";
+import { agentFrom } from "@nylorun/core/define";
+import { definitionFor } from "../definition/agent-definition.js";
+import { schemaFromJSON } from "@nylorun/core/define";
+import { hashManifest } from "@nylorun/core/define";
+import { withDeterministicIds } from "../utils/ids.js";
+import { execute } from "../loop/run.js";
+import { initializeExecutionState } from "../loop/initial-state.js";
+import { HostSuspension } from "../loop/host-suspension.js";
+import { CHECKPOINT_VERSION, ENGINE_VERSION } from "../compatibility.js";
+export function createDurableCheckpoint(input) {
+    AgentManifestSchema.parse(input.manifest);
+    return {
+        version: CHECKPOINT_VERSION,
+        engineVersion: ENGINE_VERSION,
+        manifestHash: hashManifest(input.manifest),
+        sessionId: input.sessionId,
+        turnId: input.turnId,
+        segment: input.segment ?? 0,
+        input: input.input,
+        ...(input.state ? { state: input.state } : {}),
+        ...(input.info ? { info: input.info } : {}),
+    };
+}
+/** Deterministic reconstruction uses individually journaled effects, never a replayable whole loop.
+ * A suspended checkpoint is the immutable segment start plus the host's durable effect journal.
+ * Returning waiting releases all execution stacks; no process-local continuation survives.
+ */
+export async function runDurable(options) {
+    const { manifest, checkpoint, host } = options;
+    AgentManifestSchema.parse(manifest);
+    if (checkpoint.version !== CHECKPOINT_VERSION ||
+        checkpoint.engineVersion !== ENGINE_VERSION ||
+        checkpoint.manifestHash !== hashManifest(manifest))
+        throw new HarnessError("execution.incompatible", "Incompatible durable checkpoint");
+    if (checkpoint.state &&
+        (checkpoint.state.manifestHash !== checkpoint.manifestHash ||
+            checkpoint.state.agentId !== manifest.id ||
+            checkpoint.state.executionId !== checkpoint.sessionId))
+        throw new HarnessError("execution.incompatible", "Checkpoint definition/session mismatch");
+    let serial = 0;
+    const pending = new Map();
+    const inFlight = new Set();
+    const effect = async (kind, input, context, capabilityId, toolName, identity) => {
+        const effectId = `${checkpoint.turnId}:${checkpoint.segment}:${kind}:${identity ?? ++serial}`;
+        const request = JSON.parse(JSON.stringify({
+            effectId,
+            sessionId: checkpoint.sessionId,
+            turnId: checkpoint.turnId,
+            agentId: manifest.id,
+            manifestHash: checkpoint.manifestHash,
+            kind,
+            input,
+            context,
+            ...(capabilityId ? { capabilityId } : {}),
+            ...(toolName ? { toolName } : {}),
+        }));
+        const operation = host.resolveEffect(request);
+        inFlight.add(operation);
+        let result;
+        try {
+            result = await operation;
+        }
+        finally {
+            inFlight.delete(operation);
+        }
+        if (result.status !== "completed") {
+            pending.set(effectId, result.status);
+            throw new HostSuspension(effectId, result.status);
+        }
+        return result.outcome;
+    };
+    let patchTail = Promise.resolve();
+    const hostedTool = (capabilityId, tool) => ({
+        name: tool.name,
+        ...(tool.description === undefined ? {} : { description: tool.description }),
+        inputSchema: schemaFromJSON(tool.inputSchema),
+        ...(tool.outputSchema ? { outputSchema: schemaFromJSON(tool.outputSchema) } : {}),
+        async execute(args, ctx) {
+            const previous = patchTail;
+            let release;
+            patchTail = new Promise((resolve) => {
+                release = resolve;
+            });
+            try {
+                const outcome = await effect("tool", args, {
+                    executionId: ctx.executionId,
+                    turnId: ctx.turnId,
+                    stepId: ctx.stepId,
+                    callId: ctx.callId,
+                    invocationId: ctx.invocationId,
+                    idempotencyKey: ctx.idempotencyKey,
+                    info: ctx.info,
+                    state: ctx.state.entries(),
+                    resume: ctx.resume,
+                }, capabilityId, tool.name, ctx.invocationId);
+                // Apply concurrently resolved patches in manifest call order, independent of host I/O timing.
+                await previous;
+                for (const [key, value] of Object.entries(outcome.statePatch ?? {}))
+                    ctx.state.set(key, value);
+                const value = outcome.value;
+                return value?.kind === "interaction-required"
+                    ? {
+                        ...value,
+                        interaction: {
+                            ...value.interaction,
+                            id: `${checkpoint.turnId}:${checkpoint.segment}:interaction:${ctx.invocationId}`,
+                        },
+                    }
+                    : value;
+            }
+            finally {
+                await previous;
+                release();
+            }
+        },
+    });
+    const implementations = {};
+    const sessionTools = options.sessionTools ?? [];
+    for (const capability of manifest.capabilities) {
+        const tools = {};
+        for (const tool of capability.tools ?? [])
+            tools[tool.name] = hostedTool(capability.id, tool);
+        for (const tool of sessionTools)
+            if (tool.capabilityId === capability.id)
+                tools[tool.name] = hostedTool(capability.id, tool);
+        implementations[capability.id] = {
+            tools,
+            ...(capability.beforeModelCall
+                ? {
+                    beforeModelCall: async (args) => (await effect("beforeModelCall", args, { info: checkpoint.info }, capability.id))
+                        .value,
+                }
+                : {}),
+            ...(capability.afterModelCall
+                ? {
+                    afterModelCall: async (args, ctx) => (await effect("afterModelCall", args, ctx, capability.id)).value,
+                }
+                : {}),
+        };
+    }
+    const definition = definitionFor(agentFrom(manifest, implementations, sessionTools.length === 0
+        ? undefined
+        : {
+            sessionTools: sessionTools.map((tool) => ({
+                capabilityId: tool.capabilityId,
+                name: tool.name,
+            })),
+        }));
+    // Manifest reconstruction must retain definition identity, including schemas and instructions.
+    if (definition.hash !== checkpoint.manifestHash)
+        throw new HarnessError("execution.incompatible", "Reconstructed definition hash mismatch");
+    try {
+        const result = await withDeterministicIds(`${checkpoint.turnId}_${checkpoint.segment}`, () => execute(definition, {
+            state: checkpoint.state ??
+                initializeExecutionState(definition, { executionId: checkpoint.sessionId }),
+            input: checkpoint.input,
+            info: checkpoint.info,
+            signal: options.signal,
+            onModelCall: async (call, ctx) => (await effect("model", call, { request: ctx.request, invocationId: ctx.invocationId }, undefined, undefined, ctx.invocationId)).value,
+        }));
+        return { status: result.status, checkpoint: { ...checkpoint, state: result.state }, result };
+    }
+    catch (error) {
+        // Parallel tool dispatch can suspend more than one action. Drain persistence before returning.
+        await Promise.allSettled([...inFlight]);
+        if (!(error instanceof HostSuspension))
+            throw error;
+        return {
+            status: [...pending.values()].includes("uncertain") ? "uncertain" : "waiting",
+            checkpoint,
+            effectIds: [...pending.keys()],
+        };
+    }
+}

package/dist/run/index.d.ts

@@ -0,0 +1,33 @@
+import { checkCompatibility } from "../definition/compatibility.js";
+import type { Implementations } from "@nylorun/core/define";
+import type { AgentBinding, BuiltAgent } from "@nylorun/core/define";
+import type { AgentManifest } from "@nylorun/core/define";
+import type { ExecutionState, RunOptions, RunResult } from "../types/execution.js";
+import { execute } from "../loop/run.js";
+import { createExecutionState, validateExecutionState } from "../loop/state.js";
+export interface RunBinding<Info = unknown> {
+    readonly manifest: AgentManifest;
+    readonly implementations: Implementations<Info>;
+    /** Optional authoring binding preserves live schemas and executable snapshots. */
+    readonly authoring?: AgentBinding;
+}
+export interface BoundRunOptions<Info = unknown> extends RunOptions<Info> {
+    readonly binding: RunBinding<Info>;
+}
+/**
+ * Run the model/tool loop from a definition binding + optional checkpoint.
+ * This is the public execution surface Runtime (and tests) should call.
+ */
+export declare function run<Info = unknown, Output = string>(options: BoundRunOptions<Info>): Promise<RunResult<Output>>;
+/** Create a fresh checkpoint bound to a manifest hash. */
+export declare function createRunState(binding: RunBinding, options?: {
+    readonly executionId?: string;
+    readonly state?: import("@nylorun/core/define").JsonObject;
+}): ExecutionState;
+/** Build a run binding from an explicitly authored agent. */
+export declare function bindingFromAgent(agent: BuiltAgent): RunBinding;
+export { checkCompatibility, createExecutionState, validateExecutionState, execute };
+export type { Implementations, ExecutionState, RunResult, RunOptions };
+export { createDurableCheckpoint, runDurable } from "./durable.js";
+export type { DurableCheckpoint, DurableSessionTool, HostEffect, EffectResolution, DurableHost, DurableResult, } from "./durable.js";
+export type { ModelAdapter, ModelCandidate, ModelCall, ModelRequest } from "@nylorun/core/define";

package/dist/run/index.js

@@ -0,0 +1,38 @@
+import { definitionFor, definitionFromBinding } from "../definition/agent-definition.js";
+import { checkCompatibility } from "../definition/compatibility.js";
+import { bindingFromAgent as authoringBindingFromAgent, agentFrom } from "@nylorun/core/define";
+import { execute } from "../loop/run.js";
+import { createExecutionState, validateExecutionState } from "../loop/state.js";
+import { initializeExecutionState } from "../loop/initial-state.js";
+/**
+ * Run the model/tool loop from a definition binding + optional checkpoint.
+ * This is the public execution surface Runtime (and tests) should call.
+ */
+export async function run(options) {
+    const definition = resolveDefinition(options.binding);
+    if (options.state?.manifestHash) {
+        const compatibility = checkCompatibility(definition.manifest, options.state);
+        if (!compatibility.ok)
+            throw compatibility.error;
+    }
+    const { binding: _, ...runOptions } = options;
+    return execute(definition, runOptions);
+}
+/** Create a fresh checkpoint bound to a manifest hash. */
+export function createRunState(binding, options) {
+    const definition = resolveDefinition(binding);
+    return initializeExecutionState(definition, options);
+}
+function resolveDefinition(binding) {
+    if (binding.authoring)
+        return definitionFromBinding(binding.authoring);
+    const agent = agentFrom(binding.manifest, binding.implementations);
+    return definitionFor(agent);
+}
+/** Build a run binding from an explicitly authored agent. */
+export function bindingFromAgent(agent) {
+    const authoring = authoringBindingFromAgent(agent);
+    return { manifest: authoring.manifest, implementations: authoring.implementations, authoring };
+}
+export { checkCompatibility, createExecutionState, validateExecutionState, execute };
+export { createDurableCheckpoint, runDurable } from "./durable.js";

package/dist/types/client.d.ts

@@ -0,0 +1,88 @@
+import type { JsonObject, JsonValue } from "@nylorun/core/define";
+import type { MessageInput } from "@nylorun/core/define";
+import type { SavedToolCall } from "./execution.js";
+/**
+ * Definition-parameterized client types (H11). Types only — harness does not implement Session.
+ * Runtime imports these for `openSession` / stream typing later.
+ */
+export interface InputAccepted {
+    readonly status: "accepted" | "rejected";
+    readonly error?: {
+        readonly code: string;
+        readonly message: string;
+    };
+    readonly turnId?: string;
+    readonly cursor?: string;
+    readonly steered?: boolean;
+}
+export type Result<Output = unknown> = {
+    readonly status: "completed";
+    readonly output: Output;
+} | {
+    readonly status: "paused";
+    readonly pending: readonly SavedToolCall[];
+} | {
+    readonly status: "failed";
+    readonly error: {
+        readonly code: string;
+        readonly message: string;
+    };
+} | {
+    readonly status: "cancelled";
+};
+export interface Turn<Output = unknown> {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly status: "running" | "settled";
+    readonly result?: Result<Output>;
+}
+export type Event<Output = unknown> = {
+    readonly type: "turn.started";
+    readonly cursor: string;
+    readonly at: string;
+    readonly sessionId: string;
+    readonly turnId: string;
+} | {
+    readonly type: "status";
+    readonly status: "thinking" | "calling_tool" | "waiting" | "requires_action";
+    readonly sessionId: string;
+    readonly turnId: string;
+} | {
+    readonly type: "text.delta";
+    readonly text: string;
+    readonly sessionId: string;
+    readonly turnId: string;
+} | {
+    readonly type: "tool.started" | "tool.progress" | "tool.completed" | "tool.failed";
+    readonly tool: string;
+    readonly sessionId: string;
+    readonly turnId: string;
+} | {
+    readonly type: "interaction.required";
+    readonly id: string;
+    readonly prompt: string;
+    readonly options?: JsonObject;
+    readonly sessionId: string;
+    readonly turnId: string;
+} | {
+    readonly type: "turn.settled";
+    readonly result: Result<Output>;
+    readonly sessionId: string;
+    readonly turnId: string;
+};
+/** Structural agent identity used to parameterize Session/Event types. */
+export interface AgentIdentity {
+    readonly id: string;
+}
+export interface Session<A extends AgentIdentity = AgentIdentity, Output = unknown> {
+    readonly id: string;
+    readonly agentId: A["id"];
+    input(message: MessageInput | string): Promise<InputAccepted>;
+    stream(opts?: {
+        readonly after?: string;
+    }): AsyncIterable<Event<Output>>;
+    history(): Promise<readonly JsonValue[]>;
+    approve(id: string, approved: boolean): Promise<void>;
+    respond(id: string, value: JsonValue): Promise<void>;
+    cancel(): Promise<void>;
+}

package/dist/types/execution.d.ts

@@ -1,8 +1,8 @@
-import type { ModelAdapter } from "./model.js";
-import type { InputEvent, MessageInput, TranscriptEntry } from "./transcript.js";
-import type { ObserveEvent } from "./observe.js";
-import type { JsonObject, JsonValue, Tripwire } from "./shared.js";
-import type { RequiredInteraction, ToolExecutionResume, ToolOutcome, ToolResult } from "./tool.js";
+import type { ModelAdapter } from "@nylorun/core/define";
+import type { InputEvent, MessageInput, TranscriptEntry } from "@nylorun/core/define";
+import type { ObserveEvent } from "@nylorun/core/define";
+import type { JsonObject, JsonValue, Tripwire } from "@nylorun/core/define";
+import type { RequiredInteraction, ToolExecutionResume, ToolOutcome, ToolResult } from "@nylorun/core/define";
 export type ExecutionInput = MessageInput | InputEvent | {
     readonly kind: "continue";
 } | {
@@ -11,6 +11,10 @@ export type ExecutionInput = MessageInput | InputEvent | {
     readonly outcome: Extract<ToolOutcome, {
         kind: "completed" | "failed" | "denied";
     }>;
+} | {
+    readonly kind: "wait-resolve";
+    readonly waitId: string;
+    readonly value?: JsonValue;
 };
 /** Portable reference to deployed code. Applications must preserve this value intact. */
 export interface ToolReference {
@@ -36,6 +40,12 @@ export interface SavedToolCall {
     readonly interactionPhase?: "before" | "execute";
     readonly resume?: ToolExecutionResume;
     readonly token?: JsonValue;
+    /** Optional wait metadata for H6 durable waits. */
+    readonly wait?: {
+        readonly kind: "ask" | "approve" | "sleep" | "waitFor";
+        readonly waitId: string;
+        readonly name?: string;
+    };
 }
 export interface ExecutionPlan {
     readonly turnId: string;
@@ -52,6 +62,8 @@ export interface ExecutionPlan {
 export interface ExecutionState {
     readonly version: 1;
     readonly agentId: string;
+    /** Definition binding — required for resume after Phase 2. Optional on legacy states. */
+    readonly manifestHash?: string;
     readonly executionId: string;
     readonly outputContract?: JsonObject;
     readonly revision: number;
@@ -61,6 +73,11 @@ export interface ExecutionState {
     readonly plan?: ExecutionPlan;
     /** Abandoned actions retained for reconciliation, never automatically dispatched. */
     readonly cancelledCalls?: readonly SavedToolCall[];
+    /**
+     * Durable session memory (tools write via `ctx.state`; beforeModelCall reads).
+     * Runtime persists this with the checkpoint.
+     */
+    readonly state?: JsonObject;
 }
 export type ExecutionEvent = (ObserveEvent | {
     readonly type: "execution.completed" | "execution.paused" | "execution.cancelled" | "execution.failed" | "observation.failed";

package/dist/utils/ids.d.ts

@@ -1 +1,2 @@
+export declare function withDeterministicIds<T>(seed: string, fn: () => T): T;
 export declare function createId(prefix: string): string;

package/dist/utils/ids.js

@@ -1,3 +1,13 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const scope = new AsyncLocalStorage();
+export function withDeterministicIds(seed, fn) {
+    return scope.run({ seed, counts: new Map() }, fn);
+}
 export function createId(prefix) {
-    return `${prefix}_${globalThis.crypto.randomUUID()}`;
+    const value = scope.getStore();
+    if (!value)
+        return `${prefix}_${globalThis.crypto.randomUUID()}`;
+    const count = (value.counts.get(prefix) ?? 0) + 1;
+    value.counts.set(prefix, count);
+    return `${prefix}_${value.seed}_${count}`;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nylorun/harness",
-  "version": "0.13.0-beta",
-  "description": "Nylorun's TypeScript agent runtime. See github.com/nylorun/harness.",
+  "version": "0.16.0-beta",
+  "description": "Nylorun's TypeScript agent execution engine. See github.com/nylorun/harness.",
   "type": "module",
   "license": "Apache-2.0",
   "repository": {
@@ -28,16 +28,25 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./run": {
+      "types": "./dist/run/index.d.ts",
+      "import": "./dist/run/index.js"
+    },
     "./model/adapters": {
-      "types": "./dist/execution/model/adapters.d.ts",
-      "import": "./dist/execution/model/adapters.js"
+      "types": "./dist/loop/model/adapters.d.ts",
+      "import": "./dist/loop/model/adapters.js"
+    },
+    "./compatibility": {
+      "types": "./dist/compatibility.d.ts",
+      "import": "./dist/compatibility.js"
     }
   },
   "files": [
     "dist",
     "README.md",
     "CHANGELOG.md",
-    "LICENSE"
+    "LICENSE",
+    "HOST_CONTRACT.md"
   ],
   "sideEffects": false,
   "publishConfig": {
@@ -61,12 +70,15 @@
   "devDependencies": {
     "@types/node": "^26.5.0",
     "@typescript/native": "npm:typescript@^7.0.2",
-    "prettier": "^3.9.6",
+    "prettier": "^3.9.8",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
-    "vitest": "^5.0.0",
-    "zod": "^4.1.12"
+    "vitest": "^5.0.1",
+    "zod": "^4.6.5"
+  },
+  "dependencies": {
+    "@nylorun/core": "0.2.0-beta"
   },
   "peerDependencies": {
-    "zod": "^4.1.12"
+    "zod": "^4.6.5"
   }
 }

package/dist/definition/assemble.d.ts

@@ -1,22 +0,0 @@
-import type { BoundMiddleware } from "./bound.js";
-import type { BuiltAgent } from "../types/agent.js";
-import type { AgentManifest } from "../types/manifest.js";
-import type { BuildDiagnostic } from "../types/shared.js";
-import type { RunOptions, RunResult } from "../types/execution.js";
-import type { ToolSchemaSource } from "../types/tool.js";
-import type { AgentDefinition } from "./agent-definition.js";
-type BuildResult<Agent> = {
-    readonly ok: true;
-    readonly agent: Agent;
-    readonly manifest: AgentManifest;
-} | {
-    readonly ok: false;
-    readonly diagnostics: readonly BuildDiagnostic[];
-};
-type AgentRun = (definition: AgentDefinition, options: RunOptions<any>) => Promise<RunResult<any>>;
-export declare function assembleAgent(middleware: readonly BoundMiddleware[], identity: Readonly<{
-    id: string;
-    name: string;
-    outputSchema?: ToolSchemaSource;
-}>, run: AgentRun): BuildResult<BuiltAgent>;
-export {};