@nylorun/harness 0.9.0-beta.1 → 0.11.1-beta

package/CHANGELOG.md

@@ -1,9 +1,69 @@
 # Changelog
 
+## 0.11.1-beta
+
+### Patch Changes
+
+- d27242c: Preserve opaque provider continuation metadata through assistant conversation history. Gemini tool calls now retain thought signatures when sending tool results back to the model, including signed empty text and reasoning blocks. Only the originating provider and model receive their signatures.
+
+## 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

package/README.md

@@ -1,84 +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();
-
-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.
+For installation, examples, API details, and release notes, see the
+[Nylorun Harness repository](https://github.com/nylorun/harness).
 
-See [Examples](../examples/README.md) for complete agents and [CHANGELOG.md](./CHANGELOG.md) for
-release notes.
-
-## Model adapter translators
-
-For OpenAI-compatible endpoints, keep transport and credentials in host code while Harness maps its
-canonical model call and candidate:
-
-```ts
-import { chatCompletionsAdapter } from "@nylorun/harness/model/adapters";
-
-const adapter = chatCompletionsAdapter(async (body, call, { signal }) => {
-  const response = await fetch("https://example.com/v1/chat/completions", {
-    method: "POST",
-    headers: { authorization: `Bearer ${apiKey}`, "content-type": "application/json" },
-    body: JSON.stringify({ model: "my-model", ...call.model?.config, ...body }),
-    signal,
-  });
-  if (!response.ok) throw new Error(await response.text());
-  return response.json();
-});
-```
-
-`toResponses` / `fromResponses` / `responsesAdapter` support direct OpenAI Responses transport.
-`toMessages` / `fromMessages` / `anthropicAdapter` support direct Anthropic Messages transport;
-`anthropicAdapter` requires an explicit `defaultMaxOutputTokens`. These translators support text and
-JSON tool loops only. Provider-native continuation state, streaming, images, and cache controls stay
-in application integrations.
-
-```ts
-const responses = responsesAdapter((body, call, { signal }) =>
-  openai.responses.create({ model: "gpt-5.6", ...call.model?.config, ...body }, { signal }),
-);
+> **Experimental beta.** Install with `npm install @nylorun/harness@beta`.
 
-const messages = anthropicAdapter({
-  defaultMaxOutputTokens: 1_024,
-  send: (body, call, { signal }) =>
-    anthropic.messages.create(
-      { model: "claude-sonnet-4-5", ...call.model?.config, ...body },
-      { signal },
-    ),
-});
-```
+Repository development: [contributing](../CONTRIBUTING.md). Package publication: [releasing](../RELEASING.md).

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/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/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.adapter-invalid-options" | "model.adapter-invalid-response" | "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 { 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, ContextContributor, ContextMutationOptions, ContextSnapshot, ModelCall, ModelCallTool, ModelOutputBlock, PromptContentPart, PromptItem, ModelConfigurationContributor, ModelConfigurationInstruction, ModelConfigurationMutationOptions, ModelConfigurationSnapshot, ModelConfigurationTool, ModelRequest, ModelToolCall, ModelUsage, } from "./types/model.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";

package/dist/model/adapters.d.ts

@@ -1,8 +1,11 @@
 import type { ModelAdapter, ModelAdapterContext, ModelCall, ModelCandidate } from "../types/model.js";
 import type { JsonObject } from "../types/shared.js";
 export type ChatCompletionsMessage = {
-    readonly role: "system" | "user";
+    readonly role: "system";
     readonly content: string;
+} | {
+    readonly role: "user";
+    readonly content: string | readonly ChatCompletionsContentPart[];
 } | {
     readonly role: "assistant";
     readonly content: string | null;
@@ -12,6 +15,15 @@ export type ChatCompletionsMessage = {
     readonly tool_call_id: string;
     readonly content: string;
 };
+export type ChatCompletionsContentPart = {
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: "image_url";
+    readonly image_url: Readonly<{
+        url: string;
+    }>;
+};
 export interface ChatCompletionsToolCall {
     readonly id: string;
     readonly type: "function";
@@ -32,6 +44,13 @@ export interface ChatCompletionsRequest {
     }>[];
     readonly temperature?: number;
     readonly max_completion_tokens?: number;
+    readonly response_format?: Readonly<{
+        type: "json_schema";
+        json_schema: Readonly<{
+            name: string;
+            schema: JsonObject;
+        }>;
+    }>;
 }
 export interface ResponsesRequest {
     readonly instructions?: string;
@@ -44,11 +63,18 @@ export interface ResponsesRequest {
     }>[];
     readonly temperature?: number;
     readonly max_output_tokens?: number;
+    readonly text?: Readonly<{
+        format: Readonly<{
+            type: "json_schema";
+            name: string;
+            schema: JsonObject;
+        }>;
+    }>;
 }
 export type ResponsesInputItem = {
     readonly type: "message";
     readonly role: "user" | "assistant";
-    readonly content: string;
+    readonly content: string | readonly ResponsesContentPart[];
 } | {
     readonly type: "function_call";
     readonly call_id: string;
@@ -59,6 +85,13 @@ export type ResponsesInputItem = {
     readonly call_id: string;
     readonly output: string;
 };
+export type ResponsesContentPart = {
+    readonly type: "input_text";
+    readonly text: string;
+} | {
+    readonly type: "input_image";
+    readonly image_url: string;
+};
 export interface MessagesRequest {
     readonly system?: string;
     readonly messages: readonly MessagesMessage[];
@@ -72,7 +105,7 @@ export interface MessagesRequest {
 }
 export type MessagesMessage = {
     readonly role: "user";
-    readonly content: string | readonly MessagesToolResult[];
+    readonly content: string | readonly (MessagesToolResult | MessagesUserContentPart)[];
 } | {
     readonly role: "assistant";
     readonly content: readonly MessagesAssistantPart[];
@@ -92,6 +125,16 @@ export interface MessagesToolResult {
     readonly content: string;
     readonly is_error?: boolean;
 }
+export type MessagesUserContentPart = {
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: "image";
+    readonly source: Readonly<{
+        type: "url";
+        url: string;
+    }>;
+};
 export type AdapterSend<Request> = (request: Request, call: ModelCall, context: ModelAdapterContext) => Promise<unknown>;
 export interface AnthropicAdapterOptions {
     readonly defaultMaxOutputTokens: number;
@@ -100,13 +143,13 @@ export interface AnthropicAdapterOptions {
 /** Translate a Harness call to the OpenAI Chat Completions request shape. */
 export declare function toChatCompletions(call: ModelCall): ChatCompletionsRequest;
 /** Translate a Chat Completions response into a Harness candidate. */
-export declare function fromChatCompletions(value: unknown): ModelCandidate;
+export declare function fromChatCompletions(value: unknown, call?: Pick<ModelCall, "outputSchema">): ModelCandidate;
 /** Return a Harness adapter backed by an application-owned Chat Completions send function. */
 export declare function chatCompletionsAdapter(send: AdapterSend<ChatCompletionsRequest>): ModelAdapter;
 /** Translate a Harness call to the OpenAI Responses request shape. */
 export declare function toResponses(call: ModelCall): ResponsesRequest;
 /** Translate an OpenAI Responses response into a Harness candidate. */
-export declare function fromResponses(value: unknown): ModelCandidate;
+export declare function fromResponses(value: unknown, call?: Pick<ModelCall, "outputSchema">): ModelCandidate;
 /** Return a Harness adapter backed by an application-owned Responses send function. */
 export declare function responsesAdapter(send: AdapterSend<ResponsesRequest>): ModelAdapter;
 /** Translate a Harness call to the Anthropic Messages request shape. */