@nylorun/harness 0.12.0-beta → 0.13.0-beta

package/dist/turn/runner.js

@@ -1,159 +0,0 @@
-import { beginTurn, commitCandidate, commitFinal, commitToolResults, withStatus, } from "../session/state.js";
-import { runStep } from "../step/run.js";
-import { createId } from "../utils/ids.js";
-import { copyJson } from "../utils/immutable.js";
-import { ToolPlanRunner } from "./plan-runner.js";
-/** Advances one Turn until it finalizes, trips policy, or reaches a waiting barrier. */
-export class TurnRunner {
-    agent;
-    sessionId;
-    session;
-    constructor(agent, sessionId, session) {
-        this.agent = agent;
-        this.sessionId = sessionId;
-        this.session = session;
-    }
-    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, output);
-    }
-    async continue(state, context) {
-        const turnId = createId("turn");
-        return this.advance(beginTurn(state, turnId), turnId, 1, [], [], context);
-    }
-    async resume(state, pending, event, context) {
-        const resume = pending.plan.interactionResume(event);
-        const active = pending.plan.activeInteractionRecord(pending.turnId, pending.stepId, resume);
-        state = await context.commit(withStatus(state, "running", undefined, active), "input", active);
-        context.onConversation({ type: "input", event, turnId: pending.turnId });
-        const progress = await this.runPlan(pending, context, event);
-        if (progress.kind === "interaction-required")
-            return this.waitForInteraction(state, pending, progress.interaction, context);
-        if (progress.kind === "deferred")
-            return this.waitForDeferred(state, pending, pending.plan.activeToolsRecord(pending.turnId, pending.stepId), context);
-        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, pending.output);
-    }
-    async advance(initialState, turnId, firstStep, arrivals, initialResults, context, output) {
-        let state = initialState;
-        let stepArrivals = arrivals;
-        let toolResults = initialResults;
-        for (let stepNumber = firstStep;; stepNumber += 1) {
-            const stepId = createId("step");
-            const run = await runStep({
-                agent: this.agent,
-                observe: context.observe,
-                state,
-                sessionId: this.sessionId,
-                turnId,
-                stepId,
-                turnNumber: state.turnCount,
-                stepNumber,
-                arrivals: stepArrivals,
-                toolResults,
-                signal: context.signal,
-                session: this.session,
-                states: context.states,
-                output,
-                recordModelRequested: (next, active) => context.commit(next, "model-requested", active),
-            });
-            context.assertCurrent();
-            state = run.state;
-            const pending = run.output.kind === "tools"
-                ? {
-                    plan: new ToolPlanRunner(run.output.plan),
-                    turnId,
-                    stepId,
-                    stepNumber,
-                    ...(output === undefined ? {} : { output }),
-                }
-                : undefined;
-            if (run.candidate) {
-                const active = pending?.plan.activeToolsRecord(turnId, stepId);
-                state = await context.commit(commitCandidate(state, turnId, stepId, run.candidate), "candidate", active);
-                context.observe({
-                    type: "model.completed",
-                    turnId,
-                    stepId,
-                    ...(run.requestedModelId === undefined ? {} : { requestedModelId: run.requestedModelId }),
-                    attributes: run.candidate,
-                });
-                context.onConversation({ type: "candidate", turnId, stepId, candidate: run.candidate });
-            }
-            if (run.output.kind === "tripwire")
-                return { kind: "tripwire", state, turnId, stepId, tripwire: run.output.tripwire };
-            if (run.output.kind === "deferred-model") {
-                state = await context.commit(withStatus(state, "waiting", undefined, run.output.active), "waiting", run.output.active);
-                return { kind: "deferred", state, turnId, stepId, active: run.output.active };
-            }
-            if (run.output.kind === "final") {
-                state = await context.commit(withStatus(commitFinal(state, turnId, stepId, run.output.output), "idle"), "final");
-                return { kind: "final", state, turnId, stepId, output: run.output.output };
-            }
-            const toolPlan = run.output.plan;
-            context.observe(() => ({
-                type: "tool.sealed",
-                turnId,
-                stepId,
-                attributes: {
-                    executable: Object.freeze(toolPlan.executable.map((entry) => Object.freeze({
-                        callId: entry.call.callId,
-                        toolName: entry.call.toolName,
-                        args: copyJson(entry.call.args),
-                        invocationId: entry.invocationId,
-                        owner: entry.owner,
-                        ...(entry.interaction === undefined
-                            ? {}
-                            : { interaction: copyJson(entry.interaction) }),
-                    }))),
-                    immediate: copyJson(toolPlan.immediateResults),
-                },
-            }));
-            const progress = await this.runPlan(pending, context);
-            if (progress.kind === "interaction-required")
-                return this.waitForInteraction(state, pending, progress.interaction, context);
-            if (progress.kind === "deferred")
-                return this.waitForDeferred(state, pending, pending.plan.activeToolsRecord(turnId, stepId), context);
-            state = await context.commit(commitToolResults(state, turnId, stepId, progress.results), "tool-results");
-            pending.plan.publishSettlements(context.observe);
-            const claimed = await context.claimInterrupts(state, turnId);
-            state = claimed.state;
-            stepArrivals = claimed.arrivals;
-            toolResults = progress.results;
-        }
-    }
-    async waitForInteraction(state, pending, interaction, context) {
-        const active = pending.plan.activeInteractionRecord(pending.turnId, pending.stepId);
-        state = await context.commit(withStatus(state, "waiting", interaction, active), "waiting", active);
-        pending.plan.publishSettlements(context.observe);
-        return { kind: "interaction-required", state, pending, interaction };
-    }
-    async waitForDeferred(state, pending, active, context) {
-        state = await context.commit(withStatus(state, "waiting", undefined, active), "waiting", active);
-        pending.plan.publishSettlements(context.observe);
-        return {
-            kind: "deferred",
-            state,
-            turnId: pending.turnId,
-            stepId: pending.stepId,
-            active,
-        };
-    }
-    async runPlan(pending, context, resume) {
-        context.onPlanActive(pending);
-        const progress = await pending.plan.run({
-            signal: context.signal,
-            observe: context.observe,
-            ids: { sessionId: this.sessionId, turnId: pending.turnId, stepId: pending.stepId },
-            states: context.states,
-            onModelCall: this.agent.invoke,
-        }, resume);
-        context.assertCurrent();
-        context.onPlanActive(undefined);
-        return progress;
-    }
-}

