@nylorun/runtime 0.13.0-beta → 0.15.0-beta

package/dist/api/components.js

@@ -0,0 +1,82 @@
+/**
+ * Named schemas of the OpenAPI document: each becomes `#/components/schemas/<id>`, referenced
+ * wherever a route uses it. Named with Zod's own `.meta({ id })`, which works on the contracts'
+ * schemas whenever they were created; made once per process, since ids are unique in Zod's
+ * global registry.
+ */
+import { z } from "zod";
+import { JwksSchema, CreateTokenRequestSchema, CreateTokenResponseSchema, AccessPolicyResponseSchema, PutAccessPolicyRequestSchema, SigningKeyListSchema, SigningKeyViewSchema, RotateSigningKeysRequestSchema, RevokeSigningKeyRequestSchema, ListPublishableKeysResponseSchema, PublishableKeySchema, CreatePublishableKeyRequestSchema, UpdatePublishableKeyRequestSchema, RevokeSubjectRequestSchema, RevokeSubjectResponseSchema, TenantStatusSchema, ResetTenantRequestSchema, ResetTenantResponseSchema, SeedTenantConfigRequestSchema, SeedTenantConfigResponseSchema, HostModelCatalogSchema, TenantSandboxViewSchema, ModelUsageTotalsSchema, ModelBudgetsSchema, PutModelBudgetsRequestSchema, PutTenantSandboxRequestSchema, ListProvidersResponseSchema, HostModelViewSchema, PutHostModelRequestSchema, SelectHostModelRequestSchema, CreateVaultRequestSchema, VaultInfoSchema, ListVaultsResponseSchema, CreateCredentialRequestSchema, CredentialInfoSchema, ListCredentialsResponseSchema, RotateCredentialRequestSchema, DeletedResponseSchema, ListAgentsResponseSchema, ListPublicAgentsResponseSchema, ListSessionsResponseSchema, LiveEventSchema, PutAgentRequestSchema, PutAgentResponseSchema, PutSessionRequestSchema, SessionItemsResponseSchema, SessionViewSchema, StreamClosedFrameSchema, AcceptedResponseSchema, ActionResultReceiptSchema, DeleteEndpointResponseSchema, DeliveryHeartbeatResponseSchema, ActionOutcomeSchema, EndpointPingResponseSchema, ListEndpointsResponseSchema, PutEndpointsRequestSchema, SandboxToolOutcomeSchema, SessionCommandSchema, AdminStatusSchema, HostShutdownResponseSchema, ProtocolRejectedResponseSchema, RejectedResponseSchema, EVENT_SCHEMAS, EVENT_TYPES, } from "@nylorun/core/contracts";
+function named(id, schema) {
+    return schema.meta({ id });
+}
+export const Rejected = named("Rejected", RejectedResponseSchema);
+export const ProtocolRejected = named("ProtocolRejected", ProtocolRejectedResponseSchema);
+export const AdminStatus = named("AdminStatus", AdminStatusSchema);
+export const HostShutdownResponse = named("HostShutdownResponse", HostShutdownResponseSchema);
+export const SandboxToolOutcome = named("SandboxToolOutcome", SandboxToolOutcomeSchema);
+export const PutEndpointsRequest = named("PutEndpointsRequest", PutEndpointsRequestSchema);
+export const ListEndpointsResponse = named("ListEndpointsResponse", ListEndpointsResponseSchema);
+export const DeleteEndpointResponse = named("DeleteEndpointResponse", DeleteEndpointResponseSchema);
+export const EndpointPingResponse = named("EndpointPingResponse", EndpointPingResponseSchema);
+export const DeliveryHeartbeatResponse = named("DeliveryHeartbeatResponse", DeliveryHeartbeatResponseSchema);
+export const ActionOutcome = named("ActionOutcome", ActionOutcomeSchema);
+export const SessionCommand = named("SessionCommand", SessionCommandSchema);
+export const AcceptedResponse = named("AcceptedResponse", AcceptedResponseSchema);
+export const ActionResultReceipt = named("ActionResultReceipt", ActionResultReceiptSchema);
+export const ListAgentsResponse = named("ListAgentsResponse", ListAgentsResponseSchema);
+export const ListPublicAgentsResponse = named("ListPublicAgentsResponse", ListPublicAgentsResponseSchema);
+export const PutAgentRequest = named("PutAgentRequest", PutAgentRequestSchema);
+export const PutAgentResponse = named("PutAgentResponse", PutAgentResponseSchema);
+export const ListSessionsResponse = named("ListSessionsResponse", ListSessionsResponseSchema);
+export const PutSessionRequest = named("PutSessionRequest", PutSessionRequestSchema);
+export const SessionView = named("SessionView", SessionViewSchema);
+export const LiveEvent = named("LiveEvent", LiveEventSchema);
+/** `action.delivery_failed` → `ActionDeliveryFailedEvent`. */
+export function eventComponentName(type) {
+    return `${type
+        .split(/[._]/)
+        .map((part) => part[0].toUpperCase() + part.slice(1))
+        .join("")}Event`;
+}
+/** The event catalog as components: one per event type, and `SessionEvent`, their union. */
+export const SessionEvent = named("SessionEvent", z.discriminatedUnion("type", EVENT_TYPES.map((type) => named(eventComponentName(type), EVENT_SCHEMAS[type]))));
+export const SessionItemsResponse = named("SessionItemsResponse", SessionItemsResponseSchema.extend({ items: z.array(SessionEvent) }));
+export const StreamClosedFrame = named("StreamClosedFrame", StreamClosedFrameSchema);
+export const TenantStatus = named("TenantStatus", TenantStatusSchema);
+export const ResetTenantRequest = named("ResetTenantRequest", ResetTenantRequestSchema);
+export const ResetTenantResponse = named("ResetTenantResponse", ResetTenantResponseSchema);
+export const SeedTenantConfigRequest = named("SeedTenantConfigRequest", SeedTenantConfigRequestSchema);
+export const SeedTenantConfigResponse = named("SeedTenantConfigResponse", SeedTenantConfigResponseSchema);
+export const HostModelCatalog = named("HostModelCatalog", HostModelCatalogSchema);
+export const TenantSandboxView = named("TenantSandboxView", TenantSandboxViewSchema);
+export const ModelUsageTotals = named("ModelUsageTotals", ModelUsageTotalsSchema);
+export const ModelBudgets = named("ModelBudgets", ModelBudgetsSchema);
+export const PutModelBudgetsRequest = named("PutModelBudgetsRequest", PutModelBudgetsRequestSchema);
+export const PutTenantSandboxRequest = named("PutTenantSandboxRequest", PutTenantSandboxRequestSchema);
+export const ListProvidersResponse = named("ListProvidersResponse", ListProvidersResponseSchema);
+export const HostModelView = named("HostModelView", HostModelViewSchema);
+export const PutHostModelRequest = named("PutHostModelRequest", PutHostModelRequestSchema);
+export const SelectHostModelRequest = named("SelectHostModelRequest", SelectHostModelRequestSchema);
+export const CreateVaultRequest = named("CreateVaultRequest", CreateVaultRequestSchema);
+export const VaultInfo = named("VaultInfo", VaultInfoSchema);
+export const ListVaultsResponse = named("ListVaultsResponse", ListVaultsResponseSchema);
+export const CreateCredentialRequest = named("CreateCredentialRequest", CreateCredentialRequestSchema);
+export const CredentialInfo = named("CredentialInfo", CredentialInfoSchema);
+export const ListCredentialsResponse = named("ListCredentialsResponse", ListCredentialsResponseSchema);
+export const RotateCredentialRequest = named("RotateCredentialRequest", RotateCredentialRequestSchema);
+export const DeletedResponse = named("DeletedResponse", DeletedResponseSchema);
+export const Jwks = named("Jwks", JwksSchema);
+export const CreateTokenRequest = named("CreateTokenRequest", CreateTokenRequestSchema);
+export const CreateTokenResponse = named("CreateTokenResponse", CreateTokenResponseSchema);
+export const AccessPolicyResponse = named("AccessPolicyResponse", AccessPolicyResponseSchema);
+export const PutAccessPolicyRequest = named("PutAccessPolicyRequest", PutAccessPolicyRequestSchema);
+export const SigningKeyList = named("SigningKeyList", SigningKeyListSchema);
+export const SigningKeyView = named("SigningKeyView", SigningKeyViewSchema);
+export const RotateSigningKeysRequest = named("RotateSigningKeysRequest", RotateSigningKeysRequestSchema);
+export const RevokeSigningKeyRequest = named("RevokeSigningKeyRequest", RevokeSigningKeyRequestSchema);
+export const ListPublishableKeysResponse = named("ListPublishableKeysResponse", ListPublishableKeysResponseSchema);
+export const PublishableKey = named("PublishableKey", PublishableKeySchema);
+export const CreatePublishableKeyRequest = named("CreatePublishableKeyRequest", CreatePublishableKeyRequestSchema);
+export const UpdatePublishableKeyRequest = named("UpdatePublishableKeyRequest", UpdatePublishableKeyRequestSchema);
+export const RevokeSubjectRequest = named("RevokeSubjectRequest", RevokeSubjectRequestSchema);
+export const RevokeSubjectResponse = named("RevokeSubjectResponse", RevokeSubjectResponseSchema);

