@nylorun/harness 0.11.1-beta → 0.13.0-beta

package/dist/session/scheduler.js

@@ -1,485 +0,0 @@
-import { HarnessError } from "../errors.js";
-import { createId } from "../utils/ids.js";
-import { createObserverRegistry } from "../utils/observe.js";
-import { InputQueue, isInteractionReply, snapshotWork, watchInputAbort, } from "./input-queue.js";
-import { SessionEventLog } from "./event-log.js";
-import { SubmissionStream } from "./submission-stream.js";
-import { commitInput, commitToolResults, initialState, withStatus } from "./state.js";
-import {} from "../build/agent.js";
-import { TurnRunner } from "../turn/runner.js";
-import { sessionRecord } from "./record.js";
-import { CapabilityStateRegistry } from "./capability-state.js";
-/** Coordinates one active turn at a time; TurnRunner owns the turn's internal state machine. */
-export class SessionScheduler {
-    id;
-    events = new SessionEventLog();
-    snapshotValue;
-    queue = new InputQueue();
-    sessionController = new AbortController();
-    activeController;
-    activeSubmission;
-    activeWork;
-    pending;
-    inFlightPlan;
-    running = false;
-    stopping = false;
-    stopped = false;
-    suspended = false;
-    generation = 0;
-    stopPromise;
-    recordFailure;
-    observers = createObserverRegistry();
-    turns;
-    states;
-    constructor(id, agent, session, options = {}) {
-        this.id = id;
-        this.snapshotValue = initialState(id, options.seed);
-        this.turns = new TurnRunner(agent, id, session);
-        this.session = session;
-        this.recorder = options.recorder;
-        this.states = new CapabilityStateRegistry(agent.middleware, Object.freeze({ id, ...session }), (event) => this.emitObserve(event));
-        if (options.seed) {
-            const event = Object.freeze({
-                type: "session.seeded",
-                revision: options.seed.revision,
-                transcriptEntries: options.seed.transcript.length,
-            });
-            // Construction precedes public observer registration. Defer this live-only fact
-            // by one microtask so callers can subscribe immediately after run({ seed }).
-            queueMicrotask(() => {
-                if (!this.stopped)
-                    this.emitObserve(event);
-            });
-        }
-    }
-    session;
-    recorder;
-    get snapshot() {
-        return this.snapshotValue;
-    }
-    observe(listener) {
-        if (this.stopped)
-            return () => undefined;
-        return this.observers.observe(listener);
-    }
-    submit(event, options) {
-        return this.submitWork(event, options);
-    }
-    continue(options) {
-        return this.submitWork({ kind: "continue" }, options);
-    }
-    submitWork(event, options) {
-        const stream = new SubmissionStream(createId("input"));
-        const submission = {
-            event: snapshotWork(event),
-            options,
-            stream,
-            cancelled: false,
-        };
-        if (this.stopped)
-            return this.finishStopped(stream);
-        if (options?.signal?.aborted)
-            return this.finishCancelled(stream, cancellationMessage(options.signal));
-        if (event.kind !== "continue" && isInteractionReply(event)) {
-            if (!this.enqueueReply(submission, event))
-                return stream;
-        }
-        else
-            this.enqueueOrdinaryInput(submission);
-        this.watchAbort(submission);
-        this.emitObserve({
-            type: "input.received",
-            inputId: stream.inputId,
-            kind: event.kind,
-        });
-        this.pump();
-        return stream;
-    }
-    stop(reason = "Session stopped") {
-        if (this.stopPromise)
-            return this.stopPromise;
-        this.stopping = true;
-        this.generation += 1;
-        const stopError = new HarnessError("session.stale-result", reason);
-        this.sessionController.abort(stopError);
-        this.activeController?.abort(stopError);
-        this.states.abort(stopError);
-        const activeWork = this.activeWork;
-        const activeStream = this.activeSubmission?.stream;
-        const pending = this.pending;
-        this.pending = undefined;
-        this.stopPromise = (async () => {
-            if (activeWork)
-                await activeWork;
-            if (pending && !this.recordFailure)
-                await this.commitCancelledPlan(pending, reason);
-            const stopped = await this.commit(withStatus(this.snapshotValue, "stopped"), "stopped");
-            this.snapshotValue = stopped;
-            this.stopped = true;
-            this.stopping = false;
-            const event = { type: "session.stopped", sessionId: this.id };
-            this.events.emit(event);
-            this.events.finish();
-            if (activeStream) {
-                activeStream.emit(event);
-                activeStream.finish("stopped");
-            }
-            for (const item of this.queue.drain()) {
-                item.stream.emit(event);
-                item.stream.finish("stopped");
-            }
-            this.emitObserve({ type: "session.stopped", reason });
-            await this.states.shutdown(stopError);
-            this.observers.clear();
-        })();
-        return this.stopPromise;
-    }
-    enqueueReply(submission, reply) {
-        if (!this.pending) {
-            this.reject(submission.stream, "No interaction is pending");
-            return false;
-        }
-        const expected = this.pending.plan.interactionId;
-        if (expected !== reply.interactionId) {
-            this.reject(submission.stream, "Interaction id does not match the pending interaction");
-            return false;
-        }
-        if ((this.pending.plan.interactionKind === "approval") !== (reply.kind === "approve")) {
-            this.reject(submission.stream, "Interaction input kind does not match");
-            return false;
-        }
-        this.queue.add(submission, true);
-        return true;
-    }
-    enqueueOrdinaryInput(submission) {
-        if (this.running || this.pending || this.queue.size) {
-            this.publish(submission.stream, {
-                type: "input.queued",
-                inputId: submission.stream.inputId,
-            });
-            this.emitObserve({
-                type: "input.queued",
-                inputId: submission.stream.inputId,
-            });
-        }
-        this.queue.add(submission);
-    }
-    watchAbort(submission) {
-        watchInputAbort(submission, {
-            isActive: () => this.activeSubmission === submission,
-            abortActive: (reason) => this.activeController?.abort(reason),
-            cancelQueued: () => {
-                const signal = submission.options?.signal;
-                if (signal && this.queue.remove(submission))
-                    this.finishCancelled(submission.stream, cancellationMessage(signal));
-            },
-        });
-    }
-    reject(stream, reason) {
-        this.publish(stream, { type: "input.rejected", inputId: stream.inputId, reason });
-        this.emitObserve({
-            type: "input.rejected",
-            inputId: stream.inputId,
-            reason,
-        });
-        stream.finish("rejected");
-        return stream;
-    }
-    finishCancelled(stream, reason) {
-        this.publish(stream, { type: "input.cancelled", inputId: stream.inputId, reason });
-        this.emitObserve({
-            type: "input.cancelled",
-            inputId: stream.inputId,
-            reason,
-        });
-        stream.finish("cancelled");
-        return stream;
-    }
-    finishStopped(stream) {
-        this.publish(stream, { type: "session.stopped", sessionId: this.id });
-        stream.finish("stopped");
-        return stream;
-    }
-    publish(stream, event) {
-        stream.emit(event);
-        this.events.emit(event);
-    }
-    pump() {
-        if (this.running || this.stopping || this.stopped || this.suspended)
-            return;
-        const next = this.queue.take(Boolean(this.pending));
-        if (!next)
-            return;
-        if (next.cancelled) {
-            this.pump();
-            return;
-        }
-        // This Scheduler is the sole serializing point: only one turn can mutate a Session at once.
-        this.running = true;
-        this.activeSubmission = next;
-        this.activeController = new AbortController();
-        const generation = ++this.generation;
-        const signal = AbortSignal.any([
-            this.sessionController.signal,
-            this.activeController.signal,
-            ...(next.options?.signal ? [next.options.signal] : []),
-        ]);
-        const work = this.run(next, signal, generation).finally(() => {
-            this.running = false;
-            this.activeSubmission = undefined;
-            this.activeController = undefined;
-            if (this.activeWork === work)
-                this.activeWork = undefined;
-            this.pump();
-        });
-        this.activeWork = work;
-        void work;
-    }
-    async run(submission, signal, generation) {
-        try {
-            const context = {
-                signal,
-                states: this.states,
-                observe: ((event) => this.emitObserve(() => withInputId(typeof event === "function" ? event() : event, submission.stream.inputId))),
-                assertCurrent: () => this.assertCurrent(generation, signal),
-                onPlanActive: (plan) => {
-                    this.inFlightPlan = plan;
-                },
-                commit: (state, transition, active) => this.commit(state, transition, active).then((committed) => {
-                    if (transition === "model-requested" && submission.event.kind === "continue")
-                        this.emitObserve({ type: "session.continued", inputId: submission.stream.inputId });
-                    return committed;
-                }),
-                onConversation: (event) => this.publish(submission.stream, event),
-                claimInterrupts: (state, turnId) => this.claimInterrupts(state, turnId),
-            };
-            const outcome = this.pending
-                ? await this.resumeTurn(submission, context)
-                : submission.event.kind === "continue"
-                    ? await this.turns.continue(this.snapshotValue, context)
-                    : await this.turns.start(this.snapshotValue, submission.event, context, submission.options?.output);
-            this.applyTurnOutcome(submission.stream, outcome);
-        }
-        catch (error) {
-            if (this.inFlightPlan && !this.recordFailure) {
-                try {
-                    await this.commitCancelledPlan(this.inFlightPlan, message(error));
-                }
-                catch {
-                    if (this.recordFailure)
-                        return;
-                }
-                this.inFlightPlan = undefined;
-            }
-            if (this.recordFailure || this.stopping)
-                return;
-            if (this.stopped)
-                this.finishStopped(submission.stream);
-            else {
-                if (!this.pending)
-                    this.snapshotValue = withStatus(this.snapshotValue, "idle");
-                this.finishCancelled(submission.stream, message(error));
-            }
-        }
-    }
-    async resumeTurn(submission, context) {
-        const pending = this.pending;
-        this.pending = undefined;
-        if (submission.event.kind === "continue")
-            throw new HarnessError("interaction.uncorrelated-resume", "Continue cannot answer an interaction");
-        return this.turns.resume(withStatus(this.snapshotValue, "running"), pending, submission.event, context);
-    }
-    applyTurnOutcome(stream, outcome) {
-        switch (outcome.kind) {
-            case "final":
-                this.snapshotValue = outcome.state;
-                this.publish(stream, { type: "final", output: outcome.output, turnId: outcome.turnId });
-                this.emitObserve({
-                    type: "turn.completed",
-                    turnId: outcome.turnId,
-                    stepId: outcome.stepId,
-                    inputId: stream.inputId,
-                    attributes: { output: outcome.output },
-                });
-                stream.finish("completed");
-                return;
-            case "interaction-required":
-                this.pending = outcome.pending;
-                this.snapshotValue = outcome.state;
-                this.emitObserve({
-                    type: "interaction.required",
-                    turnId: outcome.pending.turnId,
-                    stepId: outcome.pending.stepId,
-                    inputId: stream.inputId,
-                    interactionId: outcome.interaction.id,
-                    kind: outcome.interaction.kind,
-                    ...(outcome.pending.plan.interactionCallId === undefined
-                        ? {}
-                        : { callId: outcome.pending.plan.interactionCallId }),
-                    ...(outcome.pending.plan.interactionToolName === undefined
-                        ? {}
-                        : { toolName: outcome.pending.plan.interactionToolName }),
-                    phase: "interaction",
-                    attributes: {
-                        prompt: outcome.interaction.prompt,
-                        ...(outcome.interaction.metadata === undefined
-                            ? {}
-                            : { metadata: outcome.interaction.metadata }),
-                    },
-                });
-                this.publish(stream, {
-                    type: "interaction.required",
-                    interaction: outcome.interaction,
-                    turnId: outcome.pending.turnId,
-                });
-                stream.finish("waiting");
-                return;
-            case "deferred":
-                this.suspended = true;
-                this.snapshotValue = outcome.state;
-                if (outcome.active.kind === "model")
-                    this.emitObserve({
-                        type: "model.deferred",
-                        turnId: outcome.turnId,
-                        stepId: outcome.stepId,
-                        inputId: stream.inputId,
-                        invocationId: outcome.active.invocationId,
-                        attributes: outcome.active.token === undefined ? {} : { token: outcome.active.token },
-                    });
-                this.publish(stream, {
-                    type: "execution.deferred",
-                    active: outcome.active,
-                    turnId: outcome.turnId,
-                });
-                stream.finish("waiting");
-                return;
-            case "tripwire":
-                this.snapshotValue = outcome.state;
-                this.publish(stream, {
-                    type: "tripwire",
-                    tripwire: outcome.tripwire,
-                    turnId: outcome.turnId,
-                });
-                this.emitObserve({
-                    type: "tripwire",
-                    turnId: outcome.turnId,
-                    inputId: stream.inputId,
-                    ...(outcome.stepId ? { stepId: outcome.stepId } : {}),
-                    code: outcome.tripwire.code,
-                    scope: outcome.tripwire.scope ?? "step",
-                    attributes: { message: outcome.tripwire.message },
-                });
-                if (outcome.tripwire.scope === "session")
-                    void this.stop("Session policy tripwire");
-                else
-                    this.snapshotValue = withStatus(this.snapshotValue, "idle");
-                stream.finish("completed");
-        }
-    }
-    emitObserve(event) {
-        this.observers.emit(event);
-    }
-    async commitCancelledPlan(pending, reason) {
-        this.snapshotValue = await this.commit(commitToolResults(this.snapshotValue, pending.turnId, pending.stepId, pending.plan.cancelledResults(reason)), "tool-results");
-    }
-    async claimInterrupts(state, turnId) {
-        const claimed = this.queue.takeInterrupts();
-        const events = [];
-        let nextState = state;
-        for (const item of claimed) {
-            nextState = await this.commit(commitInput(nextState, turnId, item.event), "input");
-            const conversation = Object.freeze({
-                type: "input",
-                event: item.event,
-                turnId,
-            });
-            this.events.emit(conversation);
-            this.activeSubmission?.stream.emit(conversation);
-            item.stream.emit(conversation);
-            item.stream.finish("completed");
-            events.push(item.event);
-        }
-        return Object.freeze({ state: nextState, arrivals: Object.freeze(events) });
-    }
-    async commit(state, transition, active) {
-        this.assertRecordable();
-        const revision = this.snapshotValue.revision + 1;
-        const { active: _oldActive, ...rest } = state;
-        const next = Object.freeze({
-            ...rest,
-            revision,
-            ...(state.pendingInteraction === undefined
-                ? {}
-                : { pendingInteraction: state.pendingInteraction }),
-            ...(active === undefined ? {} : { active }),
-        });
-        if (this.recorder) {
-            const value = sessionRecord({ state: next, transition, session: this.session, active });
-            try {
-                await this.recorder.record(value);
-            }
-            catch (cause) {
-                const error = new HarnessError("session.record-failed", "Session recorder failed", {
-                    cause,
-                });
-                this.failRecording(error);
-                throw error;
-            }
-        }
-        this.snapshotValue = next;
-        return next;
-    }
-    assertRecordable() {
-        if (this.recordFailure)
-            throw this.recordFailure;
-        if (this.stopped && !this.stopping)
-            throw new HarnessError("session.stale-result", "Stopped Session cannot record state");
-    }
-    failRecording(error) {
-        if (this.recordFailure)
-            return;
-        this.recordFailure = error;
-        this.stopping = false;
-        this.stopped = true;
-        this.generation += 1;
-        this.sessionController.abort(error);
-        this.activeController?.abort(error);
-        void this.states.shutdown(error);
-        this.pending = undefined;
-        this.inFlightPlan = undefined;
-        this.snapshotValue = withStatus(this.snapshotValue, "stopped");
-        this.emitObserve({
-            type: "session.record.failed",
-            code: error.code,
-            attributes: { message: error.message },
-        });
-        const event = { type: "session.stopped", sessionId: this.id };
-        this.events.emit(event);
-        this.events.finish();
-        this.activeSubmission?.stream.emit(event);
-        this.activeSubmission?.stream.fail(error);
-        for (const item of this.queue.drain()) {
-            item.stream.emit(event);
-            item.stream.finish("stopped");
-        }
-    }
-    assertCurrent(generation, signal) {
-        // An abort-ignoring model or tool may resolve late; it must never re-enter this Session.
-        if (this.stopped || generation !== this.generation || signal.aborted)
-            throw (signal.reason ??
-                new HarnessError("session.stale-result", "Stale Session result quarantined"));
-    }
-}
-function withInputId(event, inputId) {
-    return "turnId" in event ? { ...event, inputId } : event;
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function cancellationMessage(signal) {
-    return signal.reason instanceof Error
-        ? signal.reason.message
-        : signal.reason
-            ? String(signal.reason)
-            : "Input cancelled";
-}

package/dist/session/seed.d.ts

@@ -1,10 +0,0 @@
-import type { SessionSeed, TranscriptEntry } from "../types/session.js";
-export interface NormalizedSessionSeed {
-    readonly id?: string;
-    readonly userId?: string;
-    readonly context?: import("../types/shared.js").JsonObject;
-    readonly turnCount: number;
-    readonly revision: number;
-    readonly transcript: readonly TranscriptEntry[];
-}
-export declare function normalizeSessionSeed(seed: SessionSeed): NormalizedSessionSeed;

package/dist/session/session.d.ts

@@ -1,18 +0,0 @@
-import type { InputHandle, InputOptions, MessageInput, Session, SessionEvent, SessionRunOptions, SessionSnapshot, SessionInput } from "../types/session.js";
-import type { ToolSchemaSource } from "../types/tool.js";
-import type { JsonValue, Observer } from "../types/shared.js";
-import type { LoopAgent } from "../build/agent.js";
-export declare class LiveSession implements Session {
-    readonly id: string;
-    private readonly scheduler;
-    constructor(id: string, agent: LoopAgent, options: SessionRunOptions);
-    get state(): SessionSnapshot;
-    input(event: SessionInput, options?: InputOptions & {
-        readonly outputSchema?: ToolSchemaSource;
-    }): InputHandle<any>;
-    interrupt(event: MessageInput, options?: InputOptions): InputHandle<any>;
-    continue(options?: InputOptions): InputHandle<any>;
-    stream(): AsyncIterable<SessionEvent<JsonValue>>;
-    observe(listener: Observer): () => void;
-    stop(reason?: string): Promise<void>;
-}

package/dist/session/session.js

@@ -1,103 +0,0 @@
-import { HarnessError } from "../errors.js";
-import { SessionScheduler } from "./scheduler.js";
-import { copyJson, copyJsonObject } from "../utils/immutable.js";
-import { normalizeSessionSeed } from "./seed.js";
-import { bindOutputContract } from "./output-contract.js";
-export class LiveSession {
-    id;
-    scheduler;
-    constructor(id, agent, options) {
-        this.id = id;
-        const seed = "seed" in options && options.seed ? normalizeSessionSeed(options.seed) : undefined;
-        const userId = seed?.userId ?? ("userId" in options ? options.userId : undefined);
-        const suppliedContext = seed?.context ?? ("context" in options ? options.context : undefined);
-        const session = Object.freeze({
-            ...(userId === undefined ? {} : { userId }),
-            ...(suppliedContext === undefined
-                ? {}
-                : { context: copyJsonObject(suppliedContext, "session context") }),
-        });
-        this.scheduler = new SessionScheduler(id, agent, session, {
-            ...(seed === undefined ? {} : { seed }),
-            ...(options.recorder === undefined ? {} : { recorder: options.recorder }),
-        });
-    }
-    get state() {
-        return this.scheduler.snapshot;
-    }
-    input(event, options) {
-        const output = options?.outputSchema === undefined ? undefined : bindOutputContract(options.outputSchema);
-        if (output && isInteractionReply(event))
-            throw new HarnessError("output.invalid-schema", "Interaction replies cannot define a turn outputSchema");
-        return this.scheduler.submit(normalizeInput(event), {
-            ...(options?.signal === undefined ? {} : { signal: options.signal }),
-            ...(output === undefined ? {} : { output }),
-        });
-    }
-    interrupt(event, options) {
-        return this.scheduler.submit(normalizeMessage("interrupt", event), options);
-    }
-    continue(options) {
-        return this.scheduler.continue(options);
-    }
-    stream() {
-        return this.scheduler.events;
-    }
-    observe(listener) {
-        return this.scheduler.observe(listener);
-    }
-    stop(reason) {
-        return this.scheduler.stop(reason);
-    }
-}
-function isInteractionReply(value) {
-    return (typeof value === "object" &&
-        "kind" in value &&
-        (value.kind === "approve" || value.kind === "respond"));
-}
-function normalizeMessage(kind, value) {
-    if (typeof value === "string")
-        return { kind, text: value };
-    if ("content" in value)
-        return {
-            kind,
-            content: snapshotContent(value.content),
-            ...(value.metadata === undefined
-                ? {}
-                : { metadata: copyJsonObject(value.metadata, "input metadata") }),
-        };
-    return {
-        kind,
-        text: value.text,
-        ...(value.metadata === undefined
-            ? {}
-            : { metadata: copyJsonObject(value.metadata, "input metadata") }),
-    };
-}
-function normalizeInput(input) {
-    if (typeof input === "string")
-        return { kind: "user-message", text: input };
-    if (isInteractionReply(input))
-        return input;
-    return normalizeMessage("user-message", input);
-}
-function snapshotContent(value) {
-    if (!Array.isArray(value))
-        throw new HarnessError("input.invalid-content", "Input content must be an array");
-    return Object.freeze(value.map((part, index) => {
-        if (!part || typeof part !== "object")
-            throw new HarnessError("input.invalid-content", `Input content part ${index} must be an object`);
-        if (part.type === "text") {
-            if (typeof part.text !== "string")
-                throw new HarnessError("input.invalid-content", `Input text part ${index} must contain text`);
-            return Object.freeze({ type: "text", text: part.text });
-        }
-        if (part.type !== "media" || typeof part.mediaType !== "string" || part.mediaType === "")
-            throw new HarnessError("input.invalid-content", `Input media part ${index} must contain a non-empty mediaType`);
-        return Object.freeze({
-            type: "media",
-            mediaType: part.mediaType,
-            reference: copyJson(part.reference),
-        });
-    }));
-}

package/dist/session/state.d.ts

@@ -1,15 +0,0 @@
-import type { ActiveExecutionRecord, InputEvent, SessionSnapshot, TranscriptEntry } from "../types/session.js";
-import type { ModelCandidate } from "../types/model.js";
-import type { RequiredInteraction, ToolResult } from "../types/tool.js";
-export declare function initialState(id: string, input?: {
-    readonly turnCount?: number;
-    readonly revision?: number;
-    readonly transcript?: readonly TranscriptEntry[];
-}): SessionSnapshot;
-export declare function withStatus(state: SessionSnapshot, status: SessionSnapshot["status"], pendingInteraction?: RequiredInteraction, active?: ActiveExecutionRecord): SessionSnapshot;
-export declare function withRevision(state: SessionSnapshot, revision: number): SessionSnapshot;
-export declare function beginTurn(state: SessionSnapshot, turnId: string, event?: InputEvent): SessionSnapshot;
-export declare const commitInput: (state: SessionSnapshot, turnId: string, event: InputEvent) => SessionSnapshot;
-export declare const commitCandidate: (state: SessionSnapshot, turnId: string, stepId: string, candidate: ModelCandidate) => SessionSnapshot;
-export declare const commitToolResults: (state: SessionSnapshot, turnId: string, stepId: string, results: readonly ToolResult[]) => SessionSnapshot;
-export declare const commitFinal: (state: SessionSnapshot, turnId: string, stepId: string, output: import("../types/shared.js").JsonValue) => SessionSnapshot;

package/dist/session/state.js

@@ -1,48 +0,0 @@
-export function initialState(id, input = {}) {
-    return Object.freeze({
-        id,
-        status: "idle",
-        turnCount: input.turnCount ?? 0,
-        revision: input.revision ?? 0,
-        transcript: Object.freeze([...(input.transcript ?? [])]),
-    });
-}
-export function withStatus(state, status, pendingInteraction, active) {
-    return Object.freeze({
-        id: state.id,
-        status,
-        turnCount: state.turnCount,
-        revision: state.revision,
-        transcript: state.transcript,
-        ...(pendingInteraction ? { pendingInteraction } : {}),
-        ...(active ? { active } : {}),
-    });
-}
-export function withRevision(state, revision) {
-    return Object.freeze({ ...state, revision });
-}
-export function beginTurn(state, turnId, event) {
-    const transcript = event
-        ? [
-            ...state.transcript,
-            Object.freeze({ kind: "input", turnId, event: Object.freeze({ ...event }) }),
-        ]
-        : [...state.transcript];
-    return Object.freeze({
-        id: state.id,
-        status: "running",
-        turnCount: state.turnCount + 1,
-        revision: state.revision,
-        transcript: Object.freeze(transcript),
-    });
-}
-function append(state, entry) {
-    return Object.freeze({
-        ...state,
-        transcript: Object.freeze([...state.transcript, Object.freeze(entry)]),
-    });
-}
-export const commitInput = (state, turnId, event) => append(state, { kind: "input", turnId, event: Object.freeze({ ...event }) });
-export const commitCandidate = (state, turnId, stepId, candidate) => append(state, { kind: "candidate", turnId, stepId, candidate });
-export const commitToolResults = (state, turnId, stepId, results) => append(state, { kind: "tool-results", turnId, stepId, results: Object.freeze([...results]) });
-export const commitFinal = (state, turnId, stepId, output) => append(state, { kind: "final", turnId, stepId, output });