@nylorun/harness 0.13.0-beta → 0.16.0-beta

package/dist/definition/assemble.js

@@ -1,43 +0,0 @@
-import { bindAgent } from "./bind-agent.js";
-import { createManifest } from "./manifest.js";
-const diagnostic = (code, message, extra = {}) => Object.freeze({ code, message, ...extra });
-export function assembleAgent(middleware, identity, run) {
-    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,
-                hasMiddleware: item.hasMiddleware,
-                ...(item.tools === undefined ? {} : { tools: item.tools }),
-                ...(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,
-        outputSchema: identity.outputSchema,
-        middleware: frozenMiddleware,
-    });
-    const agent = bindAgent(frozenMiddleware, manifest, identity, run);
-    return Object.freeze({ ok: true, agent, manifest });
-}

package/dist/definition/bind-agent.d.ts

@@ -1,9 +0,0 @@
-import type { AgentManifest } from "../types/manifest.js";
-import type { BoundMiddleware } from "./bound.js";
-import type { BuiltAgent } from "../types/agent.js";
-import type { RunOptions, RunResult } from "../types/execution.js";
-import type { ToolSchemaSource } from "../types/tool.js";
-import { type AgentDefinition } from "./agent-definition.js";
-export declare function bindAgent(middleware: readonly BoundMiddleware[], manifest: AgentManifest, options: {
-    outputSchema?: ToolSchemaSource;
-} | undefined, run: (definition: AgentDefinition, options: RunOptions<any>) => Promise<RunResult<any>>): BuiltAgent;

package/dist/definition/bind-agent.js

@@ -1,21 +0,0 @@
-import { bindOutputContract } from "./output-contract.js";
-import { registerDefinition } from "./agent-definition.js";
-import { ToolRegistry } from "./registry.js";
-export function bindAgent(middleware, manifest, options = {}, run) {
-    const definition = Object.freeze({
-        id: manifest.id,
-        middleware,
-        registry: new ToolRegistry(middleware),
-        ...(options.outputSchema === undefined
-            ? {}
-            : { output: bindOutputContract(options.outputSchema) }),
-    });
-    const agent = {
-        id: definition.id,
-        name: manifest.name,
-        manifest,
-        run: (options) => run(definition, options),
-    };
-    registerDefinition(agent, definition);
-    return agent;
-}

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

@@ -1,4 +0,0 @@
-import type { BoundToolDefinition } from "./bound.js";
-import type { 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/definition/bind-tool.js

@@ -1,19 +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({
-        source: item,
-        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 }),
-    });
-}

package/dist/definition/bound.d.ts

@@ -1,16 +0,0 @@
-import type { MiddlewareContributions, StepMiddleware } from "../types/middleware.js";
-import type { ToolDefinition, ToolExecutionContext, ToolInputSchema, ToolOutcome, ToolOutputSchema, ToolOwner, ToolSchema } from "../types/tool.js";
-export interface BoundToolDefinition<Info = unknown> extends Omit<ToolDefinition<ToolInputSchema, Info, ToolOutputSchema | undefined>, "inputSchema" | "outputSchema" | "execute"> {
-    readonly inputSchema: ToolSchema<unknown>;
-    readonly outputSchema?: ToolSchema<unknown>;
-    readonly execute: (args: unknown, context: ToolExecutionContext<Info>) => Promise<ToolOutcome>;
-    readonly owner: ToolOwner;
-    readonly source: ToolDefinition<any, any, any>;
-}
-export interface BoundMiddleware {
-    readonly id: string;
-    readonly handle: StepMiddleware;
-    readonly hasMiddleware: boolean;
-    readonly tools?: readonly ToolDefinition<any, any, any>[];
-    readonly contributions?: MiddlewareContributions;
-}

package/dist/definition/builder.d.ts

