@nylorun/runtime 0.16.0-beta → 0.19.0-beta

package/dist/host/app.js

@@ -1,11 +1,10 @@
 import { Hono } from "hono";
 import { RESPONSE_ALREADY_SENT } from "@hono/node-server/utils/response";
-import { checkCompatibility, HOST_PROTOCOL, PROTOCOL_HEADER, PUBLISHABLE_KEY_HEADER, TENANT_HEADER, tenantOfPublishableKey, } from "@nylorun/core/compatibility";
+import { checkCompatibility, HOST_PROTOCOL, PROTOCOL_HEADER, TENANT_HEADER, } from "@nylorun/core/compatibility";
 import { RUNTIME_VERSION } from "../version.js";
 import { findTenantRoute } from "../api/http/app.js";
-import { tenantDocument } from "../api/openapi.js";
-import { answerPreflight } from "./cors.js";
-import { adminKeyMatches, headerValue, isJsonContentType, jsonResponse, opaqueNotFoundResponse, protocolRejectedResponse, readBearer, pathnameIsLogged, redactRoutePath, rejectedResponse, requestHasBody, } from "./http.js";
+import { managementDocument, runtimeDocument } from "../api/openapi.js";
+import { headerValue, isJsonContentType, jsonResponse, opaqueNotFoundResponse, protocolRejectedResponse, pathnameIsLogged, redactRoutePath, rejectedResponse, requestHasBody, } from "./http.js";
 export function createHostApp(options) {
     const { module, logger } = options;
     const app = new Hono();
@@ -27,20 +26,16 @@ export function createHostApp(options) {
         }
     });
     app.use(async (c, next) => {
-        const { incoming, outgoing, role } = c.env;
+        const { incoming } = c.env;
         if (headerValue(incoming, "origin") !== undefined) {
-            const route = pathnameOf(incoming).split("/").filter(Boolean);
-            // Only Tenant routes, and only when the operator allows browsers; the Tenant then
-            // checks the publishable key and its origins before adding any CORS header.
-            const tenantRoute = route[0] === "v1" && route[1] !== "admin";
-            // The operator listener never serves browsers.
-            if (!options.browserAccess || role === "operator" || !tenantRoute)
+            // Only Tenant routes; the Tenant then accepts only a trusted issuer's token from a
+            // browser.
+            if (pathnameOf(incoming).split("/").filter(Boolean)[0] !== "v1")
                 return rejectedResponse(403, "origin_rejected", "Browser Origin headers are not accepted");
-            if (incoming.method === "OPTIONS") {
-                c.set("status", answerPreflight(incoming, outgoing, route, browserRoute));
-                return RESPONSE_ALREADY_SENT;
-            }
         }
+        // CORS is the operator's proxy's: an OPTIONS request gets no CORS header.
+        if (incoming.method === "OPTIONS")
+            return new Response(null, { status: 204, headers: { allow: ALLOWED_METHODS } });
         await next();
     });
     app.use(async (c, next) => {
@@ -53,7 +48,7 @@ export function createHostApp(options) {
         await next();
     });
     app.all("*", async (c) => {
-        const { incoming, outgoing, role } = c.env;
+        const { incoming, outgoing } = c.env;
         const url = new URL(incoming.url ?? "/", "http://runtime.local");
         const pathname = url.pathname;
         if (pathname === "/health")
@@ -75,32 +70,20 @@ export function createHostApp(options) {
             const tenant = module.ready;
             const infra = await options.readiness?.();
             const ready = listener && tenant && !options.closing() && (infra?.ok ?? true);
+            const harness = module.harnessStatus();
             return jsonResponse(ready ? 200 : 503, {
                 status: ready ? "ready" : "not_ready",
                 service: "nylorun-runtime",
                 checks: { listener, tenant, ...infra?.checks },
+                ...(harness ? { harness: { mode: harness.mode, connected: harness.connected } } : {}),
             });
         }
-        // This API's own description: public, as the npm package that ships it.
-        if (pathname === "/openapi.json" && incoming.method === "GET")
-            return jsonResponse(200, tenantDocument(), { "cache-control": "no-cache" });
-        const segments = pathname.split("/").filter(Boolean);
-        if (segments[0] === "v1" && segments[1] === "admin") {
-            // A public listener has no admin routes: the same 404 as a wrong admin key.
-            if (role === "public")
-                return opaqueNotFoundResponse();
-            if (!protocolAccepted(headerValue(incoming, PROTOCOL_HEADER)))
-                return protocolRejectedResponse();
-            const token = readBearer(headerValue(incoming, "authorization"));
-            if (!adminKeyMatches(token, options.adminKey))
-                return opaqueNotFoundResponse();
-            return await options.admin(c.req.raw, { incoming, outgoing });
-        }
-        // Tenant routes: key pattern → protocol → the Tenant → selection → the Tenant's routes.
-        const keyHeader = headerValue(incoming, PUBLISHABLE_KEY_HEADER);
-        const keyTenant = keyHeader === undefined ? undefined : tenantOfPublishableKey(keyHeader);
-        if (keyHeader !== undefined && keyTenant === undefined)
-            return rejectedResponse(400, "invalid_request", `${PUBLISHABLE_KEY_HEADER} header is malformed`);
+        // The two APIs' descriptions: public, as the npm package that ships them.
+        if ((pathname === "/openapi.json" || pathname === "/openapi/runtime.json") && incoming.method === "GET")
+            return jsonResponse(200, runtimeDocument(), { "cache-control": "no-cache" });
+        if (pathname === "/openapi/management.json" && incoming.method === "GET")
+            return jsonResponse(200, managementDocument(), { "cache-control": "no-cache" });
+        // Tenant routes: protocol → the Tenant → selection → the Tenant's routes.
         const tenantHeader = headerValue(incoming, TENANT_HEADER);
         const named = tenantHeader === undefined || tenantHeader.trim() === "" ? undefined : tenantHeader.trim();
         const protocol = headerValue(incoming, PROTOCOL_HEADER);
@@ -119,9 +102,8 @@ export function createHostApp(options) {
         }
         const { handle } = resolution;
         const tenantId = handle.envelope.id;
-        // A protocol 4 client names the Tenant; a publishable key carries one. Either naming
-        // another Tenant (or a malformed header) reached the wrong installation.
-        if ((named !== undefined && named !== tenantId) || (keyTenant !== undefined && keyTenant !== tenantId))
+        // A protocol 4 client names the Tenant: naming another reached the wrong installation.
+        if (named !== undefined && named !== tenantId)
             return opaqueNotFoundResponse();
         c.set("tenantId", tenantId);
         return await handle.fetch(c.req.raw, { incoming, outgoing });
@@ -154,10 +136,8 @@ export function createHostApp(options) {
     });
     return app;
 }
-/** A route a browser page may call, decided from the route alone (`api/http/define.ts`). */
-function browserRoute(method, segments) {
-    return findTenantRoute(method, segments)?.browser === true;
-}
+/** The methods the Runtime serves, for an `OPTIONS` answer's `Allow`. */
+const ALLOWED_METHODS = "GET, POST, PUT, DELETE, OPTIONS";
 /** The Tenant route a request names, if any; a malformed path names none. */
 function tenantRouteOf(incoming) {
     const segments = [];
@@ -169,7 +149,7 @@ function tenantRouteOf(incoming) {
             return undefined;
         }
     }
-    if (segments[0] !== "v1" || segments[1] === "admin")
+    if (segments[0] !== "v1")
         return undefined;
     return findTenantRoute(incoming.method ?? "GET", segments);
 }

