@nylorun/runtime 0.12.0-beta → 0.14.0-beta

package/dist/api/http/routes/tenant.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The Tenant's own settings (`/v1/tenant/**`): its status, reset, a first configuration, the
+ * model it calls and the sandboxes its sessions get.
+ *
+ * A reset that deletes sessions moves the Tenant to a new basin generation, so a session
+ * created again starts in an empty basin; the old basin is deleted after a grace period.
+ */
+import type { OpenAPIHono } from "@hono/zod-openapi";
+import type { TenantEnv } from "../app.js";
+export declare function tenantRoutes(api: OpenAPIHono<TenantEnv>): void;

package/dist/api/http/routes/tenant.js

@@ -0,0 +1,172 @@
+import { z } from "zod";
+import { PutHostModelRequestSchema, PutTenantSandboxRequestSchema, ResetTenantRequestSchema, SeedTenantConfigRequestSchema, SelectHostModelRequestSchema, } from "@nylorun/core/contracts";
+import { HostModelCatalog, HostModelView, ListProvidersResponse, PutHostModelRequest, PutTenantSandboxRequest, ResetTenantRequest, ResetTenantResponse, SeedTenantConfigRequest, SeedTenantConfigResponse, SelectHostModelRequest, TenantSandboxView, TenantStatus, } from "../../components.js";
+import { hostModelCatalog } from "../../../model/catalog.js";
+import { sandboxConfigErrors } from "../../../sandbox/resolve.js";
+import { effectiveSandboxConfig, readSandboxConfig, writeSandboxConfig, } from "../../../sandbox/tenant-config.js";
+import { fail } from "../../../tenant/http.js";
+import { clearObservers } from "../../../tenant/session-streams.js";
+import { usesFixtureModel } from "../../../tenant/model-setting.js";
+import { resetTenant } from "../../../tenant/reset.js";
+import { clearWork, drain } from "../../../tenant/scheduler.js";
+import { buildTenantStatus, seedTenantConfig } from "../../../tenant/status.js";
+import { tenantReset, streamsStatus, } from "../../../tenant/streams.js";
+import { readJson } from "../body.js";
+import { pathSegments, tenantRoute } from "../define.js";
+import { jsonResponse } from "../respond.js";
+const settings = (scopes) => ({
+    credentials: scopes === "never" ? ["application"] : ["application", "subject"],
+    scopes,
+});
+const SETTINGS = settings(["tenant:settings"]);
+const json = (schema, description) => ({
+    description,
+    content: { "application/json": { schema } },
+});
+const body = (schema) => ({
+    required: true,
+    content: { "application/json": { schema } },
+});
+/** `GET /v1/tenant/sandbox`: the backend report and the configuration with defaults applied. */
+async function sandboxView(ctx) {
+    const config = await ctx.store.tx((t) => readSandboxConfig(t));
+    return { ...(await ctx.sandbox.report()), config: effectiveSandboxConfig(config) };
+}
+export function tenantRoutes(api) {
+    tenantRoute(api, SETTINGS, {
+        method: "get",
+        path: "/v1/tenant",
+        tags: ["Tenant"],
+        summary: "Get the Tenant's status",
+        responses: { 200: json(TenantStatus, "Readiness, model, sandboxes, streams and counts") },
+    }, async (c) => {
+        const ctx = c.env.tenant;
+        const { vault } = ctx;
+        return jsonResponse(200, await buildTenantStatus({
+            envelope: ctx.envelope,
+            config: ctx.config,
+            store: ctx.store,
+            vault,
+            sandbox: ctx.sandbox,
+            closing: ctx.closing || ctx.closed,
+            modelConfigured: !ctx.useVaultModel ||
+                (await ctx.store.tx((t) => usesFixtureModel(t))) ||
+                (await vault.getHostModel()).configured,
+            ...(ctx.stuckInvocations ? { stuckInvocations: ctx.stuckInvocations } : {}),
+            streamsStatus: () => streamsStatus(ctx),
+        }));
+    });
+    tenantRoute(api, settings("never"), {
+        method: "post",
+        path: "/v1/tenant/reset",
+        tags: ["Tenant"],
+        summary: "Reset the Tenant",
+        description: "Deletes its sessions, its sandboxes, or both, after draining or cancelling the turns in progress. The Tenant stays open.",
+        request: { body: body(ResetTenantRequest) },
+        responses: { 200: json(ResetTenantResponse, "Reset") },
+    }, async (c) => {
+        const ctx = c.env.tenant;
+        const request = ResetTenantRequestSchema.parse(await readJson(c.req.raw));
+        await drain(ctx, request.activeWork, 30_000);
+        // A sessions reset moves the Tenant to a new basin generation, so a session created
+        // again with the same id, during or after the reset, starts in an empty basin at 0.
+        const sessionsReset = request.scope !== "sandboxes";
+        await resetTenant({
+            store: ctx.store,
+            sandbox: ctx.sandbox,
+            paths: ctx.config.paths,
+            clearSessionState: () => {
+                clearWork(ctx);
+                clearObservers(ctx.sessionStreams);
+            },
+        }, request.scope);
+        if (sessionsReset)
+            await tenantReset(ctx);
+        // Reset leaves the Tenant open for new work.
+        ctx.closing = false;
+        return jsonResponse(200, { ok: true });
+    });
+    tenantRoute(api, settings("never"), {
+        method: "put",
+        path: "/v1/tenant/config/seed",
+        tags: ["Tenant"],
+        summary: "Seed the Tenant's configuration",
+        description: "Sets each setting the Tenant does not have yet; keeps the ones it has.",
+        request: { body: body(SeedTenantConfigRequest) },
+        responses: { 200: json(SeedTenantConfigResponse, "What was set, and what was kept") },
+    }, async (c) => {
+        const ctx = c.env.tenant;
+        const request = SeedTenantConfigRequestSchema.parse(await readJson(c.req.raw));
+        return jsonResponse(200, await seedTenantConfig({ store: ctx.store, vault: ctx.vault }, request));
+    });
+    tenantRoute(api, settings(["tenant:settings", "agents:write"]), {
+        method: "get",
+        path: "/v1/tenant/models",
+        tags: ["Tenant"],
+        summary: "List model providers and models",
+        responses: { 200: json(HostModelCatalog, "Provider and model names") },
+    }, async (c) => {
+        c.env.tenant;
+        return jsonResponse(200, hostModelCatalog());
+    });
+    tenantRoute(api, SETTINGS, {
+        method: "get",
+        path: "/v1/tenant/sandbox",
+        tags: ["Tenant"],
+        summary: "Get the Tenant's sandbox configuration",
+        responses: { 200: json(TenantSandboxView, "The backend in use and the configuration in force") },
+    }, async (c) => jsonResponse(200, await sandboxView(c.env.tenant)));
+    tenantRoute(api, SETTINGS, {
+        method: "put",
+        path: "/v1/tenant/sandbox",
+        tags: ["Tenant"],
+        summary: "Set the Tenant's sandbox configuration",
+        description: "What a session gets when it names no sandbox, and the limits every session's sandbox must fit.",
+        request: { body: body(PutTenantSandboxRequest) },
+        responses: { 200: json(TenantSandboxView, "The configuration now in force") },
+    }, async (c) => {
+        const ctx = c.env.tenant;
+        const { requestId: _requestId, ...config } = PutTenantSandboxRequestSchema.parse(await readJson(c.req.raw));
+        const errors = sandboxConfigErrors(effectiveSandboxConfig(config));
+        if (errors.length > 0)
+            fail(400, errors.join(" "));
+        await ctx.store.tx((t) => writeSandboxConfig(t, config));
+        return jsonResponse(200, await sandboxView(ctx));
+    });
+    tenantRoute(api, settings(["tenant:settings", "agents:write"]), {
+        method: "get",
+        path: "/v1/tenant/providers",
+        tags: ["Tenant"],
+        summary: "List the model providers the Tenant has credentials for",
+        responses: { 200: json(ListProvidersResponse, "The providers") },
+    }, async (c) => jsonResponse(200, await (c.env.tenant).vault.listHostProviders()));
+    tenantRoute(api, SETTINGS, {
+        method: "get",
+        path: "/v1/tenant/model",
+        tags: ["Tenant"],
+        summary: "Get the Tenant's model",
+        responses: { 200: json(HostModelView, "The model its sessions call") },
+    }, async (c) => jsonResponse(200, await (c.env.tenant).vault.getHostModel()));
+    tenantRoute(api, SETTINGS, {
+        method: "put",
+        path: "/v1/tenant/model",
+        tags: ["Tenant"],
+        summary: "Set a model provider's credentials",
+        request: { body: body(PutHostModelRequest) },
+        responses: { 200: json(HostModelView, "The model now in force") },
+    }, async (c) => {
+        const ctx = c.env.tenant;
+        return jsonResponse(200, await ctx.vault.putHostModel(PutHostModelRequestSchema.parse(await readJson(c.req.raw))));
+    });
+    tenantRoute(api, SETTINGS, {
+        method: "put",
+        path: "/v1/tenant/model/selection",
+        tags: ["Tenant"],
+        summary: "Choose the provider and model",
+        request: { body: body(SelectHostModelRequest) },
+        responses: { 200: json(HostModelView, "The model now in force") },
+    }, async (c) => {
+        const ctx = c.env.tenant;
+        return jsonResponse(200, await ctx.vault.selectHostModel(SelectHostModelRequestSchema.parse(await readJson(c.req.raw))));
+    });
+}

