@nylorun/harness 0.12.0-beta → 0.15.0-beta

package/dist/types/shared.d.ts

@@ -1,249 +0,0 @@
-import type { ContextSnapshot, ModelCandidate, ModelCall, ModelConfigurationSnapshot } from "./model.js";
-import type { InputEvent, TranscriptEntry } from "./session.js";
-import type { RequiredInteraction, ToolResult } from "./tool.js";
-export type JsonPrimitive = string | number | boolean | null;
-export type JsonValue = JsonPrimitive | JsonObject | readonly JsonValue[];
-export type JsonObject = {
-    readonly [key: string]: JsonValue;
-};
-export interface DeferredOutcome {
-    readonly kind: "deferred";
-    readonly token?: JsonValue;
-}
-export interface BuildDiagnostic {
-    readonly code: string;
-    readonly message: string;
-    readonly toolName?: string;
-    readonly details?: Readonly<Record<string, string | number | boolean>>;
-    readonly cause?: unknown;
-}
-export interface ContextItem {
-    readonly type?: string;
-    readonly value: JsonValue;
-}
-export interface Tripwire {
-    readonly code: string;
-    readonly message: string;
-    readonly scope?: "step" | "session";
-}
-export interface ObserveToolSnapshot {
-    readonly name: string;
-    readonly description?: string;
-    readonly owner: {
-        readonly middlewareId: string;
-        readonly slot: string;
-    };
-    readonly inputSchema: {
-        readonly jsonSchema: JsonObject;
-    };
-    readonly outputSchema?: {
-        readonly jsonSchema: JsonObject;
-    };
-}
-/** JSON-only model-configuration view suitable for an observation stream. */
-export interface ObserveModelConfigurationSnapshot extends Omit<ModelConfigurationSnapshot, "tools"> {
-    readonly tools: readonly ObserveToolSnapshot[];
-}
-export interface ObserveSealedCall {
-    readonly callId: string;
-    readonly toolName: string;
-    readonly args: JsonValue;
-    readonly invocationId: string;
-    readonly owner: {
-        readonly middlewareId: string;
-        readonly slot: string;
-    };
-    readonly interaction?: RequiredInteraction;
-}
-export interface ObserveModelRequested {
-    /** The exact immutable logical input supplied to the ModelAdapter. */
-    readonly call: ModelCall;
-    /** Canonical configuration facts and attribution. */
-    readonly configuration: ObserveModelConfigurationSnapshot;
-    /** Current-step runtime context and attribution. */
-    readonly context: ContextSnapshot;
-}
-export type ObserveEvent = {
-    readonly type: "session.stopped";
-    readonly reason: string;
-} | {
-    readonly type: "capability.state.dispose.failed";
-    readonly capabilityId: string;
-    readonly attributes: {
-        readonly message: string;
-    };
-} | {
-    readonly type: "session.seeded";
-    readonly revision: number;
-    readonly transcriptEntries: number;
-} | {
-    readonly type: "session.continued";
-    readonly inputId?: string;
-} | {
-    readonly type: "session.record.failed";
-    readonly code: string;
-    readonly attributes: {
-        readonly message: string;
-    };
-} | {
-    readonly type: "input.received";
-    readonly inputId: string;
-    readonly kind: string;
-} | {
-    readonly type: "input.queued";
-    readonly inputId: string;
-} | {
-    readonly type: "input.rejected";
-    readonly inputId: string;
-    readonly reason: string;
-} | {
-    readonly type: "input.cancelled";
-    readonly inputId: string;
-    readonly reason: string;
-} | {
-    readonly type: "model.requested";
-    readonly turnId: string;
-    readonly stepId: string;
-    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;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly requestedModelId?: string;
-    readonly attributes: ModelCandidate;
-} | {
-    readonly type: "model.deferred";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly invocationId: string;
-    readonly attributes: {
-        readonly token?: JsonValue;
-    };
-} | {
-    readonly type: "step.started";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly turnNumber: number;
-    readonly stepNumber: number;
-    readonly attributes: {
-        readonly session?: {
-            readonly userId?: string;
-            readonly context?: JsonObject;
-        };
-        readonly arrivals: readonly InputEvent[];
-        readonly toolResults: readonly ToolResult[];
-        readonly transcript: readonly TranscriptEntry[];
-    };
-} | {
-    readonly type: "middleware.entered" | "middleware.completed";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly middlewareId: string;
-} | {
-    readonly type: "middleware.lease-violation";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly middlewareId: string;
-    readonly reason: string;
-} | {
-    readonly type: "tool.sealed";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly attributes: {
-        readonly executable: readonly ObserveSealedCall[];
-        readonly immediate: readonly ToolResult[];
-    };
-} | {
-    readonly type: "tool.started";
-    readonly sessionId: string;
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly toolName: string;
-    readonly callId: string;
-    readonly invocationId: string;
-    readonly middlewareId: string;
-    readonly slot: string;
-    readonly attributes: {
-        readonly args: JsonValue;
-    };
-} | {
-    readonly type: "tool.completed";
-    readonly sessionId: string;
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly toolName: string;
-    readonly callId: string;
-    readonly invocationId: string;
-    readonly middlewareId: string;
-    readonly slot: string;
-    readonly outcome: string;
-    readonly code?: string;
-    readonly attributes?: ToolResult;
-} | {
-    readonly type: "tool.deferred";
-    readonly sessionId: string;
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly toolName: string;
-    readonly callId: string;
-    readonly invocationId: string;
-    readonly middlewareId: string;
-    readonly slot: string;
-    readonly attributes: {
-        readonly token?: JsonValue;
-    };
-} | {
-    readonly type: "turn.completed";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly attributes: {
-        readonly output: JsonValue;
-    };
-} | {
-    readonly type: "interaction.required";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly interactionId: string;
-    readonly kind: string;
-    readonly callId?: string;
-    readonly toolName?: string;
-    readonly phase?: "interaction" | "execute";
-    readonly attributes: {
-        readonly prompt: string;
-        readonly metadata?: JsonObject;
-    };
-} | {
-    readonly type: "tripwire";
-    readonly turnId: string;
-    readonly stepId?: string;
-    readonly inputId?: string;
-    readonly code: string;
-    readonly scope: string;
-    readonly attributes: {
-        readonly message: string;
-    };
-};
-export type Observer = (event: ObserveEvent) => void | Promise<void>;

