@nylorun/core 0.0.0-bootstrap → 0.1.1-beta

package/dist/define.d.ts

@@ -0,0 +1,31 @@
+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 type { BuiltAgent } from "./types/agent.js";
+export { capability, middleware, model, tool } from "./definition/helpers.js";
+export { ToolError, isToolError } from "./definition/tool-error.js";
+export { defineSchema } from "./definition/schema.js";
+export { hashManifest } from "./utils/hash.js";
+export type { Implementations } from "./definition/implementations.js";
+export type { AgentManifest, CapabilityManifest, ManifestTool, ManifestSchemaVersion, } from "./types/manifest.js";
+export type { CapabilityDeclaration, CapabilityItems, MiddlewareContributions, StepMiddleware, StepRequest, StepResponse, } from "./types/middleware.js";
+export type { Patch, Decision, BeforeModelCallFn, AfterModelCallFn, } from "./types/dynamics.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, 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 { Interaction, RequiredInteraction, ToolContent, ToolDefinition, ToolDescriptor, ToolExecutionContext, ToolExecutionResume, ToolInputSchema, ToolOutputSchema, ToolSchema, ToolSchemaSource, StandardToolSchema, StandardSchemaIssue, SchemaIssue, SchemaValidation, SchemaOutput, ToolOwner, ToolOutcome, ToolResult, ToolValidationFailureDetails, ToolEffects, ToolApproval, ToolRunResult, SessionStateBag, } from "./types/tool.js";
+export { normalizeToolDefinition, normalizedSchemasFor, } from "./definition/schema.js";
+export { implementationsFor, bindingFromAgent } from "./definition/binding.js";
+export type { AgentBinding } from "./definition/binding.js";
+export type { BoundMiddleware, BoundToolDefinition, } from "./definition/bound.js";
+export { bindTool } from "./definition/bind-tool.js";
+export { bindOutputContract } from "./definition/output-contract.js";
+export type { TurnOutputContract } from "./definition/output-contract.js";
+export { agentFrom } from "./definition/from.js";
+export { schemaFromJSON } from "./definition/schema-json.js";
+export { normalizeSchema } from "./definition/schema.js";
+export * from "./utils/immutable.js";
+export * from "./utils/canonical.js";
+export type { TranscriptToolsEntry } from "./types/transcript.js";

package/dist/define.js

@@ -0,0 +1,15 @@
+export { Agent, AgentBuilder, AgentBuildError, AgentLifecycleError, } from "./definition/builder.js";
+export { HarnessError, isHarnessError } from "./errors.js";
+export { capability, middleware, model, tool } from "./definition/helpers.js";
+export { ToolError, isToolError } from "./definition/tool-error.js";
+export { defineSchema } from "./definition/schema.js";
+export { hashManifest } from "./utils/hash.js";
+export { normalizeToolDefinition, normalizedSchemasFor, } from "./definition/schema.js";
+export { implementationsFor, bindingFromAgent } from "./definition/binding.js";
+export { bindTool } from "./definition/bind-tool.js";
+export { bindOutputContract } from "./definition/output-contract.js";
+export { agentFrom } from "./definition/from.js";
+export { schemaFromJSON } from "./definition/schema-json.js";
+export { normalizeSchema } from "./definition/schema.js";
+export * from "./utils/immutable.js";
+export * from "./utils/canonical.js";

package/dist/definition/assemble.d.ts

@@ -0,0 +1,26 @@
+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 { ToolSchemaSource } from "../types/tool.js";
+import type { AfterModelCallFn, BeforeModelCallFn } from "../types/dynamics.js";
+import type { StepMiddleware } from "../types/middleware.js";
+type BuildResult<Agent> = {
+    readonly ok: true;
+    readonly agent: Agent;
+    readonly manifest: AgentManifest;
+} | {
+    readonly ok: false;
+    readonly diagnostics: readonly BuildDiagnostic[];
+};
+export interface CapabilityDynamics {
+    readonly beforeModelCall?: BeforeModelCallFn<any>;
+    readonly afterModelCall?: AfterModelCallFn<any>;
+    readonly middleware?: StepMiddleware<any>;
+}
+export declare function assembleAgent(middleware: readonly BoundMiddleware[], identity: Readonly<{
+    id: string;
+    name: string;
+    outputSchema?: ToolSchemaSource;
+}>, dynamics?: ReadonlyMap<string, CapabilityDynamics>): BuildResult<BuiltAgent>;
+export {};

