@nylorun/harness 0.11.1-beta → 0.13.0-beta

package/dist/session/submission-stream.d.ts

@@ -1,16 +0,0 @@
-import type { InputCompletion, InputHandle, SessionEvent } from "../types/session.js";
-import type { JsonValue } from "../types/shared.js";
-export declare class SubmissionStream implements InputHandle<JsonValue> {
-    readonly inputId: string;
-    readonly completed: Promise<InputCompletion<JsonValue>>;
-    private resolveCompletion;
-    private rejectCompletion;
-    private readonly events;
-    private readonly cleanups;
-    private done;
-    constructor(inputId: string);
-    emit(event: SessionEvent<JsonValue>): void;
-    finish(status: InputCompletion<JsonValue>["status"]): void;
-    fail(error: unknown): void;
-    onFinish(cleanup: () => void): void;
-}

package/dist/session/submission-stream.js

@@ -1,46 +0,0 @@
-export class SubmissionStream {
-    inputId;
-    completed;
-    resolveCompletion;
-    rejectCompletion;
-    events = [];
-    cleanups = [];
-    done = false;
-    constructor(inputId) {
-        this.inputId = inputId;
-        this.completed = new Promise((resolve, reject) => {
-            this.resolveCompletion = resolve;
-            this.rejectCompletion = reject;
-        });
-    }
-    emit(event) {
-        if (!this.done)
-            this.events.push(event);
-    }
-    finish(status) {
-        if (this.done)
-            return;
-        this.done = true;
-        while (this.cleanups.length)
-            this.cleanups.pop()();
-        this.resolveCompletion(Object.freeze({
-            inputId: this.inputId,
-            status,
-            events: Object.freeze([...this.events]),
-        }));
-    }
-    fail(error) {
-        if (this.done)
-            return;
-        this.done = true;
-        while (this.cleanups.length)
-            this.cleanups.pop()();
-        this.rejectCompletion(error);
-    }
-    onFinish(cleanup) {
-        if (this.done)
-            cleanup();
-        else
-            this.cleanups.push(cleanup);
-    }
-}

package/dist/step/resolve.d.ts

@@ -1,10 +0,0 @@
-import type { InputEvent } from "../types/session.js";
-import type { ModelRequest } from "../types/model.js";
-import type { ToolResult } from "../types/tool.js";
-import type { StepContext } from "./step-context.js";
-export declare function resolveModelRequest(input: {
-    context: StepContext;
-    arrivals: readonly InputEvent[];
-    toolResults: readonly ToolResult[];
-    output?: import("../session/output-contract.js").TurnOutputContract;
-}): ModelRequest;

package/dist/step/run.d.ts

@@ -1,33 +0,0 @@
-import type { ModelCandidate } from "../types/model.js";
-import type { ActiveModelExecutionRecord, InputEvent, SessionSnapshot } from "../types/session.js";
-import type { LoopAgent } from "../build/agent.js";
-import type { ObserveEmit } from "../utils/observe.js";
-import { type SealedStepOutput } from "./seal.js";
-import type { CapabilityStateRegistry } from "../session/capability-state.js";
-export interface StepRunResult {
-    readonly stepId: string;
-    readonly state: SessionSnapshot;
-    readonly candidate?: ModelCandidate;
-    readonly output: SealedStepOutput;
-    readonly requestedModelId?: string;
-}
-export declare function runStep(input: {
-    agent: LoopAgent;
-    observe: ObserveEmit;
-    state: SessionSnapshot;
-    sessionId: string;
-    turnId: string;
-    stepId: string;
-    turnNumber: number;
-    stepNumber: number;
-    arrivals: readonly InputEvent[];
-    toolResults: readonly import("../types/tool.js").ToolResult[];
-    signal: AbortSignal;
-    session: Readonly<{
-        readonly userId?: string;
-        readonly context?: import("../types/shared.js").JsonObject;
-    }>;
-    states: CapabilityStateRegistry;
-    output?: import("../session/output-contract.js").TurnOutputContract;
-    recordModelRequested(state: SessionSnapshot, active: ActiveModelExecutionRecord): Promise<SessionSnapshot>;
-}): Promise<StepRunResult>;

package/dist/turn/plan-runner.d.ts

