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

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.8.0-beta.1",
-  "description": "A provider-neutral, in-memory agent loop for TypeScript.",
+  "version": "0.11.0-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": [
@@ -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": [
@@ -44,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))));