package/dist/definition/assemble.js

@@ -0,0 +1,50 @@
+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, dynamics = new Map()) {
+    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 }),
+                ...(item.beforeModelCall ? { beforeModelCall: true } : {}),
+                ...(item.afterModelCall ? { afterModelCall: true } : {}),
+            }));
+        }
+    }
+    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, dynamics);
+    return Object.freeze({ ok: true, agent, manifest });
+}

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

@@ -0,0 +1,8 @@
+import type { AgentManifest } from "../types/manifest.js";
+import type { BoundMiddleware } from "./bound.js";
+import type { BuiltAgent } from "../types/agent.js";
+import type { ToolSchemaSource } from "../types/tool.js";
+import type { CapabilityDynamics } from "./assemble.js";
+export declare function bindAgent(middleware: readonly BoundMiddleware[], manifest: AgentManifest, options?: {
+    outputSchema?: ToolSchemaSource;
+}, dynamics?: ReadonlyMap<string, CapabilityDynamics>): BuiltAgent;

package/dist/definition/bind-agent.js

@@ -0,0 +1,61 @@
+import { bindTool } from "./bind-tool.js";
+import { HarnessError } from "../errors.js";
+import { bindOutputContract } from "./output-contract.js";
+import { hashManifest } from "../utils/hash.js";
+export function bindAgent(middleware, manifest, options = {}, dynamics = new Map()) {
+    const seen = new Set();
+    const keys = new Set();
+    const tools = [];
+    for (const declaration of middleware)
+        for (const tool of declaration.tools ?? []) {
+            const key = JSON.stringify([declaration.id, tool.name]);
+            if (seen.has(tool) || keys.has(key))
+                throw new HarnessError("tool.invalid", `Duplicate registered tool '${tool.name}' in '${declaration.id}'`);
+            seen.add(tool);
+            keys.add(key);
+            tools.push(bindTool(tool, { middlewareId: declaration.id, slot: declaration.id }));
+        }
+    const implementations = buildImplementations(middleware, dynamics, tools);
+    const binding = Object.freeze({
+        declarations: middleware,
+        tools: Object.freeze(tools),
+        ...(options.outputSchema === undefined
+            ? {}
+            : { outputSchema: options.outputSchema }),
+        manifest,
+        implementations,
+    });
+    // Validate the live output schema at authoring time without compiling engine state.
+    if (options.outputSchema)
+        bindOutputContract(options.outputSchema);
+    const agent = {
+        id: manifest.id,
+        name: manifest.name,
+        manifest,
+        hash: hashManifest(manifest),
+        toJSON: () => manifest,
+    };
+    Object.defineProperty(agent, "getBinding", {
+        value: () => binding,
+        enumerable: false,
+    });
+    return agent;
+}
+function buildImplementations(middleware, dynamics, snapshots) {
+    const table = {};
+    for (const item of middleware) {
+        const tools = {};
+        for (const tool of snapshots.filter((tool) => tool.owner.middlewareId === item.id))
+            tools[tool.name] = tool;
+        const dyn = dynamics.get(item.id);
+        table[item.id] = Object.freeze({
+            ...(Object.keys(tools).length
+                ? { tools: Object.freeze({ ...tools }) }
+                : {}),
+            ...(dyn?.beforeModelCall ? { beforeModelCall: dyn.beforeModelCall } : {}),
+            ...(dyn?.afterModelCall ? { afterModelCall: dyn.afterModelCall } : {}),
+            ...(dyn?.middleware ? { middleware: dyn.middleware } : {}),
+        });
+    }
+    return Object.freeze(table);
+}

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,25 @@
+import { HarnessError } from "../errors.js";
+import { normalizeToolDefinition, normalizedSchemasFor } from "./schema.js";
+/** Prepares an executable Tool and records its middleware slot provenance. */
+export function bindTool(item, owner) {
+    const prepared = normalizeToolDefinition(item);
+    if (!prepared.name)
+        throw new HarnessError("tool.invalid-name", "Tool name must not be empty");
+    if (typeof prepared.execute !== "function")
+        throw new HarnessError("tool.invalid", `Tool '${prepared.name}' must provide execute()`);
+    const schemas = normalizedSchemasFor(prepared);
+    return Object.freeze({
+        // Keep the original object identity so ToolRegistry WeakMap lookups succeed.
+        source: item,
+        name: prepared.name,
+        ...(prepared.description ? { description: prepared.description } : {}),
+        inputSchema: schemas.inputSchema,
+        ...(schemas.outputSchema === undefined
+            ? {}
+            : { outputSchema: schemas.outputSchema }),
+        execute: prepared.execute.bind(prepared),
+        ...(prepared.approval === undefined ? {} : { approval: prepared.approval }),
+        ...(prepared.effects === undefined ? {} : { effects: prepared.effects }),
+        owner: Object.freeze({ ...owner }),
+    });
+}

