@nylorun/harness 0.12.0-beta → 0.15.0-beta

package/dist/session/input-queue.d.ts

@@ -1,41 +0,0 @@
-import type { InputEvent, InputOptions } from "../types/session.js";
-import type { TurnOutputContract } from "./output-contract.js";
-import { SubmissionStream } from "./submission-stream.js";
-export type WorkEvent = InputEvent | {
-    readonly kind: "continue";
-};
-export interface QueuedInput {
-    readonly event: WorkEvent;
-    readonly options?: InputOptions & {
-        readonly output?: TurnOutputContract;
-    };
-    readonly stream: SubmissionStream;
-    cancelled: boolean;
-}
-export type QueuedInterrupt = Omit<QueuedInput, "event"> & {
-    readonly event: InputEvent & {
-        readonly kind: "interrupt";
-    };
-};
-export interface QueueAbortHandlers {
-    readonly isActive: () => boolean;
-    readonly abortActive: (reason: unknown) => void;
-    readonly cancelQueued: () => void;
-}
-export declare function isInteractionReply(event: InputEvent): event is Extract<InputEvent, {
-    kind: "approve" | "respond";
-}>;
-export declare function snapshotInput(event: InputEvent): InputEvent;
-export declare function snapshotWork(event: WorkEvent): WorkEvent;
-/** Serializes ordinary input while allowing a matching interaction reply to resume immediately. */
-export declare class InputQueue {
-    private readonly values;
-    get size(): number;
-    add(input: QueuedInput, priority?: boolean): void;
-    take(waitingForInteraction: boolean): QueuedInput | undefined;
-    takeInterrupts(): QueuedInterrupt[];
-    remove(input: QueuedInput): boolean;
-    drain(): readonly QueuedInput[];
-}
-/** Binds one caller-provided signal to its queue entry and always removes the listener at completion. */
-export declare function watchInputAbort(input: QueuedInput, handlers: QueueAbortHandlers): void;

package/dist/session/input-queue.js

