@nylorun/harness 0.12.0-beta → 0.13.0-beta

package/dist/session/capability-state.d.ts

@@ -1,14 +0,0 @@
-import type { BoundMiddleware } from "../types/middleware.js";
-import type { SessionIdentity } from "../types/session.js";
-import type { ObserveEmit } from "../utils/observe.js";
-/** Owns declared, process-local state for exactly one Session. */
-export declare class CapabilityStateRegistry {
-    #private;
-    private readonly session;
-    private readonly observe;
-    constructor(middleware: readonly BoundMiddleware[], session: SessionIdentity, observe: ObserveEmit);
-    has(id: string): boolean;
-    get(id: string): Promise<unknown>;
-    abort(reason: unknown): void;
-    shutdown(reason: unknown): Promise<void>;
-}

package/dist/session/capability-state.js

@@ -1,67 +0,0 @@
-import { HarnessError } from "../errors.js";
-/** Owns declared, process-local state for exactly one Session. */
-export class CapabilityStateRegistry {
-    session;
-    observe;
-    #entries = new Map();
-    #controller = new AbortController();
-    #shutdown;
-    constructor(middleware, session, observe) {
-        this.session = session;
-        this.observe = observe;
-        for (const middlewareEntry of middleware) {
-            if (middlewareEntry.state)
-                this.#entries.set(middlewareEntry.id, {
-                    id: middlewareEntry.id,
-                    state: middlewareEntry.state,
-                });
-        }
-    }
-    has(id) {
-        return this.#entries.has(id);
-    }
-    get(id) {
-        const entry = this.#entries.get(id);
-        if (!entry)
-            return Promise.reject(new HarnessError("capability.state.undeclared", `Capability '${id}' did not declare session state`));
-        if (!entry.promise) {
-            entry.promise = Promise.resolve()
-                .then(() => entry.state.create(this.session, this.#controller.signal))
-                .then((value) => {
-                entry.value = value;
-                entry.created = true;
-                return value;
-            }, (cause) => {
-                throw new HarnessError("capability.state.create-failed", `Capability '${id}' failed to create session state`, { cause });
-            });
-        }
-        return entry.promise;
-    }
-    abort(reason) {
-        this.#controller.abort(reason);
-    }
-    shutdown(reason) {
-        if (this.#shutdown)
-            return this.#shutdown;
-        this.abort(reason);
-        this.#shutdown = (async () => {
-            const created = [...this.#entries.values()].filter((entry) => entry.promise);
-            await Promise.allSettled(created.map((entry) => entry.promise));
-            for (const entry of [...created].reverse()) {
-                if (!entry.created || !entry.state.dispose)
-                    continue;
-                try {
-                    await entry.state.dispose(entry.value);
-                }
-                catch (error) {
-                    this.observe({
-                        type: "capability.state.dispose.failed",
-                        capabilityId: entry.id,
-                        attributes: { message: error instanceof Error ? error.message : String(error) },
-                    });
-                }
-            }
-        })();
-        return this.#shutdown;
-    }
-}

package/dist/session/event-log.d.ts

@@ -1,12 +0,0 @@
-import type { SessionEvent } from "../types/session.js";
-import type { JsonValue } from "../types/shared.js";
-/** Session-lifetime conversation log. Each stream() call replays from the start. */
-export declare class SessionEventLog implements AsyncIterable<SessionEvent<JsonValue>> {
-    private readonly events;
-    private readonly subscribers;
-    private done;
-    emit(event: SessionEvent<JsonValue>): void;
-    finish(): void;
-    [Symbol.asyncIterator](): AsyncIterator<SessionEvent<JsonValue>>;
-    private wake;
-}

package/dist/session/event-log.js

@@ -1,63 +0,0 @@
-/** Session-lifetime conversation log. Each stream() call replays from the start. */
-export class SessionEventLog {
-    events = [];
-    subscribers = [];
-    done = false;
-    emit(event) {
-        if (this.done)
-            return;
-        this.events.push(event);
-        this.wake();
-    }
-    finish() {
-        if (this.done)
-            return;
-        this.done = true;
-        this.wake();
-        this.subscribers.length = 0;
-    }
-    [Symbol.asyncIterator]() {
-        let index = 0;
-        let closed = false;
-        const waiting = [];
-        this.subscribers.push(waiting);
-        const detach = () => {
-            const position = this.subscribers.indexOf(waiting);
-            if (position !== -1)
-                this.subscribers.splice(position, 1);
-        };
-        const complete = () => {
-            closed = true;
-            detach();
-            return { done: true, value: undefined };
-        };
-        const pull = () => {
-            if (closed)
-                return Promise.resolve({ done: true, value: undefined });
-            if (index < this.events.length)
-                return Promise.resolve({ done: false, value: this.events[index++] });
-            if (this.done)
-                return Promise.resolve(complete());
-            return new Promise((resolve) => {
-                waiting.push(() => {
-                    void pull().then(resolve);
-                });
-            });
-        };
-        return {
-            next: pull,
-            return: () => {
-                const result = complete();
-                while (waiting.length)
-                    waiting.shift()();
-                return Promise.resolve(result);
-            },
-        };
-    }
-    wake() {
-        for (const waiting of this.subscribers) {
-            while (waiting.length)
-                waiting.shift()();
-        }
-    }
-}

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/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;
-}