package/dist/definition/binding.d.ts

@@ -0,0 +1,15 @@
+import type { AgentManifest } from "../types/manifest.js";
+import type { BuiltAgent } from "../types/agent.js";
+import type { ToolSchemaSource } from "../types/tool.js";
+import type { BoundMiddleware, BoundToolDefinition } from "./bound.js";
+import type { Implementations } from "./implementations.js";
+/** Local code binding. Only manifest is serializable; functions stay in the application. */
+export interface AgentBinding {
+    readonly manifest: AgentManifest;
+    readonly tools: readonly BoundToolDefinition[];
+    readonly declarations: readonly BoundMiddleware[];
+    readonly implementations: Implementations;
+    readonly outputSchema?: ToolSchemaSource;
+}
+export declare function bindingFromAgent(agent: BuiltAgent): AgentBinding;
+export declare function implementationsFor(agent: BuiltAgent): Implementations;

package/dist/definition/binding.js

@@ -0,0 +1,9 @@
+import { HarnessError } from "../errors.js";
+export function bindingFromAgent(agent) {
+    if (!agent || typeof agent.getBinding !== "function")
+        throw new HarnessError("execution.invalid-input", "An agent with getBinding() is required");
+    return agent.getBinding();
+}
+export function implementationsFor(agent) {
+    return bindingFromAgent(agent).implementations;
+}

package/dist/definition/bound.d.ts

@@ -0,0 +1,20 @@
+import type { MiddlewareContributions, StepMiddleware } from "../types/middleware.js";
+import type { ToolApproval, ToolDefinition, ToolEffects, ToolExecutionContext, ToolInputSchema, ToolOutputSchema, ToolOwner, ToolRunResult, ToolSchema } from "../types/tool.js";
+export interface BoundToolDefinition<Info = unknown> extends Omit<ToolDefinition<ToolInputSchema, Info, ToolOutputSchema | undefined>, "inputSchema" | "outputSchema" | "execute" | "run" | "input" | "output"> {
+    readonly inputSchema: ToolSchema<unknown>;
+    readonly outputSchema?: ToolSchema<unknown>;
+    readonly execute: (args: unknown, context: ToolExecutionContext<Info>) => Promise<ToolRunResult>;
+    readonly approval?: ToolApproval<ToolInputSchema>;
+    readonly effects?: ToolEffects;
+    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;
+    readonly beforeModelCall?: boolean;
+    readonly afterModelCall?: boolean;
+}

package/dist/definition/bound.js

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

package/dist/definition/builder.d.ts