package/dist/api/gate/keys.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The `keys` service's route on the gateway's listener (F4.2, `contract.ts`): one operation of
+ * `Keys` per request, run with the vault key of the gateway's Tenant. Errors keep their status,
+ * code and details. Logs the operation and its outcome, never an argument or a result.
+ */
+import type { Hono, MiddlewareHandler } from "hono";
+import type { Logger } from "../../tenant/types.js";
+import { type Keys } from "../../keys/keys.js";
+export declare function mountKeysRoutes(app: Hono, options: {
+    readonly authorized: MiddlewareHandler;
+    /** The gateway's Tenant's keys; rejects when the Tenant is not ready. */
+    readonly keys: () => Promise<Keys>;
+    readonly logger: Logger;
+}): void;

package/dist/api/gate/keys.js

@@ -0,0 +1,59 @@
+import { bodyLimit } from "hono/body-limit";
+import { HttpError } from "../../tenant/http.js";
+import { VaultError } from "../../vault/error.js";
+import { KEYS_PATH, MAX_KEYS_BODY_BYTES } from "../../keys/contract.js";
+import { KEYS_OPERATIONS } from "../../keys/keys.js";
+export function mountKeysRoutes(app, options) {
+    app.post(`${KEYS_PATH}/:operation`, options.authorized, bodyLimit({
+        maxSize: MAX_KEYS_BODY_BYTES,
+        onError: (c) => c.json({ error: { code: "invalid_request", message: "The body is too large" } }, 400),
+    }), async (c) => {
+        const operation = c.req.param("operation");
+        if (!KEYS_OPERATIONS.includes(operation))
+            return c.json({ error: { code: "invalid_request", message: `Unknown keys operation ${operation}` } }, 404);
+        let args;
+        try {
+            args = (await c.req.json()).args;
+        }
+        catch {
+            args = undefined;
+        }
+        if (!Array.isArray(args))
+            return c.json({ error: { code: "invalid_request", message: "The body must be {args: [...]}" } }, 400);
+        const started = Date.now();
+        let answer;
+        try {
+            const keys = await options.keys();
+            const run = keys[operation];
+            answer = { result: (await run.apply(keys, args)) ?? null };
+        }
+        catch (error) {
+            answer = { error: errorOf(error) };
+        }
+        options.logger.info("keys_request", {
+            operation,
+            ms: Date.now() - started,
+            outcome: "result" in answer ? "ok" : String(answer.error.status),
+        });
+        return c.json(answer);
+    });
+}
+function errorOf(error) {
+    if (error instanceof VaultError)
+        return { kind: "vault", status: error.status, message: error.message };
+    if (error instanceof HttpError)
+        return {
+            kind: "http",
+            status: error.status,
+            message: error.message,
+            ...(error.rejection.code === undefined ? {} : { code: error.rejection.code }),
+            ...(error.rejection.details === undefined ? {} : { details: error.rejection.details }),
+        };
+    // A request error the route would answer 400 for, or an internal failure.
+    const zod = error?.name === "ZodError";
+    return {
+        kind: "http",
+        status: zod ? 400 : 500,
+        message: zod ? error.message : "The keys service failed",
+    };
+}