package/dist/api/http/routes/vaults.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Vaults and their credentials (`/v1/vaults/**`): secrets a session's tools use, owned by one
+ * person. Acting for a subject reaches only the subject's own vaults, and never on another's
+ * behalf.
+ */
+import type { OpenAPIHono } from "@hono/zod-openapi";
+import type { TenantEnv } from "../app.js";
+export declare function vaultRoutes(api: OpenAPIHono<TenantEnv>): void;

package/dist/api/http/routes/vaults.js

@@ -0,0 +1,167 @@
+import { z } from "zod";
+import { CreateCredentialRequestSchema, CreateVaultRequestSchema, RotateCredentialRequestSchema, } from "@nylorun/core/contracts";
+import { CreateCredentialRequest, CreateVaultRequest, CredentialInfo, DeletedResponse, ListCredentialsResponse, ListVaultsResponse, RotateCredentialRequest, VaultInfo, } from "../../components.js";
+import { ownerOf } from "../../../tenant/auth.js";
+import { fail } from "../../../tenant/http.js";
+import { readJson } from "../body.js";
+import { pathSegments, tenantRoute } from "../define.js";
+import { jsonResponse } from "../respond.js";
+const OWN_VAULTS = {
+    credentials: ["application", "subject", "token"],
+    scopes: ["vaults:own"],
+    browser: true,
+};
+const json = (schema, description) => ({
+    description,
+    content: { "application/json": { schema } },
+});
+const body = (schema) => ({
+    required: true,
+    content: { "application/json": { schema } },
+});
+const vaultId = z.object({ vaultId: z.string() });
+const credentialId = vaultId.extend({ credentialId: z.string() });
+/**
+ * Who a vault route acts for: the subject, or no one in particular (an application key). Below
+ * a vault, the vault must be the subject's before anything else.
+ */
+async function ownerFor(c) {
+    const { vault } = c.env.tenant;
+    const owner = ownerOf(c.get("scope"));
+    const id = c.req.param("vaultId");
+    if (id !== undefined && owner !== undefined)
+        await vault.assertOwner(id, owner);
+    return owner;
+}
+export function vaultRoutes(api) {
+    tenantRoute(api, OWN_VAULTS, {
+        method: "post",
+        path: "/v1/vaults",
+        tags: ["Vaults"],
+        summary: "Create a vault",
+        request: { body: body(CreateVaultRequest) },
+        responses: {
+            200: json(VaultInfo, "The vault"),
+            409: { description: "The idempotency key was used for another vault" },
+        },
+    }, async (c) => {
+        const owner = await ownerFor(c);
+        const request = CreateVaultRequestSchema.parse(await readJson(c.req.raw));
+        if (owner !== undefined && request.ownerUserId !== owner)
+            fail(403, "ownerUserId must be the subject");
+        return jsonResponse(200, await c.env.tenant.vault.createVault(request));
+    });
+    tenantRoute(api, OWN_VAULTS, {
+        method: "get",
+        path: "/v1/vaults",
+        tags: ["Vaults"],
+        summary: "List a person's vaults",
+        request: {
+            query: z.object({
+                ownerUserId: z
+                    .string()
+                    .optional()
+                    .meta({ description: "Whose vaults; required with an application key acting for no one" }),
+            }),
+        },
+        responses: { 200: json(ListVaultsResponse, "The vaults") },
+    }, async (c) => {
+        const owner = await ownerFor(c);
+        const ownerUserId = c.req.query("ownerUserId") ?? owner ?? fail(400, "ownerUserId is required");
+        if (owner !== undefined && ownerUserId !== owner)
+            fail(403, "ownerUserId must be the subject");
+        return jsonResponse(200, { vaults: await c.env.tenant.vault.listVaults(ownerUserId) });
+    });
+    tenantRoute(api, OWN_VAULTS, {
+        method: "get",
+        path: "/v1/vaults/{vaultId}",
+        tags: ["Vaults"],
+        summary: "Get a vault",
+        request: { params: vaultId },
+        responses: { 200: json(VaultInfo, "The vault") },
+    }, async (c) => {
+        await ownerFor(c);
+        return jsonResponse(200, await c.env.tenant.vault.getVault(c.req.param("vaultId")));
+    });
+    tenantRoute(api, OWN_VAULTS, {
+        method: "delete",
+        path: "/v1/vaults/{vaultId}",
+        tags: ["Vaults"],
+        summary: "Delete a vault and its credentials",
+        request: { params: vaultId },
+        responses: { 200: json(DeletedResponse, "Deleted") },
+    }, async (c) => {
+        await ownerFor(c);
+        return jsonResponse(200, await c.env.tenant.vault.deleteVault(c.req.param("vaultId")));
+    });
+    tenantRoute(api, OWN_VAULTS, {
+        method: "post",
+        path: "/v1/vaults/{vaultId}/credentials",
+        tags: ["Vaults"],
+        summary: "Add a credential",
+        description: "A bearer token or OAuth tokens, bound to the URLs a tool may send them to. A subject token cannot store OAuth refresh credentials.",
+        request: { params: vaultId, body: body(CreateCredentialRequest) },
+        responses: { 200: json(CredentialInfo, "The credential, without its secret") },
+    }, async (c) => {
+        await ownerFor(c);
+        const request = CreateCredentialRequestSchema.parse(await readJson(c.req.raw));
+        // The Runtime calls a refresh credential's token endpoint itself: never for a browser.
+        if (c.get("scope").kind === "token" &&
+            request.auth.type === "oauth" &&
+            request.auth.refresh)
+            fail(403, "A subject token cannot store OAuth refresh credentials", {
+                code: "scope_required",
+            });
+        return jsonResponse(200, await c.env.tenant.vault.createCredential(c.req.param("vaultId"), request));
+    });
+    tenantRoute(api, OWN_VAULTS, {
+        method: "get",
+        path: "/v1/vaults/{vaultId}/credentials",
+        tags: ["Vaults"],
+        summary: "List a vault's credentials",
+        request: { params: vaultId },
+        responses: { 200: json(ListCredentialsResponse, "The credentials, without their secrets") },
+    }, async (c) => {
+        await ownerFor(c);
+        return jsonResponse(200, {
+            credentials: await c.env.tenant.vault.listCredentials(c.req.param("vaultId")),
+        });
+    });
+    tenantRoute(api, OWN_VAULTS, {
+        method: "get",
+        path: "/v1/vaults/{vaultId}/credentials/{credentialId}",
+        tags: ["Vaults"],
+        summary: "Get a credential",
+        request: { params: credentialId },
+        responses: { 200: json(CredentialInfo, "The credential, without its secret") },
+    }, async (c) => {
+        await ownerFor(c);
+        return jsonResponse(200, await c.env.tenant.vault.getCredential(c.req.param("vaultId"), c.req.param("credentialId")));
+    });
+    tenantRoute(api, OWN_VAULTS, {
+        method: "post",
+        path: "/v1/vaults/{vaultId}/credentials/{credentialId}",
+        tags: ["Vaults"],
+        summary: "Rotate a credential's secret",
+        request: { params: credentialId, body: body(RotateCredentialRequest) },
+        responses: {
+            200: json(CredentialInfo, "The credential"),
+            409: { description: "A credential's type cannot change" },
+        },
+    }, async (c) => {
+        await ownerFor(c);
+        const request = RotateCredentialRequestSchema.parse(await readJson(c.req.raw));
+        return jsonResponse(200, await c.env.tenant.vault.rotateCredential(c.req.param("vaultId"), c.req.param("credentialId"), request));
+    });
+    tenantRoute(api, OWN_VAULTS, {
+        method: "delete",
+        path: "/v1/vaults/{vaultId}/credentials/{credentialId}",
+        tags: ["Vaults"],
+        summary: "Delete a credential",
+        request: { params: credentialId },
+        responses: { 200: json(DeletedResponse, "Deleted") },
+    }, async (c) => {
+        await ownerFor(c);
+        return jsonResponse(200, await c.env.tenant.vault.deleteCredential(c.req.param("vaultId"), c.req.param("credentialId")));
+    });
+}

