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

package/CHANGELOG.md

@@ -4,6 +4,32 @@ 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.
 
+## [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
+
+- `Agent()` now takes identity options instead of a model adapter. Migrate
+  `Agent(adapter).use(...).build()` to
+  `Agent({ id, name, instructions }).use(...).with(adapter).build()`.
+- `.build()` exists only on `BoundAgentBuilder`, the type returned by a single `.with(onModelCall)`.
+  `AgentBuilder` has `.use()` and `.with()` only.
+- `AgentManifest` now includes `id` and `name`. Built agents expose the same fields as `agent.id`
+  and `agent.name`.
+
+### Added
+
+- Optional constructor `instructions` compile as reserved `agent` middleware. A string is
+  normalized to one instruction. Capability-specific instructions still go through `.use()`.
+
 ## [0.7.0-beta.1] - 2026-08-30
 
 ### Breaking changes
@@ -75,3 +101,5 @@ The project follows [Semantic Versioning](https://semver.org/). Before 1.0, the
 [0.5.0-beta.1]: https://github.com/nylorun/harness/tree/main/harness
 [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

@@ -18,8 +18,13 @@ const echo = tool({
   execute: async ({ text }) => ({ kind: "completed", output: text }),
 });
 
-const agent = Agent(adapter)
-  .use({ id: "echo", instructions: ["Use echo when asked."], tools: [echo] })
+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;
@@ -36,3 +41,44 @@ const result = await agent.run().input("Echo hello").completed;
 
 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 }),
