@nylorun/harness 0.8.0-beta.1 → 0.11.0-beta

package/CHANGELOG.md

@@ -1,9 +1,72 @@
 # Changelog
 
+## 0.11.0-beta
+
+### Minor Changes
+
+- 54ab304: Support portable Runtime protocol version 2 while retaining legacy Studio
+  manifest support. Move the Studio CLI into Runtime: use `nylorun studio
+--agent-url <url>` instead of `nylo studio`. Applications should install Runtime
+  directly and keep Studio as a development dependency.
+
+  Retain session lists and media across development reloads, and recognize agent
+  file changes on Windows. Validate noninteractive creator startup during release
+  verification with deferred provider configuration.
+
+  Include Harness in this release so the creator does not rely on an unpublished
+  compatibility pin. Ship and verify all four packages together.
+
 All notable changes to `@nylorun/harness` are documented in this file.
 
 The project follows [Semantic Versioning](https://semver.org/). Before 1.0, the public API is experimental: breaking changes may occur in minor releases, while patch releases are reserved for compatible fixes.
 
+## Unreleased
+
+## [0.10.0-beta.1] - 2026-09-03
+
+### Added
+
+- Portable ordered media input parts with opaque JSON references preserved through sessions,
+  transcripts, middleware, model calls, and observations.
+- `preparedModel()` for adapters that need to materialize a provider request while exposing the
+  JSON-safe derived call through the new `model.prepared` observation.
+- Direct `inputSchema` and optional `outputSchema` tool contracts. Harness accepts Zod v4,
+  synchronous Standard Schema values with JSON Schema conversion, and explicit validator-backed
+  `defineSchema()` contracts.
+- Structured input and output validation diagnostics on failed tool results.
+- Per-turn `session.input({ ... }, { outputSchema })` contracts for locally validated terminal JSON
+  results, including canonical model-call projection, JSON candidates, immutable final persistence,
+  and `output.invalid` tripwires.
+
+### Changed
+
+- Bundled provider translators map direct URL image references and fail unsupported media with the
+  stable `model.unsupported-content` error rather than dropping or stringifying it.
+- Chat Completions and Responses translators project terminal output schemas without choosing
+  provider strictness; Anthropic Messages reports `model.unsupported-output-schema` until an
+  application supplies a custom prepared adapter.
+- Tool definitions use `inputSchema` instead of `parameters`. Completed output is validated when an
+  `outputSchema` is supplied; the resulting JSON is the same value recorded, observed, and sent to
+  the model. Model configuration and `model.requested` observations expose optional output schemas.
+
+### Breaking changes
+
+- Replace every tool `parameters` field with `inputSchema`. `outputSchema` is now an optional tool
+  contract and completed tool output may be any JSON value, not only a string.
+- Terminal results, final events, and stream projections may now be JSON values. Consumers that
+  assumed string output must render or serialize `JsonValue` safely.
+- Custom model adapters receive the `reportPreparedCall` context method. Adapters that materialize
+  provider requests should use it (or `preparedModel()`) to emit one JSON-safe derived request.
+
+## [0.9.0-beta.1] - 2026-09-02
+
+### Added
+
+- Public provider translator helpers under `@nylorun/harness/model/adapters` for OpenAI-compatible
+  Chat Completions, OpenAI Responses, and Anthropic Messages model loops.
+- `MiddlewareManifest` and declared middleware contributions in `AgentManifest`, including static
+  instructions, tool metadata, and model controls for host tooling such as Studio.
+
 ## [0.8.0-beta.1] - 2026-08-31
 
 ### Breaking changes
@@ -93,3 +156,4 @@ The project follows [Semantic Versioning](https://semver.org/). Before 1.0, the
 [0.6.0-beta.1]: https://github.com/nylorun/harness/tree/main/harness
 [0.7.0-beta.1]: https://github.com/nylorun/harness/tree/main/harness
 [0.8.0-beta.1]: https://github.com/nylorun/harness/tree/main/harness
+[0.9.0-beta.1]: https://github.com/nylorun/harness/tree/main/harness

package/README.md

@@ -1,43 +1,10 @@
 # `@nylorun/harness`
 
-`@nylorun/harness` is a small, provider-neutral TypeScript loop for model calls and tools. Compose
-an agent from a model adapter and named capabilities; keep provider clients, stores, HTTP, and
-credentials in ordinary application code.
+Nylorun's TypeScript agent runtime.
 
-> **Experimental beta.** Install with `npm install @nylorun/harness@beta`.
-
-```ts
-import { Agent, model, tool } from "@nylorun/harness";
-import { z } from "zod";
-
-const adapter = model(async (call) => provider.complete(call));
-const echo = tool({
-  name: "echo",
-  description: "Echo text",
-  parameters: z.object({ text: z.string() }),
-  execute: async ({ text }) => ({ kind: "completed", output: text }),
-});
-
-const agent = Agent({
-  id: "echo",
-  name: "Echo",
-  instructions: "Use echo when asked.",
-})
-  .use({ id: "echo", tools: [echo] })
-  .with(adapter)
-  .build();
+For installation, examples, API details, and release notes, see the
+[Nylorun Harness repository](https://github.com/nylorun/harness).
 
-const result = await agent.run().input("Echo hello").completed;
-```
-
-## Design boundaries
-
-- **Capabilities** declare model-visible tools, instructions, context, and candidate review through
-  `.use()`.
-- **Services** are dependencies you construct and pass to capabilities, such as a store, MCP client,
-  or container runner.
-- **Host code** owns transport, persistence, credentials, and background work.
-- **Harness core** owns the loop, validation, scheduling, and recording invariants.
+> **Experimental beta.** Install with `npm install @nylorun/harness@beta`.
 
-See [Examples](../examples/README.md) for complete agents and [CHANGELOG.md](./CHANGELOG.md) for
-release notes.
+Repository development: [contributing](../CONTRIBUTING.md). Package publication: [releasing](../RELEASING.md).

package/dist/build/assemble.js

@@ -27,6 +27,7 @@ export function assembleAgent(middleware, invoke, identity) {
                 id: item.id,
                 handle: item.handle,
                 ...(item.state === undefined ? {} : { state: item.state }),
+                ...(item.contributions === undefined ? {} : { contributions: item.contributions }),
             }));
         }
     }

