@nylorun/harness 0.12.0-beta → 0.15.0-beta

package/dist/run/durable.js

@@ -0,0 +1,164 @@
+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 implementations = {};
+    for (const capability of manifest.capabilities) {
+        const tools = {};
+        for (const tool of capability.tools ?? [])
+            tools[tool.name] = {
+                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,
+                        }, capability.id, 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();
+                    }
+                },
+            };
+        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));
+    // 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, 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

@@ -0,0 +1,114 @@
+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";
+} | {
+    readonly kind: "settle";
+    readonly invocationId: string;
+    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 {
+    readonly capabilityId: string;
+    readonly toolName: string;
+    readonly descriptor: {
+        readonly name: string;
+        readonly description?: string;
+        readonly inputSchema: JsonObject;
+        readonly outputSchema?: JsonObject;
+    };
+}
+export interface SavedToolCall {
+    readonly callId: string;
+    readonly invocationId: string;
+    readonly toolName: string;
+    readonly args: JsonValue;
+    readonly rawArgs: JsonValue;
+    readonly reference: ToolReference;
+    readonly status: "pending" | "active" | "settled" | "interaction" | "deferred";
+    readonly result?: ToolResult;
+    readonly interaction?: RequiredInteraction;
+    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;
+    readonly stepId: string;
+    readonly stepNumber: number;
+    readonly order: readonly {
+        readonly callId: string;
+        readonly toolName: string;
+    }[];
+    readonly immediate: readonly ToolResult[];
+    readonly calls: readonly SavedToolCall[];
+}
+/** Versioned continuation data, not a live execution object. */
+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;
+    readonly turnCount: number;
+    readonly transcript: readonly TranscriptEntry[];
+    readonly status: "ready" | "active" | "completed" | "paused" | "cancelled" | "failed";
+    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";
+    readonly attributes?: JsonObject;
+}) & {
+    readonly executionId: string;
+    readonly sequence: number;
+    readonly runId: string;
+};
+export interface RunOptions<Info = unknown> {
+    readonly state?: ExecutionState;
+    readonly input: ExecutionInput;
+    readonly onModelCall: ModelAdapter;
+    readonly info?: Info;
+    readonly signal?: AbortSignal;
+    readonly onEvent?: (event: ExecutionEvent) => void | Promise<void>;
+    readonly record?: (state: ExecutionState) => void | Promise<void>;
+}
+export type RunResult<Output = string> = {
+    readonly status: "completed";
+    readonly state: ExecutionState;
+    readonly output: Output;
+} | {
+    readonly status: "paused";
+    readonly state: ExecutionState;
+    readonly pending: readonly SavedToolCall[];
+} | {
+    readonly status: "cancelled";
+    readonly state: ExecutionState;
+} | {
+    readonly status: "failed";
+    readonly state: ExecutionState;
+    readonly error: Tripwire;
+};

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.12.0-beta",
-  "description": "Nylorun's TypeScript agent runtime. See github.com/nylorun/harness.",
+  "version": "0.15.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/model/adapters.d.ts",
-      "import": "./dist/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": {
@@ -66,7 +75,10 @@
     "vitest": "^5.0.0",
     "zod": "^4.1.12"
   },
+  "dependencies": {
+    "@nylorun/core": "0.1.1-beta"
+  },
   "peerDependencies": {
-    "zod": "^4.1.12"
+    "zod": "^4.5.4"
   }
 }

package/dist/build/agent.d.ts

@@ -1,17 +0,0 @@
-import type { AgentManifest } from "../types/manifest.js";
-import type { BoundMiddleware } from "../types/middleware.js";
-import type { ModelAdapter } from "../types/model.js";
-import type { Session, SessionRunOptions } from "../types/session.js";
-export interface LoopAgent {
-    readonly middleware: readonly BoundMiddleware[];
-    readonly invoke: ModelAdapter;
-}
-export declare class BuiltAgent {
-    readonly middleware: readonly BoundMiddleware[];
-    readonly manifest: AgentManifest;
-    readonly id: string;
-    readonly name: string;
-    private constructor();
-    run(options: SessionRunOptions): Session;
-}
-export declare function bindAgent(middleware: readonly BoundMiddleware[], manifest: AgentManifest): BuiltAgent;

package/dist/build/agent.js