@@ -1,70 +0,0 @@
-import type { ObserveEmit } from "../utils/observe.js";
-import type { InputEvent } from "../types/session.js";
-import type { ActiveInteractionExecutionRecord, ActiveToolsExecutionRecord } from "../types/session.js";
-import type { RequiredInteraction, ToolExecutionResume, ToolResult } from "../types/tool.js";
-import type { JsonValue } from "../types/shared.js";
-import type { CapabilityStateRegistry } from "../session/capability-state.js";
-import type { ExecutablePlanEntry, InternalToolPlan } from "../step/seal.js";
-export interface DeferredToolCall {
-    readonly callId: string;
-    readonly toolName: string;
-    readonly args: JsonValue;
-    readonly invocationId: string;
-    readonly owner: ExecutablePlanEntry["owner"];
-    readonly token?: JsonValue;
-}
-export type ToolPlanProgress = {
-    readonly kind: "completed";
-    readonly results: readonly ToolResult[];
-} | {
-    readonly kind: "interaction-required";
-    readonly interaction: RequiredInteraction;
-} | {
-    readonly kind: "deferred";
-    readonly settled: readonly ToolResult[];
-    readonly deferred: readonly DeferredToolCall[];
-};
-export interface ToolPlanRunContext {
-    readonly signal: AbortSignal;
-    readonly observe: ObserveEmit;
-    readonly ids: {
-        readonly sessionId: string;
-        readonly turnId: string;
-        readonly stepId: string;
-    };
-    readonly states?: CapabilityStateRegistry;
-}
-/** Owns one sealed plan's deterministic interaction and concurrent execution progress. */
-export declare class ToolPlanRunner {
-    private readonly plan;
-    private readonly results;
-    private readonly deferred;
-    private readonly resumes;
-    private readonly pending;
-    private readonly settlementEvents;
-    private interactionIndex;
-    private executeStarted;
-    private resumeExecute?;
-    constructor(plan: InternalToolPlan);
-    get interactionId(): string | undefined;
-    get interactionKind(): RequiredInteraction["kind"] | undefined;
-    get interactionCallId(): string | undefined;
-    get interactionToolName(): string | undefined;
-    cancelledResults(reason: string): readonly ToolResult[];
-    /** Publishes settlement facts only after their authoritative state was recorded. */
-    publishSettlements(observe: ObserveEmit): void;
-    activeToolsRecord(turnId: string, stepId: string): ActiveToolsExecutionRecord;
-    activeInteractionRecord(turnId: string, stepId: string, resume?: ToolExecutionResume): ActiveInteractionExecutionRecord;
-    interactionResume(event: InputEvent): ToolExecutionResume;
-    run(context: ToolPlanRunContext, resume?: InputEvent): Promise<ToolPlanProgress>;
-    private acceptResume;
-    private executeBatch;
-    private execute;
-    private takeResume;
-    private enqueueInteraction;
-    private interactionRequired;
-    private orderedResults;
-    private orderedSettledResults;
-    private resultsInOrder;
-    private throwIfAborted;
-}

package/dist/turn/plan-runner.js