package/dist/types/session.d.ts

@@ -1,230 +0,0 @@
-import type { ModelAdapter, ModelCall, ModelCandidate } from "./model.js";
-import type { JsonObject, JsonValue, Observer, Tripwire } from "./shared.js";
-import type { RequiredInteraction, SchemaOutput, ToolExecutionResume, ToolOwner, ToolResult, ToolSchemaSource } from "./tool.js";
-export type InputEvent = {
-    readonly kind: "user-message" | "interrupt";
-    readonly text: string;
-    readonly metadata?: JsonObject;
-} | {
-    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";
-    readonly interactionId: string;
-    readonly approved: boolean;
-} | {
-    readonly kind: "respond";
-    readonly interactionId: string;
-    readonly value: JsonValue;
-};
-export type SessionEvent<Output = string> = {
-    readonly type: "input";
-    readonly event: InputEvent;
-    readonly turnId: string;
-} | {
-    readonly type: "candidate";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly candidate: ModelCandidate;
-} | {
-    readonly type: "final";
-    readonly output: Output;
-    readonly turnId: string;
-} | {
-    readonly type: "interaction.required";
-    readonly interaction: RequiredInteraction;
-    readonly turnId: string;
-} | {
-    readonly type: "tripwire";
-    readonly tripwire: Tripwire;
-    readonly turnId: string;
-} | {
-    readonly type: "execution.deferred";
-    readonly active: ActiveExecutionRecord;
-    readonly turnId: 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: "session.stopped";
-    readonly sessionId: string;
-};
-export interface InputCompletion<Output = string> {
-    readonly inputId: string;
-    readonly status: "completed" | "waiting" | "rejected" | "cancelled" | "stopped";
-    readonly events: readonly SessionEvent<Output>[];
-}
-export interface InputHandle<Output = string> {
-    readonly inputId: string;
-    readonly completed: Promise<InputCompletion<Output>>;
-}
-export interface SessionOptions {
-    readonly onModelCall: ModelAdapter;
-    readonly id?: string;
-    readonly userId?: string;
-    readonly context?: JsonObject;
-    readonly seed?: never;
-    readonly recorder?: SessionRecorder;
-    readonly observer?: Observer;
-}
-/** Stable host-owned facts available while a capability creates session-local state. */
-export interface SessionIdentity {
-    readonly id: string;
-    readonly userId?: string;
-    readonly context?: JsonObject;
-}
-export interface SeededSessionOptions {
-    readonly onModelCall: ModelAdapter;
-    readonly seed: SessionSeed;
-    readonly recorder?: SessionRecorder;
-    readonly observer?: Observer;
-    readonly id?: never;
-    readonly userId?: never;
-    readonly context?: never;
-}
-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";
-}>;
-/** Ordinary user text or an interaction reply. Use `Session.interrupt()` for barge-in text. */
-export type SessionInput = MessageInput | InteractionReply;
-export interface TranscriptInputEntry {
-    readonly kind: "input";
-    readonly turnId: string;
-    readonly event: InputEvent;
-}
-export interface TranscriptCandidateEntry {
-    readonly kind: "candidate";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly candidate: ModelCandidate;
-}
-export interface TranscriptToolsEntry {
-    readonly kind: "tool-results";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly results: readonly ToolResult[];
-}
-export interface TranscriptFinalEntry {
-    readonly kind: "final";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly output: JsonValue;
-}
-export type TranscriptEntry = TranscriptInputEntry | TranscriptCandidateEntry | TranscriptToolsEntry | TranscriptFinalEntry;
-export interface SessionSnapshot {
-    readonly id: string;
-    readonly status: "idle" | "running" | "waiting" | "stopped";
-    readonly turnCount: number;
-    readonly revision: number;
-    readonly transcript: readonly TranscriptEntry[];
-    readonly pendingInteraction?: RequiredInteraction;
-    readonly active?: ActiveExecutionRecord;
-}
-export interface SessionSeed {
-    readonly id?: string;
-    readonly userId?: string;
-    readonly context?: JsonObject;
-    readonly turnCount?: number;
-    readonly revision?: number;
-    readonly transcript: readonly TranscriptEntry[];
-}
-export interface ActiveModelExecutionRecord {
-    readonly kind: "model";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly invocationId: string;
-    readonly call: ModelCall;
-    readonly token?: JsonValue;
-}
-export interface ActiveToolCallRecord {
-    readonly callId: string;
-    readonly toolName: string;
-    readonly args: JsonValue;
-    readonly invocationId: string;
-    readonly owner: ToolOwner;
-    readonly status: "pending" | "settled" | "deferred";
-    readonly result?: ToolResult;
-    readonly token?: JsonValue;
-}
-export interface ActiveToolsExecutionRecord {
-    readonly kind: "tools";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly calls: readonly ActiveToolCallRecord[];
-}
-export interface ActiveInteractionExecutionRecord {
-    readonly kind: "interaction";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly callId: string;
-    readonly toolName: string;
-    readonly interaction: RequiredInteraction;
-    readonly token?: JsonValue;
-    readonly resume?: ToolExecutionResume;
-    readonly tools: ActiveToolsExecutionRecord;
-}
-export type ActiveExecutionRecord = ActiveModelExecutionRecord | ActiveToolsExecutionRecord | ActiveInteractionExecutionRecord;
-export interface SessionRecord {
-    readonly version: 1;
-    readonly revision: number;
-    readonly transition: "input" | "model-requested" | "candidate" | "tool-results" | "waiting" | "final" | "stopped";
-    readonly session: {
-        readonly id: string;
-        readonly userId?: string;
-        readonly context?: JsonObject;
-        readonly turnCount: number;
-        readonly status: SessionSnapshot["status"];
-    };
-    readonly transcript: readonly TranscriptEntry[];
-    readonly active?: ActiveExecutionRecord;
-}
-export interface SessionRecorder {
-    record(value: SessionRecord): Promise<void>;
-}
-export interface Session {
-    readonly id: string;
-    readonly state: SessionSnapshot;
-    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<JsonValue>>;
-    stop(reason?: string): Promise<void>;
-}

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.
-    }
-}