package/dist/api/gate/routes.d.ts

@@ -0,0 +1,34 @@
+import { Hono } from "hono";
+import type { ModelCallHandler } from "../../gates/handler.js";
+import { type InflightCalls } from "../../gates/inflight.js";
+import type { McpHandler } from "../../gates/mcp-handler.js";
+import type { ToolCalls } from "../../gates/tool-calls.js";
+import type { Keys } from "../../keys/keys.js";
+import type { Logger } from "../../tenant/types.js";
+import { type OutboundPolicy } from "../../tenant/outbound.js";
+export interface GatesAppOptions {
+    /** The bearer every model call must present (`NYLORUN_GATES_TOKEN`). */
+    readonly token: string;
+    /** Serves an authenticated, well-formed call. */
+    readonly modelGate: ModelCallHandler;
+    /** Keyed calls, which outlive their client (P1.2). */
+    readonly inflight: InflightCalls;
+    /** Whether the gate's dependencies answer (Postgres). */
+    readonly ready: () => Promise<boolean>;
+    /** Largest body read. Default `MAX_MODEL_CALL_BYTES`. */
+    readonly maxBodyBytes?: number;
+    /** Remote MCP servers (F4.1). Without it the MCP routes answer 404. */
+    readonly mcp?: McpHandler;
+    /** Keyed MCP calls, which outlive their client and run once (F4.1 G3). Needs `mcp`. */
+    readonly toolCalls?: ToolCalls;
+    /** The keys service's operations (F4.2). Without it the keys route answers 404. */
+    readonly keys?: () => Promise<Keys>;
+    /** Logs the keys service's requests. */
+    readonly logger?: Logger;
+    /**
+     * How the gate may call Action endpoints (the gateway's own `NYLORUN_ENDPOINT_*`), for
+     * deliveries (F4.1). Without it the delivery route answers 404.
+     */
+    readonly delivery?: OutboundPolicy;
+}
+export declare function createGatesApp(options: GatesAppOptions): Hono;

