@nylorun/runtime 0.19.1-beta → 0.21.0-beta

package/dist/infra/readiness.d.ts

@@ -1,20 +1,21 @@
 /**
  * Aggregate readiness of the Host's infrastructure (architecture §13, §14.3):
- * the Runtime's `/ready` covers Postgres, Restate and S2. s2-lite's image has
- * no health check of its own, so this is the only place its health shows.
+ * the Runtime's `/ready` covers Postgres and Restate. S2 is left out (D48): it only
+ * serves API listeners (history, SSE, AG-UI, A2A), so an outage degrades those reads
+ * and never makes the Runtime unready. Its health shows in the Tenant's status
+ * (`GET /v1/tenant`, `streams.reachable`).
  *
  * Every probe runs on each call, in parallel, bounded by one timeout. A probe
  * that throws or outlives the timeout marks its check `false`. Only check
  * names and booleans are reported; the errors stay in the report for logs.
  */
 import type { DurableExecution } from "../execution/types.js";
-import type { DurableStreams } from "../streams/types.js";
 import { type PostgresClient } from "./database.js";
 /** Resolves when the dependency answers; rejects otherwise. Must honour `signal`. */
 export type Probe = (signal: AbortSignal) => Promise<void>;
 export interface ReadinessReport {
     ok: boolean;
-    /** One entry per configured dependency, e.g. `{ postgres, restate, s2 }`. */
+    /** One entry per configured dependency, e.g. `{ postgres, restate }`. */
     checks: Record<string, boolean>;
     /** Why each failing check failed. Not for unauthenticated responses. */
     errors: Record<string, string>;
@@ -25,9 +26,8 @@ export declare const READINESS_TIMEOUT_MS = 2000;
 export declare function createReadiness(probes: Readonly<Record<string, Probe>>, options?: {
     timeoutMs?: number;
 }): Readiness;
-/** The standard checks for whichever infrastructure the Host was built with. */
+/** The standard checks for whichever infrastructure the Host was built with. Never S2 (D48). */
 export declare function infraProbes(infra: {
     database?: PostgresClient;
     execution?: DurableExecution;
-    streams?: DurableStreams;
 }): Record<string, Probe>;

package/dist/infra/readiness.js

@@ -1,6 +1,5 @@
 import { probeDatabase } from "./database.js";
 import { probeExecution } from "./execution.js";
-import { probeStreams } from "./streams.js";
 /** Default bound on one readiness pass. Compose probes `/ready` every 2 s with a 5 s timeout. */
 export const READINESS_TIMEOUT_MS = 2000;
 export function createReadiness(probes, options = {}) {
@@ -18,16 +17,14 @@ export function createReadiness(probes, options = {}) {
         return { ok: Object.values(checks).every(Boolean), checks, errors };
     };
 }
-/** The standard checks for whichever infrastructure the Host was built with. */
+/** The standard checks for whichever infrastructure the Host was built with. Never S2 (D48). */
 export function infraProbes(infra) {
     const probes = {};
-    const { database, execution, streams } = infra;
+    const { database, execution } = infra;
     if (database)
         probes.postgres = (signal) => probeDatabase(database, signal);
     if (execution)
         probes.restate = (signal) => probeExecution(execution, signal);
-    if (streams)
-        probes.s2 = (signal) => probeStreams(streams, signal);
     return probes;
 }
 /** Runs one probe under a timeout; returns its failure message, or undefined when ready. */

package/dist/keys/client.js

@@ -12,18 +12,10 @@ import { KEYS_PATH } from "./contract.js";
 import { KEYS_OPERATIONS } from "./keys.js";
 /** Signing and vault writes are short; anything slower is a gateway in trouble. */
 const KEYS_TIMEOUT_MS = 30_000;
-/**
- * MCP OAuth connect calls the authorization server several times (discovery, registration, the
- * code exchange), each bounded by `guardedFetch`'s 30 s: these wait longer.
- */
-const SLOW_OPERATIONS = {
-    startOAuth: 120_000,
-    finishOAuth: 60_000,
-};
 export function httpKeys(options) {
     const where = new URL(options.url).origin;
     function call(operation, args) {
-        const timeoutMs = Math.max(options.timeoutMs ?? KEYS_TIMEOUT_MS, SLOW_OPERATIONS[operation] ?? 0);
+        const timeoutMs = options.timeoutMs ?? KEYS_TIMEOUT_MS;
         const url = new URL(`${KEYS_PATH}/${operation}`, options.url);
         const send = url.protocol === "https:" ? httpsRequest : httpRequest;
         const payload = Buffer.from(JSON.stringify({ args }), "utf8");

package/dist/keys/keys.d.ts

@@ -1,7 +1,8 @@
-import type { CreateCredentialRequest, CredentialInfo, HostModelView, PutHostModelRequest, RotateCredentialRequest, SelectHostModelRequest, SigningKeyView } from "@nylorun/core/contracts";
+import type { CreateCredentialRequest, CredentialInfo, HostModelView, McpPreview, McpPreviewRequest, PutHostModelRequest, RotateCredentialRequest, SelectHostModelRequest, SigningKeyView } from "@nylorun/core/contracts";
 import type { SessionStore } from "../store/types.js";
+import type { OutboundPolicy } from "../tenant/outbound.js";
 import { type SigningKeys } from "../tenant/signing-keys.js";
-import type { FinishOAuthInput, StartOAuthInput, VaultService } from "../vault/service.js";
+import type { VaultService } from "../vault/service.js";
 /** One JWT to sign: its `typ` and every claim, `iss`, `aud`, `sub`, `iat`, `exp` and `jti` included. */
 export interface SignRequest {
     readonly typ: string;
@@ -26,19 +27,14 @@ export interface Keys {
     }): Promise<SigningKeyView[]>;
     /** Creates the current and standby keys when the Tenant has none. */
     ensureSigningKeys(): Promise<void>;
-    /** Starts an MCP OAuth connect into an installation vault (`VaultService.startOAuth`). */
-    startOAuth(input: StartOAuthInput): Promise<{
-        authorizeUrl: string;
-        expiresAt: string;
-    }>;
-    /** Finishes one from its callback (`VaultService.finishOAuth`). */
-    finishOAuth(input: FinishOAuthInput): Promise<{
-        vaultId: string;
-        credentialId: string;
-    }>;
+    /**
+     * Lists a remote MCP server's tools with the installation vault's credential for its URL
+     * (R2b C12, `mcp/preview.ts`); never calls a tool.
+     */
+    previewMcp(body: McpPreviewRequest): Promise<McpPreview>;
 }
 /** The operations, by the name the HTTP route carries. */
-export declare const KEYS_OPERATIONS: readonly ["createCredential", "rotateCredential", "putHostModel", "selectHostModel", "sign", "rotateSigningKeys", "ensureSigningKeys", "startOAuth", "finishOAuth"];
+export declare const KEYS_OPERATIONS: readonly ["createCredential", "rotateCredential", "putHostModel", "selectHostModel", "sign", "rotateSigningKeys", "ensureSigningKeys", "previewMcp"];
 export type KeysOperation = (typeof KEYS_OPERATIONS)[number];
 export interface InProcessKeysOptions {
     readonly store: SessionStore;
@@ -47,5 +43,7 @@ export interface InProcessKeysOptions {
     readonly signingKeys: SigningKeys;
     /** The vault key. */
     readonly kek: () => Buffer;
+    /** How a tool preview reaches the server (`TenantConfig.delivery`). Default: no limits. */
+    readonly policy?: OutboundPolicy;
 }
 export declare function inProcessKeys(options: InProcessKeysOptions): Keys;

package/dist/keys/keys.js

@@ -5,15 +5,15 @@
  * links, run and host tokens, signing-key rotation) run here, whole, so the process that calls them never
  * holds the key or a private signing key.
  *
- * MCP OAuth connect (F9-D14) runs here too: discovery, registration, the code exchange and the
- * credential it seals, so the plaintext tokens, the PKCE verifier and any client secret never
- * reach the runtime container; core only routes the start and the callback.
+ * A tool preview (R2b C12, `previewMcp`) runs here too: it sends an installation vault's
+ * credential to the server it lists, so the process that reads the plaintext makes the request.
  *
  * Two implementations: `inProcessKeys` (embedding, the ephemeral Runtime, tests, and the gates
  * service itself, which serves the HTTP routes with it), and `httpKeys` (`client.ts`), the
  * runtime container's client of the `keys` service in the gateway.
  */
 import { SignJWT } from "jose";
+import { previewMcpServer } from "../mcp/preview.js";
 import { signingKeyView } from "../tenant/signing-keys.js";
 /** The operations, by the name the HTTP route carries. */
 export const KEYS_OPERATIONS = [
@@ -24,8 +24,7 @@ export const KEYS_OPERATIONS = [
     "sign",
     "rotateSigningKeys",
     "ensureSigningKeys",
-    "startOAuth",
-    "finishOAuth",
+    "previewMcp",
 ];
 export function inProcessKeys(options) {
     const { store, vault, signingKeys, kek } = options;
@@ -34,8 +33,6 @@ export function inProcessKeys(options) {
         rotateCredential: (vaultId, id, body) => vault.rotateCredential(vaultId, id, body),
         putHostModel: (body) => vault.putHostModel(body),
         selectHostModel: (body) => vault.selectHostModel(body),
-        startOAuth: (input) => vault.startOAuth(input),
-        finishOAuth: (input) => vault.finishOAuth(input),
         async sign(request) {
             const key = kek();
             const row = await store.tx((t) => signingKeys.ensure(t, key));
@@ -54,5 +51,6 @@ export function inProcessKeys(options) {
             const key = kek();
             await store.tx((t) => signingKeys.ensure(t, key));
         },
+        previewMcp: (body) => previewMcpServer(body, { vault, policy: options.policy ?? {} }),
     };
 }