@nylorun/runtime 0.7.0-beta → 0.9.0-beta

package/dist/session/default.js

@@ -1,30 +0,0 @@
-let defaultRuntime;
-let bannerShown = false;
-let createRuntime;
-/** Wired from `server/host.ts` after `Runtime` is defined (avoids init cycles). */
-export function installDefaultRuntimeFactory(factory) {
-    createRuntime = factory;
-}
-export function setDefaultRuntime(runtime) {
-    defaultRuntime = runtime;
-}
-export function getDefaultRuntime() {
-    if (defaultRuntime)
-        return defaultRuntime;
-    if (!createRuntime)
-        throw new Error("Default Runtime factory is not installed");
-    defaultRuntime = createRuntime();
-    maybeBanner();
-    return defaultRuntime;
-}
-function maybeBanner() {
-    if (bannerShown || typeof process === "undefined")
-        return;
-    if (process.env.NYLORUN_QUIET === "1")
-        return;
-    bannerShown = true;
-    const model = process.env.MODEL_PROVIDER && process.env.MODEL
-        ? `${process.env.MODEL_PROVIDER}/${process.env.MODEL}`
-        : "unset";
-    console.info(`nylorun ▸ local runtime · loop runs in this process · sessions in memory · model ${model} (your key)`);
-}

package/dist/session/handle.d.ts

@@ -1,27 +0,0 @@
-import type { BuiltAgent, JsonObject, JsonValue, ModelAdapter } from "@nylorun/core/define";
-import type { Session } from "@nylorun/harness";
-import type { RuntimeConfig } from "../config.js";
-import type { SessionHost } from "../sessions/host.js";
-export type OpenSessionOptions = {
-    readonly id?: string;
-    /** Trusted host bag — keep the name `info` (never `user`). */
-    readonly info?: unknown;
-    /** Initial durable session memory (`ExecutionState.state`). */
-    readonly state?: JsonObject;
-};
-export type SessionHandle<Output = unknown> = Session<{
-    readonly id: string;
-}, Output> & {
-    readonly agentId: string;
-};
-export type SessionRuntime = {
-    readonly host: SessionHost;
-    readonly config: RuntimeConfig;
-    resolveModel(): ModelAdapter;
-};
-export declare function createSessionHandle(runtime: SessionRuntime, agent: BuiltAgent<any, any>, options?: OpenSessionOptions): SessionHandle;
-/** Resolve a wait by harness waitId (H6). */
-export declare function resolveWait(runtime: SessionRuntime, agent: BuiltAgent<any, any>, sessionId: string, waitId: string, value?: JsonValue, options?: {
-    readonly info?: unknown;
-    readonly onModelCall?: ModelAdapter;
-}): Promise<void>;

package/dist/session/handle.js

