@nylorun/runtime 0.14.0-beta → 0.15.0-beta

package/dist/gates/tool-client.js

@@ -0,0 +1,201 @@
+/**
+ * The loop's client of the Tool Gate in the gates service (F4.1, `tool-contract.ts`): remote
+ * MCP servers opened and called through the gate, which holds their connections and
+ * credentials, and Action deliveries POSTed by the gate. Over `node:http`, like the model gate's
+ * client (`http-client.ts`): a call answers only when it has finished.
+ *
+ * Failures keep the meaning they had in the loop's own process:
+ * - An MCP request that fails, at the server or on the hop, throws, so the pool reports a
+ *   diagnostic and `resolveEffect` marks a call `uncertain`, as before.
+ * - A delivery never throws. A hop that failed before the request was sent is `not_sent`
+ *   (the deliverer sends it again, even a tool); one that failed after is `lost`.
+ */
+import { randomUUID } from "node:crypto";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { TENANT_HEADER } from "./contract.js";
+import { GATE_CLIENT_TIMEOUT_MS } from "./http-client.js";
+import { DELIVERIES_PATH, MCP_CLOSE_PATH, MCP_CONNECT_PATH, MCP_LIST_PATH, TOOL_CALLS_PATH, } from "./tool-contract.js";
+/** How long a close or a cancel may take; neither changes an outcome. */
+const SHORT_TIMEOUT_MS = 2_000;
+/** Extra silence allowed on a delivery beyond the endpoint's own timeout. */
+const DELIVERY_SLACK_MS = 30_000;
+export function httpToolGate(options) {
+    const where = new URL(options.url).origin;
+    const timeoutMs = options.timeoutMs ?? GATE_CLIENT_TIMEOUT_MS;
+    function exchange(path, body, request) {
+        const url = new URL(path, options.url);
+        const send = url.protocol === "https:" ? httpsRequest : httpRequest;
+        const payload = body === undefined ? Buffer.alloc(0) : Buffer.from(JSON.stringify(body), "utf8");
+        const signal = request.signal;
+        return new Promise((resolve) => {
+            if (signal?.aborted)
+                return resolve({ kind: "aborted", sent: false, reason: signal.reason });
+            let settled = false;
+            let sent = false;
+            let responded = false;
+            let timedOut = false;
+            const settle = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                signal?.removeEventListener("abort", onAbort);
+                resolve(result);
+            };
+            const onAbort = () => {
+                settle({ kind: "aborted", sent, reason: signal.reason });
+                outgoing.destroy();
+            };
+            const failed = (error) => settle(sent
+                ? {
+                    kind: "lost",
+                    message: timedOut
+                        ? `Tool gate at ${where} sent nothing for ${Math.round(request.timeoutMs / 1000)} s`
+                        : `Tool gate connection lost${error ? ` (${error.message})` : ""}`,
+                }
+                : { kind: "unreachable", message: `Tool gate unreachable at ${where}${error ? ` (${error.message})` : ""}` });
+            const outgoing = send(url, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${options.token}`,
+                    "content-type": "application/json",
+                    "content-length": payload.byteLength,
+                    ...(options.tenantId ? { [TENANT_HEADER]: options.tenantId } : {}),
+                    ...(request.idempotencyKey ? { "idempotency-key": request.idempotencyKey } : {}),
+                },
+                timeout: request.timeoutMs,
+            }, (response) => {
+                responded = true;
+                readBody(response).then((text) => settle({ kind: "answer", status: response.statusCode ?? 0, text }), (error) => failed(error));
+            });
+            outgoing.on("socket", (socket) => socket.setKeepAlive(true, 30_000));
+            outgoing.on("finish", () => {
+                sent = true;
+            });
+            outgoing.on("timeout", () => {
+                timedOut = true;
+                outgoing.destroy();
+            });
+            outgoing.on("error", (error) => {
+                if (!signal?.aborted)
+                    failed(error);
+            });
+            outgoing.on("close", () => {
+                if (!signal?.aborted && !responded)
+                    failed();
+            });
+            signal?.addEventListener("abort", onAbort, { once: true });
+            outgoing.end(payload);
+        });
+    }
+    /** The result of an MCP request, or a throw the pool and `resolveEffect` read as before. */
+    async function mcp(path, body, request) {
+        const result = await exchange(path, body, { ...request, timeoutMs });
+        if (result.kind === "aborted")
+            throw result.reason ?? new Error("aborted");
+        if (result.kind !== "answer")
+            throw new Error(result.message);
+        const parsed = parse(result.text);
+        if (result.status !== 200 || !parsed || !("ok" in parsed))
+            throw new Error(gateRefusal(result.status, parsed));
+        if (parsed.ok)
+            return parsed.result;
+        throw mcpError(parsed.error);
+    }
+    async function fireAndForget(path, body) {
+        await exchange(path, body, { timeoutMs: SHORT_TIMEOUT_MS });
+    }
+    return {
+        recovers: true,
+        async openMcp(server) {
+            await mcp(MCP_CONNECT_PATH, { server }, {});
+            const client = {
+                listTools: (params, request) => mcp(MCP_LIST_PATH, { server, ...(params?.cursor ? { cursor: params.cursor } : {}) }, request?.signal ? { signal: request.signal } : {}),
+                callTool: (params, request) => {
+                    const body = {
+                        server: { ...server },
+                        effectId: request?.key ?? randomUUID(),
+                        name: params.name,
+                        arguments: params.arguments,
+                    };
+                    return mcp(TOOL_CALLS_PATH, body, {
+                        ...(request?.signal ? { signal: request.signal } : {}),
+                        ...(request?.key ? { idempotencyKey: request.key } : {}),
+                    });
+                },
+            };
+            return { client, close: () => fireAndForget(MCP_CLOSE_PATH, { server }) };
+        },
+        async cancel(request) {
+            await fireAndForget(`${TOOL_CALLS_PATH}/${encodeURIComponent(request.effectId)}/cancel`, undefined);
+        },
+        async post(delivery, signal) {
+            const result = await exchange(DELIVERIES_PATH, {
+                url: delivery.url,
+                body: delivery.body,
+                headers: { ...delivery.headers },
+                timeoutMs: delivery.timeoutMs,
+            }, { signal, timeoutMs: delivery.timeoutMs + DELIVERY_SLACK_MS });
+            if (result.kind === "aborted")
+                return {
+                    kind: result.sent ? "lost" : "not_sent",
+                    code: "ABORTED",
+                    message: "The delivery was aborted",
+                };
+            if (result.kind === "unreachable")
+                return { kind: "not_sent", code: "gateway.unreachable", message: result.message };
+            if (result.kind === "lost")
+                return { kind: "lost", code: "gateway.lost", message: result.message };
+            const parsed = parse(result.text);
+            if (result.status !== 200 || !parsed?.result)
+                // The gate refused the request before sending anything.
+                return { kind: "not_sent", code: "gateway.refused", message: gateRefusal(result.status, parsed) };
+            const wire = parsed.result;
+            if (wire.kind !== "response")
+                return wire;
+            return {
+                kind: "response",
+                status: wire.status,
+                headers: wire.headers,
+                body: Buffer.from(wire.body, "base64"),
+            };
+        },
+    };
+}
+/** An MCP failure the gate reported, as the loop's own MCP code would have thrown it. */
+function mcpError(error) {
+    const thrown = new Error(error.uncertain ? `${error.message} (the call may have run; it is not sent again)` : error.message);
+    if (error.code !== undefined)
+        thrown.code = error.code;
+    if (error.credentialIds !== undefined)
+        thrown.credentialIds = error.credentialIds;
+    return thrown;
+}
+function gateRefusal(status, parsed) {
+    const message = parsed?.error?.message;
+    if (status === 401)
+        return "The tool gate refused this Runtime's token: the runtime and gateway containers must share NYLORUN_GATES_TOKEN";
+    return `Tool gate answered ${status}${typeof message === "string" ? `: ${message}` : ""}`;
+}
+function parse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function readBody(response) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        response.on("data", (chunk) => chunks.push(chunk));
+        response.on("end", () => {
+            if (response.complete)
+                resolve(Buffer.concat(chunks).toString("utf8"));
+            else
+                reject(new Error("response ended early"));
+        });
+        response.on("error", reject);
+        response.on("aborted", () => reject(new Error("response aborted")));
+    });
+}

package/dist/gates/tool-contract.d.ts

@@ -0,0 +1,116 @@
+/**
+ * The Tool Gate's wire format (blueprint §12, F4.1): the routes the loop calls on the gates
+ * service for remote MCP servers and Action deliveries. Internal, like the model call route
+ * (`contract.ts`): same token, same optional Tenant header, not in the published OpenAPI
+ * documents.
+ *
+ * Remote MCP. The gate holds the connection and the vault credential; the loop names the
+ * server, never a URL or a credential, and the gate finds it in the session's pinned manifest.
+ * - `POST /nylorun/v1/mcp/connect` `{server}`: opens the server's connection (vault
+ *   authorization included), or keeps the open one.
+ * - `POST /nylorun/v1/mcp/list` `{server, cursor?}`: one page of `tools/list`.
+ * - `POST /nylorun/v1/tool-calls` `{server, effectId, name, arguments}`: one
+ *   `tools/call`. With an `Idempotency-Key` (the effect id) the call outlives its client and runs
+ *   once (G3); a re-send joins it or gets its outcome.
+ * - `POST /nylorun/v1/tool-calls/{key}/cancel`: aborts a keyed call; `204` either way.
+ * - `POST /nylorun/v1/mcp/close` `{server}`: closes the server's connection; `204`.
+ * Each answers `200 {ok: true, result}` or `200 {ok: false, error}`: an MCP failure is an
+ * answer, not a gate error. A keyed call whose earlier attempt was lost with the gateway answers
+ * `{ok: false, error: {uncertain: true}}` and is never run again.
+ *
+ * Action deliveries. `POST /nylorun/v1/deliveries` `{url, body, headers, timeoutMs}`: the gate
+ * POSTs the signed delivery under the gateway's own address policy and answers `200 {result}`,
+ * what `tenant/outbound.ts` `post` returned, with the answer's body in base64.
+ */
+import { z } from "zod";
+export declare const MCP_CONNECT_PATH = "/nylorun/v1/mcp/connect";
+export declare const MCP_LIST_PATH = "/nylorun/v1/mcp/list";
+export declare const MCP_CLOSE_PATH = "/nylorun/v1/mcp/close";
+export declare const TOOL_CALLS_PATH = "/nylorun/v1/tool-calls";
+export declare const DELIVERIES_PATH = "/nylorun/v1/deliveries";
+/** Largest tool call or delivery body the gate reads. */
+export declare const MAX_TOOL_BODY_BYTES: number;
+/** The longest delivery timeout the gate accepts: an endpoint's maximum `timeoutMs`. */
+export declare const MAX_DELIVERY_TIMEOUT_MS: number;
+/** The only headers the gate forwards on a delivery, lower-cased. */
+export declare const DELIVERY_HEADERS: ReadonlySet<string>;
+export declare const McpServerRefSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    agentId: z.ZodOptional<z.ZodString>;
+    capabilityId: z.ZodString;
+    serverName: z.ZodString;
+}, z.core.$strip>;
+export declare const McpServerBodySchema: z.ZodObject<{
+    server: z.ZodObject<{
+        sessionId: z.ZodString;
+        agentId: z.ZodOptional<z.ZodString>;
+        capabilityId: z.ZodString;
+        serverName: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const McpListBodySchema: z.ZodObject<{
+    server: z.ZodObject<{
+        sessionId: z.ZodString;
+        agentId: z.ZodOptional<z.ZodString>;
+        capabilityId: z.ZodString;
+        serverName: z.ZodString;
+    }, z.core.$strip>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ToolCallBodySchema: z.ZodObject<{
+    server: z.ZodObject<{
+        sessionId: z.ZodString;
+        agentId: z.ZodOptional<z.ZodString>;
+        capabilityId: z.ZodString;
+        serverName: z.ZodString;
+    }, z.core.$strip>;
+    effectId: z.ZodString;
+    name: z.ZodString;
+    arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export type ToolCallBody = z.infer<typeof ToolCallBodySchema>;
+/** Why an MCP request failed, as the loop's diagnostics read it (`mcp/connect.ts`). */
+export interface McpGateError {
+    readonly message: string;
+    /** The MCP SDK's error code, an HTTP status for transport errors (401 for a refused token). */
+    readonly code?: number;
+    /** The vault credentials a refused authorization names. */
+    readonly credentialIds?: readonly string[];
+    /** The call may have run: its earlier attempt was lost with the gateway. Never re-run. */
+    readonly uncertain?: boolean;
+}
+export type McpAnswer<T> = {
+    readonly ok: true;
+    readonly result: T;
+} | {
+    readonly ok: false;
+    readonly error: McpGateError;
+};
+export declare const DeliveryBodySchema: z.ZodObject<{
+    url: z.ZodString;
+    body: z.ZodString;
+    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    timeoutMs: z.ZodNumber;
+}, z.core.$strip>;
+export type DeliveryBody = z.infer<typeof DeliveryBodySchema>;
+/** `OutboundResult` on the wire: the answer's body in base64. */
+export type WireOutboundResult = {
+    readonly kind: "response";
+    readonly status: number;
+    readonly headers: Record<string, string | string[] | undefined>;
+    readonly body: string;
+} | {
+    readonly kind: "too_large";
+    readonly status: number;
+} | {
+    readonly kind: "not_sent";
+    readonly code: string;
+    readonly message: string;
+} | {
+    readonly kind: "lost";
+    readonly code: string;
+    readonly message: string;
+};
+export interface DeliveryAnswer {
+    readonly result: WireOutboundResult;
+}

package/dist/gates/tool-contract.js

@@ -0,0 +1,64 @@
+/**
+ * The Tool Gate's wire format (blueprint §12, F4.1): the routes the loop calls on the gates
+ * service for remote MCP servers and Action deliveries. Internal, like the model call route
+ * (`contract.ts`): same token, same optional Tenant header, not in the published OpenAPI
+ * documents.
+ *
+ * Remote MCP. The gate holds the connection and the vault credential; the loop names the
+ * server, never a URL or a credential, and the gate finds it in the session's pinned manifest.
+ * - `POST /nylorun/v1/mcp/connect` `{server}`: opens the server's connection (vault
+ *   authorization included), or keeps the open one.
+ * - `POST /nylorun/v1/mcp/list` `{server, cursor?}`: one page of `tools/list`.
+ * - `POST /nylorun/v1/tool-calls` `{server, effectId, name, arguments}`: one
+ *   `tools/call`. With an `Idempotency-Key` (the effect id) the call outlives its client and runs
+ *   once (G3); a re-send joins it or gets its outcome.
+ * - `POST /nylorun/v1/tool-calls/{key}/cancel`: aborts a keyed call; `204` either way.
+ * - `POST /nylorun/v1/mcp/close` `{server}`: closes the server's connection; `204`.
+ * Each answers `200 {ok: true, result}` or `200 {ok: false, error}`: an MCP failure is an
+ * answer, not a gate error. A keyed call whose earlier attempt was lost with the gateway answers
+ * `{ok: false, error: {uncertain: true}}` and is never run again.
+ *
+ * Action deliveries. `POST /nylorun/v1/deliveries` `{url, body, headers, timeoutMs}`: the gate
+ * POSTs the signed delivery under the gateway's own address policy and answers `200 {result}`,
+ * what `tenant/outbound.ts` `post` returned, with the answer's body in base64.
+ */
+import { z } from "zod";
+import { PROTOCOL_HEADER, SIGNATURE_HEADER } from "@nylorun/core/compatibility";
+export const MCP_CONNECT_PATH = "/nylorun/v1/mcp/connect";
+export const MCP_LIST_PATH = "/nylorun/v1/mcp/list";
+export const MCP_CLOSE_PATH = "/nylorun/v1/mcp/close";
+export const TOOL_CALLS_PATH = "/nylorun/v1/tool-calls";
+export const DELIVERIES_PATH = "/nylorun/v1/deliveries";
+/** Largest tool call or delivery body the gate reads. */
+export const MAX_TOOL_BODY_BYTES = 8 * 1024 * 1024;
+/** The longest delivery timeout the gate accepts: an endpoint's maximum `timeoutMs`. */
+export const MAX_DELIVERY_TIMEOUT_MS = 15 * 60_000;
+/** The only headers the gate forwards on a delivery, lower-cased. */
+export const DELIVERY_HEADERS = new Set([
+    SIGNATURE_HEADER.toLowerCase(),
+    PROTOCOL_HEADER.toLowerCase(),
+    "idempotency-key",
+]);
+export const McpServerRefSchema = z.object({
+    sessionId: z.string().min(1),
+    agentId: z.string().min(1).optional(),
+    capabilityId: z.string().min(1),
+    serverName: z.string().min(1),
+});
+export const McpServerBodySchema = z.object({ server: McpServerRefSchema });
+export const McpListBodySchema = z.object({
+    server: McpServerRefSchema,
+    cursor: z.string().optional(),
+});
+export const ToolCallBodySchema = z.object({
+    server: McpServerRefSchema,
+    effectId: z.string().min(1),
+    name: z.string().min(1),
+    arguments: z.record(z.string(), z.unknown()),
+});
+export const DeliveryBodySchema = z.object({
+    url: z.string().url(),
+    body: z.string(),
+    headers: z.record(z.string(), z.string()),
+    timeoutMs: z.number().int().positive().max(MAX_DELIVERY_TIMEOUT_MS),
+});

package/dist/gates/tool-gate.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The Tool Gate seam (blueprint §12, F4.1). Every tool call that leaves the loop crosses one
+ * `ToolGate`: a remote MCP server's connection and calls, and every Action delivery to an
+ * Action endpoint. The gate owns what those need that the loop must not hold: the MCP
+ * credential and its OAuth refresh, and the outbound route.
+ *
+ * Two implementations: `inProcessToolGate` (embedding, the ephemeral Runtime, tests), which
+ * opens remote servers and POSTs deliveries in this process, and the HTTP client of the gates
+ * service (`tool-client.ts`, the `gateway` container). Stdio MCP servers and the sandbox tools
+ * never cross it: they run beside the loop until the session sandbox takes them (P4).
+ */
+import type { LiveConnection } from "../mcp/connect.js";
+import type { McpServerRef } from "../mcp/pool.js";
+import { type OutboundPolicy, type OutboundResult } from "../tenant/outbound.js";
+/** One Action delivery or endpoint ping, signed by the caller. */
+export interface DeliveryRequest {
+    readonly url: string;
+    readonly body: string;
+    /** `Nylorun-Signature`, `Nylorun-Protocol` and `Idempotency-Key`; nothing else. */
+    readonly headers: Readonly<Record<string, string>>;
+    /** How long the endpoint may take to answer. */
+    readonly timeoutMs: number;
+}
+export interface ToolGate {
+    /**
+     * Opens a remote (`streamable-http` or `sse`) MCP server of a session. Absent: the loop's
+     * pool opens it itself, with the Tenant vault.
+     */
+    openMcp?(server: McpServerRef): Promise<LiveConnection>;
+    /** POSTs a delivery. Never throws; `signal` aborts it (see `tenant/outbound.ts`). */
+    post(request: DeliveryRequest, signal: AbortSignal): Promise<OutboundResult>;
+    /**
+     * True when a keyed MCP call outlives the caller's process (the gates service, G3): after a
+     * takeover or a shutdown, re-sending it joins the call or returns its outcome, and a call
+     * lost with the gateway answers `uncertain` instead of running again.
+     */
+    readonly recovers?: boolean;
+    /** Stops a keyed MCP call that outlives its caller (a user cancel). Never rejects. */
+    cancel?(request: {
+        tenantId: string;
+        effectId: string;
+    }): Promise<void>;
+}
+/** The Tool Gate in the caller's process: remote MCP through the pool, deliveries by `post`. */
+export declare function inProcessToolGate(policy?: OutboundPolicy): ToolGate;

package/dist/gates/tool-gate.js

@@ -0,0 +1,10 @@
+import { post } from "../tenant/outbound.js";
+/** The Tool Gate in the caller's process: remote MCP through the pool, deliveries by `post`. */
+export function inProcessToolGate(policy = {}) {
+    return {
+        post: (request, signal) => post(request.url, request.body, { ...request.headers }, {
+            policy,
+            signal: AbortSignal.any([signal, AbortSignal.timeout(request.timeoutMs)]),
+        }),
+    };
+}

package/dist/host/admin-api.d.ts

@@ -1,13 +1,14 @@
 /**
- * The Admin API (`/v1/admin/**`): Tenants and the Host's status, for a caller with the admin
- * key. The Host checks the listener, the protocol and the admin key first (`app.ts`); what
- * gets here is authorized. Routes are declared once, for serving and for the OpenAPI document.
+ * The Admin API (`/v1/admin/**`): the Host's status and shutdown, for a caller with the admin
+ * key. A Host serves one Tenant, so there are no Tenant routes: the status names the Tenant
+ * and, when it could not be opened, why (tenancy.md §9). The Host checks the listener, the
+ * protocol and the admin key first (`app.ts`); what gets here is authorized. Routes are
+ * declared once, for serving and for the OpenAPI document.
  */
 import { OpenAPIHono } from "@hono/zod-openapi";
-import { type AdminStatus } from "@nylorun/core/contracts";
-import { type NodeBindings, type TenantModule } from "../tenant/types.js";
+import type { AdminStatus } from "@nylorun/core/contracts";
+import type { NodeBindings } from "../tenant/types.js";
 export interface AdminApiOptions {
-    module: TenantModule;
     /** `GET /v1/admin/status`. */
     status(): Promise<AdminStatus>;
     /** Stops the Host once the shutdown answer is sent. */

package/dist/host/admin-api.js

@@ -1,16 +1,15 @@
 /**
- * The Admin API (`/v1/admin/**`): Tenants and the Host's status, for a caller with the admin
- * key. The Host checks the listener, the protocol and the admin key first (`app.ts`); what
- * gets here is authorized. Routes are declared once, for serving and for the OpenAPI document.
+ * The Admin API (`/v1/admin/**`): the Host's status and shutdown, for a caller with the admin
+ * key. A Host serves one Tenant, so there are no Tenant routes: the status names the Tenant
+ * and, when it could not be opened, why (tenancy.md §9). The Host checks the listener, the
+ * protocol and the admin key first (`app.ts`); what gets here is authorized. Routes are
+ * declared once, for serving and for the OpenAPI document.
  */
 import { OpenAPIHono } from "@hono/zod-openapi";
 import { z } from "zod";
-import { CreateTenantRequestSchema } from "@nylorun/core/contracts";
-import { AdminStatus as AdminStatusBody, AdminTenantList, AdminTenantStatus, CreateTenantRequest, HostShutdownResponse, ProtocolRejected, Rejected, TenantEnvelope, } from "../api/components.js";
+import { AdminStatus as AdminStatusBody, HostShutdownResponse, ProtocolRejected, Rejected, } from "../api/components.js";
 import { serveRoute } from "../api/route.js";
-import { TenantBusyError, TenantConflictError } from "../tenant/quarantine.js";
-import { TenantNotFoundError, } from "../tenant/types.js";
-import { jsonResponse, opaqueNotFoundResponse, readJsonBody, rejectedResponse, } from "./http.js";
+import { jsonResponse, rejectedResponse } from "./http.js";
 const json = (schema, description) => ({
     description,
     content: { "application/json": { schema } },
@@ -18,12 +17,9 @@ const json = (schema, description) => ({
 const rejected = (description) => json(Rejected, description);
 /** What every Admin route may answer before its own logic runs. */
 const gated = {
-    404: rejected("Not found: an unknown admin key, the public listener, or an unknown Tenant"),
+    404: rejected("Not found: an unknown admin key, or the public listener"),
     426: json(ProtocolRejected, "`Nylorun-Protocol` missing or unsupported"),
 };
-const tenantId = z.object({
-    tenantId: z.string().meta({ example: "tn_0123456789abcdefghjkmnpqrs" }),
-});
 function adminRoute(route) {
     return {
         ...route,
@@ -33,7 +29,6 @@ function adminRoute(route) {
     };
 }
 export function createAdminApi(options) {
-    const { module } = options;
     const api = new OpenAPIHono();
     // HEAD is not a GET here: an Admin route answers only the methods it declares.
     api.use(async (c, next) => {
@@ -41,112 +36,13 @@ export function createAdminApi(options) {
             return notFound();
         await next();
     });
-    serveRoute(api, adminRoute({
-        method: "get",
-        path: "/v1/admin/tenants",
-        summary: "List Tenants",
-        responses: { 200: json(AdminTenantList, "Every Tenant on the Host") },
-    }), async () => jsonResponse(200, await module.list()));
-    serveRoute(api, adminRoute({
-        method: "post",
-        path: "/v1/admin/tenants",
-        summary: "Create a Tenant",
-        description: "Idempotent on `idempotencyKey`: a replay answers 200 with the same Tenant.",
-        request: {
-            body: {
-                required: true,
-                content: { "application/json": { schema: CreateTenantRequest } },
-            },
-        },
-        responses: {
-            200: json(TenantEnvelope, "The Tenant, created earlier by the same request"),
-            201: json(TenantEnvelope, "The Tenant, created"),
-            400: rejected("Invalid JSON or request body (`invalid_request`)"),
-            409: rejected("Another Tenant has this id or idempotency key (`tenant_conflict`)"),
-            413: rejected("Request body over 1 MiB"),
-        },
-    }), async (c) => {
-        const body = CreateTenantRequestSchema.parse(await readJsonBody(c.req.raw));
-        try {
-            const result = await module.create({
-                tenantId: body.tenantId,
-                name: body.name,
-                principalId: body.principalId,
-                credentialHash: body.credentialHash,
-                idempotencyKey: body.idempotencyKey,
-                ...(body.studioCredentialHash
-                    ? { studioCredentialHash: body.studioCredentialHash }
-                    : {}),
-                ...(body.derivedPrincipals?.length
-                    ? { derivedPrincipals: body.derivedPrincipals }
-                    : {}),
-            });
-            return jsonResponse(result.created ? 201 : 200, result.envelope);
-        }
-        catch (error) {
-            const code = error.code;
-            if (error instanceof TenantConflictError ||
-                error.name === "TenantConflictError" ||
-                code === "conflict" ||
-                code === "tenant_conflict")
-                return rejectedResponse(409, "tenant_conflict", error instanceof Error ? error.message : "Tenant conflict");
-            throw error;
-        }
-    });
-    serveRoute(api, adminRoute({
-        method: "get",
-        path: "/v1/admin/tenants/{tenantId}",
-        summary: "Get a Tenant's status",
-        request: { params: tenantId },
-        responses: { 200: json(AdminTenantStatus, "The Tenant and its state") },
-    }), async (c) => {
-        const status = await module.status(c.req.param("tenantId"));
-        return status ? jsonResponse(200, status) : opaqueNotFoundResponse();
-    });
-    serveRoute(api, adminRoute({
-        method: "delete",
-        path: "/v1/admin/tenants/{tenantId}",
-        summary: "Delete a Tenant",
-        request: {
-            params: tenantId,
-            query: z.object({
-                activeWork: z.enum(["refuse", "drain", "cancel"]).optional().meta({
-                    description: "What to do with turns in progress: refuse to delete (default), wait for them, or cancel them",
-                }),
-            }),
-        },
-        responses: {
-            204: { description: "Deleted" },
-            400: rejected("`activeWork` is not refuse, drain or cancel (`invalid_request`)"),
-            409: rejected("The Tenant has work in progress and `activeWork` is refuse (`active_work`)"),
-        },
-    }), async (c) => {
-        const activeWork = c.req.query("activeWork") ?? "refuse";
-        if (activeWork !== "refuse" && activeWork !== "drain" && activeWork !== "cancel")
-            return rejectedResponse(400, "invalid_request", "activeWork must be refuse, drain, or cancel");
-        try {
-            await module.delete(c.req.param("tenantId"), activeWork);
-            return new Response(null, { status: 204 });
-        }
-        catch (error) {
-            if (error instanceof TenantNotFoundError)
-                return opaqueNotFoundResponse();
-            const code = error.code;
-            if (error instanceof TenantBusyError ||
-                error.name === "TenantBusyError" ||
-                code === "active_work" ||
-                code === "conflict")
-                return rejectedResponse(409, "active_work", error instanceof Error ? error.message : "Active work");
-            throw error;
-        }
-    });
     // D12: `/v1/admin/status` and `/v1/admin/host` are one answer.
     for (const path of ["/v1/admin/status", "/v1/admin/host"])
         serveRoute(api, adminRoute({
             method: "get",
             path,
             summary: path.endsWith("host") ? "Get the Host's status (alias)" : "Get the Host's status",
-            responses: { 200: json(AdminStatusBody, "Version, protocol, Tenants and the Host") },
+            responses: { 200: json(AdminStatusBody, "Version, protocol, the Tenant and the Host") },
         }), async () => jsonResponse(200, await options.status()));
     serveRoute(api, adminRoute({
         method: "post",

package/dist/host/app.d.ts

@@ -7,7 +7,7 @@ export type HostBindings = NodeBindings & {
 export type HostEnv = {
     Bindings: HostBindings;
     Variables: {
-        /** The Tenant a request named, for the request log. */
+        /** The Tenant a request reached, for the request log. */
         tenantId?: string;
         /** The status to log when it is not the answer's (a rejection after a stream started). */
         status?: number;