package/dist/types/shared.js

@@ -1 +0,0 @@
-export {};

package/dist/types/tool.d.ts

@@ -1,139 +0,0 @@
-import type { ZodType } from "zod";
-import type { DeferredOutcome, JsonObject, JsonValue } from "./shared.js";
-import type { ModelAdapter } from "./model.js";
-export interface SchemaIssue {
-    readonly path: readonly (string | number)[];
-    readonly code: string;
-    readonly message: string;
-}
-export type SchemaValidation<T> = {
-    readonly ok: true;
-    readonly value: T;
-} | {
-    readonly ok: false;
-    readonly issues: readonly SchemaIssue[];
-};
-/** The portable, locally-enforced schema contract accepted by a Harness tool. */
-export interface ToolSchema<T> {
-    readonly jsonSchema: JsonObject;
-    validate(value: unknown): SchemaValidation<T>;
-}
-/** 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 inputSchema: InputSchema;
-    readonly outputSchema?: OutputSchema;
-    execute(args: SchemaOutput<InputSchema>, context: ToolExecutionContext<State>): Promise<ToolOutcome<OutputFor<OutputSchema>>>;
-}
-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 {
-    readonly middlewareId: string;
-    readonly slot: string;
-}
-export interface Interaction {
-    readonly id?: string;
-    readonly kind: "approval" | "response";
-    readonly prompt: string;
-    readonly metadata?: JsonObject;
-}
-export interface RequiredInteraction extends Interaction {
-    readonly id: string;
-}
-export interface ToolExecutionResume {
-    readonly interactionId: string;
-    readonly kind: "approval" | "response";
-    readonly approved?: boolean;
-    readonly value?: JsonValue;
-    readonly token?: JsonValue;
-}
-export interface SealedToolCall {
-    readonly callId: string;
-    readonly toolName: string;
-    readonly args: JsonValue;
-}
-interface ToolExecutionContextBase {
-    readonly sessionId: string;
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly callId: string;
-    readonly invocationId: string;
-    readonly signal: AbortSignal;
-    /** The session's model callable, for tools that explicitly run a child agent. */
-    readonly onModelCall?: ModelAdapter;
-    readonly resume?: ToolExecutionResume;
-}
-export type ToolExecutionContext<State = never> = ToolExecutionContextBase & ([State] extends [never] ? object : {
-    readonly state: Promise<State>;
-});
-export type ToolContent = JsonValue;
-export type ToolOutcome<Output = ToolContent> = {
-    readonly kind: "completed";
-    readonly output: Output;
-} | {
-    readonly kind: "denied";
-    readonly reason: string;
-} | {
-    readonly kind: "failed";
-    readonly code: string;
-    readonly message: string;
-} | {
-    readonly kind: "interaction-required";
-    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;
-    readonly kind: "completed";
-    readonly output: ToolContent;
-} | {
-    readonly callId: string;
-    readonly toolName: string;
-    readonly kind: "denied";
-    readonly reason: string;
-} | {
-    readonly callId: string;
-    readonly toolName: string;
-    readonly kind: "failed";
-    readonly code: string;
-    readonly message: string;
-    readonly details?: ToolValidationFailureDetails;
-};
-export {};

package/dist/types/tool.js

@@ -1 +0,0 @@
-export {};

package/dist/utils/immutable.d.ts