package/dist/api/gate/routes.js

@@ -0,0 +1,235 @@
+/**
+ * The gates service's HTTP routes (blueprint §15, P1.1): the Model Gate's IR endpoint, the Tool
+ * Gate's remote MCP and delivery routes (F4.1), and the health and readiness probes. Internal:
+ * only the loop calls them, with the stack's gates token, so they are not in the published
+ * OpenAPI documents. The wire formats are `gates/contract.ts` and `gates/tool-contract.ts`.
+ */
+import { createHash } from "node:crypto";
+import { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+import { isTenantId } from "@nylorun/core/compatibility";
+import { MAX_MODEL_CALL_BYTES, MODEL_CALLS_PATH, ModelCallBodySchema, TENANT_HEADER, } from "../../gates/contract.js";
+import { InflightConflict } from "../../gates/inflight.js";
+import { mountKeysRoutes } from "./keys.js";
+import { DELIVERIES_PATH, DELIVERY_HEADERS, DeliveryBodySchema, MAX_TOOL_BODY_BYTES, MCP_CLOSE_PATH, MCP_CONNECT_PATH, MCP_LIST_PATH, McpListBodySchema, McpServerBodySchema, TOOL_CALLS_PATH, ToolCallBodySchema, } from "../../gates/tool-contract.js";
+import { post } from "../../tenant/outbound.js";
+import { adminKeyMatches } from "../../host/http.js";
+import { canonical } from "../../store/canonical.js";
+const invalid = (message) => ({
+    error: { code: "invalid_request", message },
+});
+export function createGatesApp(options) {
+    const app = new Hono();
+    const maxSize = options.maxBodyBytes ?? MAX_MODEL_CALL_BYTES;
+    app.get("/health", (c) => c.json({ status: "ok" }));
+    app.get("/ready", async (c) => (await options.ready()) ? c.json({ ready: true }) : c.json({ ready: false }, 503));
+    const authorized = async (c, next) => {
+        const presented = /^Bearer (.+)$/.exec(c.req.header("authorization") ?? "")?.[1];
+        if (!adminKeyMatches(presented, options.token)) {
+            const body = {
+                error: {
+                    code: "gate_unauthorized",
+                    message: "Missing or wrong gates token; the caller and the gateway must share NYLORUN_GATES_TOKEN",
+                },
+            };
+            return c.json(body, 401);
+        }
+        await next();
+    };
+    const tenantOf = (c) => {
+        const tenantId = c.req.header(TENANT_HEADER);
+        return tenantId !== undefined && !isTenantId(tenantId) ? false : tenantId;
+    };
+    const toolBodies = bodyLimit({
+        maxSize: MAX_TOOL_BODY_BYTES,
+        onError: (c) => c.json(invalid(`A request body may be at most ${MAX_TOOL_BODY_BYTES} bytes`), 400),
+    });
+    /** The parsed body, or the 400 to answer. */
+    async function read(c, schema) {
+        const tenantId = tenantOf(c);
+        if (tenantId === false)
+            return { ok: false, response: c.json(invalid(`The ${TENANT_HEADER} header must name a Tenant`), 400) };
+        let raw;
+        try {
+            raw = await c.req.json();
+        }
+        catch {
+            return { ok: false, response: c.json(invalid("The body must be JSON"), 400) };
+        }
+        const parsed = schema.safeParse(raw);
+        if (!parsed.success)
+            return {
+                ok: false,
+                response: c.json(invalid(`Invalid request: ${parsed.error.issues[0]?.message ?? "malformed"}`), 400),
+            };
+        return { ok: true, tenantId, body: parsed.data };
+    }
+    if (options.keys)
+        mountKeysRoutes(app, {
+            authorized,
+            keys: options.keys,
+            logger: options.logger ?? { info() { }, warn() { }, error() { } },
+        });
+    const mcp = options.mcp;
+    if (mcp) {
+        app.post(MCP_CONNECT_PATH, authorized, toolBodies, async (c) => {
+            const request = await read(c, McpServerBodySchema);
+            if (!request.ok)
+                return request.response;
+            return c.json(await mcp.connect(request.tenantId, request.body.server));
+        });
+        app.post(MCP_LIST_PATH, authorized, toolBodies, async (c) => {
+            const request = await read(c, McpListBodySchema);
+            if (!request.ok)
+                return request.response;
+            const { server, cursor } = request.body;
+            return c.json(await mcp.list(request.tenantId, server, cursor, c.req.raw.signal));
+        });
+        app.post(MCP_CLOSE_PATH, authorized, toolBodies, async (c) => {
+            const request = await read(c, McpServerBodySchema);
+            if (!request.ok)
+                return request.response;
+            await mcp.close(request.body.server);
+            return c.body(null, 204);
+        });
+        const toolCalls = options.toolCalls;
+        app.post(`${TOOL_CALLS_PATH}/:key/cancel`, authorized, (c) => {
+            if (tenantOf(c) === false)
+                return c.json(invalid(`The ${TENANT_HEADER} header must name a Tenant`), 400);
+            toolCalls?.cancel(c.req.param("key"));
+            return c.body(null, 204);
+        });
+        app.post(TOOL_CALLS_PATH, authorized, toolBodies, async (c) => {
+            const request = await read(c, ToolCallBodySchema);
+            if (!request.ok)
+                return request.response;
+            const signal = c.req.raw.signal;
+            const key = c.req.header("idempotency-key");
+            try {
+                // Keyed: the call runs under its own signal, once, and outlives this request (G3).
+                const answer = key && toolCalls
+                    ? await untilAborted(toolCalls.run(request.tenantId, key, createHash("sha256").update(canonical(request.body)).digest("hex"), request.body), signal)
+                    : await mcp.call(request.tenantId, request.body, signal);
+                if (signal.aborted)
+                    return new Response(null, { status: 499 });
+                return c.json(answer);
+            }
+            catch (error) {
+                if (error instanceof InflightConflict) {
+                    const body = { error: { code: "gate_conflict", message: error.message } };
+                    return c.json(body, 409);
+                }
+                if (signal.aborted)
+                    return new Response(null, { status: 499 });
+                throw error;
+            }
+        });
+    }
+    const policy = options.delivery;
+    if (policy) {
+        app.post(DELIVERIES_PATH, authorized, toolBodies, async (c) => {
+            const request = await read(c, DeliveryBodySchema);
+            if (!request.ok)
+                return request.response;
+            const { url, body, headers, timeoutMs } = request.body;
+            const forwarded = {};
+            for (const [name, value] of Object.entries(headers)) {
+                if (!DELIVERY_HEADERS.has(name.toLowerCase()))
+                    return c.json(invalid(`A delivery may not carry the header ${name}`), 400);
+                forwarded[name] = value;
+            }
+            const signal = c.req.raw.signal;
+            const result = await post(url, body, forwarded, {
+                policy,
+                signal: AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]),
+            });
+            if (signal.aborted)
+                return new Response(null, { status: 499 });
+            const answer = {
+                result: result.kind === "response"
+                    ? {
+                        kind: "response",
+                        status: result.status,
+                        headers: result.headers,
+                        body: result.body.toString("base64"),
+                    }
+                    : result,
+            };
+            return c.json(answer);
+        });
+    }
+    app.post(`${MODEL_CALLS_PATH}/:key/cancel`, authorized, (c) => {
+        // Optional, as on a call: the gate serves one Tenant, so the key alone names the call.
+        const tenantId = c.req.header(TENANT_HEADER);
+        if (tenantId !== undefined && !isTenantId(tenantId))
+            return c.json(invalid(`The ${TENANT_HEADER} header must name a Tenant`), 400);
+        options.inflight.cancel(c.req.param("key"));
+        return c.body(null, 204);
+    });
+    app.post(MODEL_CALLS_PATH, authorized, bodyLimit({
+        maxSize,
+        onError: (c) => c.json(invalid(`A model call body may be at most ${maxSize} bytes`), 400),
+    }), async (c) => {
+        // Optional: the gate serves its database's one Tenant, and refuses a call naming another.
+        const tenantId = c.req.header(TENANT_HEADER);
+        if (tenantId !== undefined && !isTenantId(tenantId))
+            return c.json(invalid(`The ${TENANT_HEADER} header must name a Tenant`), 400);
+        let raw;
+        try {
+            raw = await c.req.json();
+        }
+        catch {
+            return c.json(invalid("The body must be JSON"), 400);
+        }
+        const parsed = ModelCallBodySchema.safeParse(raw);
+        if (!parsed.success)
+            return c.json(invalid(`Invalid model call: ${parsed.error.issues[0]?.message ?? "malformed"}`), 400);
+        const { call, ...ids } = parsed.data;
+        const request = {
+            ...(tenantId === undefined ? {} : { tenantId }),
+            ...ids,
+            call: call,
+        };
+        const signal = c.req.raw.signal;
+        const key = c.req.header("idempotency-key");
+        try {
+            let outcome;
+            if (key) {
+                // Keyed: the call runs under its own signal and outlives this request (P1.2). The
+                // gate serves one Tenant, so the effect id alone is the key.
+                const hash = createHash("sha256").update(canonical(parsed.data)).digest("hex");
+                outcome = await untilAborted(options.inflight.run(key, hash, (own) => options.modelGate.call(request, own)), signal);
+            }
+            else
+                outcome = await options.modelGate.call(request, signal);
+            return c.json({ outcome });
+        }
+        catch (error) {
+            if (error instanceof InflightConflict) {
+                const body = { error: { code: "gate_conflict", message: error.message } };
+                return c.json(body, 409);
+            }
+            // The caller went away (or cancelled): nobody reads the answer.
+            if (signal.aborted)
+                return new Response(null, { status: 499 });
+            throw error;
+        }
+    });
+    return app;
+}
+/** `promise`, or a rejection as soon as `signal` aborts (the call itself keeps running). */
+function untilAborted(promise, signal) {
+    if (signal.aborted)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(signal.reason);
+        signal.addEventListener("abort", onAbort, { once: true });
+        promise.then((value) => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(error);
+        });
+    });
+}

