@nylorun/runtime 0.9.0-beta → 0.11.0-beta

package/dist/core/runtime.js

@@ -1,1447 +1,3 @@
-import { createServer, } from "node:http";
-import { randomUUID, timingSafeEqual } from "node:crypto";
-import { mkdirSync, openSync, closeSync, unlinkSync, writeFileSync, readFileSync, realpathSync, mkdtempSync, } from "node:fs";
-import { createHash } from "node:crypto";
-import { dirname, join } from "node:path";
-import { tmpdir } from "node:os";
-import { AgentManifestSchema, CreateCredentialRequestSchema, CreateVaultRequestSchema, PutAgentRequestSchema, PutHostModelRequestSchema, SelectHostModelRequestSchema, PutSessionRequestSchema, RegisterExecutorsRequestSchema, RotateCredentialRequestSchema, SessionCommandSchema, ActionClaimRequestSchema, ActionHeartbeatRequestSchema, } from "@nylorun/core/contracts";
-import { createDurableCheckpoint, runDurable, } from "@nylorun/harness/run";
-import { hashManifest } from "@nylorun/core/compatibility";
-import { delegateManifest, schemaFromJSON, } from "@nylorun/core/define";
-import { Store, canonical } from "./store.js";
-import { ExecutorRegistry, assertExecutorCredential, hashToken, } from "./executors.js";
-import { RUNTIME_VERSION } from "../version.js";
-import { hostModelCatalog } from "../model/catalog.js";
-import { piModel } from "../model/pi-model.js";
-import { scriptedModel } from "./provider.js";
-import { scrub } from "../redact.js";
-import { createKekFile, defaultKekPath, readVaultKek } from "../vault/kek.js";
-import { VaultError } from "../vault/error.js";
-import { VaultService } from "../vault/service.js";
-import { McpPool, serversOf } from "../mcp/pool.js";
-import { SandboxManager, sandboxCapabilityOf } from "../sandbox/manager.js";
-import { defaultSandboxBackends } from "../sandbox/select.js";
-class HttpError extends Error {
-    status;
-    constructor(status, message) {
-        super(message);
-        this.status = status;
-    }
-}
-const fail = (status, message) => {
-    throw new HttpError(status, message);
-};
-function sessionToolsOf(snapshot) {
-    if (!snapshot?.mcpTools.length)
-        return undefined;
-    return snapshot.mcpTools.map((tool) => ({
-        ...(tool.agentId === undefined ? {} : { agentId: tool.agentId }),
-        capabilityId: tool.capabilityId,
-        name: tool.name,
-        ...(tool.description === undefined
-            ? {}
-            : { description: tool.description }),
-        inputSchema: tool.inputSchema,
-        ...(tool.outputSchema === undefined
-            ? {}
-            : { outputSchema: tool.outputSchema }),
-    }));
-}
-function mcpToolOf(session, request) {
-    return session.mcpSnapshot?.mcpTools.find((tool) => tool.agentId === request.agent?.id &&
-        tool.capabilityId === request.capabilityId &&
-        tool.name === request.toolName);
-}
-/** The manifest of the agent an effect belongs to: the root, or an agent it uses as a tool. */
-function manifestFor(manifest, agent) {
-    return agent ? delegateManifest(manifest, agent.id) : manifest;
-}
-function pinnedTool(manifest, capabilityId, toolName) {
-    const capability = manifest.capabilities.find((item) => item.id === capabilityId);
-    return capability?.tools?.find((tool) => tool.name === toolName);
-}
-function acceptedToolResult(action, command) {
-    if (action.kind !== "tool" || !action.outputSchema)
-        return command;
-    const value = command.outcome.value;
-    if (isFailedToolValue(value))
-        return command;
-    // Executors wrap successful tool output as `{ kind: "completed", output }`.
-    // Validate the tool payload, not the outcome envelope.
-    const candidate = completedToolOutput(value);
-    let matches = false;
-    try {
-        matches = schemaFromJSON(action.outputSchema).validate(candidate).ok;
-    }
-    catch {
-        matches = false;
-    }
-    if (matches)
-        return command;
-    return {
-        ...command,
-        outcome: {
-            ...command.outcome,
-            value: {
-                kind: "failed",
-                code: "tool.invalid-output",
-                message: "Tool result does not match the output schema stored on the action",
-            },
-        },
-    };
-}
-function completedToolOutput(value) {
-    if (value &&
-        typeof value === "object" &&
-        !Array.isArray(value) &&
-        value.kind === "completed" &&
-        "output" in value) {
-        return value.output;
-    }
-    return value;
-}
-function isFailedToolValue(value) {
-    return (!!value &&
-        typeof value === "object" &&
-        !Array.isArray(value) &&
-        value.kind === "failed");
-}
-const semantic = (value) => {
-    const { requestId: _, ...body } = value;
-    return canonical(body);
-};
-const sessionIdentity = (value) => {
-    const { requestId: _requestId, vaultIds: _vaultIds, credentialSelections: _selections, ...body } = value ?? {};
-    return canonical(body);
-};
-const equals = (a, b) => {
-    const aa = Buffer.from(a), bb = Buffer.from(b);
-    return aa.length === bb.length && timingSafeEqual(aa, bb);
-};
-export class CoreRuntime {
-    options;
-    store;
-    vault;
-    kek;
-    kekPath;
-    running = new Map();
-    pending = new Set();
-    observers = new Map();
-    // Keyed by token hash so a rotation can end exactly the streams that the replaced token owns.
-    executorStreams = new Map();
-    registry = new ExecutorRegistry();
-    scopeId;
-    mcp;
-    sandbox;
-    server;
-    closing = false;
-    closed = false;
-    lockPath;
-    timer;
-    constructor(options) {
-        this.options = options;
-        if (options.leaseMs !== undefined &&
-            (!Number.isFinite(options.leaseMs) || options.leaseMs <= 0))
-            throw new Error("leaseMs must be finite and positive");
-        if (new Set(options.executors.map((e) => e.token)).size !==
-            options.executors.length)
-            throw new Error("Executor tokens must be unique");
-        if (!options.serverToken || options.serverToken.length < 16)
-            throw new Error("A server token of at least 16 characters is required");
-        for (const executor of options.executors)
-            assertExecutorCredential(executor, options.serverToken);
-        if (options.sqlitePath !== ":memory:") {
-            mkdirSync(dirname(options.sqlitePath), { recursive: true });
-            this.lockPath = options.sqlitePath + ".runtime-lock";
-            // One local scheduling owner; recover a stale process lock only after checking that its PID is absent.
-            try {
-                const oldPid = Number(readFileSync(this.lockPath, "utf8"));
-                if (!Number.isSafeInteger(oldPid) || oldPid < 1)
-                    throw new Error("Invalid runtime lock; inspect before removing");
-                try {
-                    process.kill(oldPid, 0);
-                    throw new Error("Another Runtime owns this SQLite database");
-                }
-                catch (error) {
-                    if (error.code !== "ESRCH")
-                        throw error;
-                    unlinkSync(this.lockPath);
-                }
-            }
-            catch (error) {
-                if (error.code !== "ENOENT")
-                    throw error;
-            }
-            const fd = openSync(this.lockPath, "wx");
-            writeFileSync(fd, String(process.pid));
-            closeSync(fd);
-        }
-        this.kekPath = options.vaultKekPath ?? defaultKekPath();
-        let store;
-        try {
-            store = new Store(options.sqlitePath);
-            this.kek = readVaultKek({
-                vaultKek: options.vaultKek,
-                vaultKekPath: this.kekPath,
-            });
-            if (store.credentialCount() > 0 && !this.kek)
-                throw new Error("Vault key-encryption key is required to open this database");
-            this.store = store;
-        }
-        catch (e) {
-            store?.db.close();
-            if (this.lockPath)
-                unlinkSync(this.lockPath);
-            throw e;
-        }
-        // A short digest of the resolved database path identifies this scope to the CLI without
-        // disclosing the path itself over the unauthenticated health route.
-        this.scopeId =
-            options.sqlitePath === ":memory:"
-                ? "memory"
-                : createHash("sha256")
-                    .update(realpathSync(options.sqlitePath))
-                    .digest("hex")
-                    .slice(0, 16);
-        // Registrations persisted by PUT /v1/executors load first; scopes supplied through
-        // NYLORUN_EXECUTORS_JSON then overlay them for this process only and are never written back.
-        this.registry.seed(this.store.allExecutors().map((row) => ({
-            agentId: row.agentId,
-            implementationVersion: row.implementationVersion,
-            ...(row.manifestHash === undefined
-                ? {}
-                : { manifestHash: row.manifestHash }),
-            tokenHash: row.tokenHash,
-            persisted: true,
-            updatedAt: row.updatedAt,
-        })));
-        const now = new Date().toISOString();
-        for (const executor of options.executors) {
-            const tokenHash = hashToken(executor.token);
-            const collision = this.registry.find(tokenHash);
-            if (collision && collision.agentId !== executor.agentId) {
-                this.store.db.close();
-                if (this.lockPath)
-                    unlinkSync(this.lockPath);
-                throw new Error("Executor tokens must be unique");
-            }
-            this.registry.upsert({
-                agentId: executor.agentId,
-                implementationVersion: executor.implementationVersion,
-                ...(executor.manifestHash === undefined
-                    ? {}
-                    : { manifestHash: executor.manifestHash }),
-                tokenHash,
-                persisted: false,
-                updatedAt: now,
-            });
-        }
-        this.vault = new VaultService(this.store.db, (fn) => this.store.tx(fn), () => this.ensureKek(), options.vaultFetch ?? globalThis.fetch);
-        this.mcp = new McpPool({
-            dataDir: dirname(options.sqlitePath),
-            authorize: (sessionId, request) => this.authorize(sessionId, request),
-        });
-        const ephemeral = options.sqlitePath === ":memory:";
-        const sandboxRoot = options.sandbox?.root ??
-            (ephemeral
-                ? mkdtempSync(join(tmpdir(), "nylorun-sandboxes-"))
-                : join(dirname(options.sqlitePath), "sandboxes"));
-        this.sandbox = new SandboxManager({
-            scope: ephemeral ? `m${randomUUID().slice(0, 8)}` : this.scopeId,
-            store: this.store,
-            backends: options.sandbox?.backends ?? defaultSandboxBackends({ root: sandboxRoot }),
-            preference: options.sandbox?.backend ?? process.env.NYLORUN_SANDBOX,
-            ephemeral,
-            emit: (sessionId, turnId, type, payload) => {
-                if (this.closed)
-                    return;
-                const event = this.store.tx(() => this.store.event(sessionId, turnId, type, payload));
-                this.publish(event);
-            },
-        });
-        if (!ephemeral && this.sandbox.hasRecords())
-            void this.sandbox
-                .reconcile((id) => !this.closed && !!this.store.get("sessions", id))
-                .catch(() => undefined);
-        this.store.tx(() => {
-            for (const effect of this.store.all("effects"))
-                if (effect.status === "invoking") {
-                    effect.status = "uncertain";
-                    this.store.put("effects", effect.request.effectId, effect);
-                    const s = this.store.get("sessions", effect.request.sessionId);
-                    if (s &&
-                        s.status !== "cancelled" &&
-                        s.activeTurnId === effect.request.turnId) {
-                        s.status = "uncertain";
-                        this.store.put("sessions", s.id, s);
-                        this.store.event(s.id, s.activeTurnId, "effect.uncertain", {
-                            effectId: effect.request.effectId,
-                        });
-                    }
-                }
-        });
-        this.retireLegacyHooks();
-        this.expireClaims();
-        this.timer = setInterval(() => this.expireClaims(), Math.min(options.leaseMs ?? 30000, 5000));
-        this.timer.unref();
-        for (const s of this.store.all("sessions"))
-            if (s.status === "running" || s.status === "runnable")
-                this.schedule(s.id);
-    }
-    session(id) {
-        return (this.store.get("sessions", id) ?? fail(404, "Session not found"));
-    }
-    publish(event) {
-        for (const response of this.observers.get(event.sessionId) ?? [])
-            this.send(response, `id: ${event.cursor}\nevent: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`);
-    }
-    send(response, data) {
-        if (!response.write(data))
-            response.destroy();
-    }
-    notify() {
-        for (const streams of this.executorStreams.values())
-            for (const response of streams)
-                this.send(response, 'event: work_available\ndata: {"type":"work_available"}\n\n');
-    }
-    /**
-     * Manifest v4 replaced beforeModelCall/afterModelCall with scoped hooks. Turns started under
-     * an older manifest cannot continue, and their hook actions no longer parse, so end them.
-     */
-    retireLegacyHooks() {
-        this.store.tx(() => {
-            for (const action of this.store.all("actions"))
-                if ((action.kind === "beforeModelCall" || action.kind === "afterModelCall") &&
-                    (action.status === "pending" || action.status === "claimed")) {
-                    action.status = "cancelled";
-                    this.store.put("actions", action.actionId, action);
-                }
-            for (const s of this.store.all("sessions"))
-                if (s.activeTurnId && s.manifest?.manifestSchemaVersion !== 4) {
-                    this.store.event(s.id, s.activeTurnId, "turn.failed", {
-                        error: {
-                            code: "execution.incompatible",
-                            message: "This turn started under manifest schema 3; see MIGRATION.md for before/after hooks",
-                        },
-                    });
-                    s.status = "failed";
-                    s.activeTurnId = null;
-                    this.store.put("sessions", s.id, s);
-                }
-        });
-    }
-    expireClaims() {
-        const events = [];
-        let redeliver = false;
-        this.store.tx(() => {
-            for (const action of this.store.all("actions"))
-                if (action.status === "claimed" &&
-                    Date.parse(action.leaseExpiresAt) <= Date.now()) {
-                    if (action.kind === "hook") {
-                        // Hooks are pure by contract, so a lost claim is simply delivered again.
-                        // The next claim bumps the generation, which fences any late result.
-                        action.status = "pending";
-                        action.claimId = null;
-                        action.leaseExpiresAt = null;
-                        this.store.put("actions", action.actionId, action);
-                        redeliver = true;
-                        continue;
-                    }
-                    action.status = "uncertain";
-                    this.store.put("actions", action.actionId, action);
-                    const effect = this.store.get("effects", action.actionId);
-                    effect.status = "uncertain";
-                    this.store.put("effects", action.actionId, effect);
-                    const s = this.session(action.sessionId);
-                    if (s.status !== "cancelled" && s.activeTurnId === action.turnId) {
-                        s.status = "uncertain";
-                        this.store.put("sessions", s.id, s);
-                        events.push(this.store.event(s.id, s.activeTurnId, "action.uncertain", {
-                            actionId: action.actionId,
-                            ...(action.agent ? { agent: action.agent } : {}),
-                        }));
-                    }
-                }
-        });
-        events.forEach((e) => this.publish(e));
-        if (redeliver)
-            this.notify();
-    }
-    schedule(id) {
-        if (this.closing)
-            return;
-        this.pending.add(id);
-        setImmediate(() => {
-            if (!this.running.has(id) && this.pending.delete(id) && !this.closing)
-                void this.execute(id);
-        });
-    }
-    async execute(id) {
-        const s = this.session(id);
-        if (!s.checkpoint || !["running", "runnable"].includes(s.status))
-            return;
-        s.status = "running";
-        this.store.tx(() => this.store.put("sessions", id, s));
-        const controller = new AbortController();
-        this.running.set(id, controller);
-        try {
-            await this.prepareMcp(id, controller.signal);
-            const current = this.session(id);
-            const result = await runDurable({
-                manifest: current.manifest,
-                checkpoint: current.checkpoint,
-                signal: controller.signal,
-                sessionTools: sessionToolsOf(current.mcpSnapshot),
-                host: {
-                    resolveEffect: (e) => this.resolveEffect(e, controller.signal),
-                },
-            });
-            let event;
-            this.store.tx(() => {
-                const current = this.session(id);
-                if (current.status === "cancelled" ||
-                    current.activeTurnId !== s.activeTurnId)
-                    return;
-                // A result can arrive during concurrent action persistence. Preserve the runnable marker.
-                const resumeRequested = current.status === "runnable";
-                if (result.status === "waiting" || result.status === "uncertain") {
-                    current.status = resumeRequested
-                        ? "runnable"
-                        : current.status === "uncertain"
-                            ? "uncertain"
-                            : result.status;
-                    current.waits = { effectIds: result.effectIds };
-                }
-                else if ("result" in result) {
-                    current.state =
-                        result.status === "failed"
-                            ? current.turnStartState
-                            : result.result.state;
-                    current.checkpoint = result.checkpoint;
-                    this.store.put("checkpoints", JSON.stringify([id, s.activeTurnId, result.checkpoint.segment]), { checkpoint: result.checkpoint, status: result.status });
-                    current.status = result.status;
-                    current.waits =
-                        result.status === "paused"
-                            ? result.result.pending
-                            : undefined;
-                    if (result.status !== "paused")
-                        current.activeTurnId = null;
-                    event = this.store.event(id, s.activeTurnId, `turn.${result.status}`, result.status === "completed"
-                        ? { output: result.result.output }
-                        : result.status === "paused"
-                            ? {
-                                interactions: (result.result.pending ?? []).map((call) => ({
-                                    invocationId: call.invocationId,
-                                    interaction: call.interaction,
-                                    wait: call.wait,
-                                    status: call.status,
-                                })),
-                            }
-                            : result.status === "failed"
-                                ? {
-                                    error: {
-                                        code: result.result.error?.code,
-                                        message: result.result.error?.message,
-                                    },
-                                }
-                                : {});
-                }
-                this.store.put("sessions", id, current);
-            });
-            if (event)
-                this.publish(event);
-        }
-        catch (error) {
-            let event;
-            this.store.tx(() => {
-                const current = this.session(id);
-                if (current.status === "cancelled" ||
-                    current.activeTurnId !== s.activeTurnId)
-                    return;
-                current.status = "failed";
-                current.state = current.turnStartState;
-                if (current.checkpoint)
-                    this.store.put("checkpoints", JSON.stringify([id, s.activeTurnId, current.checkpoint.segment]), { checkpoint: current.checkpoint, status: "failed" });
-                current.error = error instanceof Error ? error.message : String(error);
-                this.store.put("sessions", id, current);
-                event = this.store.event(id, current.activeTurnId, "turn.failed", {
-                    message: current.error,
-                });
-                current.activeTurnId = null;
-                this.store.put("sessions", id, current);
-            });
-            if (event)
-                this.publish(event);
-        }
-        finally {
-            this.running.delete(id);
-            if (!this.closing &&
-                (this.pending.has(id) || this.session(id).status === "runnable"))
-                this.schedule(id);
-        }
-    }
-    invokeModel(request, signal) {
-        if (!this.options.useHostModel)
-            return (this.options.model ?? scriptedModel())(request, signal);
-        const adapter = piModel({
-            readHostModel: () => this.vault.readHostModel(),
-            writeHostCredential: (credential) => this.vault.updateHostCredential(credential),
-        });
-        return adapter(request.input, {
-            request: request.context.request,
-            invocationId: String(request.context.invocationId),
-            signal,
-            reportPreparedCall() { },
-        });
-    }
-    async resolveEffect(request, signal) {
-        let invoke;
-        let notify = false;
-        let event;
-        const resolution = this.store.tx(() => {
-            const s = this.session(request.sessionId);
-            if (s.status === "cancelled" ||
-                s.activeTurnId !== request.turnId ||
-                signal.aborted)
-                throw new Error("Turn cancelled");
-            const existing = this.store.get("effects", request.effectId);
-            if (existing) {
-                if (canonical(existing.request) !== canonical(request))
-                    throw new Error("Effect identity request drift");
-                return existing.status === "completed"
-                    ? { status: "completed", outcome: existing.outcome }
-                    : {
-                        status: existing.status === "uncertain" ||
-                            existing.status === "invoking"
-                            ? "uncertain"
-                            : "pending",
-                    };
-            }
-            if (request.kind === "delegation") {
-                // Lifecycle points of an agent used as a tool: journaled once, so replays never re-emit.
-                const outcome = { value: null };
-                this.store.put("effects", request.effectId, {
-                    request,
-                    status: "completed",
-                    outcome,
-                });
-                const settled = request.effectId.endsWith(":settled");
-                event = this.store.event(s.id, s.activeTurnId, settled ? "delegation.completed" : "delegation.started", { agent: request.agent, ...request.input });
-                return { status: "completed", outcome };
-            }
-            const agentManifest = manifestFor(s.manifest, request.agent);
-            if (!agentManifest)
-                throw new Error(`Agent '${request.agent?.id ?? ""}' is not used as a tool`);
-            const mcpTool = request.kind === "tool" ? mcpToolOf(s, request) : undefined;
-            const sandboxTool = request.kind === "tool" && !mcpTool
-                ? sandboxCapabilityOf(agentManifest, request.capabilityId, request.toolName)
-                : undefined;
-            this.store.put("effects", request.effectId, {
-                request,
-                status: request.kind === "model" || mcpTool || sandboxTool
-                    ? "invoking"
-                    : "pending",
-            });
-            if (request.kind === "model" || mcpTool || sandboxTool) {
-                invoke = mcpTool ? "mcp" : sandboxTool ? "sandbox" : "model";
-                return undefined;
-            }
-            const tool = request.kind === "tool"
-                ? pinnedTool(agentManifest, request.capabilityId, request.toolName)
-                : undefined;
-            const base = {
-                actionId: request.effectId,
-                sessionId: request.sessionId,
-                turnId: request.turnId,
-                agentId: request.agentId,
-                manifestHash: request.manifestHash,
-                implementationVersion: s.implementationVersion,
-                input: request.input,
-                context: request.context,
-                status: "pending",
-                generation: 0,
-                claimId: null,
-                leaseExpiresAt: null,
-                ...(request.agent ? { agent: request.agent } : {}),
-            };
-            const action = request.kind === "hook"
-                ? {
-                    ...base,
-                    kind: "hook",
-                    hook: {
-                        at: request.hook.at,
-                        scope: request.hook.scope,
-                        capabilityIds: [...request.hook.capabilityIds],
-                    },
-                }
-                : {
-                    ...base,
-                    kind: "tool",
-                    capabilityId: request.capabilityId,
-                    toolName: request.toolName,
-                    ...(tool?.inputSchema ? { inputSchema: tool.inputSchema } : {}),
-                    ...(tool?.outputSchema ? { outputSchema: tool.outputSchema } : {}),
-                };
-            this.store.put("actions", action.actionId, action);
-            event = this.store.event(s.id, s.activeTurnId, "action.pending", {
-                actionId: action.actionId,
-                kind: action.kind,
-                ...actionTarget(action),
-                input: action.input,
-            });
-            notify = true;
-            return { status: "pending" };
-        });
-        if (event)
-            this.publish(event);
-        if (notify)
-            this.notify();
-        if (!invoke)
-            return resolution;
-        try {
-            const value = invoke === "mcp"
-                ? await this.callMcpTool(request)
-                : invoke === "sandbox"
-                    ? await this.callSandboxTool(request, signal)
-                    : await this.invokeModel(request, signal);
-            return this.store.tx(() => {
-                const s = this.session(request.sessionId);
-                if (s.status === "cancelled" ||
-                    s.activeTurnId !== request.turnId ||
-                    signal.aborted)
-                    throw new Error("Turn cancelled");
-                const effect = this.store.get("effects", request.effectId);
-                effect.status = "completed";
-                effect.outcome = { value };
-                this.store.put("effects", request.effectId, effect);
-                return { status: "completed", outcome: effect.outcome };
-            });
-        }
-        catch (error) {
-            let event;
-            this.store.tx(() => {
-                const effect = this.store.get("effects", request.effectId);
-                effect.status = "uncertain";
-                effect.error = error instanceof Error ? error.message : String(error);
-                this.store.put("effects", request.effectId, effect);
-                const s = this.session(request.sessionId);
-                if (s.status !== "cancelled" && s.activeTurnId === request.turnId)
-                    event = this.store.event(s.id, request.turnId, "effect.uncertain", {
-                        effectId: request.effectId,
-                        message: effect.error,
-                    });
-            });
-            if (event)
-                this.publish(event);
-            return { status: "uncertain" };
-        }
-    }
-    scope(request) {
-        const header = request.headers.authorization;
-        const token = header?.startsWith("Bearer ") ? header.slice(7) : "";
-        if (!token)
-            return fail(401, "Invalid credentials");
-        if (equals(token, this.options.serverToken))
-            return "server";
-        // The map is keyed by a digest of the presented token, so the lookup reveals nothing the
-        // caller does not already hold; the server token keeps its constant-time comparison.
-        const executor = this.registry.find(hashToken(token));
-        if (!executor)
-            return fail(401, "Invalid credentials");
-        return executor;
-    }
-    scoped(scope, action) {
-        if (scope === "server" || scope.agentId !== action.agentId)
-            fail(403, "Executor scope does not authorize this action");
-    }
-    async body(request) {
-        let data = "";
-        for await (const chunk of request) {
-            data += chunk;
-            if (Buffer.byteLength(data) > 1024 * 1024)
-                fail(413, "Request too large");
-        }
-        try {
-            return JSON.parse(data);
-        }
-        catch {
-            return fail(400, "Invalid JSON");
-        }
-    }
-    command(id, input, scope) {
-        let event;
-        let schedule = false;
-        const response = this.store.tx(() => {
-            const s = this.session(id);
-            let command = input;
-            if (command.type === "action_result") {
-                const a = this.store.get("actions", command.actionId) ??
-                    fail(404, "Action not found");
-                if (a.sessionId !== id)
-                    fail(403, "Action belongs to another session");
-                this.scoped(scope, a);
-                command = acceptedToolResult(a, command);
-            }
-            else if (scope !== "server")
-                fail(403, "Application credential required");
-            const key = JSON.stringify([id, command.idempotencyKey]);
-            const existing = this.store.get("commands", key);
-            if (existing) {
-                if (semantic(existing.command) !== semantic(command))
-                    fail(409, "Idempotency key already binds another command");
-                return existing.response;
-            }
-            if (command.type === "action_result") {
-                const action = this.store.get("actions", command.actionId);
-                const prior = this.store.get("effects", command.actionId);
-                if (action.status === "completed") {
-                    if (action.claimId !== command.claimId ||
-                        action.generation !== command.generation ||
-                        canonical(prior.outcome) !== canonical(command.outcome))
-                        fail(409, "Conflicting action result");
-                    this.store.put("commands", key, { command, response: prior.receipt });
-                    return prior.receipt;
-                }
-                if (s.status === "cancelled" ||
-                    s.activeTurnId !== action.turnId ||
-                    action.status !== "claimed" ||
-                    action.claimId !== command.claimId ||
-                    action.generation !== command.generation ||
-                    Date.parse(action.leaseExpiresAt) <= Date.now())
-                    fail(409, "Stale, expired, or cancelled claim");
-                action.status = "completed";
-                this.store.put("actions", action.actionId, action);
-                prior.status = "completed";
-                prior.outcome = command.outcome;
-                s.status = "runnable";
-                schedule = true;
-                event = this.store.event(id, s.activeTurnId, "action.completed", {
-                    actionId: action.actionId,
-                    ...actionTarget(action),
-                    kind: action.kind,
-                    result: command.outcome.value,
-                });
-                const receipt = {
-                    status: "accepted",
-                    turnId: s.activeTurnId,
-                    cursor: event.cursor,
-                    requestId: command.requestId,
-                };
-                prior.receipt = receipt;
-                this.store.put("effects", action.actionId, prior);
-            }
-            else if (command.type === "cancel") {
-                const cancelledTurnId = s.activeTurnId;
-                s.status = "cancelled";
-                for (const a of this.store.all("actions"))
-                    if (a.sessionId === id &&
-                        a.turnId === cancelledTurnId &&
-                        ["pending", "claimed"].includes(a.status)) {
-                        // Claimed work may already have an external effect. Preserve it for reconciliation.
-                        a.status = a.status === "claimed" ? "uncertain" : "cancelled";
-                        this.store.put("actions", a.actionId, a);
-                        const effect = this.store.get("effects", a.actionId);
-                        effect.status = a.status;
-                        this.store.put("effects", a.actionId, effect);
-                    }
-                for (const effect of this.store.all("effects"))
-                    if (effect.request.sessionId === id &&
-                        effect.request.turnId === cancelledTurnId &&
-                        effect.status === "invoking") {
-                        effect.status = "uncertain";
-                        effect.error =
-                            "Turn cancelled before model outcome was durably recorded";
-                        this.store.put("effects", effect.request.effectId, effect);
-                    }
-                event = this.store.event(id, cancelledTurnId, "turn.cancelled", {
-                    reason: command.reason,
-                });
-                s.activeTurnId = null;
-                // The next turn starts from the state preceding the cancelled turn, never its paused plan.
-                if (cancelledTurnId !== null)
-                    s.state = s.turnStartState;
-                s.checkpoint = undefined;
-                s.waits = undefined;
-                s.error = undefined;
-            }
-            else {
-                if (command.type === "message") {
-                    if (!["idle", "completed", "failed", "cancelled"].includes(s.status))
-                        fail(409, "Session has active or unresolved work");
-                    s.turnStartState = s.state;
-                    s.activeTurnId = randomUUID();
-                    s.checkpoint = createDurableCheckpoint({
-                        manifest: s.manifest,
-                        sessionId: id,
-                        turnId: s.activeTurnId,
-                        input: command.content,
-                        state: s.state,
-                        info: s.info,
-                    });
-                }
-                else {
-                    if (s.status !== "paused" || !s.state || !s.activeTurnId)
-                        fail(409, "Session is not awaiting a response");
-                    const pending = s.state.plan?.calls ?? [];
-                    if (!pending.some((c) => c.status === "interaction" &&
-                        c.interaction?.id === command.interactionId &&
-                        (command.type === "approve") ===
-                            (c.interaction?.kind === "approval")))
-                        fail(409, "Unknown interaction");
-                    const input = command.type === "approve"
-                        ? {
-                            kind: "approve",
-                            interactionId: command.interactionId,
-                            approved: command.approved,
-                        }
-                        : {
-                            kind: "respond",
-                            interactionId: command.interactionId,
-                            value: command.value,
-                        };
-                    s.checkpoint = createDurableCheckpoint({
-                        manifest: s.manifest,
-                        sessionId: id,
-                        turnId: s.activeTurnId,
-                        input: input,
-                        state: s.state,
-                        info: s.info,
-                        segment: (s.checkpoint?.segment ?? 0) + 1,
-                    });
-                }
-                this.store.put("checkpoints", JSON.stringify([id, s.activeTurnId, s.checkpoint.segment]), { checkpoint: s.checkpoint, status: "runnable" });
-                s.status = "runnable";
-                s.waits = undefined;
-                schedule = true;
-                event = this.store.event(id, s.activeTurnId, `command.${command.type}`, command);
-            }
-            this.store.put("sessions", id, s);
-            const response = {
-                status: "accepted",
-                turnId: s.activeTurnId,
-                cursor: event?.cursor ?? this.store.history(id).cursor,
-                requestId: command.requestId,
-            };
-            this.store.put("commands", key, { command, response });
-            return response;
-        });
-        if (event)
-            this.publish(event);
-        if (input.type === "cancel")
-            this.running.get(id)?.abort();
-        if (schedule)
-            this.schedule(id);
-        return response;
-    }
-    sse(request, response, set, whenEmpty) {
-        response.writeHead(200, {
-            "content-type": "text/event-stream",
-            "cache-control": "no-cache",
-            connection: "keep-alive",
-            "x-accel-buffering": "no",
-        });
-        response.flushHeaders();
-        set.add(response);
-        const timer = setInterval(() => this.send(response, ": keepalive\n\n"), 15000);
-        timer.unref();
-        request.on("close", () => {
-            clearInterval(timer);
-            set.delete(response);
-            if (!set.size)
-                whenEmpty?.();
-        });
-    }
-    async handle(request, response) {
-        const json = (value, status = 200) => {
-            response.writeHead(status, { "content-type": "application/json" });
-            response.end(JSON.stringify(value));
-        };
-        try {
-            const url = new URL(request.url ?? "/", "http://runtime");
-            const path = url.pathname
-                .split("/")
-                .filter(Boolean)
-                .map(decodeURIComponent);
-            const method = request.method;
-            if (url.pathname === "/health")
-                return json({
-                    status: "ok",
-                    service: "oss-runtime",
-                    version: RUNTIME_VERSION,
-                    scopeId: this.scopeId,
-                    pid: process.pid,
-                });
-            if (url.pathname === "/ready") {
-                this.store.db.prepare("SELECT 1").get();
-                return json({
-                    status: this.closing ? "not_ready" : "ready",
-                    service: "oss-runtime",
-                    checks: {
-                        sqlite: true,
-                        scheduler: !this.closing,
-                        modelConfigured: true,
-                    },
-                }, this.closing ? 503 : 200);
-            }
-            const scope = this.scope(request);
-            if (path[0] !== "v1")
-                fail(404, "Route not found");
-            if (path[1] === "executors" &&
-                path[2] === "connect" &&
-                method === "GET") {
-                if (scope === "server")
-                    fail(403, "Executor credential required");
-                const tokenHash = scope.tokenHash;
-                let streams = this.executorStreams.get(tokenHash);
-                if (!streams)
-                    this.executorStreams.set(tokenHash, (streams = new Set()));
-                this.sse(request, response, streams, () => this.executorStreams.delete(tokenHash));
-                this.send(response, 'event: work_available\ndata: {"type":"work_available"}\n\n');
-                return;
-            }
-            if (path[1] === "actions") {
-                if (scope === "server")
-                    return fail(403, "Executor credential required");
-                this.expireClaims();
-                if (path.length === 2 && method === "GET")
-                    return json({
-                        actions: this.store
-                            .all("actions")
-                            .filter((a) => a.status === "pending" && a.agentId === scope.agentId),
-                    });
-                const actionId = path[2];
-                if (!actionId)
-                    fail(404, "Action not found");
-                const body = await this.body(request);
-                let event;
-                const result = this.store.tx(() => {
-                    const action = this.store.get("actions", actionId) ??
-                        fail(404, "Action not found");
-                    this.scoped(scope, action);
-                    if (method === "POST" && path[3] === "claim") {
-                        ActionClaimRequestSchema.parse(body);
-                        if (action.status !== "pending" ||
-                            this.session(action.sessionId).status === "cancelled" ||
-                            this.session(action.sessionId).activeTurnId !== action.turnId)
-                            fail(409, "Action unavailable");
-                        action.status = "claimed";
-                        action.generation++;
-                        action.claimId = randomUUID();
-                        action.leaseExpiresAt = new Date(Date.now() + (this.options.leaseMs ?? 30000)).toISOString();
-                        this.store.put("actions", actionId, action);
-                        event = this.store.event(action.sessionId, action.turnId, "action.claimed", {
-                            actionId,
-                            generation: action.generation,
-                            ...(action.agent ? { agent: action.agent } : {}),
-                        });
-                        return {
-                            action,
-                            claimId: action.claimId,
-                            generation: action.generation,
-                            leaseExpiresAt: action.leaseExpiresAt,
-                        };
-                    }
-                    if (method === "POST" && path[3] === "heartbeat") {
-                        const beat = ActionHeartbeatRequestSchema.parse(body);
-                        if (this.session(action.sessionId).activeTurnId !== action.turnId ||
-                            action.status !== "claimed" ||
-                            action.claimId !== beat.claimId ||
-                            action.generation !== beat.generation ||
-                            Date.parse(action.leaseExpiresAt) <= Date.now())
-                            fail(409, "Stale or expired claim");
-                        action.leaseExpiresAt = new Date(Date.now() + (this.options.leaseMs ?? 30000)).toISOString();
-                        this.store.put("actions", actionId, action);
-                        return { leaseExpiresAt: action.leaseExpiresAt };
-                    }
-                    return fail(404, "Route not found");
-                });
-                if (event)
-                    this.publish(event);
-                return json(result);
-            }
-            if (path[1] === "sessions" &&
-                path[2] &&
-                path[3] === "commands" &&
-                method === "POST")
-                return json(this.command(path[2], SessionCommandSchema.parse(await this.body(request)), scope));
-            if (path[1] === "vaults")
-                return json(await this.dispatchVault(scope, method, path, url, request));
-            if (path[1] === "host")
-                return json(await this.dispatchHost(scope, method, path, request));
-            if (scope !== "server")
-                fail(403, "Application credential required");
-            if (path[1] === "executors" && path.length === 2 && method === "GET")
-                return json({
-                    executors: this.registry.list().map((e) => ({
-                        agentId: e.agentId,
-                        implementationVersion: e.implementationVersion,
-                        ...(e.manifestHash === undefined
-                            ? {}
-                            : { manifestHash: e.manifestHash }),
-                        connected: (this.executorStreams.get(e.tokenHash)?.size ?? 0) > 0,
-                        updatedAt: e.updatedAt,
-                    })),
-                });
-            // The length guard matters: the connect branch above only matches GET, so without it a
-            // PUT to /v1/executors/connect would register an agent literally named "connect".
-            if (path[1] === "executors" && path.length === 2 && method === "PUT") {
-                const body = RegisterExecutorsRequestSchema.parse(await this.body(request));
-                // Credential rules are shared with startup validation, which throws plainly; on the
-                // wire a rejected registration is a bad request, not a server fault.
-                try {
-                    for (const executor of body.executors)
-                        assertExecutorCredential(executor, this.options.serverToken);
-                }
-                catch (error) {
-                    fail(400, error instanceof Error ? error.message : String(error));
-                }
-                if (new Set(body.executors.map((e) => e.agentId)).size !==
-                    body.executors.length ||
-                    new Set(body.executors.map((e) => e.token)).size !==
-                        body.executors.length)
-                    fail(400, "Executor registrations must be unique per agent and token");
-                const updatedAt = new Date().toISOString();
-                const records = body.executors.map((executor) => ({
-                    agentId: executor.agentId,
-                    implementationVersion: executor.implementationVersion,
-                    ...(executor.manifestHash === undefined
-                        ? {}
-                        : { manifestHash: executor.manifestHash }),
-                    tokenHash: hashToken(executor.token),
-                    persisted: true,
-                    updatedAt,
-                }));
-                for (const record of records) {
-                    const collision = this.registry.find(record.tokenHash);
-                    if (collision && collision.agentId !== record.agentId)
-                        fail(409, "Executor tokens must be unique");
-                }
-                // Persist the whole batch first; the in-memory registry must never run ahead of SQLite.
-                this.store.tx(() => {
-                    for (const record of records)
-                        this.store.putExecutor({
-                            agentId: record.agentId,
-                            tokenHash: record.tokenHash,
-                            implementationVersion: record.implementationVersion,
-                            ...(record.manifestHash === undefined
-                                ? {}
-                                : { manifestHash: record.manifestHash }),
-                            updatedAt,
-                        });
-                });
-                const results = records.map((record) => {
-                    const { rotated, previousHash } = this.registry.upsert(record);
-                    if (rotated && previousHash) {
-                        for (const r of this.executorStreams.get(previousHash) ?? [])
-                            r.end();
-                        this.executorStreams.delete(previousHash);
-                    }
-                    return {
-                        agentId: record.agentId,
-                        implementationVersion: record.implementationVersion,
-                        rotated,
-                    };
-                });
-                return json({ executors: results });
-            }
-            if (path[1] === "executors" &&
-                path.length === 3 &&
-                path[2] &&
-                method === "DELETE") {
-                const agentId = path[2];
-                const existing = this.registry.get(agentId) ?? fail(404, "Executor not found");
-                if (!existing.persisted)
-                    fail(409, "Executor is provided by NYLORUN_EXECUTORS_JSON and cannot be deleted");
-                this.store.tx(() => this.store.deleteExecutor(agentId));
-                this.registry.remove(agentId);
-                for (const r of this.executorStreams.get(existing.tokenHash) ?? [])
-                    r.end();
-                this.executorStreams.delete(existing.tokenHash);
-                return json({ agentId, deleted: true });
-            }
-            if (path[1] === "agents" && path.length === 2 && method === "GET")
-                return json({
-                    agents: this.store.all("definitions").map((d) => ({
-                        agentId: d.manifest.id,
-                        manifest: d.manifest,
-                        manifestHash: d.manifestHash,
-                        implementationVersion: d.implementationVersion,
-                    })),
-                });
-            if (path[1] === "sessions" && path.length === 2 && method === "GET")
-                return json({
-                    sessions: this.store
-                        .all("sessions")
-                        .filter((s) => !url.searchParams.has("agentId") ||
-                        s.agentId === url.searchParams.get("agentId"))
-                        .map((s) => ({
-                        id: s.id,
-                        agentId: s.agentId,
-                        ownerUserId: s.ownerUserId,
-                        status: s.status,
-                        activeTurnId: s.activeTurnId,
-                    })),
-                });
-            if (path[1] === "agents" &&
-                path[2] &&
-                path.length === 3 &&
-                method === "PUT") {
-                const body = PutAgentRequestSchema.parse(await this.body(request));
-                if (body.manifest.id !== path[2])
-                    fail(400, "Agent id mismatch");
-                AgentManifestSchema.parse(body.manifest);
-                const definition = {
-                    ...body,
-                    manifestHash: hashManifest(body.manifest),
-                };
-                this.store.tx(() => {
-                    this.store.put("definitions", path[2], definition);
-                });
-                return json({
-                    agentId: path[2],
-                    manifestHash: definition.manifestHash,
-                    implementationVersion: body.implementationVersion,
-                });
-            }
-            if (path[1] === "sessions" && path[2]) {
-                const id = path[2];
-                if (method === "PUT" && path.length === 3) {
-                    const body = PutSessionRequestSchema.parse(await this.body(request));
-                    const vaultIds = body.vaultIds ?? [];
-                    const credentialSelections = body.credentialSelections ?? [];
-                    const result = this.store.tx(() => {
-                        this.vault.assertAttachment(body.ownerUserId, vaultIds, credentialSelections);
-                        const prior = this.store.get("sessions", id);
-                        if (prior) {
-                            if (sessionIdentity(prior.creation) !== sessionIdentity(body))
-                                fail(409, "Session already exists with different creation parameters");
-                            prior.vaultIds = vaultIds;
-                            prior.credentialSelections = credentialSelections;
-                            prior.creation = body;
-                            this.store.put("sessions", id, prior);
-                            this.vault.recordAttachment(id, vaultIds);
-                            return prior;
-                        }
-                        const definition = this.store.get("definitions", body.agentId) ??
-                            fail(404, "Definition not found");
-                        const s = {
-                            id,
-                            agentId: body.agentId,
-                            ownerUserId: body.ownerUserId,
-                            manifest: definition.manifest,
-                            manifestHash: definition.manifestHash,
-                            implementationVersion: definition.implementationVersion,
-                            info: body.info,
-                            status: "idle",
-                            activeTurnId: null,
-                            creation: body,
-                            vaultIds,
-                            credentialSelections,
-                            pluginRoots: definition.pluginRoots ?? {},
-                        };
-                        this.store.put("sessions", id, s);
-                        this.vault.recordAttachment(id, vaultIds);
-                        return s;
-                    });
-                    return json(this.view(result));
-                }
-                const s = this.session(id);
-                if (method === "GET" && path.length === 3)
-                    return json(this.view(s));
-                const cursor = url.searchParams.get("cursor") ??
-                    (typeof request.headers["last-event-id"] === "string"
-                        ? request.headers["last-event-id"]
-                        : undefined);
-                if (method === "GET" && path[3] === "items")
-                    return json(this.store.history(id, cursor, url.searchParams.get("agent") ?? undefined));
-                if (method === "GET" && path[3] === "events") {
-                    const history = this.store.history(id, cursor);
-                    const set = this.observers.get(id) ?? new Set();
-                    this.observers.set(id, set);
-                    this.sse(request, response, set);
-                    for (const event of history.items)
-                        this.send(response, `id: ${event.cursor}\nevent: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`);
-                    return;
-                }
-            }
-            fail(404, "Route not found");
-        }
-        catch (error) {
-            if (response.headersSent) {
-                response.end();
-                return;
-            }
-            const status = error instanceof HttpError || error instanceof VaultError
-                ? error.status
-                : error?.name === "ZodError" ||
-                    error?.message === "Invalid cursor"
-                    ? 400
-                    : 500;
-            json({
-                status: "rejected",
-                code: status === 500 ? "internal_error" : "request_rejected",
-                message: status === 500
-                    ? "Runtime request failed"
-                    : error.message,
-            }, status);
-        }
-    }
-    view(s) {
-        return {
-            id: s.id,
-            agentId: s.agentId,
-            ownerUserId: s.ownerUserId,
-            manifestHash: s.manifestHash,
-            implementationVersion: s.implementationVersion,
-            status: s.status,
-            activeTurnId: s.activeTurnId,
-            vaultIds: s.vaultIds ?? [],
-            credentialSelections: s.credentialSelections ?? [],
-            mcpSnapshot: s.mcpSnapshot ?? null,
-            mcpDiagnostics: s.mcpDiagnostics ?? [],
-            waits: Array.isArray(s.waits)
-                ? s.waits.map((call) => ({
-                    invocationId: call.invocationId,
-                    interaction: call.interaction,
-                    wait: call.wait,
-                    status: call.status,
-                }))
-                : s.waits,
-            error: s.error,
-            actions: this.store
-                .all("actions")
-                .filter((a) => a.sessionId === s.id &&
-                !["completed", "cancelled"].includes(a.status)),
-            uncertainEffects: this.store
-                .all("effects")
-                .filter((e) => e.request.sessionId === s.id && e.status === "uncertain")
-                .map((e) => ({
-                effectId: e.request.effectId,
-                turnId: e.request.turnId,
-                kind: e.request.kind,
-                error: e.error,
-            })),
-        };
-    }
-    async prepareMcp(id, signal) {
-        const s = this.session(id);
-        if (serversOf(s.manifest).length === 0)
-            return;
-        if (!s.mcpSnapshot) {
-            const found = await this.mcp.discover({
-                sessionId: id,
-                manifest: s.manifest,
-                manifestHash: s.manifestHash,
-                pluginRoots: s.pluginRoots ?? {},
-                signal,
-            });
-            this.store.tx(() => {
-                const current = this.session(id);
-                if (current.mcpSnapshot)
-                    return;
-                current.mcpSnapshot = found.snapshot;
-                current.mcpDiagnostics = found.diagnostics;
-                this.store.put("sessions", id, current);
-            });
-            return;
-        }
-        const diagnostics = await this.mcp.reconnect({
-            sessionId: id,
-            manifest: s.manifest,
-            pluginRoots: s.pluginRoots ?? {},
-            tools: s.mcpSnapshot.mcpTools,
-            signal,
-        });
-        if (diagnostics.length === 0)
-            return;
-        this.store.tx(() => {
-            const current = this.session(id);
-            const prior = [...(current.mcpDiagnostics ?? [])];
-            for (const item of diagnostics) {
-                const index = prior.findIndex((existing) => existing.capabilityId === item.capabilityId &&
-                    existing.serverName === item.serverName);
-                if (index >= 0)
-                    prior[index] = item;
-                else
-                    prior.push(item);
-            }
-            current.mcpDiagnostics = prior;
-            this.store.put("sessions", id, current);
-        });
-    }
-    async callMcpTool(request) {
-        const s = this.session(request.sessionId);
-        const tool = mcpToolOf(s, request);
-        if (!tool)
-            throw new Error(`MCP tool '${request.toolName ?? ""}' is not in the session snapshot`);
-        return this.mcp.call({
-            sessionId: s.id,
-            ...(tool.agentId === undefined ? {} : { agentId: tool.agentId }),
-            capabilityId: tool.capabilityId,
-            serverName: tool.serverName,
-            serverToolName: tool.serverToolName,
-            args: request.input,
-            manifest: s.manifest,
-            pluginRoots: s.pluginRoots ?? {},
-        });
-    }
-    async callSandboxTool(request, signal) {
-        const s = this.session(request.sessionId);
-        // Agents used as tools share the session's sandbox; the tree declares one sandbox spec.
-        const capability = sandboxCapabilityOf(manifestFor(s.manifest, request.agent), request.capabilityId, request.toolName);
-        if (!capability)
-            throw new Error(`'${request.toolName ?? ""}' is not a sandbox tool`);
-        return this.sandbox.run({ id: s.id, activeTurnId: s.activeTurnId, manifest: s.manifest }, capability, request.toolName, request.input, signal);
-    }
-    async authorize(sessionId, request) {
-        const s = this.session(sessionId);
-        const result = await this.vault.authorize({
-            sessionId,
-            vaultIds: s.vaultIds ?? [],
-            credentialSelections: s.credentialSelections ?? [],
-            url: request.url,
-            serverName: request.serverName,
-        });
-        if (result.status === "authorized") {
-            const token = result.headers.authorization.slice("Bearer ".length);
-            scrub({ authorization: result.headers.authorization, url: result.url }, [
-                token,
-            ]);
-        }
-        return result;
-    }
-    ensureKek() {
-        if (this.kek)
-            return this.kek;
-        if (this.options.vaultKek === null)
-            throw new Error("Vault key-encryption key is required");
-        this.kek = createKekFile(this.kekPath);
-        return this.kek;
-    }
-    async dispatchHost(scope, method, path, request) {
-        if (scope !== "server") {
-            this.vault.reject(path.join("/"));
-            fail(403, "Application credential required");
-        }
-        if (path[2] === "models" && path.length === 3 && method === "GET")
-            return hostModelCatalog();
-        if (path[2] === "sandbox" && path.length === 3 && method === "GET")
-            return this.sandbox.report();
-        if (path[2] === "providers" && path.length === 3 && method === "GET")
-            return this.vault.listHostProviders();
-        if (path[2] === "model" && path.length === 3 && method === "GET")
-            return this.vault.getHostModel();
-        if (path[2] === "model" && path.length === 3 && method === "PUT")
-            return this.vault.putHostModel(PutHostModelRequestSchema.parse(await this.body(request)));
-        if (path[2] === "model" &&
-            path[3] === "selection" &&
-            path.length === 4 &&
-            method === "PUT")
-            return this.vault.selectHostModel(SelectHostModelRequestSchema.parse(await this.body(request)));
-        fail(404, "Route not found");
-    }
-    async dispatchVault(scope, method, path, url, request) {
-        if (scope !== "server") {
-            this.vault.reject(path.join("/"));
-            fail(403, "Application credential required");
-        }
-        if (path.length === 2 && method === "POST") {
-            const body = CreateVaultRequestSchema.parse(await this.body(request));
-            return this.vault.createVault(body);
-        }
-        if (path.length === 2 && method === "GET") {
-            const ownerUserId = url.searchParams.get("ownerUserId") ??
-                fail(400, "ownerUserId is required");
-            return { vaults: this.vault.listVaults(ownerUserId) };
-        }
-        const vaultId = path[2];
-        if (!vaultId)
-            fail(404, "Vault not found");
-        if (path.length === 3 && method === "GET")
-            return this.vault.getVault(vaultId);
-        if (path.length === 3 && method === "DELETE")
-            return this.vault.deleteVault(vaultId);
-        if (path[3] !== "credentials")
-            fail(404, "Route not found");
-        if (path.length === 4 && method === "POST") {
-            const body = CreateCredentialRequestSchema.parse(await this.body(request));
-            return this.vault.createCredential(vaultId, body);
-        }
-        if (path.length === 4 && method === "GET")
-            return { credentials: this.vault.listCredentials(vaultId) };
-        const credentialId = path[4];
-        if (!credentialId)
-            fail(404, "Credential not found");
-        if (path.length === 5 && method === "GET")
-            return this.vault.getCredential(vaultId, credentialId);
-        if (path.length === 5 && method === "POST") {
-            const body = RotateCredentialRequestSchema.parse(await this.body(request));
-            return this.vault.rotateCredential(vaultId, credentialId, body);
-        }
-        if (path.length === 5 && method === "DELETE")
-            return this.vault.deleteCredential(vaultId, credentialId);
-        fail(404, "Route not found");
-    }
-    async listen(port = 8787, hostname = "127.0.0.1") {
-        if (this.server)
-            throw new Error("Already listening");
-        this.server = createServer((q, s) => {
-            void this.handle(q, s);
-        });
-        await new Promise((resolve, reject) => {
-            this.server.once("error", reject);
-            this.server.listen(port, hostname, resolve);
-        });
-        const address = this.server.address();
-        return {
-            url: `http://${hostname}:${typeof address === "object" && address ? address.port : port}`,
-        };
-    }
-    async close() {
-        this.closing = true;
-        clearInterval(this.timer);
-        for (const c of this.running.values())
-            c.abort();
-        await this.mcp.close();
-        for (const streams of this.executorStreams.values())
-            for (const r of streams)
-                r.end();
-        for (const set of this.observers.values())
-            for (const r of set)
-                r.end();
-        if (this.server)
-            await new Promise((resolve) => {
-                this.server.close(() => resolve());
-                this.server.closeIdleConnections();
-            });
-        // Providers must honor AbortSignal. Keep storage open until any in-flight journal writes have drained.
-        while (this.running.size)
-            await new Promise((resolve) => setTimeout(resolve, 10));
-        await this.sandbox.close();
-        this.closed = true;
-        this.store.db.close();
-        if (this.lockPath)
-            unlinkSync(this.lockPath);
-    }
-}
-export function createRuntime(options) {
-    return new CoreRuntime(options);
-}
-export async function startRuntime(options) {
-    const runtime = createRuntime(options);
-    try {
-        const { url } = await runtime.listen(options.port, options.hostname);
-        return Object.assign(runtime, { url });
-    }
-    catch (error) {
-        await runtime.close();
-        throw error;
-    }
-}
-/** What an action runs, for events: a tool name, or a hook point and its capabilities. */
-function actionTarget(action) {
-    return {
-        ...(action.kind === "hook" ? { hook: action.hook } : { toolName: action.toolName }),
-        ...(action.agent ? { agent: action.agent } : {}),
-    };
-}
+export { openTenantRuntime, TenantRuntime, } from "../tenant/runtime.js";
+export { startEphemeralRuntime, } from "../tenant/ephemeral.js";
+export { scriptedModel, gatewayModel } from "./provider.js";