package/dist/api/openapi.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The Runtime's OpenAPI 3.2 documents, generated from the routes as declared for serving:
+ *
+ * - the Tenant API (`tenantDocument`): every Tenant route, with `/health`, `/ready` and
+ *   `/openapi.json`. Served at `GET /openapi.json`, packed as `@nylorun/runtime/openapi.json`
+ *   and attached to each release.
+ * - the Admin API (`adminDocument`): served at `GET /v1/admin/openapi.json` behind the admin
+ *   key, packed as `@nylorun/runtime/admin-openapi.json`.
+ *
+ * Event streams are `text/event-stream` with an `itemSchema` (OpenAPI 3.2). Nothing here reads
+ * the environment: the same Runtime makes the same document.
+ */
+import { OpenApiGeneratorV32 } from "@asteasolutions/zod-to-openapi";
+type OpenApiDocument = ReturnType<OpenApiGeneratorV32["generateDocument"]>;
+/** The Tenant API's document. */
+export declare function tenantDocument(): OpenApiDocument;
+/** The Admin API's document. */
+export declare function adminDocument(): OpenApiDocument;
+export {};

package/dist/api/openapi.js

@@ -0,0 +1,138 @@
+/**
+ * The Runtime's OpenAPI 3.2 documents, generated from the routes as declared for serving:
+ *
+ * - the Tenant API (`tenantDocument`): every Tenant route, with `/health`, `/ready` and
+ *   `/openapi.json`. Served at `GET /openapi.json`, packed as `@nylorun/runtime/openapi.json`
+ *   and attached to each release.
+ * - the Admin API (`adminDocument`): served at `GET /v1/admin/openapi.json` behind the admin
+ *   key, packed as `@nylorun/runtime/admin-openapi.json`.
+ *
+ * Event streams are `text/event-stream` with an `itemSchema` (OpenAPI 3.2). Nothing here reads
+ * the environment: the same Runtime makes the same document.
+ */
+import { OpenAPIRegistry, OpenApiGeneratorV32, } from "@asteasolutions/zod-to-openapi";
+import { HOST_PROTOCOL } from "@nylorun/core/compatibility";
+import { HealthResponseSchema, ReadyResponseSchema } from "@nylorun/core/contracts";
+import { createAdminApi } from "../host/admin-api.js";
+import { RUNTIME_VERSION } from "../version.js";
+import { tenantApi } from "./http/app.js";
+const PROTOCOL = {
+    min: HOST_PROTOCOL.min,
+    max: HOST_PROTOCOL.max,
+    features: [...HOST_PROTOCOL.features],
+};
+const bearer = (description, bearerFormat) => ({
+    type: "http",
+    scheme: "bearer",
+    ...(bearerFormat ? { bearerFormat } : {}),
+    description,
+});
+/** `/health`, `/ready` and `/openapi.json`: what every listener answers without a key. */
+function hostRoutes() {
+    const registry = new OpenAPIRegistry();
+    const route = (config) => registry.registerPath(config);
+    route({
+        method: "get",
+        path: "/health",
+        tags: ["Host"],
+        summary: "Check the Runtime",
+        description: "The protocol range and features a client checks first. Refuses an `Origin`.",
+        responses: {
+            200: {
+                description: "The Runtime is up",
+                content: { "application/json": { schema: HealthResponseSchema.meta({ id: "Health" }) } },
+            },
+        },
+    });
+    route({
+        method: "get",
+        path: "/ready",
+        tags: ["Host"],
+        summary: "Check the Runtime is ready",
+        description: "The listeners, Tenant discovery, Postgres, Restate and S2.",
+        responses: {
+            200: {
+                description: "Ready",
+                content: { "application/json": { schema: ReadyResponseSchema.meta({ id: "Ready" }) } },
+            },
+            503: { description: "Not ready: `checks` says what is not" },
+        },
+    });
+    route({
+        method: "get",
+        path: "/openapi.json",
+        tags: ["Host"],
+        summary: "Get this document",
+        responses: { 200: { description: "The Tenant API's OpenAPI document" } },
+    });
+    return registry;
+}
+function tenantSchemes(registry) {
+    registry.registerComponent("securitySchemes", "applicationKey", bearer("An application key of the Tenant, or a key derived from the admin key. With `Nylorun-Subject` and `Nylorun-Scopes`, it acts for that person, narrowed to those scopes."));
+    registry.registerComponent("securitySchemes", "subjectToken", bearer("A subject token (`POST /v1/tokens`): one person and one role of the access policy, for at most 15 minutes.", "JWT"));
+    registry.registerComponent("securitySchemes", "deliveryToken", bearer("The delivery token the Runtime signs each Action delivery with (`Nylorun-Signature`), sent back by the Action endpoint. It reaches only that Action's heartbeat, result and sandbox routes, while that delivery is current, for at most 15 minutes.", "JWT"));
+    registry.registerComponent("securitySchemes", "publishableKey", {
+        type: "apiKey",
+        in: "header",
+        name: "Nylorun-Key",
+        description: "A publishable key, sent by a browser page on one of its origins. Public by design: it names the Tenant and grants the access policy's anonymous scopes.",
+    });
+}
+let tenant;
+let admin;
+/** The Tenant API's document. */
+export function tenantDocument() {
+    if (tenant)
+        return tenant;
+    const host = hostRoutes();
+    tenantSchemes(host);
+    tenant = new OpenApiGeneratorV32([
+        ...host.definitions,
+        ...tenantApi().openAPIRegistry.definitions,
+    ]).generateDocument({
+        openapi: "3.2.0",
+        info: {
+            title: "Nylorun Runtime: Tenant API",
+            version: RUNTIME_VERSION,
+            description: "Agents, sessions and their events, vaults, access and the Tenant's settings, for one Tenant (`Nylorun-Tenant`). Every request sends `Nylorun-Protocol`. Who may call each operation is its `security` and its `x-nylorun-credentials`, `x-nylorun-scopes` (the subject scopes that reach it) and `x-nylorun-browser` fields.",
+            "x-nylorun-protocol": PROTOCOL,
+        },
+        servers: [
+            {
+                url: "{origin}",
+                description: "A Runtime: the local stack (`nylorun start`), or where yours runs",
+                variables: { origin: { default: "http://localhost:8787" } },
+            },
+        ],
+    });
+    return tenant;
+}
+/** The Admin API's document. */
+export function adminDocument() {
+    if (admin)
+        return admin;
+    // Only the routes' declarations are read: nothing is served from this app.
+    const api = createAdminApi({
+        module: undefined,
+        status: () => Promise.reject(new Error("Not served")),
+        shutdown: () => { },
+    });
+    api.openAPIRegistry.registerComponent("securitySchemes", "adminKey", bearer("The Host's admin key (`host-credentials.json`). Never a Tenant bearer."));
+    admin = new OpenApiGeneratorV32(api.openAPIRegistry.definitions).generateDocument({
+        openapi: "3.2.0",
+        info: {
+            title: "Nylorun Runtime: Admin API",
+            version: RUNTIME_VERSION,
+            description: "Tenants and the Host's status, with the admin key. Served on the operator listener when the Host has one; the public listener answers these routes with the opaque 404.",
+            "x-nylorun-protocol": PROTOCOL,
+        },
+        servers: [
+            {
+                url: "{origin}",
+                description: "The operator listener: the local stack's, or where yours runs",
+                variables: { origin: { default: "http://localhost:8788" } },
+            },
+        ],
+    });
+    return admin;
+}