package/dist/api/http/app.d.ts

@@ -0,0 +1,18 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import type { AuthScope, TenantContext } from "../../tenant/context.js";
+import type { NodeBindings } from "../../tenant/types.js";
+import { type RouteAccess } from "./define.js";
+export type TenantBindings = NodeBindings & {
+    readonly tenant: TenantContext;
+};
+export type TenantEnv = {
+    Bindings: TenantBindings;
+    Variables: {
+        /** Who is calling, once authenticated. */
+        scope: AuthScope;
+    };
+};
+/** The Tenant API, built on first use. */
+export declare function tenantApi(): OpenAPIHono<TenantEnv>;
+/** Who may call `method` on a Tenant path (its decoded segments), if it is a route. */
+export declare function findTenantRoute(method: string, segments: readonly string[]): RouteAccess | undefined;

package/dist/api/http/app.js

@@ -0,0 +1,58 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { RESPONSE_ALREADY_SENT } from "@hono/node-server/utils/response";
+import { fail } from "../../tenant/http.js";
+import { a2aRoutes } from "../a2a/endpoint.js";
+import { agUiRoutes } from "../ag-ui/endpoint.js";
+import { authenticateCaller, declaredRoute, pathSegments } from "./define.js";
+import { jsonResponse, rejectionOf } from "./respond.js";
+import { accessRoutes } from "./routes/access.js";
+import { endpointRoutes } from "./routes/endpoints.js";
+import { actionRoutes } from "./routes/actions.js";
+import { sessionRoutes } from "./routes/sessions.js";
+import { tenantRoutes } from "./routes/tenant.js";
+import { vaultRoutes } from "./routes/vaults.js";
+let app;
+/** The Tenant API, built on first use. */
+export function tenantApi() {
+    return (app ??= build());
+}
+/** Who may call `method` on a Tenant path (its decoded segments), if it is a route. */
+export function findTenantRoute(method, segments) {
+    tenantApi();
+    return declaredRoute(method, segments);
+}
+/** No route: authenticated first, so an unknown credential stays the opaque 404. */
+async function notFound(c) {
+    await authenticateCaller(c);
+    return fail(404, "Route not found");
+}
+function build() {
+    const api = new OpenAPIHono();
+    // Hono serves HEAD with the GET route; the Tenant API has no HEAD routes.
+    api.use(async (c, next) => (c.req.method === "HEAD" ? await notFound(c) : await next()));
+    // A malformed path is rejected before anything else reads it.
+    api.use(async (c, next) => {
+        pathSegments(c.env.incoming);
+        await next();
+    });
+    actionRoutes(api);
+    endpointRoutes(api);
+    sessionRoutes(api);
+    tenantRoutes(api);
+    vaultRoutes(api);
+    accessRoutes(api);
+    agUiRoutes(api);
+    a2aRoutes(api);
+    api.notFound(notFound);
+    api.onError((error, c) => {
+        const { outgoing } = c.env;
+        // Once a response has started, the rejection can only end it.
+        if (outgoing.headersSent) {
+            outgoing.end();
+            return RESPONSE_ALREADY_SENT;
+        }
+        const rejection = rejectionOf(error);
+        return jsonResponse(rejection.status, rejection.body, rejection.headers);
+    });
+    return api;
+}