package/dist/host/config-for.d.ts

@@ -1,4 +1,3 @@
-import type { HostConfigFile } from "./config.js";
 import type { Logger, TenantConfig } from "../tenant/types.js";
 /**
  * Builds the TenantConfig of the Host's Tenant for `openTenantRuntime`.
@@ -7,13 +6,14 @@ import type { Logger, TenantConfig } from "../tenant/types.js";
  */
 export declare function configForFactory(options: {
     hostRoot: string;
-    hostConfig: HostConfigFile;
     logger: Logger;
-    /** Allowlisted baseline from `baselineEnvironment` (built in `host/main.ts`). */
-    baseline: Readonly<Record<string, string>>;
     mode?: TenantConfig["mode"];
     /** Override model; default vault. Fixture/scripted require ephemeral/test mode. */
     model?: TenantConfig["model"];
-    /** How Tenants may call Action endpoints (`StackConfig.delivery`). */
+    /** How Tenants may call MCP servers and HTTP tools (`StackConfig.delivery`). */
     delivery?: TenantConfig["delivery"];
+    /** The trusted issuers of the identity file (`NYLORUN_IDENTITY_FILE`). */
+    issuers?: TenantConfig["issuers"];
+    /** `NYLORUN_PUBLIC_URL`: the base of the MCP OAuth callback (F9 C2). */
+    publicUrl?: string;
 }): (id: string) => TenantConfig;

