@nylorun/runtime 0.4.0-beta → 0.6.0-beta

package/dist/session/api.d.ts

@@ -0,0 +1,10 @@
+import type { BuiltAgent } from "@nylorun/core/define";
+import { setDefaultRuntime } from "./default.js";
+import type { OpenSessionOptions, SessionHandle } from "./handle.js";
+export { setDefaultRuntime };
+export type { OpenSessionOptions, SessionHandle };
+/** Open-or-create a local session with an agent (bound to the default Runtime). */
+export declare function openSession(agent: BuiltAgent<any, any>, options?: OpenSessionOptions): SessionHandle;
+export declare function listSessions(agentId: string): Promise<readonly import("../sessions/store.js").SessionSummary[]>;
+export declare function getSession(agentId: string, sessionId: string): Promise<import("../sessions/store.js").StoredSession | undefined>;
+export declare function deleteSession(agentId: string, sessionId: string): Promise<boolean>;

package/dist/session/api.js

@@ -0,0 +1,15 @@
+import { getDefaultRuntime, setDefaultRuntime, } from "./default.js";
+export { setDefaultRuntime };
+/** Open-or-create a local session with an agent (bound to the default Runtime). */
+export function openSession(agent, options) {
+    return getDefaultRuntime().openSession(agent, options);
+}
+export async function listSessions(agentId) {
+    return getDefaultRuntime().listSessions(agentId);
+}
+export async function getSession(agentId, sessionId) {
+    return getDefaultRuntime().getSession(agentId, sessionId);
+}
+export async function deleteSession(agentId, sessionId) {
+    return getDefaultRuntime().deleteSession(agentId, sessionId);
+}

package/dist/session/default.d.ts

@@ -0,0 +1,5 @@
+import type { Runtime } from "../server/host.js";
+/** Wired from `server/host.ts` after `Runtime` is defined (avoids init cycles). */
+export declare function installDefaultRuntimeFactory(factory: () => Runtime): void;
+export declare function setDefaultRuntime(runtime: Runtime | undefined): void;
+export declare function getDefaultRuntime(): Runtime;

package/dist/session/default.js

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,199 @@
+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

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

package/dist/session/index.js

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

package/dist/sessions/host.d.ts

@@ -0,0 +1,39 @@
+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;