package/dist/api/route.d.ts

@@ -0,0 +1,12 @@
+/**
+ * How the Runtime declares an HTTP route: once, for both serving and the OpenAPI document.
+ *
+ * `app.openapi(route, handler)` from `@hono/zod-openapi` also validates the path, query and
+ * body before the handler runs, answering failures its own way. The Runtime's handlers parse
+ * where they always have (after the lookups and checks a rejection must come after), so their
+ * rejections keep their order and messages; `serveRoute` registers the route and serves it
+ * with no validators of its own.
+ */
+import type { OpenAPIHono, RouteConfig } from "@hono/zod-openapi";
+import type { Env, Handler } from "hono";
+export declare function serveRoute<E extends Env>(app: OpenAPIHono<E>, route: RouteConfig, handler: Handler<E>): void;

package/dist/api/route.js

@@ -0,0 +1,4 @@
+export function serveRoute(app, route, handler) {
+    app.openAPIRegistry.registerPath(route);
+    app.on(route.method.toUpperCase(), route.path.replaceAll(/\/{(.+?)}/g, "/:$1"), handler);
+}

package/dist/core/bearer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Application keys are 256-bit CSPRNG values and the wire schema requires at least 16
+ * characters, so an unsalted digest is adequate to keep them out of the Session Store at rest.
+ * This is not a password KDF and must not be used for one.
+ */
+export declare const hashToken: (token: string) => string;
+/** Mint a 32-byte hex application key for tests and CLI bootstrap. */
+export declare function mintBearerToken(): string;