+);
+
+const messages = anthropicAdapter({
+  defaultMaxOutputTokens: 1_024,
+  send: (body, call, { signal }) =>
+    anthropic.messages.create(
+      { model: "claude-sonnet-4-5", ...call.model?.config, ...body },
+      { signal },
+    ),
+});
+```

package/dist/build/agent.d.ts

@@ -10,6 +10,8 @@ export declare class BuiltAgent {
     #private;
     readonly middleware: readonly BoundMiddleware[];
     readonly manifest: AgentManifest;
+    readonly id: string;
+    readonly name: string;
     private constructor();
     run(options?: SessionRunOptions): Session;
 }

package/dist/build/agent.js

@@ -5,10 +5,14 @@ let createBoundAgent;
 export class BuiltAgent {
     middleware;
     manifest;
+    id;
+    name;
     #loopAgent;
     constructor(middleware, invoke, manifest) {
         this.middleware = middleware;
         this.manifest = manifest;
+        this.id = manifest.id;
+        this.name = manifest.name;
         this.#loopAgent = Object.freeze({
             middleware,
             invoke,

package/dist/build/assemble.d.ts

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

package/dist/build/assemble.js

@@ -1,8 +1,14 @@
 import { bindAgent } from "./agent.js";
 import { createManifest } from "./manifest.js";
 const diagnostic = (code, message, extra = {}) => Object.freeze({ code, message, ...extra });
-export function assembleAgent(middleware, invoke) {
+export function assembleAgent(middleware, invoke, identity) {
     const diagnostics = [];
+    if (typeof identity.id !== "string" || identity.id.length === 0) {
+        diagnostics.push(diagnostic("agent.invalid-id", "Agent id must be a non-empty string"));
+    }
+    if (typeof identity.name !== "string" || identity.name.length === 0) {
+        diagnostics.push(diagnostic("agent.invalid-name", "Agent name must be a non-empty string"));
+    }
     if (typeof invoke !== "function") {
         diagnostics.push(diagnostic("harness.invalid-model", "A model invoke function is required"));
     }
@@ -21,13 +27,18 @@ export function assembleAgent(middleware, invoke) {
                 id: item.id,
                 handle: item.handle,
                 ...(item.state === undefined ? {} : { state: item.state }),
+                ...(item.contributions === undefined ? {} : { contributions: item.contributions }),
             }));
         }
     }
     if (diagnostics.length)
         return Object.freeze({ ok: false, diagnostics: Object.freeze(diagnostics) });
     const frozenMiddleware = Object.freeze(frozen);
-    const manifest = createManifest({ middleware: frozenMiddleware });
+    const manifest = createManifest({
+        id: identity.id,
+        name: identity.name,
+        middleware: frozenMiddleware,
+    });
     const agent = bindAgent(frozenMiddleware, invoke, manifest);
     return Object.freeze({ ok: true, agent, manifest });
 }

package/dist/build/builder.d.ts

@@ -1,8 +1,24 @@
-import type { CapabilityDeclaration, StepMiddleware } from "../types/middleware.js";
+import type { BoundMiddleware, CapabilityDeclaration, StepMiddleware } from "../types/middleware.js";
 import type { ModelAdapter } from "../types/model.js";
 import type { BuildDiagnostic } from "../types/shared.js";
 import { HarnessError } from "../errors.js";
 import type { BuiltAgent } from "./agent.js";
+export interface AgentOptions {
+    readonly id: string;
+    readonly name: string;
+    readonly instructions?: string | readonly string[];
+}
+interface BuilderState {
+    readonly id: string;
+    readonly name: string;
+    readonly middleware: BoundMiddleware[];
+    invoke?: ModelAdapter;
+    bound: boolean;
+    sealed: boolean;
+    agent?: BuiltAgent;
+    error?: AgentBuildError;
+    middlewareSeq: number;
+}
 export declare class AgentBuildError extends HarnessError {
     readonly diagnostics: readonly BuildDiagnostic[];
     constructor(diagnostics: readonly BuildDiagnostic[]);
@@ -10,19 +26,21 @@ export declare class AgentBuildError extends HarnessError {
 export declare class AgentLifecycleError extends HarnessError {
     constructor(message: string);
 }
-export declare function Agent(model: ModelAdapter): AgentBuilder;
+export declare function Agent(options: AgentOptions): AgentBuilder;
 export declare class AgentBuilder {
-    private readonly invoke;
-    private readonly middleware;
-    private sealed;
-    private agent?;
-    private error?;
-    private middlewareSeq;
-    constructor(invoke: ModelAdapter);
+    private readonly state;
+    constructor(state: BuilderState);
     use(middleware: StepMiddleware): this;
     use(id: string, middleware: StepMiddleware): this;
     use<State>(declaration: CapabilityDeclaration<State>): this;
-    build(): BuiltAgent;
+    with(onModelCall: ModelAdapter): BoundAgentBuilder;
     private nextMiddlewareId;
     private push;
+    private assertOpen;
+}
+export declare class BoundAgentBuilder {
+    private readonly state;
+    constructor(state: BuilderState);
+    build(): BuiltAgent;
 }
+export {};

package/dist/build/builder.js

@@ -14,18 +14,13 @@ export class AgentLifecycleError extends HarnessError {
         this.name = "AgentLifecycleError";
     }
 }
-export function Agent(model) {
-    return new AgentBuilder(model);
+export function Agent(options) {
+    return new AgentBuilder(createState(options));
 }
 export class AgentBuilder {
-    invoke;
-    middleware = [];
-    sealed = false;
-    agent;
-    error;
-    middlewareSeq = 0;
-    constructor(invoke) {
-        this.invoke = invoke;
+    state;
+    constructor(state) {
+        this.state = state;
     }
     use(idOrMiddleware, middleware) {
         if (typeof idOrMiddleware === "function") {
@@ -35,40 +30,76 @@ export class AgentBuilder {
             return this.push(compileDeclaration(idOrMiddleware));
         return this.push({ id: idOrMiddleware, handle: middleware });
     }
-    build() {
-        if (this.agent)
-            return this.agent;
-        if (this.error)
-            throw this.error;
-        this.sealed = true;
-        const result = assembleAgent(this.middleware, this.invoke);
-        if (!result.ok) {
-            this.error = new AgentBuildError(result.diagnostics);
-            throw this.error;
-        }
-        this.agent = result.agent;
-        return this.agent;
+    with(onModelCall) {
+        this.assertOpen("with()");
+        this.state.bound = true;
+        this.state.invoke = onModelCall;
+        return new BoundAgentBuilder(this.state);
     }
     nextMiddlewareId() {
-        const taken = new Set(this.middleware.map((item) => item.id));
+        const taken = new Set(this.state.middleware.map((item) => item.id));
         let id;
         do {
-            this.middlewareSeq += 1;
-            id = `middleware-${this.middlewareSeq}`;
+            this.state.middlewareSeq += 1;
+            id = `middleware-${this.state.middlewareSeq}`;
         } while (taken.has(id));
         return id;
     }
     push(entry) {
-        if (this.sealed)
-            throw new AgentLifecycleError("AgentBuilder cannot be changed after build()");
-        this.middleware.push(entry);
+        this.assertOpen("build()");
+        this.state.middleware.push(entry);
         return this;
     }
+    assertOpen(after) {
+        if (this.state.bound)
+            throw new AgentLifecycleError("AgentBuilder cannot be changed after with()");
+        if (this.state.sealed)
+            throw new AgentLifecycleError(`AgentBuilder cannot be changed after ${after}`);
+    }
+}
+export class BoundAgentBuilder {
+    state;
+    constructor(state) {
+        this.state = state;
+    }
+    build() {
+        if (this.state.agent)
+            return this.state.agent;
+        if (this.state.error)
+            throw this.state.error;
+        this.state.sealed = true;
+        const result = assembleAgent(this.state.middleware, this.state.invoke, {
+            id: this.state.id,
+            name: this.state.name,
+        });
+        if (!result.ok) {
+            this.state.error = new AgentBuildError(result.diagnostics);
+            throw this.state.error;
+        }
+        this.state.agent = result.agent;
+        return this.state.agent;
+    }
+}
+function createState(options) {
+    const middleware = [];
+    if (options.instructions !== undefined) {
+        const instructions = typeof options.instructions === "string" ? [options.instructions] : options.instructions;
+        middleware.push(compileDeclaration({ id: "agent", instructions }));
+    }
+    return {
+        id: options.id,
+        name: options.name,
+        middleware,
+        bound: false,
+        sealed: false,
+        middlewareSeq: 0,
+    };
 }
 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);
@@ -84,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/manifest.d.ts

@@ -1,5 +1,7 @@
 import type { AgentManifest } from "../types/manifest.js";
 import type { BoundMiddleware } from "../types/middleware.js";
 export declare function createManifest(input: {
+    id: string;
+    name: string;
     middleware: readonly BoundMiddleware[];
 }): AgentManifest;

package/dist/build/manifest.js

@@ -1,7 +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/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" | "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 HarnessErrorDetails = Readonly<Record<string, string | number | boolean>>;
 export interface HarnessErrorOptions {
     readonly cause?: unknown;

package/dist/index.d.ts

@@ -1,11 +1,12 @@
-export { Agent, AgentBuilder, AgentBuildError, AgentLifecycleError } from "./build/builder.js";
+export { Agent, AgentBuilder, AgentBuildError, AgentLifecycleError, BoundAgentBuilder, } from "./build/builder.js";
+export type { AgentOptions } from "./build/builder.js";
 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 { 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 { BoundMiddleware, CapabilityDeclaration, CapabilityItems, CapabilityState, StepInput, StepMiddleware, StepRequest, StepResponse, } from "./types/middleware.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";

package/dist/index.js

@@ -1,4 +1,4 @@
-export { Agent, AgentBuilder, AgentBuildError, AgentLifecycleError } from "./build/builder.js";
+export { Agent, AgentBuilder, AgentBuildError, AgentLifecycleError, BoundAgentBuilder, } from "./build/builder.js";
 export { HarnessError, isHarnessError } from "./errors.js";
 export { BuiltAgent } from "./build/agent.js";
 export { middleware, model, tool } from "./build/helpers.js";

package/dist/model/adapters.d.ts

@@ -0,0 +1,117 @@
+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 content: string;
+} | {
+    readonly role: "assistant";
+    readonly content: string | null;
+    readonly tool_calls?: readonly ChatCompletionsToolCall[];
+} | {
+    readonly role: "tool";
+    readonly tool_call_id: string;
+    readonly content: string;
+};
+export interface ChatCompletionsToolCall {
+    readonly id: string;
+    readonly type: "function";
+    readonly function: Readonly<{
+        name: string;
+        arguments: string;
+    }>;
+}
+export interface ChatCompletionsRequest {
+    readonly messages: readonly ChatCompletionsMessage[];
+    readonly tools?: readonly Readonly<{
+        type: "function";
+        function: Readonly<{
+            name: string;
+            description?: string;
+            parameters: JsonObject;
+        }>;
+    }>[];
+    readonly temperature?: number;
+    readonly max_completion_tokens?: number;
+}
+export interface ResponsesRequest {
+    readonly instructions?: string;
+    readonly input: readonly ResponsesInputItem[];
+    readonly tools?: readonly Readonly<{
+        type: "function";
+        name: string;
+        description?: string;
+        parameters: JsonObject;
+    }>[];
+    readonly temperature?: number;
+    readonly max_output_tokens?: number;
+}
+export type ResponsesInputItem = {
+    readonly type: "message";
+    readonly role: "user" | "assistant";
+    readonly content: string;
+} | {
+    readonly type: "function_call";
+    readonly call_id: string;
+    readonly name: string;
+    readonly arguments: string;
+} | {
+    readonly type: "function_call_output";
+    readonly call_id: string;
+    readonly output: string;
+};
+export interface MessagesRequest {
+    readonly system?: string;
+    readonly messages: readonly MessagesMessage[];
+    readonly tools?: readonly Readonly<{
+        name: string;
+        description?: string;
+        input_schema: JsonObject;
+    }>[];
+    readonly temperature?: number;
+    readonly max_tokens: number;
+}
+export type MessagesMessage = {
+    readonly role: "user";
+    readonly content: string | readonly MessagesToolResult[];
+} | {
+    readonly role: "assistant";
+    readonly content: readonly MessagesAssistantPart[];
+};
+export type MessagesAssistantPart = {
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: "tool_use";
+    readonly id: string;
+    readonly name: string;
+    readonly input: JsonObject;
+};
+export interface MessagesToolResult {
+    readonly type: "tool_result";
+    readonly tool_use_id: string;
+    readonly content: string;
+    readonly is_error?: boolean;
+}
+export type AdapterSend<Request> = (request: Request, call: ModelCall, context: ModelAdapterContext) => Promise<unknown>;
+export interface AnthropicAdapterOptions {
+    readonly defaultMaxOutputTokens: number;
+    readonly send: AdapterSend<MessagesRequest>;
+}
+/** 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;
+/** 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;
+/** 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. */
+export declare function toMessages(call: ModelCall, defaultMaxOutputTokens: number): MessagesRequest;
+/** Translate an Anthropic Messages response into a Harness candidate. */
+export declare function fromMessages(value: unknown): ModelCandidate;
+/** Return a Harness adapter backed by an application-owned Anthropic Messages send function. */
+export declare function anthropicAdapter(options: AnthropicAdapterOptions): ModelAdapter;

package/dist/model/adapters.js

@@ -0,0 +1,431 @@
+import { HarnessError } from "../errors.js";
+import { copyJsonObject } from "../utils/immutable.js";
+/** Translate a Harness call to the OpenAI Chat Completions request shape. */
+export function toChatCompletions(call) {
+    const messages = call.prompt.map((item) => {
+        if (item.kind === "instructions")
+            return { role: "system", content: textOf(item) };
+        if (item.kind === "tool-result")
+            return { role: "tool", tool_call_id: item.toolCallId, content: textOf(item) };
+        if (item.kind === "message" && item.role === "assistant") {
+            const toolCalls = toolCallsOf(item.content).map((part) => ({
+                id: part.id,
+                type: "function",
+                function: { name: part.name, arguments: JSON.stringify(part.args) },
+            }));
+            const text = textOf(item);
+            return {
+                role: "assistant",
+                content: text === "" ? null : text,
+                ...(toolCalls.length === 0 ? {} : { tool_calls: toolCalls }),
+            };
+        }
+        return { role: "user", content: textOf(item) };
+    });
+    return {
+        messages,
+        ...(call.tools.length === 0
+            ? {}
+            : {
+                tools: call.tools.map((tool) => ({
+                    type: "function",
+                    function: {
+                        name: tool.name,
+                        ...(tool.description === undefined ? {} : { description: tool.description }),
+                        parameters: tool.inputSchema,
+                    },
+                })),
+            }),
+        ...chatControls(call),
+    };
+}
+/** Translate a Chat Completions response into a Harness candidate. */
+export function fromChatCompletions(value) {
+    const response = record(value, "response");
+    const choices = array(response.choices, "response.choices");
+    if (choices.length === 0)
+        throw invalidResponse("response.choices must contain a choice", "response.choices");
+    const choice = record(choices[0], "response.choices[0]");
+    const message = record(choice.message, "response.choices[0].message");
+    const output = [];
+    if (typeof message.content === "string" && message.content !== "")
+        output.push({ type: "text", text: message.content });
+    if (typeof message.reasoning_content === "string" && message.reasoning_content !== "")
+        output.push({ type: "reasoning", text: message.reasoning_content });
+    for (const [index, raw] of optionalArray(message.tool_calls, "response.choices[0].message.tool_calls").entries()) {
+        const call = record(raw, `response.choices[0].message.tool_calls[${index}]`);
+        const fn = record(call.function, `response.choices[0].message.tool_calls[${index}].function`);
+        output.push({
+            type: "tool-call",
+            id: string(call.id, `response.choices[0].message.tool_calls[${index}].id`),
+            name: string(fn.name, `response.choices[0].message.tool_calls[${index}].function.name`),
+            ...argumentsOf(fn.arguments, `response.choices[0].message.tool_calls[${index}].function.arguments`),
+        });
+    }
+    return candidate({
+        output,
+        finishReason: chatFinishReason(choice.finish_reason, output),
+        usage: chatUsage(response.usage),
+        evidence: evidence(response),
+    });
+}
+/** Return a Harness adapter backed by an application-owned Chat Completions send function. */
+export function chatCompletionsAdapter(send) {
+    return async (call, context) => fromChatCompletions(await send(toChatCompletions(call), call, context));
+}
+/** Translate a Harness call to the OpenAI Responses request shape. */
+export function toResponses(call) {
+    const instructions = call.prompt.filter((item) => item.kind === "instructions").map(textOf);
+    const input = call.prompt.flatMap((item) => {
+        if (item.kind === "instructions")
+            return [];
+        if (item.kind === "tool-result")
+            return [{ type: "function_call_output", call_id: item.toolCallId, output: textOf(item) }];
+        if (item.kind === "message" && item.role === "assistant") {
+            const text = textOf(item);
+            return [
+                ...(text === ""
+                    ? []
+                    : [{ type: "message", role: "assistant", content: text }]),
+                ...toolCallsOf(item.content).map((part) => ({
+                    type: "function_call",
+                    call_id: part.id,
+                    name: part.name,
+                    arguments: JSON.stringify(part.args),
+                })),
+            ];
+        }
+        return [{ type: "message", role: "user", content: textOf(item) }];
+    });
+    return {
+        ...(instructions.length === 0 ? {} : { instructions: instructions.join("\n\n") }),
+        input,
+        ...(call.tools.length === 0
+            ? {}
+            : {
+                tools: call.tools.map((tool) => ({
+                    type: "function",
+                    name: tool.name,
+                    ...(tool.description === undefined ? {} : { description: tool.description }),
+                    parameters: tool.inputSchema,
+                })),
+            }),
+        ...responsesControls(call),
+    };
+}
+/** Translate an OpenAI Responses response into a Harness candidate. */
+export function fromResponses(value) {
+    const response = record(value, "response");
+    if (response.error !== undefined && response.error !== null)
+        throw invalidResponse("response.error is present", "response.error");
+    const output = [];
+    for (const [index, raw] of array(response.output, "response.output").entries()) {
+        const item = record(raw, `response.output[${index}]`);
+        if (item.type === "function_call") {
+            output.push({
+                type: "tool-call",
+                id: string(item.call_id, `response.output[${index}].call_id`),
+                name: string(item.name, `response.output[${index}].name`),
+                ...argumentsOf(item.arguments, `response.output[${index}].arguments`),
+            });
+            continue;
+        }
+        if (item.type === "message") {
+            for (const [partIndex, rawPart] of optionalArray(item.content, `response.output[${index}].content`).entries()) {
+                const part = record(rawPart, `response.output[${index}].content[${partIndex}]`);
+                if (part.type === "output_text" && typeof part.text === "string")
+                    output.push({ type: "text", text: part.text });
+            }
+            continue;
+        }
+        if (item.type === "reasoning") {
+            const summary = optionalArray(item.summary, `response.output[${index}].summary`)
+                .map((rawPart, partIndex) => record(rawPart, `response.output[${index}].summary[${partIndex}]`))
+                .filter((part) => part.type === "summary_text" && typeof part.text === "string")
+                .map((part) => part.text)
+                .join("\n");
+            if (summary !== "")
+                output.push({ type: "reasoning", text: summary });
+        }
+    }
+    return candidate({
+        output,
+        finishReason: responsesFinishReason(response, output),
+        usage: responsesUsage(response.usage),
+        evidence: evidence(response),
+    });
+}
+/** Return a Harness adapter backed by an application-owned Responses send function. */
+export function responsesAdapter(send) {
+    return async (call, context) => fromResponses(await send(toResponses(call), call, context));
+}
+/** Translate a Harness call to the Anthropic Messages request shape. */
+export function toMessages(call, defaultMaxOutputTokens) {
+    checkedMaxOutputTokens(defaultMaxOutputTokens);
+    const instructions = call.prompt.filter((item) => item.kind === "instructions").map(textOf);
+    const messages = call.prompt.flatMap((item) => {
+        if (item.kind === "instructions")
+            return [];
+        if (item.kind === "tool-result")
+            return [
+                {
+                    role: "user",
+                    content: [
+                        {
+                            type: "tool_result",
+                            tool_use_id: item.toolCallId,
+                            content: textOf(item),
+                            ...(item.status === "completed" ? {} : { is_error: true }),
+                        },
+                    ],
+                },
+            ];
+        if (item.kind === "message" && item.role === "assistant")
+            return [
+                {
+                    role: "assistant",
+                    content: item.content.map((part) => part.type === "text"
+                        ? { type: "text", text: part.text }
+                        : { type: "tool_use", id: part.id, name: part.name, input: part.args }),
+                },
+            ];
+        return [{ role: "user", content: textOf(item) }];
+    });
+    return {
+        ...(instructions.length === 0 ? {} : { system: instructions.join("\n\n") }),
+        messages,
+        ...(call.tools.length === 0
+            ? {}
+            : {
+                tools: call.tools.map((tool) => ({
+                    name: tool.name,
+                    ...(tool.description === undefined ? {} : { description: tool.description }),
+                    input_schema: tool.inputSchema,
+                })),
+            }),
+        ...(call.model?.controls?.temperature === undefined
+            ? {}
+            : { temperature: call.model.controls.temperature }),
+        max_tokens: call.model?.controls?.maxOutputTokens ?? defaultMaxOutputTokens,
+    };
+}
+/** Translate an Anthropic Messages response into a Harness candidate. */
+export function fromMessages(value) {
+    const response = record(value, "response");
+    const output = [];
+    for (const [index, raw] of array(response.content, "response.content").entries()) {
+        const part = record(raw, `response.content[${index}]`);
+        if (part.type === "text" && typeof part.text === "string") {
+            output.push({ type: "text", text: part.text });
+            continue;
+        }
+        if (part.type === "thinking" && typeof part.thinking === "string") {
+            output.push({ type: "reasoning", text: part.thinking });
+            continue;
+        }
+        if (part.type === "tool_use") {
+            output.push({
+                type: "tool-call",
+                id: string(part.id, `response.content[${index}].id`),
+                name: string(part.name, `response.content[${index}].name`),
+                args: jsonObject(part.input, `response.content[${index}].input`),
+            });
+        }
+    }
+    return candidate({
+        output,
+        finishReason: messagesFinishReason(response.stop_reason, output),
+        usage: messagesUsage(response.usage),
+        evidence: evidence(response),
+    });
+}
+/** Return a Harness adapter backed by an application-owned Anthropic Messages send function. */
+export function anthropicAdapter(options) {
+    checkedMaxOutputTokens(options.defaultMaxOutputTokens);
+    return async (call, context) => fromMessages(await options.send(toMessages(call, options.defaultMaxOutputTokens), call, context));
+}
+function textOf(item) {
+    return item.content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("");
+}
+function toolCallsOf(parts) {
+    return parts.filter((part) => part.type === "tool-call");
+}
+function chatControls(call) {
+    return {
+        ...(call.model?.controls?.temperature === undefined
+            ? {}
+            : { temperature: call.model.controls.temperature }),
+        ...(call.model?.controls?.maxOutputTokens === undefined
+            ? {}
+            : { max_completion_tokens: call.model.controls.maxOutputTokens }),
+    };
+}
+function responsesControls(call) {
+    return {
+        ...(call.model?.controls?.temperature === undefined
+            ? {}
+            : { temperature: call.model.controls.temperature }),
+        ...(call.model?.controls?.maxOutputTokens === undefined
+            ? {}
+            : { max_output_tokens: call.model.controls.maxOutputTokens }),
+    };
+}
+function argumentsOf(value, path) {
+    const raw = string(value, path);
+    try {
+        return { args: jsonObject(JSON.parse(raw), path), raw };
+    }
+    catch (error) {
+        throw invalidResponse(`${path} must be a JSON object`, path, error);
+    }
+}
+function jsonObject(value, path) {
+    try {
+        return copyJsonObject(value, path);
+    }
+    catch (error) {
+        throw invalidResponse(`${path} must be a JSON object`, path, error);
+    }
+}
+function candidate(value) {
+    return {
+        output: value.output,
+        ...(value.finishReason === undefined ? {} : { finishReason: value.finishReason }),
+        ...(value.usage === undefined ? {} : { usage: value.usage }),
+        ...(value.evidence === undefined ? {} : { evidence: value.evidence }),
+    };
+}
+function chatFinishReason(value, output) {
+    if (value === "tool_calls" || value === "function_call")
+        return "tool-calls";
+    if (value === "length")
+        return "length";
+    if (value === "content_filter")
+        return "content-filter";
+    if (value === "stop" || value === null || value === undefined)
+        return hasToolCall(output) ? "tool-calls" : "stop";
+    return "other";
+}
+function responsesFinishReason(response, output) {
+    if (response.status === "incomplete") {
+        const details = response.incomplete_details === undefined
+            ? undefined
+            : record(response.incomplete_details, "response.incomplete_details");
+        return details?.reason === "max_output_tokens" ? "length" : "other";
+    }
+    if (response.status === "failed" || response.status === "cancelled")
+        throw invalidResponse(`response.status is ${String(response.status)}`, "response.status");
+    return hasToolCall(output) ? "tool-calls" : "stop";
+}
+function messagesFinishReason(value, output) {
+    if (value === "tool_use")
+        return "tool-calls";
+    if (value === "max_tokens")
+        return "length";
+    if (value === "end_turn" || value === "stop_sequence" || value === undefined || value === null)
+        return hasToolCall(output) ? "tool-calls" : "stop";
+    return "other";
+}
+function chatUsage(value) {
+    const usage = optionalRecord(value, "response.usage");
+    if (usage === undefined)
+        return undefined;
+    return usageOf({
+        inputTokens: usage.prompt_tokens,
+        outputTokens: usage.completion_tokens,
+        totalTokens: usage.total_tokens,
+        cachedTokens: optionalRecord(usage.prompt_tokens_details, "response.usage.prompt_tokens_details")?.cached_tokens,
+        reasoningTokens: optionalRecord(usage.completion_tokens_details, "response.usage.completion_tokens_details")?.reasoning_tokens,
+    }, "response.usage");
+}
+function responsesUsage(value) {
+    const usage = optionalRecord(value, "response.usage");
+    if (usage === undefined)
+        return undefined;
+    return usageOf({
+        inputTokens: usage.input_tokens,
+        outputTokens: usage.output_tokens,
+        totalTokens: usage.total_tokens,
+        cachedTokens: optionalRecord(usage.input_tokens_details, "response.usage.input_tokens_details")?.cached_tokens,
+        reasoningTokens: optionalRecord(usage.output_tokens_details, "response.usage.output_tokens_details")?.reasoning_tokens,
+    }, "response.usage");
+}
+function messagesUsage(value) {
+    const usage = optionalRecord(value, "response.usage");
+    if (usage === undefined)
+        return undefined;
+    return usageOf({
+        inputTokens: usage.input_tokens,
+        outputTokens: usage.output_tokens,
+        cachedTokens: usage.cache_read_input_tokens,
+    }, "response.usage");
+}
+function usageOf(value, path) {
+    const fields = Object.entries(value).flatMap(([key, raw]) => {
+        if (raw === undefined)
+            return [];
+        if (!isNonNegativeInteger(raw))
+            throw invalidResponse(`${path}.${key} must be a non-negative integer`, `${path}.${key}`);
+        return [[key, raw]];
+    });
+    return Object.fromEntries(fields);
+}
+function evidence(response) {
+    const requestId = optionalString(response.id, "response.id");
+    const resolvedModel = optionalString(response.model, "response.model");
+    return requestId === undefined && resolvedModel === undefined
+        ? undefined
+        : {
+            ...(requestId === undefined ? {} : { requestId }),
+            ...(resolvedModel === undefined ? {} : { resolvedModel }),
+        };
+}
+function record(value, path) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw invalidResponse(`${path} must be an object`, path);
+    return value;
+}
+function optionalRecord(value, path) {
+    return value === undefined || value === null ? undefined : record(value, path);
+}
+function array(value, path) {
+    if (!Array.isArray(value))
+        throw invalidResponse(`${path} must be an array`, path);
+    return value;
+}
+function optionalArray(value, path) {
+    if (value === undefined || value === null)
+        return [];
+    if (!Array.isArray(value))
+        throw invalidResponse(`${path} must be an array`, path);
+    return value;
+}
+function string(value, path) {
+    if (typeof value !== "string")
+        throw invalidResponse(`${path} must be a string`, path);
+    return value;
+}
+function optionalString(value, path) {
+    if (value === undefined || value === null)
+        return undefined;
+    return string(value, path);
+}
+function checkedMaxOutputTokens(value) {
+    if (!isNonNegativeInteger(value))
+        throw new HarnessError("model.adapter-invalid-options", "Anthropic defaultMaxOutputTokens must be a non-negative integer", { details: { path: "defaultMaxOutputTokens" } });
+}
+function isNonNegativeInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function hasToolCall(output) {
+    return output.some((part) => part.type === "tool-call");
+}
+function invalidResponse(message, path, cause) {
+    return new HarnessError("model.adapter-invalid-response", message, {
+        ...(cause === undefined ? {} : { cause }),
+        details: { path },
+    });
+}

package/dist/{model-normalize.d.ts → model/normalize.d.ts}

@@ -1,5 +1,5 @@
-import { HarnessError } from "./errors.js";
-import type { ModelCandidate, ModelDirective, ModelOutputBlock } from "./types/model.js";
+import { HarnessError } from "../errors.js";
+import type { ModelCandidate, ModelDirective, ModelOutputBlock } from "../types/model.js";
 export declare function normalizeDirective(value: unknown): ModelDirective | HarnessError;
 export declare function sameDirective(left: ModelDirective, right: ModelDirective): boolean;
 export declare function textFromOutput(output: readonly ModelOutputBlock[]): string;

package/dist/{model-normalize.js → model/normalize.js}

@@ -1,6 +1,6 @@
-import { HarnessError, isHarnessError } from "./errors.js";
-import { digest } from "./utils/digest.js";
-import { copyJsonObject } from "./utils/immutable.js";
+import { HarnessError, isHarnessError } from "../errors.js";
+import { digest } from "../utils/digest.js";
+import { copyJsonObject } from "../utils/immutable.js";
 const FINISH_REASONS = new Set([
     "stop",
     "length",

package/dist/session/seed.js

@@ -1,5 +1,5 @@
 import { HarnessError } from "../errors.js";
-import { normalizeCandidate } from "../model-normalize.js";
+import { normalizeCandidate } from "../model/normalize.js";
 import { assertJson, copyJson, copyJsonObject } from "../utils/immutable.js";
 export function normalizeSessionSeed(seed) {
     try {

package/dist/step/model-configuration.js

@@ -1,6 +1,6 @@
 import { bindTool } from "../build/bind-tool.js";
 import { HarnessError, isHarnessError } from "../errors.js";
-import { normalizeDirective, sameDirective } from "../model-normalize.js";
+import { normalizeDirective, sameDirective } from "../model/normalize.js";
 import { digest } from "../utils/digest.js";
 import { copyJson } from "../utils/immutable.js";
 import { checkedReason, slotOwner, SlotDraft } from "./slot-assembly.js";

package/dist/step/run.js

@@ -1,4 +1,4 @@
-import { normalizeCandidate } from "../model-normalize.js";
+import { normalizeCandidate } from "../model/normalize.js";
 import { HarnessError, isHarnessError } from "../errors.js";
 import { copyJson } from "../utils/immutable.js";
 import { runMiddleware } from "./compose.js";

package/dist/step/seal.js

@@ -1,4 +1,4 @@
-import { textFromOutput } from "../model-normalize.js";
+import { textFromOutput } from "../model/normalize.js";
 import { createId } from "../utils/ids.js";
 import { HarnessError, isHarnessError } from "../errors.js";
 import { assertJson, copyJson } from "../utils/immutable.js";

package/dist/step/step-context.js

@@ -1,6 +1,6 @@
 import { HarnessError, isHarnessError } from "../errors.js";
 import { callsFromCanonical, candidateFromCanonical, canonicalizeOutput, identityKey, } from "./canonicalize.js";
-import { normalizeCandidate } from "../model-normalize.js";
+import { normalizeCandidate } from "../model/normalize.js";
 import { ContextDraft } from "./context-draft.js";
 import { ModelConfigurationDraft } from "./model-configuration.js";
 const branded = new WeakSet();

package/dist/types/manifest.d.ts

@@ -1,9 +1,12 @@
-import type { BoundMiddleware } from "./middleware.js";
+import type { BoundMiddleware, MiddlewareContributions } from "./middleware.js";
 import type { BuildDiagnostic } from "./shared.js";
+export interface MiddlewareManifest extends MiddlewareContributions {
+    readonly id: string;
+}
 export interface AgentManifest {
-    readonly middleware: readonly {
-        readonly id: string;
-    }[];
+    readonly id: string;
+    readonly name: string;
+    readonly middleware: readonly MiddlewareManifest[];
 }
 export type BuildResult<Agent> = {
     readonly ok: true;

package/dist/types/middleware.d.ts

@@ -78,9 +78,18 @@ export interface CapabilityDeclaration<State = never> {
     readonly state?: CapabilityState<State>;
     readonly middleware?: StepMiddleware<State>;
 }
+export interface MiddlewareContributions {
+    readonly instructions?: readonly string[];
+    readonly tools?: readonly {
+        readonly name: string;
+        readonly description?: string;
+    }[];
+    readonly model?: Pick<ModelDirective, "id" | "controls">;
+}
 export interface BoundMiddleware {
     readonly id: string;
     readonly handle: StepMiddleware;
     readonly state?: CapabilityState<unknown>;
+    readonly contributions?: MiddlewareContributions;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/harness",
-  "version": "0.7.0-beta.1",
+  "version": "0.9.0-beta.1",
   "description": "A provider-neutral, in-memory agent loop for TypeScript.",
   "type": "module",
   "license": "Apache-2.0",
@@ -27,6 +27,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./model/adapters": {
+      "types": "./dist/model/adapters.d.ts",
+      "import": "./dist/model/adapters.js"
     }
   },
   "files": [