@nylorun/harness 0.5.0-beta.1 → 0.8.0-beta.1

package/dist/session/scheduler.js

@@ -1,12 +1,14 @@
 import { HarnessError } from "../errors.js";
 import { createId } from "../utils/ids.js";
 import { createObserverRegistry } from "../utils/observe.js";
-import { InputQueue, isInteractionReply, snapshotInput, watchInputAbort, } from "./input-queue.js";
+import { InputQueue, isInteractionReply, snapshotWork, watchInputAbort, } from "./input-queue.js";
 import { SessionEventLog } from "./event-log.js";
 import { SubmissionStream } from "./submission-stream.js";
-import { commitToolResults, initialState, withStatus } from "./state.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;
@@ -20,16 +22,38 @@ export class SessionScheduler {
     pending;
     inFlightPlan;
     running = false;
+    stopping = false;
     stopped = false;
+    suspended = false;
     generation = 0;
     stopPromise;
+    recordFailure;
     observers = createObserverRegistry();
     turns;
-    constructor(id, agent, session) {
+    states;
+    constructor(id, agent, session, options = {}) {
         this.id = id;
-        this.snapshotValue = initialState(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;
     }
@@ -39,9 +63,15 @@ export class SessionScheduler {
         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: snapshotInput(event),
+            event: snapshotWork(event),
             options,
             stream,
             cancelled: false,
@@ -50,7 +80,7 @@ export class SessionScheduler {
             return this.finishStopped(stream);
         if (options?.signal?.aborted)
             return this.finishCancelled(stream, cancellationMessage(options.signal));
-        if (isInteractionReply(event)) {
+        if (event.kind !== "continue" && isInteractionReply(event)) {
             if (!this.enqueueReply(submission, event))
                 return stream;
         }
@@ -68,11 +98,39 @@ export class SessionScheduler {
     stop(reason = "Session stopped") {
         if (this.stopPromise)
             return this.stopPromise;
-        this.beginStop(reason);
+        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;
     }
@@ -147,7 +205,7 @@ export class SessionScheduler {
         this.events.emit(event);
     }
     pump() {
-        if (this.running || this.stopped)
+        if (this.running || this.stopping || this.stopped || this.suspended)
             return;
         const next = this.queue.take(Boolean(this.pending));
         if (!next)
@@ -172,8 +230,6 @@ export class SessionScheduler {
             this.activeController = undefined;
             if (this.activeWork === work)
                 this.activeWork = undefined;
-            if (!this.stopped && !this.pending)
-                this.snapshotValue = withStatus(this.snapshotValue, "idle");
             this.pump();
         });
         this.activeWork = work;
@@ -183,27 +239,40 @@ export class SessionScheduler {
         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;
                 },
-                onState: (state) => {
-                    this.snapshotValue = state;
-                },
+                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: (turnId) => this.claimInterrupts(turnId),
+                claimInterrupts: (state, turnId) => this.claimInterrupts(state, turnId),
             };
             const outcome = this.pending
                 ? await this.resumeTurn(submission, context)
-                : await this.turns.start(this.snapshotValue, submission.event, context);
+                : submission.event.kind === "continue"
+                    ? await this.turns.continue(this.snapshotValue, context)
+                    : await this.turns.start(this.snapshotValue, submission.event, context);
             this.applyTurnOutcome(submission.stream, outcome);
         }
         catch (error) {
-            if (this.inFlightPlan) {
-                this.commitCancelledPlan(this.inFlightPlan, message(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 {
@@ -216,13 +285,14 @@ export class SessionScheduler {
     async resumeTurn(submission, context) {
         const pending = this.pending;
         this.pending = undefined;
-        this.snapshotValue = withStatus(this.snapshotValue, "running");
-        return this.turns.resume(this.snapshotValue, pending, submission.event, context);
+        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 = withStatus(outcome.state, "idle");
+                this.snapshotValue = outcome.state;
                 this.publish(stream, { type: "final", output: outcome.output, turnId: outcome.turnId });
                 this.emitObserve({
                     type: "turn.completed",
@@ -235,7 +305,7 @@ export class SessionScheduler {
                 return;
             case "interaction-required":
                 this.pending = outcome.pending;
-                this.snapshotValue = withStatus(outcome.state, "waiting", outcome.interaction);
+                this.snapshotValue = outcome.state;
                 this.emitObserve({
                     type: "interaction.required",
                     turnId: outcome.pending.turnId,
@@ -249,9 +319,7 @@ export class SessionScheduler {
                     ...(outcome.pending.plan.interactionToolName === undefined
                         ? {}
                         : { toolName: outcome.pending.plan.interactionToolName }),
-                    ...(outcome.pending.plan.interactionPhase === undefined
-                        ? {}
-                        : { phase: outcome.pending.plan.interactionPhase }),
+                    phase: "interaction",
                     attributes: {
                         prompt: outcome.interaction.prompt,
                         ...(outcome.interaction.metadata === undefined
@@ -266,6 +334,25 @@ export class SessionScheduler {
                 });
                 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, {
@@ -283,40 +370,24 @@ export class SessionScheduler {
                     attributes: { message: outcome.tripwire.message },
                 });
                 if (outcome.tripwire.scope === "session")
-                    this.beginStop("Session policy tripwire");
+                    void this.stop("Session policy tripwire");
                 else
                     this.snapshotValue = withStatus(this.snapshotValue, "idle");
                 stream.finish("completed");
         }
     }
-    beginStop(reason) {
-        if (this.stopped)
-            return;
-        this.stopped = true;
-        this.generation += 1;
-        this.sessionController.abort(new HarnessError("session.stale-result", reason));
-        this.activeController?.abort(new HarnessError("session.stale-result", reason));
-        if (this.pending)
-            this.commitCancelledPlan(this.pending, reason);
-        this.pending = undefined;
-        this.snapshotValue = withStatus(this.snapshotValue, "stopped");
-        this.events.emit({ type: "session.stopped", sessionId: this.id });
-        this.events.finish();
-        this.emitObserve({ type: "session.stopped", reason });
-        this.observers.clear();
-        for (const item of this.queue.drain())
-            this.finishStopped(item.stream);
-    }
     emitObserve(event) {
         this.observers.emit(event);
     }
-    commitCancelledPlan(pending, reason) {
-        this.snapshotValue = commitToolResults(this.snapshotValue, pending.turnId, pending.stepId, pending.plan.cancelledResults(reason));
+    async commitCancelledPlan(pending, reason) {
+        this.snapshotValue = await this.commit(commitToolResults(this.snapshotValue, pending.turnId, pending.stepId, pending.plan.cancelledResults(reason)), "tool-results");
     }
-    claimInterrupts(turnId) {
+    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,
@@ -328,10 +399,72 @@ export class SessionScheduler {
             item.stream.finish("completed");
             events.push(item.event);
         }
-        return Object.freeze(events);
+        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 adapter may resolve late; its state must never re-enter this Session.
+        // 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"));

package/dist/session/seed.d.ts

@@ -0,0 +1,10 @@
+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/seed.js

@@ -0,0 +1,219 @@
+import { HarnessError } from "../errors.js";
+import { normalizeCandidate } from "../model-normalize.js";
+import { assertJson, copyJson, copyJsonObject } from "../utils/immutable.js";
+export function normalizeSessionSeed(seed) {
+    try {
+        return normalizeSeed(seed);
+    }
+    catch (cause) {
+        if (cause instanceof HarnessError && cause.code === "session.invalid-seed")
+            throw cause;
+        throw new HarnessError("session.invalid-seed", "Session seed contains invalid typed JSON", {
+            cause,
+        });
+    }
+}
+function normalizeSeed(seed) {
+    if (!seed || typeof seed !== "object")
+        fail("Session seed must be an object");
+    if (!Array.isArray(seed.transcript))
+        fail("Session seed transcript must be an array");
+    optionalString(seed.id, "Session seed id");
+    optionalString(seed.userId, "Session seed userId");
+    const turnCount = count(seed.turnCount, "turnCount");
+    const revision = count(seed.revision, "revision");
+    const transcript = Object.freeze(seed.transcript.map((entry, index) => entryAt(entry, index)));
+    return Object.freeze({
+        ...(seed.id === undefined ? {} : { id: seed.id }),
+        ...(seed.userId === undefined ? {} : { userId: seed.userId }),
+        ...(seed.context === undefined
+            ? {}
+            : { context: copyJsonObject(seed.context, "session seed context") }),
+        turnCount,
+        revision,
+        transcript,
+    });
+}
+function entryAt(value, index) {
+    if (!value || typeof value !== "object")
+        fail(`Transcript entry ${index} must be an object`);
+    const entry = value;
+    requiredString(entry.kind, `Transcript entry ${index} kind`);
+    requiredString(entry.turnId, `Transcript entry ${index} turnId`);
+    switch (entry.kind) {
+        case "input":
+            exactKeys(entry, ["kind", "turnId", "event"], `Transcript entry ${index}`);
+            return Object.freeze({
+                kind: "input",
+                turnId: entry.turnId,
+                event: inputEvent(entry.event, index),
+            });
+        case "candidate": {
+            exactKeys(entry, ["kind", "turnId", "stepId", "candidate"], `Transcript entry ${index}`);
+            requiredString(entry.stepId, `Transcript entry ${index} stepId`);
+            try {
+                validateSeedCandidate(entry.candidate, index);
+                return Object.freeze({
+                    kind: "candidate",
+                    turnId: entry.turnId,
+                    stepId: entry.stepId,
+                    candidate: normalizeCandidate(entry.candidate),
+                });
+            }
+            catch (cause) {
+                throw new HarnessError("session.invalid-seed", `Invalid candidate at transcript ${index}`, {
+                    cause,
+                });
+            }
+        }
+        case "tool-results": {
+            exactKeys(entry, ["kind", "turnId", "stepId", "results"], `Transcript entry ${index}`);
+            requiredString(entry.stepId, `Transcript entry ${index} stepId`);
+            if (!Array.isArray(entry.results))
+                fail(`Transcript entry ${index} tool results must be an array`);
+            const result = Object.freeze({
+                kind: "tool-results",
+                turnId: entry.turnId,
+                stepId: entry.stepId,
+                results: Object.freeze(entry.results.map((item, resultIndex) => toolResult(item, resultIndex))),
+            });
+            return result;
+        }
+        case "final":
+            exactKeys(entry, ["kind", "turnId", "stepId", "output"], `Transcript entry ${index}`);
+            requiredString(entry.stepId, `Transcript entry ${index} stepId`);
+            if (typeof entry.output !== "string")
+                fail(`Transcript entry ${index} output must be a string`);
+            return Object.freeze({
+                kind: "final",
+                turnId: entry.turnId,
+                stepId: entry.stepId,
+                output: entry.output,
+            });
+        default:
+            fail(`Transcript entry ${index} has unknown kind '${String(entry.kind)}'`);
+    }
+}
+function inputEvent(value, index) {
+    if (!value || typeof value !== "object")
+        fail(`Transcript input ${index} must be an object`);
+    const event = value;
+    switch (event.kind) {
+        case "user-message":
+        case "interrupt":
+            exactKeys(event, ["kind", "text", "metadata"], `Transcript input ${index}`);
+            if (typeof event.text !== "string")
+                fail(`Transcript input ${index} text must be a string`);
+            return Object.freeze({
+                kind: event.kind,
+                text: event.text,
+                ...(event.metadata === undefined
+                    ? {}
+                    : { metadata: copyJsonObject(event.metadata, `transcript input ${index} metadata`) }),
+            });
+        case "approve":
+            exactKeys(event, ["kind", "interactionId", "approved"], `Transcript input ${index}`);
+            requiredString(event.interactionId, `Transcript input ${index} interactionId`);
+            if (typeof event.approved !== "boolean")
+                fail(`Transcript input ${index} approved must be a boolean`);
+            return Object.freeze({
+                kind: "approve",
+                interactionId: event.interactionId,
+                approved: event.approved,
+            });
+        case "respond":
+            exactKeys(event, ["kind", "interactionId", "value"], `Transcript input ${index}`);
+            requiredString(event.interactionId, `Transcript input ${index} interactionId`);
+            assertJson(event.value, `transcript input ${index} value`);
+            return Object.freeze({
+                kind: "respond",
+                interactionId: event.interactionId,
+                value: copyJson(event.value),
+            });
+        default:
+            fail(`Transcript input ${index} has unknown kind '${String(event.kind)}'`);
+    }
+}
+function toolResult(value, index) {
+    if (!value || typeof value !== "object")
+        fail(`Tool result ${index} must be an object`);
+    const result = value;
+    requiredString(result.callId, `Tool result ${index} callId`);
+    requiredString(result.toolName, `Tool result ${index} toolName`);
+    const base = { callId: result.callId, toolName: result.toolName };
+    switch (result.kind) {
+        case "completed":
+            exactKeys(result, ["callId", "toolName", "kind", "output"], `Tool result ${index}`);
+            assertJson(result.output, `tool result ${index} output`);
+            return Object.freeze({ ...base, kind: "completed", output: copyJson(result.output) });
+        case "denied":
+            exactKeys(result, ["callId", "toolName", "kind", "reason"], `Tool result ${index}`);
+            if (typeof result.reason !== "string")
+                fail(`Tool result ${index} reason must be a string`);
+            return Object.freeze({ ...base, kind: "denied", reason: result.reason });
+        case "failed":
+            exactKeys(result, ["callId", "toolName", "kind", "code", "message"], `Tool result ${index}`);
+            if (typeof result.code !== "string" || typeof result.message !== "string")
+                fail(`Tool result ${index} code and message must be strings`);
+            return Object.freeze({
+                ...base,
+                kind: "failed",
+                code: result.code,
+                message: result.message,
+            });
+        default:
+            fail(`Tool result ${index} has unknown kind '${String(result.kind)}'`);
+    }
+}
+function validateSeedCandidate(value, index) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        fail(`Candidate at transcript ${index} must be an object`);
+    const candidate = value;
+    exactKeys(candidate, ["output", "finishReason", "usage", "evidence"], `Candidate at transcript ${index}`);
+    if (!Array.isArray(candidate.output))
+        fail(`Candidate at transcript ${index} output must be an array`);
+    candidate.output.forEach((value, blockIndex) => {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            fail(`Candidate output ${blockIndex} at transcript ${index} must be an object`);
+        const block = value;
+        if (block.type === "text" || block.type === "reasoning") {
+            exactKeys(block, ["type", "text"], `Candidate output ${blockIndex}`);
+            if (typeof block.text !== "string")
+                fail(`Candidate output ${blockIndex} text must be a string`);
+            return;
+        }
+        if (block.type === "tool-call") {
+            exactKeys(block, ["type", "id", "name", "args", "raw"], `Candidate output ${blockIndex}`);
+            requiredString(block.id, `Candidate output ${blockIndex} id`);
+            requiredString(block.name, `Candidate output ${blockIndex} name`);
+            if (block.raw !== undefined && typeof block.raw !== "string")
+                fail(`Candidate output ${blockIndex} raw must be a string`);
+            copyJsonObject(block.args, `candidate output ${blockIndex} args`);
+            return;
+        }
+        fail(`Candidate output ${blockIndex} has unknown kind '${String(block.type)}'`);
+    });
+}
+function exactKeys(value, allowed, label) {
+    for (const key of Object.keys(value))
+        if (!allowed.includes(key))
+            fail(`${label} has unknown field '${key}'`);
+}
+function count(value, label) {
+    if (value === undefined)
+        return 0;
+    if (!Number.isSafeInteger(value) || value < 0)
+        fail(`Session seed ${label} must be a non-negative safe integer`);
+    return value;
+}
+function optionalString(value, label) {
+    if (value !== undefined)
+        requiredString(value, label);
+}
+function requiredString(value, label) {
+    if (typeof value !== "string" || value.length === 0)
+        fail(`${label} must be a non-empty string`);
+}
+function fail(message) {
+    throw new HarnessError("session.invalid-seed", message);
+}

package/dist/session/session.d.ts

@@ -1,13 +1,14 @@
-import type { InputHandle, InputOptions, MessageInput, Session, SessionEvent, SessionOptions, SessionSnapshot, SessionInput } from "../types/session.js";
+import type { InputHandle, InputOptions, MessageInput, Session, SessionEvent, SessionRunOptions, SessionSnapshot, SessionInput } from "../types/session.js";
 import type { 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: SessionOptions);
+    constructor(id: string, agent: LoopAgent, options: SessionRunOptions);
     get state(): SessionSnapshot;
     input(event: SessionInput, options?: InputOptions): InputHandle;
     interrupt(event: MessageInput, options?: InputOptions): InputHandle;
+    continue(options?: InputOptions): InputHandle;
     stream(): AsyncIterable<SessionEvent>;
     observe(listener: Observer): () => void;
     stop(reason?: string): Promise<void>;

package/dist/session/session.js

@@ -1,15 +1,24 @@
 import { SessionScheduler } from "./scheduler.js";
 import { copyJsonObject } from "../utils/immutable.js";
+import { normalizeSessionSeed } from "./seed.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({
-            ...(options.userId ? { userId: options.userId } : {}),
-            ...(options.context ? { context: copyJsonObject(options.context, "session context") } : {}),
+            ...(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 }),
         });
-        this.scheduler = new SessionScheduler(id, agent, session);
     }
     get state() {
         return this.scheduler.snapshot;
@@ -20,6 +29,9 @@ export class LiveSession {
     interrupt(event, options) {
         return this.scheduler.submit(normalizeMessage("interrupt", event), options);
     }
+    continue(options) {
+        return this.scheduler.continue(options);
+    }
     stream() {
         return this.scheduler.events;
     }