@nylorun/runtime 0.5.0-beta → 0.7.0-beta

package/dist/mcp/stdio.js

@@ -0,0 +1,80 @@
+import { mkdirSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+const ROOT_TOKEN = "${PLUGIN_ROOT}";
+const DATA_TOKEN = "${PLUGIN_DATA}";
+/** Single-pass replacement. Text inserted for a token is not scanned again. */
+export function expandPluginPlaceholders(value, pluginRoot, pluginData) {
+    let out = "";
+    for (let index = 0; index < value.length;) {
+        if (value.startsWith(ROOT_TOKEN, index)) {
+            out += pluginRoot;
+            index += ROOT_TOKEN.length;
+            continue;
+        }
+        if (value.startsWith(DATA_TOKEN, index)) {
+            out += pluginData;
+            index += DATA_TOKEN.length;
+            continue;
+        }
+        out += value[index];
+        index += 1;
+    }
+    return out;
+}
+export function prepareStdioLaunch(server, options) {
+    const pluginData = options.pluginData;
+    mkdirSync(pluginData, { recursive: true });
+    const pluginRoot = options.pluginRoot;
+    if (needsPluginRoot(server) && !pluginRoot)
+        throw new Error("stdio server requires a plugin root");
+    for (const key of Object.keys(server.env ?? {})) {
+        if (key === "PLUGIN_ROOT" || key === "PLUGIN_DATA")
+            throw new Error(`stdio env must not set ${key}`);
+    }
+    const command = server.command.startsWith("./")
+        ? resolve(pluginRoot, server.command)
+        : server.command;
+    const args = (server.args ?? []).map((arg) => expand(arg, pluginRoot, pluginData));
+    const cwd = server.cwd
+        ? resolveContainedCwd(server.cwd, pluginRoot, pluginData)
+        : (pluginRoot ?? pluginData);
+    const env = {};
+    for (const [key, value] of Object.entries(server.env ?? {}))
+        env[key] = expand(value, pluginRoot, pluginData);
+    if (pluginRoot)
+        env.PLUGIN_ROOT = pluginRoot;
+    env.PLUGIN_DATA = pluginData;
+    return { command, args, cwd, env };
+}
+function needsPluginRoot(server) {
+    if (server.command.startsWith("./"))
+        return true;
+    const values = [
+        ...(server.args ?? []),
+        ...Object.values(server.env ?? {}),
+        ...(server.cwd === undefined ? [] : [server.cwd]),
+    ];
+    return values.some((value) => value.includes(ROOT_TOKEN));
+}
+function expand(value, pluginRoot, pluginData) {
+    if (value.includes(ROOT_TOKEN) && !pluginRoot)
+        throw new Error("stdio server requires a plugin root");
+    return expandPluginPlaceholders(value, pluginRoot ?? "", pluginData);
+}
+function resolveContainedCwd(cwd, pluginRoot, pluginData) {
+    const expanded = expand(cwd, pluginRoot, pluginData);
+    const base = cwdTargetsData(cwd) ? pluginData : pluginRoot;
+    if (!base)
+        throw new Error("stdio server requires a plugin root");
+    const absolute = isAbsolute(expanded) ? expanded : resolve(base, expanded);
+    if (!isInside(base, absolute))
+        throw new Error(`Working directory escapes ${base}`);
+    return absolute;
+}
+function cwdTargetsData(cwd) {
+    return cwd === DATA_TOKEN || cwd.startsWith(`${DATA_TOKEN}/`);
+}
+function isInside(root, target) {
+    const rel = relative(root, target);
+    return rel === "" || (!rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel));
+}

package/dist/model/defaults.d.ts