@@ -1,199 +0,0 @@
-export function createSessionHandle(runtime, agent, options = {}) {
-    const id = options.id ?? crypto.randomUUID();
-    let seedState = options.state;
-    const info = options.info;
-    const submitOptions = () => {
-        const sessionState = seedState;
-        seedState = undefined;
-        return {
-            info: info === undefined
-                ? { sessionId: id }
-                : { ...info, sessionId: id },
-            onModelCall: runtime.resolveModel(),
-            ...(sessionState ? { sessionState } : {}),
-        };
-    };
-    const handle = {
-        id,
-        agentId: agent.id,
-        async input(message) {
-            try {
-                const result = await runtime.host.submit(agent, id, message, submitOptions());
-                const cursor = String((await runtime.host.read(agent.id, id))?.events.at(-1)?.seq ?? 0);
-                return {
-                    status: "accepted",
-                    turnId: result.state.plan?.turnId ?? result.state.executionId,
-                    cursor,
-                };
-            }
-            catch (error) {
-                return {
-                    status: "rejected",
-                    error: {
-                        code: error && typeof error === "object" && "code" in error
-                            ? String(error.code)
-                            : "runtime.input-rejected",
-                        message: error instanceof Error ? error.message : String(error),
-                    },
-                };
-            }
-        },
-        async *stream(opts) {
-            let after = opts?.after ? Number(opts.after) : 0;
-            if (!Number.isFinite(after) || after < 0)
-                after = 0;
-            const queue = [];
-            let notify;
-            const wake = () => {
-                notify?.();
-                notify = undefined;
-            };
-            const unsubscribe = runtime.host.subscribe(agent.id, id, (event) => {
-                queue.push(event);
-                wake();
-            });
-            try {
-                const existing = await runtime.host.read(agent.id, id);
-                for (const event of existing?.events ?? [])
-                    if (event.seq > after)
-                        queue.push(event);
-                for (;;) {
-                    while (queue.length) {
-                        const event = queue.shift();
-                        if (event.seq <= after)
-                            continue;
-                        after = event.seq;
-                        const mapped = mapEvent(event, id);
-                        if (mapped)
-                            yield mapped;
-                    }
-                    await new Promise((resolve) => {
-                        notify = resolve;
-                    });
-                }
-            }
-            finally {
-                unsubscribe();
-            }
-        },
-        async history() {
-            const document = await runtime.host.read(agent.id, id);
-            return (document?.events ?? [])
-                .filter((event) => ["final", "interaction.required", "error", "cancelled"].includes(event.type))
-                .map((event) => event.payload);
-        },
-        async approve(interactionId, approved) {
-            await runtime.host.submit(agent, id, { kind: "approve", interactionId, approved }, submitOptions());
-        },
-        async respond(interactionId, value) {
-            await runtime.host.submit(agent, id, { kind: "respond", interactionId, value }, submitOptions());
-        },
-        async cancel() {
-            await runtime.host.cancel(agent, id);
-        },
-    };
-    return handle;
-}
-/** Resolve a wait by harness waitId (H6). */
-export async function resolveWait(runtime, agent, sessionId, waitId, value, options) {
-    const input = {
-        kind: "wait-resolve",
-        waitId,
-        ...(value === undefined ? {} : { value }),
-    };
-    await runtime.host.submit(agent, sessionId, input, {
-        info: options?.info,
-        onModelCall: options?.onModelCall ?? runtime.resolveModel(),
-    });
-}
-function mapEvent(event, sessionId) {
-    const turnId = typeof event.payload.turnId === "string"
-        ? event.payload.turnId
-        : typeof event.payload.executionId === "string"
-            ? event.payload.executionId
-            : sessionId;
-    const cursor = String(event.seq);
-    const at = event.ts;
-    switch (event.type) {
-        case "session.run.started":
-            return { type: "turn.started", cursor, at, sessionId, turnId };
-        case "tool.started":
-            return {
-                type: "tool.started",
-                tool: String(event.payload.toolName ?? "tool"),
-                sessionId,
-                turnId,
-            };
-        case "tool.progress":
-            return {
-                type: "tool.progress",
-                tool: String(event.payload.toolName ?? "tool"),
-                sessionId,
-                turnId,
-            };
-        case "tool.completed":
-            return {
-                type: event.payload.outcome === "failed" ? "tool.failed" : "tool.completed",
-                tool: String(event.payload.toolName ?? "tool"),
-                sessionId,
-                turnId,
-            };
-        case "interaction.required": {
-            const interaction = event.payload.interaction;
-            return {
-                type: "interaction.required",
-                id: String(interaction?.id ?? ""),
-                prompt: String(interaction?.prompt ?? ""),
-                ...(interaction?.metadata ? { options: interaction.metadata } : {}),
-                sessionId,
-                turnId,
-            };
-        }
-        case "final":
-            return {
-                type: "turn.settled",
-                result: {
-                    status: "completed",
-                    output: event.payload.output,
-                },
-                sessionId,
-                turnId,
-            };
-        case "error":
-            return {
-                type: "turn.settled",
-                result: {
-                    status: "failed",
-                    error: {
-                        code: String(event.payload.code ?? "execution.failed"),
-                        message: String(event.payload.message ?? "failed"),
-                    },
-                },
-                sessionId,
-                turnId,
-            };
-        case "cancelled":
-            return {
-                type: "turn.settled",
-                result: { status: "cancelled" },
-                sessionId,
-                turnId,
-            };
-        default:
-            if (event.type === "model.requested" || event.type === "model.completed")
-                return {
-                    type: "status",
-                    status: "thinking",
-                    sessionId,
-                    turnId,
-                };
-            if (event.type.startsWith("tool."))
-                return {
-                    type: "status",
-                    status: "calling_tool",
-                    sessionId,
-                    turnId,
-                };
-            return undefined;
-    }
-}