@@ -1,388 +0,0 @@
-import { HarnessError, isHarnessError } from "../errors.js";
-import { createId } from "../utils/ids.js";
-import { assertJson, copyJson, copyJsonObject } from "../utils/immutable.js";
-/** Owns one sealed plan's deterministic interaction and concurrent execution progress. */
-export class ToolPlanRunner {
-    plan;
-    results;
-    deferred = new Map();
-    resumes = new Map();
-    pending = [];
-    settlementEvents = [];
-    interactionIndex = 0;
-    executeStarted = false;
-    resumeExecute;
-    constructor(plan) {
-        this.plan = plan;
-        this.results = new Map(plan.immediateResults.map((item) => [item.callId, item]));
-    }
-    get interactionId() {
-        return this.pending[0]?.interaction.id;
-    }
-    get interactionKind() {
-        return this.pending[0]?.interaction.kind;
-    }
-    get interactionCallId() {
-        const pending = this.pending[0];
-        return pending ? this.plan.executable[pending.index]?.call.callId : undefined;
-    }
-    get interactionToolName() {
-        const pending = this.pending[0];
-        return pending ? this.plan.executable[pending.index]?.call.toolName : undefined;
-    }
-    cancelledResults(reason) {
-        return this.resultsInOrder("tool.cancelled", reason);
-    }
-    /** Publishes settlement facts only after their authoritative state was recorded. */
-    publishSettlements(observe) {
-        for (const event of this.settlementEvents.splice(0))
-            observe(event);
-    }
-    activeToolsRecord(turnId, stepId) {
-        return Object.freeze({
-            kind: "tools",
-            turnId,
-            stepId,
-            calls: Object.freeze(this.plan.executable.map((entry) => {
-                const result = this.results.get(entry.call.callId);
-                const deferred = this.deferred.get(entry.call.callId);
-                return Object.freeze({
-                    callId: entry.call.callId,
-                    toolName: entry.call.toolName,
-                    args: copyJson(entry.call.args),
-                    invocationId: entry.invocationId,
-                    owner: entry.owner,
-                    status: result
-                        ? "settled"
-                        : deferred
-                            ? "deferred"
-                            : "pending",
-                    ...(result ? { result } : {}),
-                    ...(deferred?.token === undefined ? {} : { token: deferred.token }),
-                });
-            })),
-        });
-    }
-    activeInteractionRecord(turnId, stepId, resume) {
-        const pending = this.pending[0];
-        const entry = pending ? this.plan.executable[pending.index] : undefined;
-        if (!pending || !entry)
-            throw new HarnessError("interaction.invalid", "Missing pending interaction state");
-        return Object.freeze({
-            kind: "interaction",
-            turnId,
-            stepId,
-            callId: entry.call.callId,
-            toolName: entry.call.toolName,
-            interaction: pending.interaction,
-            ...(pending.token === undefined ? {} : { token: pending.token }),
-            ...(resume === undefined ? {} : { resume }),
-            tools: this.activeToolsRecord(turnId, stepId),
-        });
-    }
-    interactionResume(event) {
-        const pending = this.pending[0];
-        if (!pending)
-            throw new HarnessError("interaction.invalid", "Missing pending interaction state");
-        return resumeValue(event, pending);
-    }
-    async run(context, resume) {
-        this.acceptResume(resume);
-        while (this.interactionIndex < this.plan.executable.length) {
-            this.throwIfAborted(context.signal);
-            const entry = this.plan.executable[this.interactionIndex];
-            if (this.results.has(entry.call.callId)) {
-                this.interactionIndex += 1;
-                continue;
-            }
-            if (entry.interaction) {
-                this.enqueueInteraction({ index: this.interactionIndex, interaction: entry.interaction });
-                return this.interactionRequired();
-            }
-            this.interactionIndex += 1;
-        }
-        if (this.resumeExecute) {
-            const entry = this.resumeExecute;
-            this.resumeExecute = undefined;
-            await this.executeBatch([entry], context);
-        }
-        else if (!this.executeStarted) {
-            this.executeStarted = true;
-            await this.executeBatch(this.plan.executable.filter((entry) => !this.results.has(entry.call.callId)), context);
-        }
-        if (this.pending.length)
-            return this.interactionRequired();
-        if (this.deferred.size)
-            return {
-                kind: "deferred",
-                settled: this.orderedSettledResults(),
-                deferred: Object.freeze(this.plan.executable.flatMap((entry) => {
-                    const value = this.deferred.get(entry.call.callId);
-                    return value ? [value] : [];
-                })),
-            };
-        return { kind: "completed", results: this.orderedResults() };
-    }
-    acceptResume(resume) {
-        const pending = this.pending.shift();
-        if (!pending)
-            return;
-        if (!resume)
-            throw new HarnessError("interaction.missing-resume", "A pending tool plan requires a correlated interaction input");
-        const value = resumeValue(resume, pending);
-        const entry = this.plan.executable[pending.index];
-        if (value.kind === "approval" && value.approved === false) {
-            this.results.set(entry.call.callId, Object.freeze({
-                callId: entry.call.callId,
-                toolName: entry.call.toolName,
-                kind: "denied",
-                reason: "Approval rejected",
-            }));
-            this.interactionIndex = Math.max(this.interactionIndex, pending.index + 1);
-            return;
-        }
-        this.resumes.set(entry.call.callId, value);
-        if (this.executeStarted)
-            this.resumeExecute = entry;
-        else
-            this.interactionIndex = Math.max(this.interactionIndex, pending.index + 1);
-    }
-    async executeBatch(entries, context) {
-        const settled = await Promise.allSettled(entries.map((entry) => this.execute(entry, context)));
-        if (context.signal.aborted)
-            throw context.signal.reason;
-        for (const outcome of settled) {
-            if (outcome.status === "rejected")
-                throw outcome.reason;
-            if (outcome.value)
-                this.enqueueInteraction(outcome.value);
-        }
-    }
-    async execute(entry, context) {
-        context.observe({
-            type: "tool.started",
-            sessionId: context.ids.sessionId,
-            turnId: context.ids.turnId,
-            stepId: context.ids.stepId,
-            toolName: entry.call.toolName,
-            callId: entry.call.callId,
-            invocationId: entry.invocationId,
-            middlewareId: entry.owner.middlewareId,
-            slot: entry.owner.slot,
-            attributes: { args: copyJson(entry.call.args) },
-        });
-        try {
-            const toolContext = {
-                sessionId: context.ids.sessionId,
-                turnId: context.ids.turnId,
-                stepId: context.ids.stepId,
-                callId: entry.call.callId,
-                invocationId: entry.invocationId,
-                signal: context.signal,
-                resume: this.takeResume(entry.call.callId),
-            };
-            if (context.states?.has(entry.owner.middlewareId))
-                Object.defineProperty(toolContext, "state", {
-                    enumerable: true,
-                    get: () => context.states.get(entry.owner.middlewareId),
-                });
-            const outcome = await entry.execute(entry.call.args, Object.freeze(toolContext));
-            this.throwIfAborted(context.signal);
-            if (!outcome || typeof outcome !== "object" || typeof outcome.kind !== "string")
-                throw new HarnessError("tool.invalid-tool-result", "Tool returned an invalid outcome");
-            if (outcome.kind === "interaction-required")
-                return interactionBarrier(this.plan.executable.indexOf(entry), outcome);
-            if (outcome.kind === "deferred") {
-                const value = Object.freeze({
-                    callId: entry.call.callId,
-                    toolName: entry.call.toolName,
-                    args: copyJson(entry.call.args),
-                    invocationId: entry.invocationId,
-                    owner: entry.owner,
-                    ...(outcome.token === undefined ? {} : { token: copyJson(outcome.token) }),
-                });
-                this.deferred.set(entry.call.callId, value);
-                this.settlementEvents.push({
-                    type: "tool.deferred",
-                    sessionId: context.ids.sessionId,
-                    turnId: context.ids.turnId,
-                    stepId: context.ids.stepId,
-                    toolName: entry.call.toolName,
-                    callId: entry.call.callId,
-                    invocationId: entry.invocationId,
-                    middlewareId: entry.owner.middlewareId,
-                    slot: entry.owner.slot,
-                    attributes: outcome.token === undefined ? {} : { token: copyJson(outcome.token) },
-                });
-                return undefined;
-            }
-            const result = resultFrom(entry, outcome);
-            this.results.set(entry.call.callId, result);
-            this.settlementEvents.push(completedEvent(entry, context, result));
-        }
-        catch (error) {
-            this.throwIfAborted(context.signal);
-            const result = failed(entry, isHarnessError(error) ? error.code : "tool.execution-failed", error);
-            this.results.set(entry.call.callId, result);
-            this.settlementEvents.push(completedEvent(entry, context, result));
-        }
-        return undefined;
-    }
-    takeResume(callId) {
-        const value = this.resumes.get(callId);
-        this.resumes.delete(callId);
-        return value;
-    }
-    enqueueInteraction(pending) {
-        const position = this.pending.findIndex((item) => item.index > pending.index);
-        if (position === -1)
-            this.pending.push(pending);
-        else
-            this.pending.splice(position, 0, pending);
-    }
-    interactionRequired() {
-        const pending = this.pending[0];
-        if (!pending)
-            throw new HarnessError("interaction.invalid", "Missing pending interaction");
-        return { kind: "interaction-required", interaction: pending.interaction };
-    }
-    orderedResults() {
-        return this.resultsInOrder("tool.missing-result", "Tool call did not produce a result");
-    }
-    orderedSettledResults() {
-        return Object.freeze(this.plan.order.flatMap(({ callId }) => {
-            const result = this.results.get(callId);
-            return result ? [result] : [];
-        }));
-    }
-    resultsInOrder(code, message) {
-        return Object.freeze(this.plan.order.map(({ callId, toolName }) => this.results.get(callId) ??
-            Object.freeze({ kind: "failed", callId, toolName, code, message })));
-    }
-    throwIfAborted(signal) {
-        if (signal.aborted)
-            throw signal.reason;
-    }
-}
-function interactionBarrier(index, outcome) {
-    return {
-        index,
-        interaction: normalizeInteraction(outcome.interaction),
-        ...(outcome.token === undefined ? {} : { token: copyJson(outcome.token) }),
-    };
-}
-function normalizeInteraction(value) {
-    if (!value || typeof value !== "object")
-        throw new HarnessError("interaction.invalid", "Interaction must be an object");
-    if (value.kind !== "approval" && value.kind !== "response")
-        throw new HarnessError("interaction.invalid", "Interaction kind must be approval or response");
-    if (typeof value.prompt !== "string")
-        throw new HarnessError("interaction.invalid", "Interaction prompt must be a string");
-    if (value.id !== undefined && (typeof value.id !== "string" || !value.id))
-        throw new HarnessError("interaction.invalid", "Interaction id must be a non-empty string");
-    return Object.freeze({
-        id: value.id ?? createId("interaction"),
-        kind: value.kind,
-        prompt: value.prompt,
-        ...(value.metadata === undefined
-            ? {}
-            : { metadata: copyJsonObject(value.metadata, "interaction metadata") }),
-    });
-}
-function resumeValue(event, pending) {
-    if (event.kind === "approve")
-        return Object.freeze({
-            interactionId: event.interactionId,
-            kind: "approval",
-            approved: event.approved,
-            ...(pending.token === undefined ? {} : { token: pending.token }),
-        });
-    if (event.kind === "respond")
-        return Object.freeze({
-            interactionId: event.interactionId,
-            kind: "response",
-            value: event.value,
-            ...(pending.token === undefined ? {} : { token: pending.token }),
-        });
-    throw new HarnessError("interaction.uncorrelated-resume", "Only correlated interaction input can resume a plan");
-}
-function resultFrom(entry, outcome) {
-    const base = { callId: entry.call.callId, toolName: entry.call.toolName };
-    switch (outcome.kind) {
-        case "completed": {
-            const output = validatedOutput(entry, outcome.output);
-            if (!output.ok)
-                return Object.freeze({
-                    ...base,
-                    kind: "failed",
-                    code: "tool.invalid-output",
-                    message: output.message,
-                    details: output.details,
-                });
-            return Object.freeze({ ...base, kind: "completed", output: output.value });
-        }
-        case "denied":
-            if (typeof outcome.reason !== "string")
-                throw new HarnessError("tool.invalid-tool-result", "Tool denial reason must be a string");
-            return Object.freeze({ ...base, kind: "denied", reason: outcome.reason });
-        case "failed":
-            if (typeof outcome.code !== "string" || typeof outcome.message !== "string")
-                throw new HarnessError("tool.invalid-tool-result", "Tool failure code and message must be strings");
-            return Object.freeze({
-                ...base,
-                kind: "failed",
-                code: outcome.code,
-                message: outcome.message,
-            });
-    }
-}
-function validatedOutput(entry, value) {
-    const validation = entry.outputSchema?.validate(value) ?? { ok: true, value };
-    if (!validation.ok)
-        return validationFailure("output", validation.issues);
-    try {
-        assertJson(validation.value, `output for '${entry.call.toolName}'`);
-        return { ok: true, value: copyJson(validation.value) };
-    }
-    catch (error) {
-        return validationFailure("output", [
-            Object.freeze({
-                path: Object.freeze([]),
-                code: "invalid_json",
-                message: error instanceof Error ? error.message : String(error),
-            }),
-        ]);
-    }
-}
-function validationFailure(phase, issues) {
-    return {
-        ok: false,
-        message: issues.map((item) => `${item.path.join(".") || "(root)"}: ${item.message}`).join("; "),
-        details: Object.freeze({ phase, issues: Object.freeze([...issues]) }),
-    };
-}
-function completedEvent(entry, context, result) {
-    return {
-        type: "tool.completed",
-        sessionId: context.ids.sessionId,
-        turnId: context.ids.turnId,
-        stepId: context.ids.stepId,
-        toolName: entry.call.toolName,
-        callId: entry.call.callId,
-        invocationId: entry.invocationId,
-        middlewareId: entry.owner.middlewareId,
-        slot: entry.owner.slot,
-        outcome: result.kind,
-        ...(result.kind === "failed" ? { code: result.code } : {}),
-        attributes: copyJson(result),
-    };
-}
-function failed(entry, code, error) {
-    return Object.freeze({
-        callId: entry.call.callId,
-        toolName: entry.call.toolName,
-        kind: "failed",
-        code,
-        message: error instanceof Error ? error.message : String(error),
-    });
-}

