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

package/dist/turn/runner.js

@@ -13,11 +13,11 @@ export class TurnRunner {
         this.sessionId = sessionId;
         this.session = session;
     }
-    async start(state, event, context) {
+    async start(state, event, context, output) {
         const turnId = createId("turn");
         state = await context.commit(beginTurn(state, turnId, event), "input");
         context.onConversation({ type: "input", event, turnId });
-        return this.advance(state, turnId, 1, [event], [], context);
+        return this.advance(state, turnId, 1, [event], [], context, output);
     }
     async continue(state, context) {
         const turnId = createId("turn");
@@ -36,9 +36,9 @@ export class TurnRunner {
         state = await context.commit(commitToolResults(state, pending.turnId, pending.stepId, progress.results), "tool-results");
         pending.plan.publishSettlements(context.observe);
         const claimed = await context.claimInterrupts(state, pending.turnId);
-        return this.advance(claimed.state, pending.turnId, pending.stepNumber + 1, claimed.arrivals, progress.results, context);
+        return this.advance(claimed.state, pending.turnId, pending.stepNumber + 1, claimed.arrivals, progress.results, context, pending.output);
     }
-    async advance(initialState, turnId, firstStep, arrivals, initialResults, context) {
+    async advance(initialState, turnId, firstStep, arrivals, initialResults, context, output) {
         let state = initialState;
         let stepArrivals = arrivals;
         let toolResults = initialResults;
@@ -58,6 +58,7 @@ export class TurnRunner {
                 signal: context.signal,
                 session: this.session,
                 states: context.states,
+                output,
                 recordModelRequested: (next, active) => context.commit(next, "model-requested", active),
             });
             context.assertCurrent();
@@ -68,6 +69,7 @@ export class TurnRunner {
                     turnId,
                     stepId,
                     stepNumber,
+                    ...(output === undefined ? {} : { output }),
                 }
                 : undefined;
             if (run.candidate) {

package/dist/types/middleware.d.ts

@@ -72,7 +72,7 @@ export type CapabilityItems<Item> = readonly Item[] | Readonly<{
 /** A named capability that may supply static model surface and one typed middleware handler. */
 export interface CapabilityDeclaration<State = never> {
     readonly id: string;
-    readonly tools?: CapabilityItems<ToolDefinition<ToolDefinition["parameters"], State>>;
+    readonly tools?: CapabilityItems<ToolDefinition<ToolDefinition["inputSchema"], State>>;
     readonly instructions?: CapabilityItems<string>;
     readonly model?: ModelDirective;
     readonly state?: CapabilityState<State>;

package/dist/types/model.d.ts

@@ -1,4 +1,4 @@
-import type { ContextItem, DeferredOutcome, JsonObject } from "./shared.js";
+import type { ContextItem, DeferredOutcome, JsonObject, JsonValue } from "./shared.js";
 import type { InputEvent, TranscriptEntry } from "./session.js";
 import type { BoundToolDefinition, ToolResult } from "./tool.js";
 export interface ModelToolCall {
@@ -9,11 +9,17 @@ export interface ModelToolCall {
 export type ModelOutputBlock = {
     readonly type: "text";
     readonly text: string;
+    readonly providerMetadata?: JsonObject;
 } | {
     readonly type: "reasoning";
     readonly text: string;
+    readonly providerMetadata?: JsonObject;
+} | {
+    readonly type: "json";
+    readonly value: JsonValue;
 } | {
     readonly type: "tool-call";
+    readonly providerMetadata?: JsonObject;
     readonly id: string;
     readonly name: string;
     readonly args: JsonObject;
@@ -58,34 +64,27 @@ export interface ModelConfigurationContributor {
     readonly middlewareId: string;
     readonly slot: string;
     readonly order: number;
-    readonly digest: string;
     readonly reason?: string;
 }
 export interface ModelConfigurationTool {
     readonly name: string;
     readonly description?: string;
     readonly inputSchema: JsonObject;
-    readonly digest: string;
+    readonly outputSchema?: JsonObject;
     readonly contributor: ModelConfigurationContributor;
 }
 export interface ModelConfigurationInstruction {
     readonly text: string;
-    readonly digest: string;
     readonly contributor: ModelConfigurationContributor;
 }
 export interface ModelConfigurationSnapshot {
     readonly version: 1;
     readonly model?: ModelDirective;
     readonly instructions: readonly ModelConfigurationInstruction[];
-    /** Bound tools are retained for execution; their digest covers only their provider-visible contract. */
+    /** Bound tools are retained for execution. */
     readonly tools: readonly BoundToolDefinition[];
     readonly toolContracts: readonly ModelConfigurationTool[];
     readonly contributors: readonly ModelConfigurationContributor[];
-    readonly digests: Readonly<{
-        readonly logical: string;
-        readonly model: string;
-        readonly request: string;
-    }>;
 }
 /** A middleware-owned declaration for this model call's runtime context. */
 export interface ContextMutationOptions {
@@ -96,14 +95,12 @@ export interface ContextContributor {
     readonly middlewareId: string;
     readonly slot: string;
     readonly order: number;
-    readonly digest: string;
     readonly reason?: string;
 }
-/** Canonical runtime context for one model call. Not part of the configuration digest. */
+/** Canonical runtime context for one model call. */
 export interface ContextSnapshot {
     readonly items: readonly ContextItem[];
     readonly contributors: readonly ContextContributor[];
-    readonly digest: string;
 }
 export interface ModelRequest {
     readonly sessionId: string;
@@ -119,12 +116,24 @@ export interface ModelRequest {
     readonly toolResults: readonly ToolResult[];
     /** Tools are normalized and immutable by the time a Model sees them. */
     readonly tools: readonly BoundToolDefinition[];
+    /** Optional portable contract for this turn's terminal JSON result. */
+    readonly outputSchema?: JsonObject;
 }
 export type PromptContentPart = {
+    readonly type: "reasoning";
+    readonly text: string;
+    readonly providerMetadata?: JsonObject;
+} | {
     readonly type: "text";
     readonly text: string;
+    readonly providerMetadata?: JsonObject;
+} | {
+    readonly type: "media";
+    readonly mediaType: string;
+    readonly reference: JsonValue;
 } | {
     readonly type: "tool-call";
+    readonly providerMetadata?: JsonObject;
     readonly id: string;
     readonly name: string;
     readonly args: JsonObject;
@@ -157,11 +166,19 @@ export interface ModelCall {
     readonly model?: ModelDirective;
     readonly prompt: readonly PromptItem[];
     readonly tools: readonly ModelCallTool[];
+    /** Optional portable contract for this turn's terminal JSON result. */
+    readonly outputSchema?: JsonObject;
     readonly sessionId: string;
 }
 export interface ModelAdapterContext {
     readonly request: ModelRequest;
     readonly invocationId: string;
     readonly signal: AbortSignal;
+    /** Publishes one JSON-safe provider request derived from the canonical ModelCall. */
+    reportPreparedCall(prepared: ModelPreparedCall): void;
+}
+export interface ModelPreparedCall {
+    readonly adapter: string;
+    readonly call: JsonValue;
 }
 export type ModelAdapter = (call: ModelCall, context: ModelAdapterContext) => Promise<ModelCandidate | string | DeferredOutcome>;

package/dist/types/session.d.ts

@@ -1,13 +1,15 @@
 import type { ModelCall, ModelCandidate } from "./model.js";
 import type { JsonObject, JsonValue, Observer, Tripwire } from "./shared.js";
-import type { RequiredInteraction, ToolExecutionResume, ToolOwner, ToolResult } from "./tool.js";
+import type { RequiredInteraction, SchemaOutput, ToolExecutionResume, ToolOwner, ToolResult, ToolSchemaSource } from "./tool.js";
 export type InputEvent = {
-    readonly kind: "user-message";
+    readonly kind: "user-message" | "interrupt";
     readonly text: string;
     readonly metadata?: JsonObject;
 } | {
-    readonly kind: "interrupt";
-    readonly text: string;
+    readonly kind: "user-message" | "interrupt";
+    readonly content: readonly UserContentPart[];
+    /** Undefined for content-bearing events; retained for text-event narrowing compatibility. */
+    readonly text?: undefined;
     readonly metadata?: JsonObject;
 } | {
     readonly kind: "approve";
@@ -18,7 +20,7 @@ export type InputEvent = {
     readonly interactionId: string;
     readonly value: JsonValue;
 };
-export type SessionEvent = {
+export type SessionEvent<Output = string> = {
     readonly type: "input";
     readonly event: InputEvent;
     readonly turnId: string;
@@ -29,7 +31,7 @@ export type SessionEvent = {
     readonly candidate: ModelCandidate;
 } | {
     readonly type: "final";
-    readonly output: string;
+    readonly output: Output;
     readonly turnId: string;
 } | {
     readonly type: "interaction.required";
@@ -58,14 +60,14 @@ export type SessionEvent = {
     readonly type: "session.stopped";
     readonly sessionId: string;
 };
-export interface InputCompletion {
+export interface InputCompletion<Output = string> {
     readonly inputId: string;
     readonly status: "completed" | "waiting" | "rejected" | "cancelled" | "stopped";
-    readonly events: readonly SessionEvent[];
+    readonly events: readonly SessionEvent<Output>[];
 }
-export interface InputHandle {
+export interface InputHandle<Output = string> {
     readonly inputId: string;
-    readonly completed: Promise<InputCompletion>;
+    readonly completed: Promise<InputCompletion<Output>>;
 }
 export interface SessionOptions {
     readonly id?: string;
@@ -91,9 +93,25 @@ export type SessionRunOptions = SessionOptions | SeededSessionOptions;
 export interface InputOptions {
     readonly signal?: AbortSignal;
 }
+/** Per-turn, locally-enforced terminal JSON contract. */
+export interface OutputInputOptions<Schema extends ToolSchemaSource = ToolSchemaSource> extends InputOptions {
+    readonly outputSchema?: Schema;
+}
+/** Ordered, model-visible user content. Media references stay host-owned JSON values. */
+export type UserContentPart = {
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: "media";
+    readonly mediaType: string;
+    readonly reference: JsonValue;
+};
 export type MessageInput = string | {
     readonly text: string;
     readonly metadata?: JsonObject;
+} | {
+    readonly content: readonly UserContentPart[];
+    readonly metadata?: JsonObject;
 };
 export type InteractionReply = Extract<InputEvent, {
     kind: "approve" | "respond";
@@ -121,7 +139,7 @@ export interface TranscriptFinalEntry {
     readonly kind: "final";
     readonly turnId: string;
     readonly stepId: string;
-    readonly output: string;
+    readonly output: JsonValue;
 }
 export type TranscriptEntry = TranscriptInputEntry | TranscriptCandidateEntry | TranscriptToolsEntry | TranscriptFinalEntry;
 export interface SessionSnapshot {
@@ -197,10 +215,13 @@ export interface SessionRecorder {
 export interface Session {
     readonly id: string;
     readonly state: SessionSnapshot;
-    input(event: SessionInput, options?: InputOptions): InputHandle;
+    input<Schema extends ToolSchemaSource>(event: MessageInput, options: OutputInputOptions<Schema> & {
+        readonly outputSchema: Schema;
+    }): InputHandle<SchemaOutput<Schema>>;
+    input(event: SessionInput, options?: InputOptions): InputHandle<string>;
     interrupt(event: MessageInput, options?: InputOptions): InputHandle;
     continue(options?: InputOptions): InputHandle;
-    stream(): AsyncIterable<SessionEvent>;
+    stream(): AsyncIterable<SessionEvent<JsonValue>>;
     observe(listener: Observer): () => void;
     stop(reason?: string): Promise<void>;
 }

package/dist/types/shared.d.ts

@@ -33,7 +33,10 @@ export interface ObserveToolSnapshot {
         readonly middlewareId: string;
         readonly slot: string;
     };
-    readonly parameters: {
+    readonly inputSchema: {
+        readonly jsonSchema: JsonObject;
+    };
+    readonly outputSchema?: {
         readonly jsonSchema: JsonObject;
     };
 }
@@ -55,7 +58,7 @@ export interface ObserveSealedCall {
 export interface ObserveModelRequested {
     /** The exact immutable logical input supplied to the ModelAdapter. */
     readonly call: ModelCall;
-    /** Canonical configuration facts and attribution; hashes have no policy semantics. */
+    /** Canonical configuration facts and attribution. */
     readonly configuration: ObserveModelConfigurationSnapshot;
     /** Current-step runtime context and attribution. */
     readonly context: ContextSnapshot;
@@ -104,6 +107,16 @@ export type ObserveEvent = {
     readonly inputId?: string;
     readonly requestedModelId?: string;
     readonly attributes: ObserveModelRequested;
+} | {
+    readonly type: "model.prepared";
+    readonly turnId: string;
+    readonly stepId: string;
+    readonly inputId?: string;
+    readonly requestedModelId?: string;
+    readonly attributes: {
+        readonly adapter: string;
+        readonly call: JsonValue;
+    };
 } | {
     readonly type: "model.completed";
     readonly turnId: string;
@@ -206,7 +219,7 @@ export type ObserveEvent = {
     readonly stepId: string;
     readonly inputId?: string;
     readonly attributes: {
-        readonly output: string;
+        readonly output: JsonValue;
     };
 } | {
     readonly type: "interaction.required";

package/dist/types/tool.d.ts

@@ -1,29 +1,61 @@
-import type { ZodObject, output } from "zod";
+import type { ZodType } from "zod";
 import type { DeferredOutcome, JsonObject, JsonValue } from "./shared.js";
-type SchemaValidationSuccess<T> = {
+export interface SchemaIssue {
+    readonly path: readonly (string | number)[];
+    readonly code: string;
+    readonly message: string;
+}
+export type SchemaValidation<T> = {
     readonly ok: true;
     readonly value: T;
-};
-type SchemaValidationFailure = {
+} | {
     readonly ok: false;
-    readonly issues: readonly string[];
+    readonly issues: readonly SchemaIssue[];
 };
-type SchemaValidation<T> = SchemaValidationSuccess<T> | SchemaValidationFailure;
-/** Harness tool parameters are synchronous Zod object schemas. */
-export type ToolObjectSchema = ZodObject;
-export interface BoundToolSchema<T> {
+/** The portable, locally-enforced schema contract accepted by a Harness tool. */
+export interface ToolSchema<T> {
     readonly jsonSchema: JsonObject;
     validate(value: unknown): SchemaValidation<T>;
 }
-export interface ToolDefinition<Parameters extends ToolObjectSchema = ToolObjectSchema, State = never> {
+/** The synchronous Standard Schema subset required to project and validate a tool contract. */
+export interface StandardToolSchema<Input = unknown, Output = unknown> {
+    readonly "~standard": {
+        readonly validate: (value: Input) => {
+            readonly value: Output;
+            readonly issues?: undefined;
+        } | {
+            readonly issues: readonly StandardSchemaIssue[];
+            readonly value?: undefined;
+        } | Promise<unknown>;
+        readonly jsonSchema: {
+            readonly input: () => unknown;
+            readonly output: () => unknown;
+        };
+    };
+}
+export interface StandardSchemaIssue {
+    readonly message?: string;
+    readonly path?: readonly (string | number | symbol)[];
+    readonly code?: string;
+}
+export type ToolSchemaSource<T = unknown> = ZodType<T> | StandardToolSchema<any, T> | ToolSchema<T>;
+export type SchemaOutput<Schema> = Schema extends ZodType<infer Value> ? Value : Schema extends StandardToolSchema<any, infer Value> ? Value : Schema extends ToolSchema<infer Value> ? Value : never;
+export type ToolInputSchema = ToolSchemaSource;
+export type ToolOutputSchema = ToolSchemaSource;
+export interface BoundToolSchema<T> extends ToolSchema<T> {
+}
+type OutputFor<Schema> = Schema extends ToolSchemaSource ? SchemaOutput<Schema> : ToolContent;
+export interface ToolDefinition<InputSchema extends ToolInputSchema = ToolInputSchema, State = never, OutputSchema extends ToolOutputSchema | undefined = undefined> {
     readonly name: string;
     readonly description?: string;
-    readonly parameters: Parameters;
-    execute(args: output<Parameters>, context: ToolExecutionContext<State>): Promise<ToolOutcome>;
+    readonly inputSchema: InputSchema;
+    readonly outputSchema?: OutputSchema;
+    execute(args: SchemaOutput<InputSchema>, context: ToolExecutionContext<State>): Promise<ToolOutcome<OutputFor<OutputSchema>>>;
 }
-export interface BoundToolDefinition<Parameters extends ToolObjectSchema = ToolObjectSchema, State = never> extends Omit<ToolDefinition<Parameters, State>, "parameters" | "execute"> {
-    readonly parameters: BoundToolSchema<output<Parameters>>;
-    readonly execute: ToolDefinition<Parameters, State>["execute"];
+export interface BoundToolDefinition<State = never> extends Omit<ToolDefinition<ToolInputSchema, State, ToolOutputSchema | undefined>, "inputSchema" | "outputSchema" | "execute"> {
+    readonly inputSchema: BoundToolSchema<unknown>;
+    readonly outputSchema?: BoundToolSchema<unknown>;
+    readonly execute: (args: unknown, context: ToolExecutionContext<State>) => Promise<ToolOutcome>;
     readonly owner: ToolOwner;
 }
 export interface ToolOwner {
@@ -64,9 +96,9 @@ export type ToolExecutionContext<State = never> = ToolExecutionContextBase & ([S
     readonly state: Promise<State>;
 });
 export type ToolContent = JsonValue;
-export type ToolOutcome = {
+export type ToolOutcome<Output = ToolContent> = {
     readonly kind: "completed";
-    readonly output: ToolContent;
+    readonly output: Output;
 } | {
     readonly kind: "denied";
     readonly reason: string;
@@ -79,6 +111,10 @@ export type ToolOutcome = {
     readonly interaction: Interaction;
     readonly token?: JsonValue;
 } | DeferredOutcome;
+export interface ToolValidationFailureDetails {
+    readonly phase: "input" | "output";
+    readonly issues: readonly SchemaIssue[];
+}
 export type ToolResult = {
     readonly callId: string;
     readonly toolName: string;
@@ -95,5 +131,6 @@ export type ToolResult = {
     readonly kind: "failed";
     readonly code: string;
     readonly message: string;
+    readonly details?: ToolValidationFailureDetails;
 };
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nylorun/harness",
-  "version": "0.9.0-beta.1",
-  "description": "A provider-neutral, in-memory agent loop for TypeScript.",
+  "version": "0.11.1-beta",
+  "description": "Nylorun's TypeScript agent runtime. See github.com/nylorun/harness.",
   "type": "module",
   "license": "Apache-2.0",
   "repository": {
@@ -9,7 +9,7 @@
     "url": "git+https://github.com/nylorun/harness.git",
     "directory": "harness"
   },
-  "homepage": "https://github.com/nylorun/harness/tree/main/harness#readme",
+  "homepage": "https://github.com/nylorun/harness",
   "bugs": "https://github.com/nylorun/harness/issues",
   "author": "Nylo",
   "keywords": [
@@ -48,26 +48,25 @@
     "node": "^22.14.0 || ^24.0.0 || >=26.0.0"
   },
   "scripts": {
-    "clean": "node -e \"import('node:fs').then(({rmSync})=>rmSync('dist',{recursive:true,force:true}))\"",
-    "build": "npm run clean && tsc -p tsconfig.json",
+    "build": "npm run clean && node ../scripts/check-typescript-version.mjs && tsc -p tsconfig.json",
+    "check": "npm run format:check && npm run build && npm run test:types && npm test && node scripts/check-package.mjs",
+    "typecheck": "node ../scripts/check-typescript-version.mjs && tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
+    "test:types": "tsc -p test/types/tsconfig.json",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
-    "test:types": "tsc -p test/types/tsconfig.json",
-    "check": "npm run format:check && npm run build && npm run test:types && npm test && node scripts/check-package.mjs",
+    "clean": "node -e \"import('node:fs').then(({rmSync})=>rmSync('dist',{recursive:true,force:true}))\"",
     "prepack": "npm run build"
   },
   "devDependencies": {
     "@types/node": "^22.18.0",
+    "@typescript/native": "npm:typescript@^7.0.2",
     "prettier": "^3.9.6",
-    "typescript": "^5.9.3",
-    "vitest": "^3.2.4",
+    "typescript": "npm:@typescript/typescript6@^6.0.2",
+    "vitest": "^4.1.11",
     "zod": "^4.1.12"
   },
   "peerDependencies": {
     "zod": "^4.1.12"
-  },
-  "dependencies": {
-    "@noble/hashes": "^2.3.0"
   }
 }

package/dist/utils/digest.d.ts

@@ -1 +0,0 @@
-export declare const digest: (value: unknown) => string;

package/dist/utils/digest.js

@@ -1,14 +0,0 @@
-import { sha256 } from "@noble/hashes/sha2.js";
-import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils.js";
-function canonical(value) {
-    if (Array.isArray(value))
-        return `[${value.map(canonical).join(",")}]`;
-    if (value && typeof value === "object") {
-        return `{${Object.entries(value)
-            .sort(([a], [b]) => a.localeCompare(b))
-            .map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`)
-            .join(",")}}`;
-    }
-    return JSON.stringify(value);
-}
-export const digest = (value) => bytesToHex(sha256(utf8ToBytes(canonical(value))));