@@ -0,0 +1,63 @@
+import type { BoundMiddleware } from "./bound.js";
+import type { CapabilityDeclaration, StepMiddleware } from "../types/middleware.js";
+import type { BuildDiagnostic } from "../types/shared.js";
+import { HarnessError } from "../errors.js";
+import type { ToolDefinition, ToolSchemaSource, SchemaOutput } from "../types/tool.js";
+import type { BuiltAgent } from "../types/agent.js";
+import type { AgentManifest } from "../types/manifest.js";
+import type { AfterModelCallFn, BeforeModelCallFn } from "../types/dynamics.js";
+import type { Implementations } from "./implementations.js";
+import { type CapabilityDynamics } from "./assemble.js";
+export interface AgentOptions<Schema extends ToolSchemaSource | undefined = undefined> {
+    readonly outputSchema?: Schema;
+    readonly id: string;
+    readonly name: string;
+    readonly instructions?: string | readonly string[];
+    /** Top-level tools (H2). Composed as capability id `"agent"`. */
+    readonly tools?: readonly ToolDefinition<any, any, any>[];
+}
+interface BuilderSnapshot {
+    readonly id: string;
+    readonly name: string;
+    readonly outputSchema?: ToolSchemaSource;
+    readonly entries: readonly BoundMiddleware[];
+    readonly dynamics: ReadonlyMap<string, CapabilityDynamics>;
+    readonly agentBefore?: BeforeModelCallFn;
+    readonly agentAfter?: AfterModelCallFn;
+}
+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 namespace Agent {
+    function from<Info = unknown>(json: AgentManifest | import("../types/shared.js").JsonObject, implementations: Implementations<Info>): BuiltAgent<Info>;
+}
+declare const SNAPSHOT: unique symbol;
+export declare class AgentBuilder<Info = unknown, Schema extends ToolSchemaSource | undefined = undefined> {
+    #private;
+    getBinding(): import("./binding.js").AgentBinding;
+    constructor(options: AgentOptions<Schema>);
+    /** @internal */
+    constructor(snapshot: BuilderSnapshot, brand: typeof SNAPSHOT);
+    static create<Info, Schema extends ToolSchemaSource | undefined>(options: AgentOptions<Schema>): AgentBuilder<Info, Schema>;
+    private static withSnapshot;
+    /** Compose-time identity — available before `.build()`. */
+    get id(): string;
+    get name(): string;
+    get manifest(): AgentManifest;
+    get hash(): string;
+    toJSON(): AgentManifest;
+    use(middleware: StepMiddleware<Info>): AgentBuilder<Info, Schema>;
+    use(id: string, middleware: StepMiddleware<Info>): AgentBuilder<Info, Schema>;
+    use(declaration: CapabilityDeclaration<Info>): AgentBuilder<Info, Schema>;
+    beforeModelCall(fn: BeforeModelCallFn<Info>): AgentBuilder<Info, Schema>;
+    afterModelCall(fn: AfterModelCallFn<Info>): AgentBuilder<Info, Schema>;
+    /** Optional no-op: returns the assembled agent facade. */
+    build(): BuiltAgent<Info, Schema extends ToolSchemaSource ? SchemaOutput<Schema> : string>;
+    private ensure;
+}
+export type { Implementations };

package/dist/definition/builder.js