package/dist/turn/runner.d.ts

@@ -1,69 +0,0 @@
-import type { ActiveExecutionRecord, InputEvent, SessionEvent, SessionRecord, SessionSnapshot } from "../types/session.js";
-import type { JsonObject, JsonValue, Tripwire } from "../types/shared.js";
-import type { RequiredInteraction } from "../types/tool.js";
-import type { LoopAgent } from "../build/agent.js";
-import type { ObserveEmit } from "../utils/observe.js";
-import { ToolPlanRunner } from "./plan-runner.js";
-import type { CapabilityStateRegistry } from "../session/capability-state.js";
-import type { TurnOutputContract } from "../session/output-contract.js";
-export interface PendingTurn {
-    readonly plan: ToolPlanRunner;
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly stepNumber: number;
-    readonly output?: TurnOutputContract;
-}
-export type TurnProgress = {
-    readonly kind: "final";
-    readonly state: SessionSnapshot;
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly output: JsonValue;
-} | {
-    readonly kind: "interaction-required";
-    readonly state: SessionSnapshot;
-    readonly pending: PendingTurn;
-    readonly interaction: RequiredInteraction;
-} | {
-    readonly kind: "deferred";
-    readonly state: SessionSnapshot;
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly active: ActiveExecutionRecord;
-} | {
-    readonly kind: "tripwire";
-    readonly state: SessionSnapshot;
-    readonly turnId: string;
-    readonly stepId?: string;
-    readonly tripwire: Tripwire;
-};
-export interface TurnRunContext {
-    readonly signal: AbortSignal;
-    readonly states: CapabilityStateRegistry;
-    readonly observe: ObserveEmit;
-    readonly assertCurrent: () => void;
-    readonly onPlanActive: (pending: PendingTurn | undefined) => void;
-    readonly commit: (state: SessionSnapshot, transition: SessionRecord["transition"], active?: ActiveExecutionRecord) => Promise<SessionSnapshot>;
-    readonly onConversation: (event: SessionEvent<JsonValue>) => void;
-    readonly claimInterrupts: (state: SessionSnapshot, turnId: string) => Promise<{
-        readonly state: SessionSnapshot;
-        readonly arrivals: readonly InputEvent[];
-    }>;
-}
-/** Advances one Turn until it finalizes, trips policy, or reaches a waiting barrier. */
-export declare class TurnRunner {
-    private readonly agent;
-    private readonly sessionId;
-    private readonly session;
-    constructor(agent: LoopAgent, sessionId: string, session: Readonly<{
-        readonly userId?: string;
-        readonly context?: JsonObject;
-    }>);
-    start(state: SessionSnapshot, event: InputEvent, context: TurnRunContext, output?: TurnOutputContract): Promise<TurnProgress>;
-    continue(state: SessionSnapshot, context: TurnRunContext): Promise<TurnProgress>;
-    resume(state: SessionSnapshot, pending: PendingTurn, event: InputEvent, context: TurnRunContext): Promise<TurnProgress>;
-    private advance;
-    private waitForInteraction;
-    private waitForDeferred;
-    private runPlan;
-}