package/dist/session/index.d.ts

@@ -1,2 +0,0 @@
-export { createSessionHandle, resolveWait, type OpenSessionOptions, type SessionHandle, type SessionRuntime, } from "./handle.js";
-export { getDefaultRuntime, setDefaultRuntime, installDefaultRuntimeFactory, } from "./default.js";

package/dist/session/index.js

@@ -1,2 +0,0 @@
-export { createSessionHandle, resolveWait, } from "./handle.js";
-export { getDefaultRuntime, setDefaultRuntime, installDefaultRuntimeFactory, } from "./default.js";

package/dist/sessions/host.d.ts

@@ -1,39 +0,0 @@
-import type { BuiltAgent, JsonObject, ModelAdapter } from "@nylorun/core/define";
-import type { ExecutionInput, ExecutionState, RunResult } from "@nylorun/harness";
-import type { CanonicalEvent, SessionStore, StoredSession, SessionSummary } from "./store.js";
-export interface SubmitOptions {
-    readonly runId?: string;
-    readonly info?: unknown;
-    readonly signal?: AbortSignal;
-    readonly onModelCall: ModelAdapter;
-    readonly secrets?: readonly string[];
-    readonly onEvent?: (event: CanonicalEvent) => void;
-    readonly started?: Record<string, unknown>;
-    /** Seed `ExecutionState.state` when creating a new checkpoint (openSession). */
-    readonly sessionState?: JsonObject;
-}
-/** The built-in single-process coordinator. Storage adapters do not implement execution. */
-export declare class SessionHost {
-    readonly store: SessionStore;
-    private readonly queues;
-    private readonly generations;
-    private readonly active;
-    private readonly listeners;
-    private closed;
-    constructor(store: SessionStore);
-    private key;
-    read(agentId: string, sessionId: string): Promise<StoredSession | undefined>;
-    list(agentId: string): Promise<readonly SessionSummary[]>;
-    delete(agentId: string, sessionId: string): Promise<boolean>;
-    subscribe(agentId: string, sessionId: string, listener: (event: CanonicalEvent) => void): () => void;
-    submit(agent: BuiltAgent<any, any>, sessionId: string, input: ExecutionInput, options: SubmitOptions): Promise<RunResult<any>>;
-    cancel(agent: BuiltAgent<any, any>, sessionId: string): Promise<void>;
-    interrupt(agent: BuiltAgent<any, any>, sessionId: string, input: ExecutionInput, options: SubmitOptions): Promise<RunResult<any>>;
-    close(): Promise<void>;
-}
-/**
- * Map DX `wait-resolve` onto harness approve/respond/settle using wait metadata.
- * Engine `ExecutionInput` already includes `wait-resolve`; resume is wired via
- * existing interaction/deferred kinds until full wait-id resume lands.
- */
-export declare function resolveEngineInput(state: ExecutionState | undefined, input: ExecutionInput): ExecutionInput;

package/dist/sessions/host.js