@@ -1,30 +0,0 @@
-import type { CapabilityDeclaration, StepMiddleware } from "../types/middleware.js";
-import type { BuildDiagnostic } from "../types/shared.js";
-import { HarnessError } from "../errors.js";
-import type { ToolSchemaSource, SchemaOutput } from "../types/tool.js";
-import type { BuiltAgent } from "../types/agent.js";
-export interface AgentOptions<Schema extends ToolSchemaSource | undefined = undefined> {
-    readonly outputSchema?: Schema;
-    readonly id: string;
-    readonly name: string;
-    readonly instructions?: string | readonly string[];
-}
-export declare class AgentBuildError extends HarnessError {
-    readonly diagnostics: readonly BuildDiagnostic[];
-    constructor(diagnostics: readonly BuildDiagnostic[]);
-}
-export declare class AgentLifecycleError extends HarnessError {
-    constructor(message: string);
-}
-export declare function Agent<Info = unknown, Schema extends ToolSchemaSource | undefined = undefined>(options: AgentOptions<Schema>): AgentBuilder<Info, Schema>;
-export declare class AgentBuilder<Info = unknown, Schema extends ToolSchemaSource | undefined = undefined> {
-    #private;
-    constructor(options: AgentOptions<Schema>);
-    use(middleware: StepMiddleware<Info>): this;
-    use(id: string, middleware: StepMiddleware<Info>): this;
-    use(declaration: CapabilityDeclaration<Info>): this;
-    build(): BuiltAgent<Info, Schema extends ToolSchemaSource ? SchemaOutput<Schema> : string>;
-    private nextMiddlewareId;
-    private push;
-    private assertOpen;
-}

package/dist/definition/builder.js