package/dist/host/config-for.js

@@ -1,12 +1,10 @@
 import { tenantPaths } from "../tenant/paths.js";
-import { tenantChildEnvironment } from "./environment.js";
 /**
  * Builds the TenantConfig of the Host's Tenant for `openTenantRuntime`.
  * The sandbox backend here is the Host default; a Tenant's seeded `sandbox.backend`
  * setting overrides it when the Tenant opens (I1, A18).
  */
 export function configForFactory(options) {
-    const { baseline } = options;
     return (id) => {
         const tenant = tenantPaths(options.hostRoot);
         const sandboxBackend = "auto";
@@ -17,7 +15,8 @@ export function configForFactory(options) {
             sandbox: { backend: sandboxBackend },
             model: options.model ?? { kind: "vault" },
             ...(options.delivery ? { delivery: options.delivery } : {}),
-            childEnv: tenantChildEnvironment(baseline, options.hostConfig, tenant),
+            ...(options.issuers ? { issuers: options.issuers } : {}),
+            ...(options.publicUrl ? { publicUrl: options.publicUrl } : {}),
             logger: {
                 info: (message, fields) => options.logger.info(message, { tenantId: id, ...fields }),
                 warn: (message, fields) => options.logger.warn(message, { tenantId: id, ...fields }),

package/dist/host/config.d.ts

@@ -4,17 +4,6 @@ export interface HostConfigFile {
     host: string;
     port: number;
     allowNonLoopback?: boolean;
-    /**
-     * Whether browser requests (an `Origin` with a publishable key) may reach Tenant routes.
-     * Default off for a Host started from host.json; container mode reads
-     * `NYLORUN_BROWSER_ACCESS` instead.
-     */
-    browserAccess?: boolean;
-    /**
-     * The operator listener's port: the Admin API moves there (on `host`, loopback only), and
-     * `port` serves the Tenant API alone. Absent: one port serves both.
-     */
-    adminPort?: number;
     proxy?: {
         httpsProxy?: string;
         noProxy?: string;

package/dist/host/create-host.d.ts

@@ -1,15 +1,14 @@
 import type { Logger, TenantModule } from "../tenant/types.js";
-import type { HostConfigFile, HostCredentialsFile } from "./config.js";
+import type { HostConfigFile } from "./config.js";
 import type { ContainerListen } from "./stack-config.js";
 export interface CreateHostOptions {
     hostRoot: string;
     module: TenantModule;
     config: HostConfigFile;
-    credentials: HostCredentialsFile;
     logger: Logger;
     /** Diagnostic package version of `@nylorun/core` for `/health`. */
     coreVersion: string;
-    /** Process id reported by `/health` and admin host status. Defaults to `process.pid`. */
+    /** Process id reported by `/health`. Defaults to `process.pid`. */
     pid?: number;
     /**
      * Container mode: bind this address and port instead of host.json's, and
@@ -17,26 +16,6 @@ export interface CreateHostOptions {
      * loopback-only rule). host.json then describes the client-facing address.
      */
     listen?: ContainerListen;
-    /**
-     * The client-facing URL `/v1/admin/status` reports as `host.url`
-     * (`NYLORUN_PUBLIC_URL`). Defaults to the bound address, which in container
-     * mode is `http://0.0.0.0:4000`.
-     */
-    publicUrl?: string;
-    /**
-     * Browser access (Host feature `browser-access`): requests with an `Origin` may reach Tenant
-     * routes, where the publishable key's origin allowlist decides. Off by default: every
-     * `Origin` is `403 origin_rejected`, as before. Admin routes, `/health` and `/ready` refuse
-     * `Origin` either way.
-     */
-    browserAccess?: boolean;
-    /**
-     * The operator listener: the Admin API (and the Tenant API, never with browser access) on
-     * its own address, kept off the network that reaches the Tenant API. When set, the main
-     * listener is public and answers admin routes with the opaque 404. Absent: one listener
-     * serves everything, as before.
-     */
-    operator?: OperatorListen;
     /**
      * Infrastructure readiness (`infra/readiness.ts`). `/ready` adds its checks
      * and answers 503 while it reports not ok. Default: the listener and the
@@ -48,7 +27,7 @@ export interface CreateHostOptions {
     }>;
     /**
      * Shutdown steps around closing the Tenant. `close()` runs them whatever asked for it
-     * (SIGTERM in `host/main.ts`, `POST /v1/admin/host/shutdown`): the listener stops, then
+     * (SIGTERM in `host/main.ts`): the listener stops, then
      * `beforeTenants` (stop the Worker so no advance starts on the closing Tenant), the Tenant
      * closes, then `afterTenants` (end the infrastructure clients). A failing step is logged
      * and shutdown goes on.
@@ -58,27 +37,11 @@ export interface CreateHostOptions {
         afterTenants?(): Promise<void>;
     };
 }
-/** Where the operator listener binds, and the `Host` values it accepts. */
-export interface OperatorListen {
-    host: string;
-    port: number;
-    /** Exact `Host` values (lowercase `name:port`); absent means the loopback forms of the port. */
-    allowedHosts?: readonly string[];
-}
-/**
- * What a listener serves. `combined`: everything (one port). `public`: the Tenant API, with
- * browser access when enabled; admin routes are the opaque 404. `operator`: the Admin API and
- * the Tenant API, never to browsers.
- */
-export type ListenerRole = "combined" | "public" | "operator";
 export interface HostServer {
     listen(): Promise<void>;
     close(): Promise<void>;
     /** Settles once `close()` has finished, whatever called it. */
     readonly closed: Promise<void>;
     readonly url: string;
-    /** Where the Admin API answers: the operator listener, or `url` when there is one listener. */
-    readonly adminUrl: string;
 }
-export { adminKeyMatches } from "./http.js";
 export declare function createHost(options: CreateHostOptions): HostServer;

package/dist/host/create-host.js

@@ -1,15 +1,9 @@
 import { createServer, } from "node:http";
 import { getRequestListener, RequestError } from "@hono/node-server";
-import { HOST_PROTOCOL } from "@nylorun/core/compatibility";
-import { AdminStatusSchema } from "@nylorun/core/contracts";
-import { adminDocument } from "../api/openapi.js";
-import { createAdminApi } from "./admin-api.js";
 import { createHostApp } from "./app.js";
 import { bindListener as bind, EXIT_NON_LOOPBACK, headerValue, HostListenError, isAllowedRequestHost, isLoopbackHost, pathnameIsLogged, redactRoutePath, rejectedResponse, sendRejected, } from "./http.js";
-import { RUNTIME_VERSION } from "../version.js";
-export { adminKeyMatches } from "./http.js";
 export function createHost(options) {
-    const { hostRoot, module, config, credentials, logger, coreVersion, } = options;
+    const { module, config, logger, coreVersion } = options;
     const pid = options.pid ?? process.pid;
     const containerListen = options.listen;
     const bindHost = containerListen?.host ?? config.host;
@@ -17,52 +11,20 @@ export function createHost(options) {
     let server;
     let url = "";
     let listenPort = bindPort;
-    const operator = options.operator;
-    let operatorServer;
-    let operatorPort = operator?.port ?? 0;
-    let adminUrl = "";
-    const mainRole = operator ? "public" : "combined";
     let closing = false;
     let closePromise;
-    const adminStatusBody = async () => {
-        const aggregate = await module.summarize();
-        return AdminStatusSchema.parse({
-            service: "nylorun-runtime",
-            version: RUNTIME_VERSION,
-            protocol: {
-                min: HOST_PROTOCOL.min,
-                max: HOST_PROTOCOL.max,
-                features: [...HOST_PROTOCOL.features],
-            },
-            tenant: module.tenant(),
-            aggregate,
-            host: {
-                hostId: config.hostId,
-                url: options.publicUrl ?? url,
-                pid,
-            },
-        });
-    };
-    const adminApi = createAdminApi({
-        status: adminStatusBody,
-        shutdown: () => void close(),
-        document: adminDocument,
-    });
     const app = createHostApp({
         module,
         logger,
         hostId: config.hostId,
-        adminKey: credentials.adminKey,
         coreVersion,
         pid,
-        browserAccess: options.browserAccess === true,
         ...(options.readiness ? { readiness: options.readiness } : {}),
-        listening: () => Boolean(server?.listening) && (!operator || Boolean(operatorServer?.listening)),
+        listening: () => Boolean(server?.listening),
         closing: () => closing,
-        admin: async (request, node) => await adminApi.fetch(request, node),
     });
-    /** Where a listener's requests go once their `Host` header checks out. */
-    const pipeline = (role) => getRequestListener(async (request, node) => alreadySent(await app.fetch(request, { ...node, role })), {
+    /** Where requests go once their `Host` header checks out. */
+    const pipeline = () => getRequestListener(async (request, node) => alreadySent(await app.fetch(request, node)), {
         // The Runtime runs inside other processes (`startEphemeralRuntime`): leave their
         // `Request` and `Response` alone.
         overrideGlobalObjects: false,
@@ -76,30 +38,23 @@ export function createHost(options) {
             return rejectedResponse(500, "internal_error", "Internal error");
         },
     });
-    /** The `Host` values a listener accepts. */
-    const hostAllowed = (role, hostHeader) => role === "operator"
-        ? isAllowedRequestHost(hostHeader, {
-            port: operatorPort,
-            host: operator.host,
-            allowNonLoopback: false,
-            ...(operator.allowedHosts ? { allowedHosts: operator.allowedHosts } : {}),
-        })
-        : isAllowedRequestHost(hostHeader, {
-            port: listenPort,
-            host: config.host,
-            allowNonLoopback: config.allowNonLoopback,
-            ...(containerListen ? { allowedHosts: containerListen.allowedHosts } : {}),
-        });
+    /** The `Host` values the listener accepts. */
+    const hostAllowed = (hostHeader) => isAllowedRequestHost(hostHeader, {
+        port: listenPort,
+        host: config.host,
+        allowNonLoopback: config.allowNonLoopback,
+        ...(containerListen ? { allowedHosts: containerListen.allowedHosts } : {}),
+    });
     /** Responses not yet finished; shutdown ends the streams among them. */
     const inFlight = new Set();
-    const serve = (role) => {
-        const next = pipeline(role);
+    const serve = () => {
+        const next = pipeline();
         return (req, res) => {
             const started = Date.now();
             inFlight.add(res);
             res.once("close", () => inFlight.delete(res));
             // D§11: `Host` first, before anything reads the request.
-            if (hostAllowed(role, headerValue(req, "host")))
+            if (hostAllowed(headerValue(req, "host")))
                 return void next(req, res);
             sendRejected(res, 421, "host_rejected", "Host header is not an allowed loopback or configured address");
             if (pathnameIsLogged(req.url))
@@ -123,39 +78,15 @@ export function createHost(options) {
             !isLoopbackHost(config.host)) {
             throw new HostListenError(`Refusing to bind non-loopback host ${config.host} without allowNonLoopback`, EXIT_NON_LOOPBACK);
         }
-        if (operator && !containerListen && !isLoopbackHost(operator.host))
-            throw new HostListenError(`Refusing to bind the operator listener on non-loopback host ${operator.host}`, EXIT_NON_LOOPBACK);
-        server = createServer(serve(mainRole));
+        server = createServer(serve());
         await bindListener(server, bindPort, bindHost);
         const address = server.address();
         listenPort =
             typeof address === "object" && address ? address.port : bindPort;
         url = `http://${bindHost}:${listenPort}`;
-        adminUrl = url;
-        if (operator) {
-            operatorServer = createServer(serve("operator"));
-            await bindListener(operatorServer, operator.port, operator.host).catch(async (error) => {
-                // Leave nothing half-open: the main listener closes too.
-                await new Promise((resolve) => server.close(() => resolve()));
-                server = undefined;
-                throw error;
-            });
-            const operatorAddress = operatorServer.address();
-            operatorPort =
-                typeof operatorAddress === "object" && operatorAddress
-                    ? operatorAddress.port
-                    : operator.port;
-            adminUrl = `http://${operator.host}:${operatorPort}`;
-        }
-        // The Tenant opens once the listener is bound: `/ready` and `/v1/admin/status` answer
-        // while it opens, and say why when it cannot.
+        // The Tenant opens once the listener is bound: `/ready` answers while it opens.
         await module.start();
-        logger.info("host_listening", {
-            hostId: config.hostId,
-            url,
-            ...(operator ? { adminUrl } : {}),
-            pid,
-        });
+        logger.info("host_listening", { hostId: config.hostId, url, pid });
     }
     const step = async (name, run) => {
         try {
@@ -178,7 +109,7 @@ export function createHost(options) {
         closePromise = (async () => {
             closing = true;
             logger.info("host_shutdown", { hostId: config.hostId });
-            const listeners = [server, operatorServer].filter((listening) => listening !== undefined);
+            const listeners = server ? [server] : [];
             const stopped = Promise.all(listeners.map((listening) => new Promise((resolve) => {
                 listening.close(() => resolve());
                 listening.closeIdleConnections();
@@ -211,7 +142,6 @@ export function createHost(options) {
                 await stopped;
             }
             server = undefined;
-            operatorServer = undefined;
             await step("beforeTenants", options.shutdown?.beforeTenants);
             await step("tenants", () => module.close());
             await step("afterTenants", options.shutdown?.afterTenants);
@@ -225,9 +155,6 @@ export function createHost(options) {
         get url() {
             return url;
         },
-        get adminUrl() {
-            return adminUrl;
-        },
     };
 }
 /**

package/dist/host/environment.d.ts

@@ -1,6 +1,5 @@
 import type { HostConfigFile } from "./config.js";
 import type { HostPaths } from "../tenant/paths.js";
-import type { TenantPaths } from "../tenant/types.js";
 /**
  * Allowlisted ambient keys for Host and Tenant child processes.
  * `NODE_OPTIONS` is never copied.
@@ -9,5 +8,3 @@ export declare function baselineEnvironment(env: NodeJS.ProcessEnv | Readonly<Re
 export type HostProcessPathInputs = Pick<HostPaths, "root" | "home" | "tmp">;
 /** Environment for the Runtime Host process itself (CLI spawn / `runtime run`). */
 export declare function hostProcessEnvironment(baseline: Readonly<Record<string, string>>, hostConfig: HostConfigFile, paths: HostProcessPathInputs): Record<string, string>;
-/** Environment for Tenant-owned children (MCP stdio, sandboxes). */
-export declare function tenantChildEnvironment(baseline: Readonly<Record<string, string>>, hostConfig: HostConfigFile, tenantPaths: TenantPaths): Record<string, string>;

package/dist/host/environment.js

@@ -42,12 +42,3 @@ export function hostProcessEnvironment(baseline, hostConfig, paths) {
         NYLORUN_HOME: paths.root,
     };
 }
-/** Environment for Tenant-owned children (MCP stdio, sandboxes). */
-export function tenantChildEnvironment(baseline, hostConfig, tenantPaths) {
-    return {
-        ...baseline,
-        ...proxyEnv(hostConfig),
-        HOME: tenantPaths.home,
-        TMPDIR: tenantPaths.tmp,
-    };
-}

package/dist/host/gates.d.ts

@@ -40,7 +40,10 @@ export interface StartGatesOptions {
     readonly drainMs?: number;
     /** How long keyed outcomes are kept, and how many (tests). */
     readonly inflight?: InflightCallsOptions;
-    /** How the gate may call Action endpoints (`NYLORUN_ENDPOINT_*`). Default: no limits. */
+    /**
+     * How the gate may call MCP servers and HTTP tools (`NYLORUN_ENDPOINT_*`).
+     * Default: no limits.
+     */
     readonly delivery?: OutboundPolicy;
     /** How long an MCP connection may sit unused. Default `GATE_MCP_IDLE_MS`. */
     readonly mcpIdleMs?: number;

package/dist/host/gates.js

@@ -17,6 +17,7 @@ import { createModelCallHandler } from "../gates/handler.js";
 import { createInflightCalls } from "../gates/inflight.js";
 import { createMcpHandler, GATE_MCP_IDLE_MS } from "../gates/mcp-handler.js";
 import { createToolCalls } from "../gates/tool-calls.js";
+import { gateHttpTools } from "../gates/http-tool.js";
 import { existsSync } from "node:fs";
 import { tenantPaths } from "../tenant/paths.js";
 import { staleRun, verifyRunToken } from "../tenant/run-token.js";
@@ -34,7 +35,12 @@ export async function startGates(options) {
     if (!vaults) {
         if (!database || options.hostRoot === undefined)
             throw new Error("startGates needs the Postgres pool and the Host root");
-        vaults = createTenantVaults({ sql: database, hostRoot: options.hostRoot });
+        vaults = createTenantVaults({
+            sql: database,
+            hostRoot: options.hostRoot,
+            ...(gates.resolver ? { resolver: gates.resolver } : {}),
+            ...(options.delivery ? { delivery: options.delivery } : {}),
+        });
     }
     const blobs = options.blobs ??
         (options.hostRoot !== undefined
@@ -47,10 +53,10 @@ export async function startGates(options) {
         logger,
         idleMs: mcpIdleMs,
         ...(options.openMcp ? { open: options.openMcp } : {}),
+        ...(options.delivery ? { delivery: options.delivery } : {}),
     });
     const toolCalls = createToolCalls({
         vaults,
-        mcp,
         logger,
         ...(options.inflight ? { inflight: options.inflight } : {}),
     });
@@ -93,8 +99,8 @@ export async function startGates(options) {
         },
         ...(options.maxBodyBytes !== undefined ? { maxBodyBytes: options.maxBodyBytes } : {}),
         mcp,
+        http: gateHttpTools(vaults, options.delivery ?? {}, logger),
         toolCalls,
-        delivery: options.delivery ?? {},
         logger,
         ...(options.keys ? { keys: async () => (await vaults.open()).keys() } : {}),
     });

package/dist/host/http.d.ts

@@ -48,11 +48,10 @@ export declare function pathnameIsLogged(rawUrl: string | undefined): boolean;
  * (a credential) after `/v1/artifact-links/`.
  */
 export declare function redactRoutePath(pathname: string): string;
-/** Constant-time comparison of SHA-256 digests of the presented and stored admin keys. */
+/** Constant-time comparison of SHA-256 digests of a presented and a stored secret. */
 export declare function adminKeyMatches(presented: string | undefined, adminKey: string): boolean;
 /** A request header's first value. */
 export declare function headerValue(incoming: IncomingMessage, name: string): string | undefined;
-export declare function readBearer(authorization: string | undefined): string | undefined;
 /** A JSON request body, capped at `limit` bytes (413); `undefined` when there is none. */
 export declare function readJsonBody(request: Request, limit?: number): Promise<unknown>;
 export declare function isLoopbackHost(host: string): boolean;

package/dist/host/http.js

@@ -149,7 +149,7 @@ export function redactRoutePath(pathname) {
         return "/v1/artifact-links/:token";
     return pathname;
 }
-/** Constant-time comparison of SHA-256 digests of the presented and stored admin keys. */
+/** Constant-time comparison of SHA-256 digests of a presented and a stored secret. */
 export function adminKeyMatches(presented, adminKey) {
     if (presented === undefined)
         return false;
@@ -164,12 +164,6 @@ export function headerValue(incoming, name) {
         return raw[0];
     return raw;
 }
-export function readBearer(authorization) {
-    if (!authorization)
-        return undefined;
-    const match = /^Bearer\s+(\S+)/i.exec(authorization.trim());
-    return match?.[1];
-}
 /** A JSON request body, capped at `limit` bytes (413); `undefined` when there is none. */
 export async function readJsonBody(request, limit = 1024 * 1024) {
     if (request.body === null)

package/dist/host/index.d.ts

@@ -1,6 +1,6 @@
 export type { HostConfigFile, HostCredentialsFile, } from "./config.js";
-export { baselineEnvironment, hostProcessEnvironment, tenantChildEnvironment, } from "./environment.js";
-export { createHost, adminKeyMatches, type CreateHostOptions, type HostServer } from "./create-host.js";
+export { baselineEnvironment, hostProcessEnvironment, } from "./environment.js";
+export { createHost, type CreateHostOptions, type HostServer } from "./create-host.js";
 export { createHostLogger } from "./logger.js";
 export { configForFactory } from "./config-for.js";
 export { createHostExecution, type CreateHostExecutionOptions, type HostExecution, } from "./execution.js";

package/dist/host/index.js

@@ -1,5 +1,5 @@
-export { baselineEnvironment, hostProcessEnvironment, tenantChildEnvironment, } from "./environment.js";
-export { createHost, adminKeyMatches } from "./create-host.js";
+export { baselineEnvironment, hostProcessEnvironment, } from "./environment.js";
+export { createHost } from "./create-host.js";
 export { createHostLogger } from "./logger.js";
 export { configForFactory } from "./config-for.js";
 export { createHostExecution, } from "./execution.js";