package/dist/build/bind-tool.js

@@ -1,16 +1,17 @@
 import { HarnessError } from "../errors.js";
-import { normalizedSchemaFor } from "./schema.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 parameters = normalizedSchemaFor(item);
+    const schemas = normalizedSchemasFor(item);
     return Object.freeze({
         name: item.name,
         ...(item.description ? { description: item.description } : {}),
-        parameters: parameters,
+        inputSchema: schemas.inputSchema,
+        ...(schemas.outputSchema === undefined ? {} : { outputSchema: schemas.outputSchema }),
         execute: item.execute.bind(item),
         owner: Object.freeze({ ...owner }),
     });

package/dist/build/builder.js

@@ -99,6 +99,7 @@ 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);
@@ -114,8 +115,33 @@ function compileDeclaration(declaration) {
         ...(declaration.state === undefined
             ? {}
             : { state: declaration.state }),
+        ...(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;

package/dist/build/helpers.d.ts

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

package/dist/build/manifest.js

@@ -1,9 +1,20 @@
 import { deepFreeze } from "../utils/immutable.js";
 export function createManifest(input) {
-    const middleware = input.middleware.map(({ id }) => ({ id }));
+    const middleware = input.middleware.map((item) => projectMiddleware(item));
     return deepFreeze({
         id: input.id,
         name: input.name,
         middleware,
     });
 }
+function projectMiddleware(item) {
+    const contributions = item.contributions;
+    return {
+        id: item.id,
+        ...(contributions?.instructions === undefined
+            ? {}
+            : { instructions: contributions.instructions }),
+        ...(contributions?.tools === undefined ? {} : { tools: contributions.tools }),
+        ...(contributions?.model === undefined ? {} : { model: contributions.model }),
+    };
+}

package/dist/build/schema.d.ts

@@ -1,19 +1,14 @@
-import type { output } from "zod";
-import type { ToolDefinition, ToolObjectSchema } from "../types/tool.js";
-export type SchemaValidation<T> = {
-    readonly ok: true;
-    readonly value: T;
-} | {
-    readonly ok: false;
-    readonly issues: readonly string[];
-};
-export interface NormalizedToolSchema<T> {
-    readonly jsonSchema: import("../types/shared.js").JsonObject;
-    validate(value: unknown): SchemaValidation<T>;
+import type { BoundToolSchema, ToolDefinition, ToolSchema, ToolSchemaSource } from "../types/tool.js";
+export type { SchemaValidation } from "../types/tool.js";
+interface NormalizedToolSchemas {
+    readonly inputSchema: BoundToolSchema<unknown>;
+    readonly outputSchema?: BoundToolSchema<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 a cached normalized schema, preparing raw definitions on first bind. */
-export declare function normalizedSchemaFor(definition: ToolDefinition): NormalizedToolSchema<unknown>;
-/** Converts a synchronous Zod object schema into Harness's immutable runtime representation. */
-export declare function normalizeSchema<Parameters extends ToolObjectSchema>(parameters: Parameters): NormalizedToolSchema<output<Parameters>>;
+/** 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"): BoundToolSchema<T>;

package/dist/build/schema.js

@@ -2,56 +2,162 @@ 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) {
-    normalizedSchemaFor(definition);
+    normalizedSchemasFor(definition);
     return definition;
 }
-/** Returns a cached normalized schema, preparing raw definitions on first bind. */
-export function normalizedSchemaFor(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 = normalizeSchema(definition.parameters);
+    const normalized = Object.freeze({
+        inputSchema: normalizeSchema(definition.inputSchema, "input"),
+        ...(definition.outputSchema === undefined
+            ? {}
+            : { outputSchema: normalizeSchema(definition.outputSchema, "output") }),
+    });
     preparedSchemas.set(definition, normalized);
     return normalized;
 }
-/** Converts a synchronous Zod object schema into Harness's immutable runtime representation. */
-export function normalizeSchema(parameters) {
-    if (!(parameters instanceof z.ZodObject)) {
-        throw new HarnessError("tool.invalid-schema", "Tool parameters schema must be a Zod object schema");
-    }
-    if (hasDeclaredAsyncWork(parameters)) {
-        throw new HarnessError("tool.invalid-schema", "Tool parameters schema must validate synchronously");
-    }
+/** 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(parameters, { target: "draft-07" }), "tool.parameters.jsonSchema");
+        jsonSchema = copyJsonObject(z.toJSONSchema(source, { target: "draft-07" }), `tool.${role}Schema.jsonSchema`);
     }
     catch (error) {
-        throw new HarnessError("tool.invalid-schema", `Tool parameters schema must convert to JSON Schema: ${message(error)}`, { cause: error });
-    }
-    if (jsonSchema.type !== "object") {
-        throw new HarnessError("tool.invalid-schema", "Tool JSON Schema root type must be object");
+        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 = parameters.safeParse(value);
+                const result = source.safeParse(value);
                 if (result.success)
                     return { ok: true, value: result.data };
                 return {
                     ok: false,
-                    issues: result.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`),
+                    issues: Object.freeze(result.error.issues.map((entry) => issue(entry.path.filter(isPathSegment), entry.code, entry.message))),
                 };
             }
             catch (error) {
-                return { ok: false, issues: [synchronousIssue(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());
@@ -64,8 +170,6 @@ function visitDefinition(value, seen) {
     if (seen.has(value))
         return false;
     seen.add(value);
-    // Nested Zod schemas carry their own definition graph. Inspect it directly so public helpers
-    // such as `parseAsync` do not make every otherwise-synchronous schema look asynchronous.
     const nestedDefinition = value._zod?.def;
     if (nestedDefinition !== undefined && nestedDefinition !== value)
         return visitDefinition(nestedDefinition, seen);
@@ -75,6 +179,21 @@ function visitDefinition(value, seen) {
     }
     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")

package/dist/errors.d.ts

@@ -1,5 +1,5 @@
 /** Machine-readable error raised by Harness-owned code. */
-export type HarnessErrorCode = "agent.build-failed" | "agent.lifecycle-sealed" | "capability.state.create-failed" | "capability.state.undeclared" | "context.invalid-item" | "context.invalid-item-type" | "context.invalid-order" | "context.invalid-reason" | "context.invalid-slot" | "interaction.invalid" | "interaction.missing-resume" | "interaction.uncorrelated-resume" | "json.invalid-data" | "json.invalid-object" | "middleware.next-after-return" | "middleware.next-called-twice" | "middleware.request-mutators-revoked" | "model.candidate-missing" | "model.invalid-candidate" | "model.invalid-directive" | "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" | "session.invalid-seed" | "session.record-failed" | "session.stale-result" | "tool.invalid" | "tool.invalid-arguments" | "tool.invalid-name" | "tool.invalid-schema" | "tool.invalid-tool-result";
+export type HarnessErrorCode = "agent.build-failed" | "agent.lifecycle-sealed" | "capability.state.create-failed" | "capability.state.undeclared" | "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" | "session.invalid-seed" | "session.record-failed" | "session.stale-result" | "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;

package/dist/index.d.ts

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

package/dist/index.js

@@ -2,3 +2,5 @@ export { Agent, AgentBuilder, AgentBuildError, AgentLifecycleError, BoundAgentBu
 export { HarnessError, isHarnessError } from "./errors.js";
 export { BuiltAgent } from "./build/agent.js";
 export { middleware, model, tool } from "./build/helpers.js";
+export { defineSchema } from "./build/schema.js";
+export { preparedModel } from "./model/prepared.js";