@@ -1,94 +0,0 @@
-import { HarnessError } from "../errors.js";
-import { execute } from "../execution/run.js";
-import { assembleAgent } from "./assemble.js";
-import { compileDeclaration } from "./declaration.js";
-export class AgentBuildError extends HarnessError {
-    diagnostics;
-    constructor(diagnostics) {
-        super("agent.build-failed", diagnostics.map((item) => item.message).join("; ") || "Agent build failed");
-        this.diagnostics = diagnostics;
-        this.name = "AgentBuildError";
-    }
-}
-export class AgentLifecycleError extends HarnessError {
-    constructor(message) {
-        super("agent.lifecycle-sealed", message);
-        this.name = "AgentLifecycleError";
-    }
-}
-export function Agent(options) {
-    return new AgentBuilder(options);
-}
-export class AgentBuilder {
-    #state;
-    constructor(options) {
-        this.#state = createState(options);
-    }
-    use(idOrMiddleware, middleware) {
-        if (typeof idOrMiddleware === "function") {
-            return this.push({
-                id: this.nextMiddlewareId(),
-                handle: idOrMiddleware,
-                hasMiddleware: true,
-            });
-        }
-        if (typeof idOrMiddleware === "object")
-            return this.push(compileDeclaration(idOrMiddleware));
-        return this.push({
-            id: idOrMiddleware,
-            handle: middleware,
-            hasMiddleware: true,
-        });
-    }
-    build() {
-        if (this.#state.agent)
-            return this.#state.agent;
-        if (this.#state.error)
-            throw this.#state.error;
-        this.#state.sealed = true;
-        const result = assembleAgent(this.#state.middleware, {
-            id: this.#state.id,
-            name: this.#state.name,
-            outputSchema: this.#state.outputSchema,
-        }, execute);
-        if (!result.ok) {
-            this.#state.error = new AgentBuildError(result.diagnostics);
-            throw this.#state.error;
-        }
-        this.#state.agent = result.agent;
-        return this.#state.agent;
-    }
-    nextMiddlewareId() {
-        const taken = new Set(this.#state.middleware.map((item) => item.id));
-        let id;
-        do {
-            this.#state.middlewareSeq += 1;
-            id = `middleware-${this.#state.middlewareSeq}`;
-        } while (taken.has(id));
-        return id;
-    }
-    push(entry) {
-        this.assertOpen();
-        this.#state.middleware.push(entry);
-        return this;
-    }
-    assertOpen() {
-        if (this.#state.sealed)
-            throw new AgentLifecycleError("AgentBuilder cannot be changed after build()");
-    }
-}
-function createState(options) {
-    const middleware = [];
-    if (options.instructions !== undefined) {
-        const instructions = typeof options.instructions === "string" ? [options.instructions] : options.instructions;
-        middleware.push(compileDeclaration({ id: "agent", instructions }));
-    }
-    return {
-        id: options.id,
-        outputSchema: options.outputSchema,
-        name: options.name,
-        middleware,
-        sealed: false,
-        middlewareSeq: 0,
-    };
-}

package/dist/definition/declaration.d.ts

@@ -1,3 +0,0 @@
-import type { BoundMiddleware } from "./bound.js";
-import type { CapabilityDeclaration } from "../types/middleware.js";
-export declare function compileDeclaration<State>(declaration: CapabilityDeclaration<State>): BoundMiddleware;

package/dist/definition/declaration.js

@@ -1,53 +0,0 @@
-export function compileDeclaration(declaration) {
-    const tools = copyItems(declaration.tools, declaration.id);
-    const instructions = copyItems(declaration.instructions, declaration.id);
-    const model = declaration.model;
-    const contributions = snapshotContributions(instructions?.items, tools?.items, model);
-    const handle = async (request, next) => {
-        if (tools)
-            request.configuration.tools.set(tools.slot, tools.items);
-        if (instructions)
-            request.configuration.instructions.set(instructions.slot, instructions.items);
-        if (model)
-            request.configuration.model.select(model);
-        return declaration.middleware ? declaration.middleware(request, next) : next();
-    };
-    return {
-        id: declaration.id,
-        handle,
-        hasMiddleware: declaration.middleware !== undefined,
-        tools: tools?.items,
-        ...(contributions === undefined ? {} : { contributions }),
-    };
-}
-function snapshotContributions(instructions, tools, model) {
-    const snapInstructions = instructions === undefined ? undefined : Object.freeze([...instructions]);
-    const snapTools = tools === undefined
-        ? undefined
-        : Object.freeze(tools.map((tool) => Object.freeze({
-            name: tool.name,
-            ...(tool.description === undefined ? {} : { description: tool.description }),
-        })));
-    const snapModel = model === undefined ? undefined : snapshotModel(model);
-    if (snapInstructions === undefined && snapTools === undefined && snapModel === undefined) {
-        return undefined;
-    }
-    return Object.freeze({
-        ...(snapInstructions === undefined ? {} : { instructions: snapInstructions }),
-        ...(snapTools === undefined ? {} : { tools: snapTools }),
-        ...(snapModel === undefined ? {} : { model: snapModel }),
-    });
-}
-function snapshotModel(model) {
-    return Object.freeze({
-        ...(model.id === undefined ? {} : { id: model.id }),
-        ...(model.controls === undefined ? {} : { controls: Object.freeze({ ...model.controls }) }),
-    });
-}
-function copyItems(value, defaultSlot) {
-    if (value === undefined)
-        return undefined;
-    if (!("items" in value))
-        return Object.freeze({ slot: defaultSlot, items: Object.freeze([...value]) });
-    return Object.freeze({ slot: value.slot, items: Object.freeze([...value.items]) });
-}

package/dist/definition/helpers.d.ts

@@ -1,6 +0,0 @@
-import type { ModelAdapter } from "../types/model.js";
-import type { StepMiddleware } from "../types/middleware.js";
-import type { ToolDefinition, ToolInputSchema, ToolOutputSchema } from "../types/tool.js";
-export declare const tool: <InputSchema extends ToolInputSchema, Info = unknown, OutputSchema extends ToolOutputSchema | undefined = undefined>(value: ToolDefinition<InputSchema, Info, OutputSchema>) => ToolDefinition<InputSchema, Info, OutputSchema>;
-export declare const model: <T extends ModelAdapter>(value: T) => T;
-export declare const middleware: <T extends StepMiddleware>(value: T) => T;

package/dist/definition/helpers.js

@@ -1,4 +0,0 @@
-import { prepareTool } from "./schema.js";
-export const tool = (value) => prepareTool(value);
-export const model = (value) => value;
-export const middleware = (value) => value;

package/dist/definition/manifest.d.ts

@@ -1,9 +0,0 @@
-import type { BoundMiddleware } from "./bound.js";
-import type { AgentManifest } from "../types/manifest.js";
-import type { ToolSchemaSource } from "../types/tool.js";
-export declare function createManifest(input: {
-    id: string;
-    name: string;
-    outputSchema?: ToolSchemaSource;
-    middleware: readonly BoundMiddleware[];
-}): AgentManifest;

package/dist/definition/manifest.js

@@ -1,45 +0,0 @@
-import { bindOutputContract } from "./output-contract.js";
-import { normalizedSchemasFor } from "./schema.js";
-import { deepFreeze } from "../utils/immutable.js";
-export function createManifest(input) {
-    const capabilities = input.middleware.map((item) => projectCapability(item));
-    return deepFreeze({
-        id: input.id,
-        name: input.name,
-        ...(input.outputSchema === undefined
-            ? {}
-            : { outputSchema: bindOutputContract(input.outputSchema).schema.jsonSchema }),
-        capabilities,
-    });
-}
-function projectCapability(item) {
-    const contributions = item.contributions;
-    return {
-        id: item.id,
-        kind: capabilityKind(item),
-        hasMiddleware: item.hasMiddleware,
-        ...(contributions?.instructions === undefined
-            ? {}
-            : { instructions: contributions.instructions }),
-        ...(item.tools === undefined ? {} : { tools: item.tools.map((tool) => projectTool(tool)) }),
-        ...(contributions?.model === undefined ? {} : { model: contributions.model }),
-    };
-}
-function capabilityKind(item) {
-    if (item.id === "agent")
-        return "agent";
-    if (item.contributions !== undefined)
-        return "capability";
-    return "middleware";
-}
-function projectTool(tool) {
-    const schemas = normalizedSchemasFor(tool);
-    return {
-        name: tool.name,
-        ...(tool.description === undefined ? {} : { description: tool.description }),
-        inputSchema: schemas.inputSchema.jsonSchema,
-        ...(schemas.outputSchema === undefined
-            ? {}
-            : { outputSchema: schemas.outputSchema.jsonSchema }),
-    };
-}

package/dist/definition/output-contract.d.ts

@@ -1,6 +0,0 @@
-import type { ToolSchema, ToolSchemaSource } from "../types/tool.js";
-/** Runtime-only validator paired with the portable JSON Schema projected to models. */
-export interface TurnOutputContract {
-    readonly schema: ToolSchema<unknown>;
-}
-export declare function bindOutputContract(source: ToolSchemaSource): TurnOutputContract;

package/dist/definition/output-contract.js

@@ -1,12 +0,0 @@
-import { HarnessError, isHarnessError } from "../errors.js";
-import { normalizeSchema } from "./schema.js";
-export function bindOutputContract(source) {
-    try {
-        return Object.freeze({ schema: normalizeSchema(source, "output") });
-    }
-    catch (cause) {
-        if (isHarnessError(cause))
-            throw new HarnessError("output.invalid-schema", cause.message, { cause });
-        throw new HarnessError("output.invalid-schema", String(cause), { cause });
-    }
-}

package/dist/definition/schema.d.ts

@@ -1,14 +0,0 @@
-import type { ToolDefinition, ToolSchema, ToolSchemaSource } from "../types/tool.js";
-export type { SchemaValidation } from "../types/tool.js";
-interface NormalizedToolSchemas {
-    readonly inputSchema: ToolSchema<unknown>;
-    readonly outputSchema?: ToolSchema<unknown>;
-}
-/** Creates a portable, explicitly validated schema source from raw JSON Schema. */
-export declare function defineSchema<T>(value: ToolSchema<T>): ToolSchema<T>;
-/** Eagerly prepares a definition authored through Harness's tool() helper. */
-export declare function prepareTool<T extends ToolDefinition>(definition: T): T;
-/** Returns cached normalized contracts, preparing raw definitions on first bind. */
-export declare function normalizedSchemasFor(definition: ToolDefinition): NormalizedToolSchemas;
-/** Converts an accepted tool schema source into Harness's immutable runtime representation. */
-export declare function normalizeSchema<T>(source: ToolSchemaSource<T>, role: "input" | "output"): ToolSchema<T>;

package/dist/definition/schema.js

@@ -1,205 +0,0 @@
-import { z } from "zod";
-import { HarnessError } from "../errors.js";
-import { copyJsonObject } from "../utils/immutable.js";
-const preparedSchemas = new WeakMap();
-/** Creates a portable, explicitly validated schema source from raw JSON Schema. */
-export function defineSchema(value) {
-    if (!value || typeof value !== "object" || typeof value.validate !== "function")
-        throw new HarnessError("tool.invalid-schema", "Tool schema must provide validate()");
-    return Object.freeze({
-        jsonSchema: copyJsonObject(value.jsonSchema, "tool schema jsonSchema"),
-        validate: value.validate.bind(value),
-    });
-}
-/** Eagerly prepares a definition authored through Harness's tool() helper. */
-export function prepareTool(definition) {
-    normalizedSchemasFor(definition);
-    return definition;
-}
-/** Returns cached normalized contracts, preparing raw definitions on first bind. */
-export function normalizedSchemasFor(definition) {
-    const cached = preparedSchemas.get(definition);
-    if (cached)
-        return cached;
-    const normalized = Object.freeze({
-        inputSchema: normalizeSchema(definition.inputSchema, "input"),
-        ...(definition.outputSchema === undefined
-            ? {}
-            : { outputSchema: normalizeSchema(definition.outputSchema, "output") }),
-    });
-    preparedSchemas.set(definition, normalized);
-    return normalized;
-}
-/** Converts an accepted tool schema source into Harness's immutable runtime representation. */
-export function normalizeSchema(source, role) {
-    const normalized = isZodSchema(source)
-        ? normalizeZodSchema(source, role)
-        : isStandardSchema(source)
-            ? normalizeStandardSchema(source, role)
-            : isToolSchema(source)
-                ? normalizeExplicitSchema(source)
-                : undefined;
-    if (!normalized)
-        throw new HarnessError("tool.invalid-schema", "Tool schema must be a Zod schema, synchronous Standard Schema with JSON Schema conversion, or defineSchema() contract");
-    if (role === "input" && normalized.jsonSchema.type !== "object")
-        throw new HarnessError("tool.invalid-schema", "Tool inputSchema JSON Schema root type must be object");
-    return normalized;
-}
-function normalizeZodSchema(source, role) {
-    if (hasDeclaredAsyncWork(source))
-        throw new HarnessError("tool.invalid-schema", "Tool schema must validate synchronously");
-    let jsonSchema;
-    try {
-        jsonSchema = copyJsonObject(z.toJSONSchema(source, { target: "draft-07" }), `tool.${role}Schema.jsonSchema`);
-    }
-    catch (error) {
-        throw new HarnessError("tool.invalid-schema", `Tool ${role}Schema must convert to JSON Schema: ${message(error)}`, { cause: error });
-    }
-    return Object.freeze({
-        jsonSchema,
-        validate(value) {
-            try {
-                const result = source.safeParse(value);
-                if (result.success)
-                    return { ok: true, value: result.data };
-                return {
-                    ok: false,
-                    issues: Object.freeze(result.error.issues.map((entry) => issue(entry.path.filter(isPathSegment), entry.code, entry.message))),
-                };
-            }
-            catch (error) {
-                return { ok: false, issues: [issue([], "schema_error", synchronousIssue(error))] };
-            }
-        },
-    });
-}
-function normalizeStandardSchema(source, role) {
-    let jsonSchema;
-    try {
-        jsonSchema = copyJsonObject(role === "input"
-            ? source["~standard"].jsonSchema.input()
-            : source["~standard"].jsonSchema.output(), `tool.${role}Schema.jsonSchema`);
-    }
-    catch (error) {
-        throw new HarnessError("tool.invalid-schema", `Tool ${role}Schema must convert to JSON Schema: ${message(error)}`, { cause: error });
-    }
-    return Object.freeze({
-        jsonSchema,
-        validate(value) {
-            try {
-                const result = source["~standard"].validate(value);
-                if (isPromiseLike(result))
-                    return {
-                        ok: false,
-                        issues: [issue([], "async_validation", "Schema validation must be synchronous")],
-                    };
-                if (result && typeof result === "object" && "issues" in result && result.issues)
-                    return { ok: false, issues: Object.freeze(result.issues.map(standardIssue)) };
-                if (result && typeof result === "object" && "value" in result)
-                    return { ok: true, value: result.value };
-                return {
-                    ok: false,
-                    issues: [issue([], "schema_error", "Standard Schema returned an invalid result")],
-                };
-            }
-            catch (error) {
-                return { ok: false, issues: [issue([], "schema_error", synchronousIssue(error))] };
-            }
-        },
-    });
-}
-function normalizeExplicitSchema(source) {
-    return Object.freeze({
-        jsonSchema: copyJsonObject(source.jsonSchema, "tool schema jsonSchema"),
-        validate(value) {
-            try {
-                const result = source.validate(value);
-                if (isPromiseLike(result))
-                    return {
-                        ok: false,
-                        issues: [issue([], "async_validation", "Schema validation must be synchronous")],
-                    };
-                if (!result || typeof result !== "object" || typeof result.ok !== "boolean")
-                    return {
-                        ok: false,
-                        issues: [issue([], "schema_error", "Tool schema returned an invalid result")],
-                    };
-                if (result.ok)
-                    return { ok: true, value: result.value };
-                return { ok: false, issues: Object.freeze(result.issues.map(normalizeIssue)) };
-            }
-            catch (error) {
-                return { ok: false, issues: [issue([], "schema_error", synchronousIssue(error))] };
-            }
-        },
-    });
-}
-function isZodSchema(value) {
-    return value instanceof z.ZodType;
-}
-function isStandardSchema(value) {
-    if (!value || typeof value !== "object" || !("~standard" in value))
-        return false;
-    const standard = value["~standard"];
-    if (!standard || typeof standard !== "object")
-        return false;
-    const record = standard;
-    if (typeof record.validate !== "function" ||
-        !record.jsonSchema ||
-        typeof record.jsonSchema !== "object")
-        return false;
-    const jsonSchema = record.jsonSchema;
-    return typeof jsonSchema.input === "function" && typeof jsonSchema.output === "function";
-}
-function isToolSchema(value) {
-    return (!!value &&
-        typeof value === "object" &&
-        "jsonSchema" in value &&
-        "validate" in value &&
-        typeof value.validate === "function");
-}
-/** Zod exposes declared checks in its stable v4 definition graph; reject async checks before a run. */
-function hasDeclaredAsyncWork(schema) {
-    return visitDefinition(schema._zod?.def, new Set());
-}
-function visitDefinition(value, seen) {
-    if (typeof value === "function")
-        return value.constructor.name === "AsyncFunction";
-    if (!value || typeof value !== "object")
-        return false;
-    if (seen.has(value))
-        return false;
-    seen.add(value);
-    const nestedDefinition = value._zod?.def;
-    if (nestedDefinition !== undefined && nestedDefinition !== value)
-        return visitDefinition(nestedDefinition, seen);
-    for (const item of Object.values(value)) {
-        if (visitDefinition(item, seen))
-            return true;
-    }
-    return false;
-}
-function standardIssue(value) {
-    return issue(value.path?.filter(isPathSegment) ?? [], value.code ?? "invalid", value.message ?? "Invalid value");
-}
-function normalizeIssue(value) {
-    return issue(value.path?.filter(isPathSegment) ?? [], value.code ?? "invalid", value.message ?? "Invalid value");
-}
-function issue(path, code, text) {
-    return Object.freeze({ path: Object.freeze([...path]), code, message: text });
-}
-function isPathSegment(value) {
-    return typeof value === "string" || typeof value === "number";
-}
-function isPromiseLike(value) {
-    return (!!value && typeof value === "object" && typeof value.then === "function");
-}
-function synchronousIssue(error) {
-    const reason = message(error);
-    return reason.includes("Promise during synchronous parse")
-        ? "Schema validation must be synchronous"
-        : reason;
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/errors.d.ts

@@ -1,17 +0,0 @@
-/** Machine-readable error raised by Harness-owned code. */
-export type HarnessErrorCode = "execution.invalid-state" | "execution.invalid-input" | "execution.incompatible" | "execution.record-failed" | "tool.unregistered" | "tool.invalid-binding" | "agent.build-failed" | "agent.lifecycle-sealed" | "context.invalid-item" | "context.invalid-item-type" | "context.invalid-order" | "context.invalid-reason" | "context.invalid-slot" | "interaction.invalid" | "interaction.missing-resume" | "interaction.uncorrelated-resume" | "input.invalid-content" | "output.invalid" | "output.invalid-schema" | "json.invalid-data" | "json.invalid-object" | "middleware.next-after-return" | "middleware.next-called-twice" | "middleware.request-mutators-revoked" | "model.candidate-missing" | "model.adapter-invalid-options" | "model.adapter-invalid-response" | "model.invalid-candidate" | "model.invalid-directive" | "model.unsupported-content" | "model.unsupported-output-schema" | "configuration.duplicate-tool-name" | "configuration.invalid" | "configuration.invalid-instructions" | "configuration.invalid-order" | "configuration.invalid-reason" | "configuration.invalid-slot" | "configuration.invalid-tools" | "configuration.model-selection-conflict" | "response.invalid-replacement" | "tool.invalid" | "tool.invalid-arguments" | "tool.invalid-output" | "tool.invalid-name" | "tool.invalid-schema" | "tool.invalid-tool-result";
-export type HarnessErrorDetails = Readonly<Record<string, string | number | boolean>>;
-export interface HarnessErrorOptions {
-    readonly cause?: unknown;
-    readonly details?: HarnessErrorDetails;
-}
-/**
- * The sole error shape produced by Harness itself. Message text is explanatory;
- * callers must branch on `code`.
- */
-export declare class HarnessError extends Error {
-    readonly code: HarnessErrorCode;
-    readonly details: HarnessErrorDetails;
-    constructor(code: HarnessErrorCode, message: string, options?: HarnessErrorOptions);
-}
-export declare function isHarnessError(error: unknown): error is HarnessError;

package/dist/errors.js

@@ -1,17 +0,0 @@
-/**
- * The sole error shape produced by Harness itself. Message text is explanatory;
- * callers must branch on `code`.
- */
-export class HarnessError extends Error {
-    code;
-    details;
-    constructor(code, message, options = {}) {
-        super(message, options.cause === undefined ? undefined : { cause: options.cause });
-        this.name = "HarnessError";
-        this.code = code;
-        this.details = Object.freeze({ ...(options.details ?? {}) });
-    }
-}
-export function isHarnessError(error) {
-    return error instanceof HarnessError;
-}