@@ -0,0 +1,215 @@
+import { HarnessError } from "../errors.js";
+import { assembleAgent } from "./assemble.js";
+import { compileDeclaration } from "./declaration.js";
+import { agentFrom } from "./from.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 AgentBuilder.create(options);
+}
+(function (Agent) {
+    function from(json, implementations) {
+        return agentFrom(json, implementations);
+    }
+    Agent.from = from;
+})(Agent || (Agent = {}));
+const SNAPSHOT = Symbol("AgentBuilder.snapshot");
+export class AgentBuilder {
+    #snapshot;
+    #agent;
+    #error;
+    getBinding() {
+        return this.build().getBinding();
+    }
+    constructor(optionsOrSnapshot, brand) {
+        this.#snapshot =
+            brand === SNAPSHOT
+                ? optionsOrSnapshot
+                : createSnapshot(optionsOrSnapshot);
+    }
+    static create(options) {
+        return new AgentBuilder(options);
+    }
+    static withSnapshot(snapshot) {
+        return new AgentBuilder(snapshot, SNAPSHOT);
+    }
+    /** Compose-time identity — available before `.build()`. */
+    get id() {
+        return this.#snapshot.id;
+    }
+    get name() {
+        return this.#snapshot.name;
+    }
+    get manifest() {
+        return this.ensure().manifest;
+    }
+    get hash() {
+        return this.ensure().hash;
+    }
+    toJSON() {
+        return this.ensure().toJSON();
+    }
+    use(idOrMiddleware, middleware) {
+        let compiled;
+        if (typeof idOrMiddleware === "function") {
+            compiled = {
+                bound: {
+                    id: nextMiddlewareId(this.#snapshot.entries),
+                    handle: idOrMiddleware,
+                    hasMiddleware: true,
+                },
+                middleware: idOrMiddleware,
+            };
+        }
+        else if (typeof idOrMiddleware === "object") {
+            compiled = compileDeclaration(idOrMiddleware);
+        }
+        else {
+            compiled = {
+                bound: {
+                    id: idOrMiddleware,
+                    handle: middleware,
+                    hasMiddleware: true,
+                },
+                middleware: middleware,
+            };
+        }
+        const dynamics = new Map(this.#snapshot.dynamics);
+        dynamics.set(compiled.bound.id, {
+            ...(compiled.beforeModelCall
+                ? { beforeModelCall: compiled.beforeModelCall }
+                : {}),
+            ...(compiled.afterModelCall
+                ? { afterModelCall: compiled.afterModelCall }
+                : {}),
+            ...(compiled.middleware ? { middleware: compiled.middleware } : {}),
+        });
+        return AgentBuilder.withSnapshot({
+            ...this.#snapshot,
+            entries: Object.freeze([...this.#snapshot.entries, compiled.bound]),
+            dynamics,
+        });
+    }
+    beforeModelCall(fn) {
+        const dynamics = new Map(this.#snapshot.dynamics);
+        const existing = dynamics.get("agent") ?? {};
+        dynamics.set("agent", {
+            ...existing,
+            beforeModelCall: fn,
+        });
+        const entries = ensureAgentCapabilityFlag(this.#snapshot.entries, "beforeModelCall");
+        return AgentBuilder.withSnapshot({
+            ...this.#snapshot,
+            entries,
+            dynamics,
+            agentBefore: fn,
+        });
+    }
+    afterModelCall(fn) {
+        const dynamics = new Map(this.#snapshot.dynamics);
+        const existing = dynamics.get("agent") ?? {};
+        dynamics.set("agent", {
+            ...existing,
+            afterModelCall: fn,
+        });
+        const entries = ensureAgentCapabilityFlag(this.#snapshot.entries, "afterModelCall");
+        return AgentBuilder.withSnapshot({
+            ...this.#snapshot,
+            entries,
+            dynamics,
+            agentAfter: fn,
+        });
+    }
+    /** Optional no-op: returns the assembled agent facade. */
+    build() {
+        return this.ensure();
+    }
+    ensure() {
+        if (this.#agent)
+            return this.#agent;
+        if (this.#error)
+            throw this.#error;
+        const result = assembleAgent(this.#snapshot.entries, {
+            id: this.#snapshot.id,
+            name: this.#snapshot.name,
+            outputSchema: this.#snapshot.outputSchema,
+        }, this.#snapshot.dynamics);
+        if (!result.ok) {
+            this.#error = new AgentBuildError(result.diagnostics);
+            throw this.#error;
+        }
+        this.#agent = result.agent;
+        return this.#agent;
+    }
+}
+function createSnapshot(options) {
+    const entries = [];
+    const dynamics = new Map();
+    const instructions = options.instructions === undefined
+        ? undefined
+        : typeof options.instructions === "string"
+            ? [options.instructions]
+            : options.instructions;
+    if (instructions !== undefined || options.tools !== undefined) {
+        const compiled = compileDeclaration({
+            id: "agent",
+            ...(instructions === undefined ? {} : { instructions }),
+            ...(options.tools === undefined ? {} : { tools: options.tools }),
+        });
+        entries.push(compiled.bound);
+        dynamics.set("agent", {});
+    }
+    return {
+        id: options.id,
+        name: options.name,
+        outputSchema: options.outputSchema,
+        entries: Object.freeze(entries),
+        dynamics,
+    };
+}
+function nextMiddlewareId(entries) {
+    const taken = new Set(entries.map((item) => item.id));
+    let seq = 0;
+    let id;
+    do {
+        seq += 1;
+        id = `middleware-${seq}`;
+    } while (taken.has(id));
+    return id;
+}
+function ensureAgentCapabilityFlag(entries, flag) {
+    const index = entries.findIndex((item) => item.id === "agent");
+    if (index >= 0) {
+        const current = entries[index];
+        if (current[flag])
+            return entries;
+        const next = Object.freeze({ ...current, [flag]: true });
+        return Object.freeze([
+            ...entries.slice(0, index),
+            next,
+            ...entries.slice(index + 1),
+        ]);
+    }
+    return Object.freeze([
+        ...entries,
+        Object.freeze({
+            id: "agent",
+            handle: async (_request, next) => next(),
+            hasMiddleware: false,
+            contributions: Object.freeze({}),
+            [flag]: true,
+        }),
+    ]);
+}

package/dist/definition/declaration.d.ts

@@ -0,0 +1,10 @@
+import type { BoundMiddleware } from "./bound.js";
+import type { CapabilityDeclaration, StepMiddleware } from "../types/middleware.js";
+import type { AfterModelCallFn, BeforeModelCallFn } from "../types/dynamics.js";
+export interface CompiledCapability {
+    readonly bound: BoundMiddleware;
+    readonly beforeModelCall?: BeforeModelCallFn<any>;
+    readonly afterModelCall?: AfterModelCallFn<any>;
+    readonly middleware?: StepMiddleware<any>;
+}
+export declare function compileDeclaration<State>(declaration: CapabilityDeclaration<State>): CompiledCapability;

package/dist/definition/declaration.js

@@ -0,0 +1,70 @@
+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 {
+        bound: {
+            id: declaration.id,
+            handle,
+            hasMiddleware: declaration.middleware !== undefined,
+            tools: tools?.items,
+            ...(contributions === undefined ? {} : { contributions }),
+            ...(declaration.beforeModelCall ? { beforeModelCall: true } : {}),
+            ...(declaration.afterModelCall ? { afterModelCall: true } : {}),
+        },
+        ...(declaration.beforeModelCall
+            ? { beforeModelCall: declaration.beforeModelCall }
+            : {}),
+        ...(declaration.afterModelCall
+            ? { afterModelCall: declaration.afterModelCall }
+            : {}),
+        ...(declaration.middleware ? { middleware: declaration.middleware } : {}),
+    };
+}
+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 }),
+        })));
+    // Model is Runtime-owned for the published manifest; still allow local middleware select().
+    void model;
+    if (snapInstructions === undefined && snapTools === undefined) {
+        return undefined;
+    }
+    return Object.freeze({
+        ...(snapInstructions === undefined
+            ? {}
+            : { instructions: snapInstructions }),
+        ...(snapTools === undefined ? {} : { tools: snapTools }),
+    });
+}
+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/from.d.ts

@@ -0,0 +1,6 @@
+import type { AgentManifest } from "../types/manifest.js";
+import type { BuiltAgent } from "../types/agent.js";
+import type { JsonObject } from "../types/shared.js";
+import type { Implementations } from "./implementations.js";
+/** Rebuild an agent from manifest JSON + in-process implementations (T28). */
+export declare function agentFrom<Info = unknown>(json: AgentManifest | JsonObject, implementations: Implementations<Info>): BuiltAgent<Info>;