@@ -1,32 +0,0 @@
-import { LiveSession } from "../session/session.js";
-import { createId } from "../utils/ids.js";
-import { HarnessError } from "../errors.js";
-let createBoundAgent;
-export class BuiltAgent {
-    middleware;
-    manifest;
-    id;
-    name;
-    constructor(middleware, manifest) {
-        this.middleware = middleware;
-        this.manifest = manifest;
-        this.id = manifest.id;
-        this.name = manifest.name;
-    }
-    static {
-        createBoundAgent = (middleware, manifest) => new BuiltAgent(middleware, manifest);
-    }
-    run(options) {
-        const seeded = "seed" in options && options.seed !== undefined;
-        if (seeded &&
-            (("id" in options && options.id !== undefined) ||
-                ("userId" in options && options.userId !== undefined) ||
-                ("context" in options && options.context !== undefined)))
-            throw new HarnessError("session.invalid-seed", "Seeded run options cannot include id, userId, or context outside the seed");
-        const id = (seeded ? options.seed.id : "id" in options ? options.id : undefined) ?? createId("session");
-        return new LiveSession(id, Object.freeze({ middleware: this.middleware, invoke: options.onModelCall }), options);
-    }
-}
-export function bindAgent(middleware, manifest) {
-    return createBoundAgent(middleware, manifest);
-}

package/dist/build/assemble.d.ts

@@ -1,7 +0,0 @@
-import type { BuildResult } from "../types/manifest.js";
-import type { BoundMiddleware } from "../types/middleware.js";
-import { type BuiltAgent } from "./agent.js";
-export declare function assembleAgent(middleware: readonly BoundMiddleware[], identity: Readonly<{
-    id: string;
-    name: string;
-}>): BuildResult<BuiltAgent>;

package/dist/build/assemble.js

@@ -1,41 +0,0 @@
-import { bindAgent } from "./agent.js";
-import { createManifest } from "./manifest.js";
-const diagnostic = (code, message, extra = {}) => Object.freeze({ code, message, ...extra });
-export function assembleAgent(middleware, identity) {
-    const diagnostics = [];
-    if (typeof identity.id !== "string" || identity.id.length === 0) {
-        diagnostics.push(diagnostic("agent.invalid-id", "Agent id must be a non-empty string"));
-    }
-    if (typeof identity.name !== "string" || identity.name.length === 0) {
-        diagnostics.push(diagnostic("agent.invalid-name", "Agent name must be a non-empty string"));
-    }
-    const middlewareIds = new Set();
-    const frozen = [];
-    for (const item of middleware) {
-        if (!item.id)
-            diagnostics.push(diagnostic("middleware.invalid-id", "Middleware id must not be empty"));
-        else if (middlewareIds.has(item.id))
-            diagnostics.push(diagnostic("middleware.duplicate-id", `Duplicate middleware id '${item.id}'`));
-        else if (typeof item.handle !== "function")
-            diagnostics.push(diagnostic("middleware.invalid", `Middleware '${item.id}' must provide a function`));
-        else {
-            middlewareIds.add(item.id);
-            frozen.push(Object.freeze({
-                id: item.id,
-                handle: item.handle,
-                ...(item.state === undefined ? {} : { state: item.state }),
-                ...(item.contributions === undefined ? {} : { contributions: item.contributions }),
-            }));
-        }
-    }
-    if (diagnostics.length)
-        return Object.freeze({ ok: false, diagnostics: Object.freeze(diagnostics) });
-    const frozenMiddleware = Object.freeze(frozen);
-    const manifest = createManifest({
-        id: identity.id,
-        name: identity.name,
-        middleware: frozenMiddleware,
-    });
-    const agent = bindAgent(frozenMiddleware, manifest);
-    return Object.freeze({ ok: true, agent, manifest });
-}

package/dist/build/bind-tool.d.ts

@@ -1,3 +0,0 @@
-import type { BoundToolDefinition, ToolDefinition } from "../types/tool.js";
-/** Prepares an executable Tool and records its middleware slot provenance. */
-export declare function bindTool(item: ToolDefinition, owner: BoundToolDefinition["owner"]): BoundToolDefinition;

package/dist/build/bind-tool.js

@@ -1,18 +0,0 @@
-import { HarnessError } from "../errors.js";
-import { normalizedSchemasFor } from "./schema.js";
-/** Prepares an executable Tool and records its middleware slot provenance. */
-export function bindTool(item, owner) {
-    if (!item.name)
-        throw new HarnessError("tool.invalid-name", "Tool name must not be empty");
-    if (typeof item.execute !== "function")
-        throw new HarnessError("tool.invalid", `Tool '${item.name}' must provide execute()`);
-    const schemas = normalizedSchemasFor(item);
-    return Object.freeze({
-        name: item.name,
-        ...(item.description ? { description: item.description } : {}),
-        inputSchema: schemas.inputSchema,
-        ...(schemas.outputSchema === undefined ? {} : { outputSchema: schemas.outputSchema }),
-        execute: item.execute.bind(item),
-        owner: Object.freeze({ ...owner }),
-    });
-}