@@ -1,4 +1,4 @@
-import type { ModelAdapter } from "@nylorun/harness";
+import type { ModelAdapter } from "@nylorun/core/define";
 import { type ModelEnvironment } from "./http-model.js";
 export interface ModelPreview {
     readonly invocationId: string;

package/dist/model/http-model.d.ts

@@ -1,4 +1,4 @@
-import type { ModelAdapter } from "@nylorun/harness";
+import type { ModelAdapter } from "@nylorun/core/define";
 import type { ModelFactoryOptions } from "./defaults.js";
 export type ModelEnvironment = Readonly<Record<string, string | undefined>>;
 export interface HttpModelOptions extends ModelFactoryOptions {

package/dist/node/local-sessions.js

@@ -134,6 +134,23 @@ export function localSessions(options) {
                 .flatMap((session) => (session ? [sessionSummary(session)] : []))
                 .sort((a, b) => b.startedAt - a.startedAt);
         },
+        async delete(agentId, sessionId) {
+            const operation = operations.then(async () => {
+                await check();
+                const target = pathFor(agentId, sessionId);
+                try {
+                    await rm(target);
+                    return true;
+                }
+                catch (error) {
+                    if (isMissing(error))
+                        return false;
+                    throw error;
+                }
+            });
+            operations = operation.then(() => { }, () => { });
+            return operation;
+        },
         async close() {
             await operations;
             if (closed)

package/dist/server/host.d.ts

@@ -1,8 +1,10 @@
 import { Hono, type Context } from "hono";
 import type { JsonValue, RuntimeAgent } from "../contracts.js";
+import type { BuiltAgent, ModelAdapter } from "@nylorun/core/define";
 import { SessionHost } from "../sessions/host.js";
 import type { RuntimeConfig } from "../config.js";
 import type { ModelEnvironment } from "../model/http-model.js";
+import { type OpenSessionOptions, type SessionHandle } from "../session/handle.js";
 export type RuntimeActor = Readonly<{
     id: string;
     context?: Record<string, JsonValue>;
@@ -14,19 +16,55 @@ export type AgentRouterOptions = Readonly<{
     getEnvironment?: (context: Context) => ModelEnvironment | Promise<ModelEnvironment>;
     getRequestMetadata?: (context: Context) => Record<string, JsonValue> | undefined | Promise<Record<string, JsonValue> | undefined>;
 }>;
-export type ServeAgentsOptions = AgentRouterOptions & {
+/** 1.0 compatibility: requires an explicit Runtime and returns a Hono app. */
+export type ServeAgentsCompatOptions = AgentRouterOptions & {
     readonly agents: readonly RuntimeAgent[];
     readonly runtime: Runtime;
 };
+/** DX v5.6 local: optional Runtime; returns `{ fetch }`. */
+export type ServeAgentsFetchOptions = AgentRouterOptions & {
+    readonly agents?: readonly RuntimeAgent[];
+    readonly runtime?: Runtime;
+    /** Alias for `getInfo` — keep the name `info` (never `user`). */
+    readonly info?: AgentRouterOptions["getInfo"];
+    readonly on?: {
+        readonly session?: {
+            readonly created?: (session: {
+                readonly id: string;
+                readonly agentId: string;
+            }) => void;
+            readonly idle?: (session: {
+                readonly id: string;
+                readonly agentId: string;
+            }) => void;
+            readonly failed?: (session: {
+                readonly id: string;
+                readonly agentId: string;
+            }) => void;
+        };
+    };
+};
+export type ServeAgentsOptions = ServeAgentsCompatOptions;
+export type ServeAgentsFetch = {
+    readonly fetch: (request: Request) => Response | Promise<Response>;
+};
 declare const kServe: unique symbol;
 export declare class Runtime {
-    private readonly config;
+    readonly config: RuntimeConfig;
     readonly host: SessionHost;
     private served;
     private closing?;
     constructor(config?: RuntimeConfig);
     close: () => Promise<void>;
-    [kServe](options: Omit<ServeAgentsOptions, "runtime">): Hono<any>;
+    resolveModel(onPreview?: (preview: import("../model/defaults.js").ModelPreview) => void): ModelAdapter;
+    openSession(agent: BuiltAgent<any, any>, options?: OpenSessionOptions): SessionHandle;
+    listSessions(agentId: string): Promise<readonly import("../sessions/store.js").SessionSummary[]>;
+    getSession(agentId: string, sessionId: string): Promise<import("../sessions/store.js").StoredSession | undefined>;
+    deleteSession(agentId: string, sessionId: string): Promise<boolean>;
+    [kServe](options: Omit<ServeAgentsCompatOptions, "runtime"> & {
+        readonly agents: readonly RuntimeAgent[];
+    }): Hono<any>;
 }
-export declare function serveAgents(options: ServeAgentsOptions): Hono<any>;
+export declare function serveAgents(options: ServeAgentsCompatOptions): Hono<any>;
+export declare function serveAgents(options: ServeAgentsFetchOptions): ServeAgentsFetch;
 export {};

package/dist/server/host.js

@@ -8,6 +8,8 @@ import { memorySessions } from "../sessions/store.js";
 import { SessionHost } from "../sessions/host.js";
 import { IMAGE_MEDIA_TYPES, MAX_IMAGE_BYTES, decodeImageBase64, } from "../media.js";
 import { defaultModel, processEnvironment, registerRuntimeLifecycle, } from "../model/defaults.js";
+import { createSessionHandle, } from "../session/handle.js";
+import { installDefaultRuntimeFactory } from "../session/default.js";
 const randomUUID = () => crypto.randomUUID();
 const kServe = Symbol("serve");
 export class Runtime {
@@ -21,6 +23,26 @@ export class Runtime {
         registerRuntimeLifecycle(this.close);
     }
     close = () => (this.closing ??= this.host.close());
+    resolveModel(onPreview) {
+        return (this.config.onModelCall ??
+            (this.config.createModel ?? defaultModel)({
+                environment: this.config.environment ?? processEnvironment(),
+                onPreview,
+                media: this.config.media,
+            }));
+    }
+    openSession(agent, options) {
+        return createSessionHandle(this, agent, options);
+    }
+    async listSessions(agentId) {
+        return this.host.list(agentId);
+    }
+    async getSession(agentId, sessionId) {
+        return this.host.read(agentId, sessionId);
+    }
+    async deleteSession(agentId, sessionId) {
+        return this.host.delete(agentId, sessionId);
+    }
     [kServe](options) {
         if (this.served)
             throw new Error("A Runtime may only be served once.");
@@ -141,8 +163,20 @@ export class Runtime {
                 id: document.id,
                 state: document.status,
                 pending_interaction: document.state?.plan?.calls.find((call) => call.status === "interaction")?.interaction,
+                pending_waits: document.state?.plan?.calls
+                    .filter((call) => (call.status === "interaction" || call.status === "deferred") &&
+                    call.wait)
+                    .map((call) => call.wait),
             });
         });
+        app.delete("/:agentId/v1/sessions/:session", async (context) => {
+            const agent = agentFor(context);
+            const sessionId = context.req.param("session");
+            const deleted = await this.host.delete(agent.id, sessionId);
+            if (!deleted)
+                return context.json({ error: "unknown session" }, 404);
+            return context.json({ session_id: sessionId, deleted: true });
+        });
         app.post("/:agentId/v1/sessions/:session", async (context) => {
             const agent = agentFor(context), sessionId = context.req.param("session");
             const payload = await context.req.json();
@@ -161,6 +195,20 @@ export class Runtime {
             }
             if (payload.settlement)
                 input = { kind: "settle", ...payload.settlement };
+            else if (payload.action === "wait-resolve" ||
+                payload.waitResolve ||
+                (interaction?.kind === "wait-resolve" &&
+                    typeof interaction.waitId === "string")) {
+                const wait = payload.waitResolve ??
+                    (interaction?.kind === "wait-resolve" ? interaction : payload);
+                if (typeof wait.waitId !== "string")
+                    return context.json({ error: "wait-resolve requires waitId" }, 400);
+                input = {
+                    kind: "wait-resolve",
+                    waitId: wait.waitId,
+                    ...("value" in wait ? { value: wait.value } : {}),
+                };
+            }
             else if (interaction?.kind === "approval" &&
                 typeof interaction.id === "string" &&
                 typeof interaction.approved === "boolean")
@@ -178,7 +226,9 @@ export class Runtime {
                     value: interaction.value,
                 };
             else
-                return context.json({ error: "expected a correlated interaction or settlement" }, 400);
+                return context.json({
+                    error: "expected a correlated interaction, settlement, or wait-resolve",
+                }, 400);
             const document = await this.host.read(agent.id, sessionId);
             if (!document || document.status !== "waiting")
                 return context.json({ error: "interaction is no longer pending" }, 409);
@@ -280,9 +330,25 @@ export class Runtime {
     }
 }
 export function serveAgents(options) {
-    const { runtime, ...rest } = options;
-    return runtime[kServe](rest);
+    if ("runtime" in options && options.runtime) {
+        const { runtime, ...rest } = options;
+        return runtime[kServe]({
+            ...rest,
+            agents: options.agents ?? [],
+        });
+    }
+    const runtime = new Runtime({});
+    const getInfo = options.getInfo ?? ("info" in options ? options.info : undefined);
+    const app = runtime[kServe]({
+        ...options,
+        agents: options.agents ?? [],
+        ...(getInfo ? { getInfo } : {}),
+    });
+    return {
+        fetch: (request) => app.fetch(request),
+    };
 }
+installDefaultRuntimeFactory(() => new Runtime({}));
 /** Workers-style provider bindings on context.env; ignore Hono Node stream slots. */
 function bindingsEnvironment(context) {
     const env = context.env;

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

@@ -1,4 +1,5 @@
-import type { BuiltAgent, ExecutionInput, ModelAdapter, RunResult } from "@nylorun/harness";
+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;
@@ -8,6 +9,8 @@ export interface SubmitOptions {
     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 {
@@ -21,9 +24,16 @@ export declare class SessionHost {
     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;