@@ -1,359 +0,0 @@
-import { HarnessError, isHarnessError } from "@nylorun/core/define";
-import { bindingFromAgent, createRunState, run, } from "@nylorun/harness/run";
-import { scrub } from "../redact.js";
-/** The built-in single-process coordinator. Storage adapters do not implement execution. */
-export class SessionHost {
-    store;
-    queues = new Map();
-    generations = new Map();
-    active = new Map();
-    listeners = new Map();
-    closed = false;
-    constructor(store) {
-        this.store = store;
-    }
-    key(agentId, sessionId) {
-        return JSON.stringify([agentId, sessionId]);
-    }
-    async read(agentId, sessionId) {
-        const document = await this.store.get(agentId, sessionId);
-        if (document?.active && !this.active.has(this.key(agentId, sessionId)))
-            return { ...document, status: "interrupted" };
-        return document;
-    }
-    async list(agentId) {
-        return (await this.store.list(agentId)).map((session) => session.status === "running" &&
-            !this.active.has(this.key(agentId, session.session))
-            ? { ...session, status: "interrupted" }
-            : session);
-    }
-    async delete(agentId, sessionId) {
-        const key = this.key(agentId, sessionId);
-        if (this.active.has(key))
-            throw new Error("Cannot delete a session while a run is active");
-        if ("delete" in this.store && typeof this.store.delete === "function")
-            return this.store.delete(agentId, sessionId);
-        const existing = await this.store.get(agentId, sessionId);
-        if (!existing)
-            return false;
-        // Stores without delete: archive by removing via put tombstone is not supported;
-        // require ManagedSessionStore.delete or memorySessions.delete.
-        throw new Error("Session store does not support delete");
-    }
-    subscribe(agentId, sessionId, listener) {
-        const key = this.key(agentId, sessionId);
-        let listeners = this.listeners.get(key);
-        if (!listeners) {
-            listeners = new Set();
-            this.listeners.set(key, listeners);
-        }
-        listeners.add(listener);
-        return () => {
-            listeners.delete(listener);
-            if (!listeners.size)
-                this.listeners.delete(key);
-        };
-    }
-    submit(agent, sessionId, input, options) {
-        const key = this.key(agent.id, sessionId);
-        const generation = this.generations.get(key) ?? 0;
-        const prior = this.queues.get(key) ?? Promise.resolve();
-        const work = prior
-            .catch(() => { })
-            .then(async () => {
-            if ((this.generations.get(key) ?? 0) !== generation)
-                throw new Error("Queued input cancelled by interruption");
-            if (this.closed)
-                throw new Error("Runtime is closed");
-            options.signal?.throwIfAborted();
-            const stored = await this.store.get(agent.id, sessionId);
-            // Cancellation/shutdown can arrive while an asynchronous store is loading.
-            if ((this.generations.get(key) ?? 0) !== generation)
-                throw new Error("Queued input cancelled by interruption");
-            if (this.closed)
-                throw new Error("Runtime is closed");
-            options.signal?.throwIfAborted();
-            if (stored?.active ||
-                stored?.status === "interrupted" ||
-                stored?.status === "archived")
-                throw new Error("This session is interrupted or archived. Reconcile external effects or start a new session.");
-            const controller = new AbortController();
-            this.active.set(key, controller);
-            const abort = () => controller.abort(options.signal?.reason);
-            options.signal?.addEventListener("abort", abort, { once: true });
-            if (options.signal?.aborted)
-                abort();
-            const now = Date.now();
-            const runId = options.runId ?? crypto.randomUUID();
-            let document = stored ?? {
-                version: 1,
-                id: sessionId,
-                agentId: agent.id,
-                status: "running",
-                startedAt: now,
-                updatedAt: now,
-                events: [],
-            };
-            const title = typeof input === "string"
-                ? input
-                : "text" in input
-                    ? input.text
-                    : "content" in input
-                        ? input.content
-                            .filter((part) => part.type === "text")
-                            .map((part) => part.text)
-                            .join(" ")
-                        : undefined;
-            const events = [...document.events];
-            let sequence = events.at(-1)?.seq ?? 0;
-            const add = (type, payload, publish = true) => {
-                const event = {
-                    session: sessionId,
-                    seq: ++sequence,
-                    ts: new Date().toISOString(),
-                    type,
-                    payload: scrub({ ...payload, runId }, options.secrets ?? []),
-                };
-                events.push(event);
-                if (publish)
-                    publishEvent(event);
-                return event;
-            };
-            const publishEvent = (event) => {
-                for (const listener of [
-                    options.onEvent,
-                    ...(this.listeners.get(key) ?? []),
-                ]) {
-                    try {
-                        listener?.(event);
-                    }
-                    catch {
-                        /* Delivery cannot acknowledge or block persistence. */
-                    }
-                }
-            };
-            const save = async () => {
-                document = {
-                    ...document,
-                    updatedAt: Date.now(),
-                    events: [...events],
-                };
-                await this.store.put(agent.id, sessionId, document);
-            };
-            try {
-                document = {
-                    ...document,
-                    status: "running",
-                    active: { runId, input },
-                    ...(document.title === undefined && title
-                        ? { title: title.slice(0, 120) }
-                        : {}),
-                };
-                add("session.run.started", options.started ?? {
-                    input_kind: typeof input === "string"
-                        ? "user-message"
-                        : "kind" in input
-                            ? input.kind
-                            : "user-message",
-                    ...(typeof input === "string" ? { input } : {}),
-                });
-                await save();
-                const binding = bindingFromAgent(agent);
-                const engineInput = resolveEngineInput(document.state, input);
-                const state = ensureEngineState(binding, document.state, options.sessionState);
-                const result = await run({
-                    binding,
-                    state,
-                    input: engineInput,
-                    info: options.info,
-                    signal: controller.signal,
-                    onModelCall: options.onModelCall,
-                    onEvent: (event) => {
-                        add(event.type, event);
-                    },
-                    record: async (next) => {
-                        document = { ...document, state: next };
-                        await save();
-                    },
-                });
-                const { active: _, ...rest } = document;
-                document = {
-                    ...rest,
-                    state: result.state,
-                    status: result.status === "paused" ? "waiting" : result.status,
-                };
-                const terminal = result.status === "completed"
-                    ? add("final", { output: result.output }, false)
-                    : result.status === "paused"
-                        ? add("interaction.required", {
-                            pending: result.pending,
-                            ...(result.pending.find((item) => item.interaction)
-                                ?.interaction
-                                ? {
-                                    interaction: result.pending.find((item) => item.interaction).interaction,
-                                }
-                                : {}),
-                        }, false)
-                        : add(result.status === "failed" ? "error" : "cancelled", result.status === "failed" ? { ...result.error } : {}, false);
-                await save();
-                publishEvent(terminal);
-                return result;
-            }
-            catch (error) {
-                if (isHarnessError(error) &&
-                    [
-                        "execution.invalid-input",
-                        "execution.invalid-state",
-                        "execution.incompatible",
-                    ].includes(error.code)) {
-                    // Keep the prior continuation, but commit the rejected attempt so event
-                    // sequence numbers already observed by subscribers are never reused.
-                    const rejected = add("error", {
-                        message: error instanceof Error ? error.message : String(error),
-                    }, false);
-                    const { active: _, ...rest } = document;
-                    await this.store.put(agent.id, sessionId, {
-                        ...(stored ?? { ...rest, status: "failed" }),
-                        updatedAt: Date.now(),
-                        events: [...events],
-                    });
-                    publishEvent(rejected);
-                    throw error;
-                }
-                // A failed commit must leave the durable active marker intact. Never replay it.
-                add("error", {
-                    message: error instanceof Error ? error.message : String(error),
-                });
-                throw error;
-            }
-            finally {
-                options.signal?.removeEventListener("abort", abort);
-                this.active.delete(key);
-            }
-        });
-        this.queues.set(key, work);
-        void work
-            .finally(() => {
-            if (this.queues.get(key) === work)
-                this.queues.delete(key);
-        })
-            .catch(() => { });
-        return work;
-    }
-    async cancel(agent, sessionId) {
-        const key = this.key(agent.id, sessionId);
-        this.generations.set(key, (this.generations.get(key) ?? 0) + 1);
-        this.active.get(key)?.abort(new Error("Run cancelled"));
-        const prior = this.queues.get(key) ?? Promise.resolve();
-        const work = prior
-            .catch(() => { })
-            .then(async () => {
-            const stored = await this.store.get(agent.id, sessionId);
-            if (stored?.active || stored?.status === "interrupted")
-                throw new Error("This session was interrupted; reconcile its external effects before cancellation.");
-            if (stored?.state?.status !== "paused")
-                return;
-            const binding = bindingFromAgent(agent);
-            const result = await run({
-                binding,
-                state: stored.state,
-                input: { kind: "continue" },
-                signal: AbortSignal.abort(new Error("Paused execution cancelled")),
-                onModelCall: async () => {
-                    throw new Error("Cancelled execution cannot call a model");
-                },
-            });
-            const event = {
-                session: sessionId,
-                seq: (stored.events.at(-1)?.seq ?? 0) + 1,
-                ts: new Date().toISOString(),
-                type: "cancelled",
-                payload: { executionId: result.state.executionId },
-            };
-            await this.store.put(agent.id, sessionId, {
-                ...stored,
-                state: result.state,
-                status: "cancelled",
-                updatedAt: Date.now(),
-                events: [...stored.events, event],
-            });
-            for (const listener of this.listeners.get(key) ?? []) {
-                try {
-                    listener(event);
-                }
-                catch {
-                    /* Observation cannot change committed cancellation. */
-                }
-            }
-        });
-        this.queues.set(key, work);
-        try {
-            await work;
-        }
-        finally {
-            if (this.queues.get(key) === work)
-                this.queues.delete(key);
-        }
-    }
-    async interrupt(agent, sessionId, input, options) {
-        await this.cancel(agent, sessionId);
-        return this.submit(agent, sessionId, input, options);
-    }
-    async close() {
-        this.closed = true;
-        for (const controller of this.active.values())
-            controller.abort(new Error("Runtime closing"));
-        await Promise.allSettled(this.queues.values());
-        this.listeners.clear();
-        if ("close" in this.store && typeof this.store.close === "function")
-            await this.store.close();
-    }
-}
-function ensureEngineState(binding, existing, sessionState) {
-    if (existing) {
-        if (!sessionState || Object.keys(existing.state ?? {}).length > 0)
-            return existing;
-        return {
-            ...existing,
-            state: { ...(existing.state ?? {}), ...sessionState },
-        };
-    }
-    return createRunState(binding, {
-        ...(sessionState ? { state: sessionState } : {}),
-    });
-}
-/**
- * Map DX `wait-resolve` onto harness approve/respond/settle using wait metadata.
- * Engine `ExecutionInput` already includes `wait-resolve`; resume is wired via
- * existing interaction/deferred kinds until full wait-id resume lands.
- */
-export function resolveEngineInput(state, input) {
-    if (typeof input !== "object" || !("kind" in input) || input.kind !== "wait-resolve")
-        return input;
-    const call = state?.plan?.calls.find((item) => item.wait?.waitId === input.waitId);
-    if (!call)
-        throw new HarnessError("execution.invalid-input", "No pending wait matches waitId");
-    if (call.status === "interaction" && call.interaction) {
-        if (call.interaction.kind === "approval")
-            return {
-                kind: "approve",
-                interactionId: call.interaction.id,
-                approved: input.value !== false && input.value !== "false",
-            };
-        return {
-            kind: "respond",
-            interactionId: call.interaction.id,
-            value: input.value ?? null,
-        };
-    }
-    if (call.status === "deferred")
-        return {
-            kind: "settle",
-            invocationId: call.invocationId,
-            outcome: {
-                kind: "completed",
-                output: input.value ?? null,
-            },
-        };
-    throw new HarnessError("execution.invalid-input", "Wait is no longer pending");
-}