package/dist/core/bearer.js

@@ -0,0 +1,11 @@
+import { createHash, randomBytes } from "node:crypto";
+/**
+ * Application keys are 256-bit CSPRNG values and the wire schema requires at least 16
+ * characters, so an unsalted digest is adequate to keep them out of the Session Store at rest.
+ * This is not a password KDF and must not be used for one.
+ */
+export const hashToken = (token) => createHash("sha256").update(token, "utf8").digest("hex");
+/** Mint a 32-byte hex application key for tests and CLI bootstrap. */
+export function mintBearerToken() {
+    return randomBytes(32).toString("hex");
+}

package/dist/core/flow-host.d.ts

@@ -1,4 +1,4 @@
-import type { Action, ActionOutcome } from "@nylorun/core/contracts";
+import type { ActionOutcome } from "@nylorun/core/contracts";
 import type { JsonValue, WorkflowManifest } from "@nylorun/core/define";
 import type { HostEffect } from "@nylorun/harness/run";
 import type { Wake } from "../execution/types.js";
@@ -73,7 +73,7 @@ export type CascadeCancelPlan = {
     /** Linked agent sessions to cancel, deepest path first. */
     readonly agentSessionIds: string[];
     readonly pendingActionIds: string[];
-    readonly claimedActionIds: string[];
+    readonly deliveringActionIds: string[];
 };
 /** Wakes a session after commit (`DurableExecution.wake` through the Tenant context). */
 type Schedule = (sessionId: string, wake: Wake) => void | Promise<void>;