package/dist/api/http/body.d.ts

@@ -0,0 +1,4 @@
+/** The body as text. */
+export declare function readText(request: Request): Promise<string>;
+/** The body as JSON, before any schema. */
+export declare function readJson(request: Request): Promise<unknown>;

package/dist/api/http/body.js

@@ -0,0 +1,37 @@
+/**
+ * Request bodies of Tenant routes, read as the router they replace read them
+ * (`tenant/http.ts`): at most 1 MiB, UTF-8, and a missing or malformed JSON body is
+ * `400 Invalid JSON`.
+ */
+import { fail } from "../../tenant/http.js";
+const MAX_BODY_BYTES = 1024 * 1024;
+/** The body as text. */
+export async function readText(request) {
+    if (request.body === null)
+        return "";
+    const chunks = [];
+    let bytes = 0;
+    const reader = request.body.getReader();
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        bytes += value.byteLength;
+        if (bytes > MAX_BODY_BYTES) {
+            await reader.cancel();
+            fail(413, "Request too large");
+        }
+        chunks.push(value);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+/** The body as JSON, before any schema. */
+export async function readJson(request) {
+    const text = await readText(request);
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return fail(400, "Invalid JSON");
+    }
+}

package/dist/api/http/define.d.ts

@@ -0,0 +1,39 @@
+/**
+ * How a Tenant API route is declared: once, with who may call it, for serving and for the
+ * OpenAPI document.
+ *
+ * `RouteAccess` says which credentials a route takes, which subject scopes reach it and
+ * whether browsers may call it: the one statement of who may call a route. The document shows
+ * it as the operation's `security`, its `Nylorun-*` headers and `x-nylorun-*` fields; the Host
+ * answers browser preflights from it (`findTenantRoute`). Serving runs the Tenant's checks in
+ * order: the browser client, the bearer, the subject's scopes, then the handler, which parses
+ * its body.
+ */
+import type { IncomingMessage } from "node:http";
+import type { OpenAPIHono, RouteConfig } from "@hono/zod-openapi";
+import type { Context, Handler } from "hono";
+import type { SubjectScope } from "@nylorun/core/contracts";
+import type { AuthScope } from "../../tenant/context.js";
+import type { TenantEnv } from "./app.js";
+export type Credential = "application" | "subject" | "token" | "publishable" | "delivery";
+export interface RouteAccess {
+    readonly credentials: readonly Credential[];
+    /** The subject scopes that reach the route: any one of them, none (`never`), or all (`any`). */
+    readonly scopes: readonly SubjectScope[] | "never" | "any";
+    /** A browser page may call it: its preflight is allowed. */
+    readonly browser?: boolean;
+    /**
+     * Public data: a request with no credential at all (no `Authorization`, no `Nylorun-Key`) is
+     * served too. A credential that is sent is still checked, so a wrong one stays the opaque 404.
+     */
+    readonly anonymous?: boolean;
+}
+/** The route's path segments, decoded, as the Tenant's checks read them. */
+export declare function pathSegments(incoming: IncomingMessage): string[];
+/** Who is calling: the browser client and the bearer, as every Tenant request checks them. */
+export declare function authenticateCaller(c: Context<TenantEnv>, 
+/** The route serves public data (`RouteAccess.anonymous`): no credential is needed. */
+anonymous?: boolean): Promise<AuthScope>;
+/** The declared route `method path` is, if any. `{param}` segments match any one segment. */
+export declare function declaredRoute(method: string, segments: readonly string[]): RouteAccess | undefined;
+export declare function tenantRoute(api: OpenAPIHono<TenantEnv>, access: RouteAccess, route: RouteConfig, handler: Handler<TenantEnv>): void;