@@ -1,94 +0,0 @@
-import { copyJson, copyJsonObject } from "../utils/immutable.js";
-import { SubmissionStream } from "./submission-stream.js";
-export function isInteractionReply(event) {
-    return event.kind === "approve" || event.kind === "respond";
-}
-export function snapshotInput(event) {
-    switch (event.kind) {
-        case "user-message":
-        case "interrupt":
-            if ("content" in event)
-                return Object.freeze({
-                    kind: event.kind,
-                    content: Object.freeze(event.content.map((part) => part.type === "text"
-                        ? Object.freeze({ type: "text", text: part.text })
-                        : Object.freeze({
-                            type: "media",
-                            mediaType: part.mediaType,
-                            reference: copyJson(part.reference),
-                        }))),
-                    ...(event.metadata ? { metadata: copyJsonObject(event.metadata, "input metadata") } : {}),
-                });
-            return Object.freeze({
-                kind: event.kind,
-                text: event.text,
-                ...(event.metadata ? { metadata: copyJsonObject(event.metadata, "input metadata") } : {}),
-            });
-        case "approve":
-            return Object.freeze({ ...event });
-        case "respond":
-            return Object.freeze({ ...event, value: copyJson(event.value) });
-    }
-}
-export function snapshotWork(event) {
-    return event.kind === "continue" ? Object.freeze({ kind: "continue" }) : snapshotInput(event);
-}
-/** Serializes ordinary input while allowing a matching interaction reply to resume immediately. */
-export class InputQueue {
-    values = [];
-    get size() {
-        return this.values.length;
-    }
-    add(input, priority = false) {
-        if (priority)
-            this.values.unshift(input);
-        else
-            this.values.push(input);
-    }
-    take(waitingForInteraction) {
-        const next = this.values[0];
-        if (!next ||
-            (waitingForInteraction && (next.event.kind === "continue" || !isInteractionReply(next.event))))
-            return undefined;
-        return this.values.shift();
-    }
-    takeInterrupts() {
-        const claimed = [];
-        for (let index = 0; index < this.values.length;) {
-            const item = this.values[index];
-            if (item.event.kind !== "interrupt") {
-                index += 1;
-                continue;
-            }
-            this.values.splice(index, 1);
-            if (!item.cancelled)
-                claimed.push(item);
-        }
-        return claimed;
-    }
-    remove(input) {
-        const index = this.values.indexOf(input);
-        if (index < 0)
-            return false;
-        this.values.splice(index, 1);
-        return true;
-    }
-    drain() {
-        return this.values.splice(0);
-    }
-}
-/** Binds one caller-provided signal to its queue entry and always removes the listener at completion. */
-export function watchInputAbort(input, handlers) {
-    const signal = input.options?.signal;
-    if (!signal)
-        return;
-    const onAbort = () => {
-        input.cancelled = true;
-        if (handlers.isActive())
-            handlers.abortActive(signal.reason);
-        else
-            handlers.cancelQueued();
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-    input.stream.onFinish(() => signal.removeEventListener("abort", onAbort));
-}

package/dist/session/output-contract.d.ts

@@ -1,6 +0,0 @@
-import type { BoundToolSchema, ToolSchemaSource } from "../types/tool.js";
-/** Runtime-only validator paired with the portable JSON Schema projected to models. */
-export interface TurnOutputContract {
-    readonly schema: BoundToolSchema<unknown>;
-}
-export declare function bindOutputContract(source: ToolSchemaSource): TurnOutputContract;

package/dist/session/output-contract.js

@@ -1,12 +0,0 @@
-import { HarnessError, isHarnessError } from "../errors.js";
-import { normalizeSchema } from "../build/schema.js";
-export function bindOutputContract(source) {
-    try {
-        return Object.freeze({ schema: normalizeSchema(source, "output") });
-    }
-    catch (cause) {
-        if (isHarnessError(cause))
-            throw new HarnessError("output.invalid-schema", cause.message, { cause });
-        throw new HarnessError("output.invalid-schema", String(cause), { cause });
-    }
-}

package/dist/session/record.d.ts

@@ -1,11 +0,0 @@
-import type { ActiveExecutionRecord, SessionRecord, SessionSnapshot } from "../types/session.js";
-import type { JsonObject } from "../types/shared.js";
-export declare function sessionRecord(input: {
-    readonly state: SessionSnapshot;
-    readonly transition: SessionRecord["transition"];
-    readonly session: Readonly<{
-        readonly userId?: string;
-        readonly context?: JsonObject;
-    }>;
-    readonly active?: ActiveExecutionRecord;
-}): SessionRecord;

package/dist/session/record.js

@@ -1,26 +0,0 @@
-import { copyJson } from "../utils/immutable.js";
-export function sessionRecord(input) {
-    const value = {
-        version: 1,
-        revision: input.state.revision,
-        transition: input.transition,
-        session: {
-            id: input.state.id,
-            ...(input.session.userId === undefined ? {} : { userId: input.session.userId }),
-            ...(input.session.context === undefined ? {} : { context: copyJson(input.session.context) }),
-            turnCount: input.state.turnCount,
-            status: input.state.status,
-        },
-        transcript: copyJson(input.state.transcript),
-        ...(input.active === undefined ? {} : { active: copyJson(input.active) }),
-    };
-    return deepFreeze(value);
-}
-function deepFreeze(value, seen = new WeakSet()) {
-    if (!value || typeof value !== "object" || seen.has(value))
-        return value;
-    seen.add(value);
-    for (const child of Object.values(value))
-        deepFreeze(child, seen);
-    return Object.freeze(value);
-}

package/dist/session/scheduler.d.ts

@@ -1,62 +0,0 @@
-import type { InputEvent, InputOptions, SessionRecorder, SessionSnapshot } from "../types/session.js";
-import type { Observer } from "../types/shared.js";
-import { SessionEventLog } from "./event-log.js";
-import { SubmissionStream } from "./submission-stream.js";
-import { type LoopAgent } from "../build/agent.js";
-import type { NormalizedSessionSeed } from "./seed.js";
-/** Coordinates one active turn at a time; TurnRunner owns the turn's internal state machine. */
-export declare class SessionScheduler {
-    readonly id: string;
-    readonly events: SessionEventLog;
-    private snapshotValue;
-    private readonly queue;
-    private readonly sessionController;
-    private activeController?;
-    private activeSubmission?;
-    private activeWork?;
-    private pending?;
-    private inFlightPlan?;
-    private running;
-    private stopping;
-    private stopped;
-    private suspended;
-    private generation;
-    private stopPromise?;
-    private recordFailure?;
-    private readonly turns;
-    private readonly states;
-    constructor(id: string, agent: LoopAgent, session: Readonly<{
-        readonly userId?: string;
-        readonly context?: import("../types/shared.js").JsonObject;
-    }>, options?: {
-        readonly seed?: NormalizedSessionSeed;
-        readonly recorder?: SessionRecorder;
-        readonly observer?: Observer;
-    });
-    private readonly session;
-    private readonly recorder?;
-    private readonly observer?;
-    get snapshot(): SessionSnapshot;
-    submit(event: InputEvent, options?: InputOptions): SubmissionStream;
-    continue(options?: InputOptions): SubmissionStream;
-    private submitWork;
-    stop(reason?: string): Promise<void>;
-    private enqueueReply;
-    private enqueueOrdinaryInput;
-    private watchAbort;
-    private reject;
-    private finishCancelled;
-    private finishStopped;
-    private publish;
-    private pump;
-    private run;
-    private resumeTurn;
-    private applyTurnOutcome;
-    private emitObserve;
-    private commitCancelledPlan;
-    private claimInterrupts;
-    private commit;
-    private assertRecordable;
-    private failRecording;
-    private assertCurrent;
-}