@@ -83,7 +83,7 @@ export type FlowEffect = EffectDoc & {
     outcome?: ActionOutcome;
     error?: string;
 };
-/** Active agent turns + pending/claimed actions for one workflow turn. */
+/** Active agent turns + pending/delivering actions for one workflow turn. */
 export declare function countActiveFlowWork(t: Tx, workflowSessionId: string, turnId: string): Promise<number>;
 /** The `commands` document key of a session command's idempotency key (`tenant/commands.ts`). */
 export declare function commandKey(sessionId: string, idempotencyKey: string): string;
@@ -132,20 +132,11 @@ export declare function reconcilePendingAgentEffect(input: {
     readonly effectId: string;
     readonly schedule: Schedule;
 }): Promise<boolean>;
-/** Claimed `fn`/`verify` Actions, for the re-offer after a Tenant opens. */
-export declare function claimedFnVerifyActions(t: Tx): Promise<Action[]>;
-/**
- * Re-offer one claimed `fn`/`verify` Action (SD-P7 / WF-C9): they are pure or repeat-safe, so
- * a claim left by an executor of an earlier process is offered again at once rather than
- * after its lease. The next claim bumps the generation, which fences a late result. Locks
- * only the Action's session. Returns true when it re-offered.
- */
-export declare function reofferFnVerifyClaim(t: Tx, actionId: string): Promise<boolean>;
 /** Path depth for deepest-first cancel ordering. */
 export declare function pathDepth(path: string): number;
 /**
  * Plan a cancel cascade for a workflow session: linked agents deepest first,
- * then pending → cancelled and claimed → uncertain actions (SD-P11 / WF-R53).
+ * then pending → cancelled and delivering → uncertain actions (SD-P11 / WF-R53).
  */
 export declare function planCancelCascade(input: {
     readonly t: Tx;
@@ -155,7 +146,7 @@ export declare function planCancelCascade(input: {
 /**
  * Cancel sibling work under a Parallel/Map parent when one branch fails (PAR-R6).
  * Agent turns listed in `agentSessionIds` are returned for the caller to cancel;
- * pending actions → cancelled, claimed tool actions → uncertain.
+ * pending actions → cancelled, delivering tool actions → uncertain.
  * When `cancelEffectIds` is provided, those effects are marked cancelled and their
  * paths are included in the sibling path set.
  */
@@ -169,7 +160,8 @@ export declare function cancelSiblingWork(input: {
     readonly cancelEffectIds?: readonly string[];
 }): Promise<CancelSiblingResult>;
 /**
- * Apply cancel fencing to workflow-session actions (pending→cancelled, claimed→uncertain).
+ * Apply cancel fencing to workflow-session actions (pending→cancelled,
+ * delivering→uncertain).
  */
 export declare function fenceWorkflowActions(input: {
     readonly t: Tx;