@@ -1,5 +0,0 @@
-import type { JsonObject, JsonValue } from "../types/shared.js";
-export declare function assertJson(value: unknown, path?: string): asserts value is JsonValue;
-export declare function copyJson<T>(value: T): T;
-export declare function copyJsonObject(value: unknown, path: string): JsonObject;
-export declare function deepFreeze<T>(value: T): T;

package/dist/utils/immutable.js

@@ -1,68 +0,0 @@
-import { HarnessError } from "../errors.js";
-export function assertJson(value, path = "value") {
-    assertJsonValue(value, path, new WeakSet());
-}
-function assertJsonValue(value, path, ancestors) {
-    if (value === null || typeof value === "string" || typeof value === "boolean")
-        return;
-    if (typeof value === "number" && Number.isFinite(value))
-        return;
-    if (Array.isArray(value)) {
-        enterJsonContainer(value, path, ancestors);
-        value.forEach((item, index) => assertJsonValue(item, `${path}[${index}]`, ancestors));
-        ancestors.delete(value);
-        return;
-    }
-    if (typeof value === "object") {
-        const prototype = Object.getPrototypeOf(value);
-        if (prototype !== Object.prototype && prototype !== null)
-            throw new HarnessError("json.invalid-data", `${path} must be plain JSON data`, {
-                details: { path },
-            });
-        enterJsonContainer(value, path, ancestors);
-        for (const [key, item] of Object.entries(value)) {
-            if (item === undefined)
-                throw new HarnessError("json.invalid-data", `${path}.${key} cannot be undefined`, {
-                    details: { path: `${path}.${key}` },
-                });
-            assertJsonValue(item, `${path}.${key}`, ancestors);
-        }
-        ancestors.delete(value);
-        return;
-    }
-    throw new HarnessError("json.invalid-data", `${path} must be JSON-serializable`, {
-        details: { path },
-    });
-}
-function enterJsonContainer(value, path, ancestors) {
-    if (ancestors.has(value))
-        throw new HarnessError("json.invalid-data", `${path} cannot contain a cycle`, {
-            details: { path },
-        });
-    ancestors.add(value);
-}
-export function copyJson(value) {
-    assertJson(value);
-    if (Array.isArray(value))
-        return Object.freeze(value.map((item) => copyJson(item)));
-    if (value !== null && typeof value === "object") {
-        return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, copyJson(item)])));
-    }
-    return value;
-}
-export function copyJsonObject(value, path) {
-    assertJson(value, path);
-    if (value === null || Array.isArray(value) || typeof value !== "object")
-        throw new HarnessError("json.invalid-object", `${path} must be a JSON object`, {
-            details: { path },
-        });
-    return copyJson(value);
-}
-export function deepFreeze(value) {
-    if (value && typeof value === "object" && !Object.isFrozen(value)) {
-        Object.freeze(value);
-        for (const item of Object.values(value))
-            deepFreeze(item);
-    }
-    return value;
-}

package/dist/utils/maps.d.ts

@@ -1 +0,0 @@
-export declare function createFixedMap<K, V>(values: Iterable<readonly [K, V]>): ReadonlyMap<K, V>;

package/dist/utils/maps.js

@@ -1,37 +0,0 @@
-class FixedReadonlyMap {
-    #values;
-    constructor(values) {
-        this.#values = new Map(values);
-        Object.freeze(this);
-    }
-    get size() {
-        return this.#values.size;
-    }
-    get(key) {
-        return this.#values.get(key);
-    }
-    has(key) {
-        return this.#values.has(key);
-    }
-    entries() {
-        return this.#values.entries();
-    }
-    keys() {
-        return this.#values.keys();
-    }
-    values() {
-        return this.#values.values();
-    }
-    forEach(callbackfn, thisArg) {
-        this.#values.forEach((value, key) => callbackfn.call(thisArg, value, key, this));
-    }
-    [Symbol.iterator]() {
-        return this.#values[Symbol.iterator]();
-    }
-    get [Symbol.toStringTag]() {
-        return "FixedReadonlyMap";
-    }
-}
-export function createFixedMap(values) {
-    return new FixedReadonlyMap(values);
-}

package/dist/utils/observe.d.ts

@@ -1,3 +0,0 @@
-import type { ObserveEvent, Observer } from "../types/shared.js";
-export type ObserveEmit = (event: ObserveEvent | (() => ObserveEvent)) => void;
-export declare function emitObserve(listener: Observer | undefined, event: ObserveEvent | (() => ObserveEvent)): void;

package/dist/utils/observe.js

@@ -1,13 +0,0 @@
-export function emitObserve(listener, event) {
-    if (!listener)
-        return;
-    const snapshot = Object.freeze({ ...(typeof event === "function" ? event() : event) });
-    try {
-        const result = listener(snapshot);
-        if (result && typeof result.then === "function")
-            void Promise.resolve(result).catch(() => undefined);
-    }
-    catch {
-        // Observation is deliberately fail-open.
-    }
-}