@nylorun/runtime 0.14.0-beta → 0.15.0-beta

package/dist/keys/keys.js

@@ -0,0 +1,50 @@
+/**
+ * The keys seam (blueprint §14, F4.2): everything that needs the vault key. Vault writes that
+ * touch a secret (creating and rotating a credential, setting and selecting the host model;
+ * rotation and selection decrypt the old secret first) and all token signing (subject and
+ * delivery tokens, signing-key rotation) run here, whole, so the process that calls them never
+ * holds the key or a private signing key.
+ *
+ * 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 { signingKeyView } from "../tenant/signing-keys.js";
+/** The operations, by the name the HTTP route carries. */
+export const KEYS_OPERATIONS = [
+    "createCredential",
+    "rotateCredential",
+    "putHostModel",
+    "selectHostModel",
+    "sign",
+    "rotateSigningKeys",
+    "ensureSigningKeys",
+];
+export function inProcessKeys(options) {
+    const { store, vault, signingKeys, kek } = options;
+    return {
+        createCredential: (vaultId, body) => vault.createCredential(vaultId, body),
+        rotateCredential: (vaultId, id, body) => vault.rotateCredential(vaultId, id, body),
+        putHostModel: (body) => vault.putHostModel(body),
+        selectHostModel: (body) => vault.selectHostModel(body),
+        async sign(request) {
+            const key = kek();
+            const row = await store.tx((t) => signingKeys.ensure(t, key));
+            const signer = await signingKeys.privateKey(row, key);
+            const token = await new SignJWT({ ...request.claims })
+                .setProtectedHeader({ alg: "ES256", typ: request.typ, kid: signer.id })
+                .sign(signer.key);
+            return { token, keyId: signer.id };
+        },
+        async rotateSigningKeys(request) {
+            const key = kek();
+            const rows = await store.tx((t) => signingKeys.rotate(t, key, request.maxTtlSeconds, request.force));
+            return rows.map(signingKeyView);
+        },
+        async ensureSigningKeys() {
+            const key = kek();
+            await store.tx((t) => signingKeys.ensure(t, key));
+        },
+    };
+}

package/dist/mcp/connect.d.ts

@@ -2,10 +2,49 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { McpServerManifest } from "@nylorun/core/define";
 import type { AuthorizeResult } from "../vault/service.js";
 import { type McpDiagnostic, type McpToolRecord } from "./snapshot.js";
+/** Options of one MCP request. */
+export interface McpRequestOptions {
+    readonly signal?: AbortSignal;
+}
+/** Options of one tool call. */
+export interface McpCallOptions extends McpRequestOptions {
+    /**
+     * The call's effect id. A gate runs a keyed call once and keeps its outcome, so a re-send
+     * after a takeover joins it (F4.1). An in-process connection ignores it.
+     */
+    readonly key?: string;
+}
+/** A page of `tools/list`, as the MCP SDK returns it. */
+export interface McpToolPage {
+    readonly tools: readonly {
+        readonly name: string;
+        readonly description?: string;
+        readonly inputSchema?: unknown;
+        readonly outputSchema?: unknown;
+    }[];
+    readonly nextCursor?: string;
+}
+/**
+ * What the pool needs of an MCP client: the SDK `Client` over a transport of this process
+ * (`sdkClient`), or a client of the gates service that holds the real connection
+ * (`gates/tool-client.ts`).
+ */
+export interface McpClient {
+    listTools(params?: {
+        cursor?: string;
+    }, options?: McpRequestOptions): Promise<McpToolPage>;
+    /** The raw `CallToolResult`; `callMcpTool` reads it. */
+    callTool(params: {
+        name: string;
+        arguments: Record<string, unknown>;
+    }, options?: McpCallOptions): Promise<Record<string, unknown>>;
+}
 export interface LiveConnection {
-    readonly client: Client;
+    readonly client: McpClient;
     close(): Promise<void>;
 }
+/** An SDK `Client` as an `McpClient`. */
+export declare function sdkClient(client: Client): McpClient;
 export declare function openMcpServer(input: {
     server: McpServerManifest;
     authorize?: (url: string) => Promise<AuthorizeResult>;
@@ -13,15 +52,16 @@ export declare function openMcpServer(input: {
     pluginData: string;
     childEnv?: Readonly<Record<string, string>>;
 }): Promise<LiveConnection>;
-export declare function listMcpTools(client: Client, input: {
+export declare function listMcpTools(client: McpClient, input: {
     capabilityId: string;
     serverName: string;
     taken: Set<string>;
+    signal?: AbortSignal;
 }): Promise<{
     tools: McpToolRecord[];
     omitted: string[];
 }>;
-export declare function callMcpTool(client: Client, serverToolName: string, args: unknown): Promise<{
+export declare function callMcpTool(client: McpClient, serverToolName: string, args: unknown, options?: McpCallOptions): Promise<{
     kind: "completed";
     output: unknown;
 } | {

package/dist/mcp/connect.js

@@ -5,6 +5,13 @@ import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/
 import { schemaFromJSON } from "@nylorun/core/define";
 import { modelToolName, } from "./snapshot.js";
 import { prepareStdioLaunch } from "./stdio.js";
+/** An SDK `Client` as an `McpClient`. */
+export function sdkClient(client) {
+    return {
+        listTools: (params, options) => client.listTools(params, options?.signal ? { signal: options.signal } : undefined),
+        callTool: (params, options) => client.callTool(params, undefined, options?.signal ? { signal: options.signal } : undefined),
+    };
+}
 export async function openMcpServer(input) {
     if (input.server.type === "stdio") {
         const launch = prepareStdioLaunch(input.server, {
@@ -23,7 +30,7 @@ export async function openMcpServer(input) {
         transport.stderr?.on("data", () => { });
         const client = createClient();
         await client.connect(transport);
-        return { client, close: () => client.close() };
+        return { client: sdkClient(client), close: () => client.close() };
     }
     const authorize = input.authorize;
     if (!authorize)
@@ -42,14 +49,14 @@ export async function openMcpServer(input) {
         : new StreamableHTTPClientTransport(url, { fetch: fetchImpl });
     const client = createClient();
     await client.connect(transport);
-    return { client, close: () => client.close() };
+    return { client: sdkClient(client), close: () => client.close() };
 }
 export async function listMcpTools(client, input) {
     const tools = [];
     const omitted = [];
     let cursor;
     for (let page = 0; page < 100; page += 1) {
-        const listed = await client.listTools(cursor ? { cursor } : undefined);
+        const listed = await client.listTools(cursor ? { cursor } : undefined, input.signal ? { signal: input.signal } : undefined);
         for (const tool of listed.tools) {
             if (typeof tool.name !== "string" || tool.name.length === 0)
                 continue;
@@ -81,13 +88,13 @@ export async function listMcpTools(client, input) {
     }
     return { tools, omitted };
 }
-export async function callMcpTool(client, serverToolName, args) {
+export async function callMcpTool(client, serverToolName, args, options = {}) {
     const result = await client.callTool({
         name: serverToolName,
         arguments: args && typeof args === "object" && !Array.isArray(args)
             ? args
             : {},
-    });
+    }, options);
     if ("isError" in result && result.isError) {
         return {
             kind: "failed",

package/dist/mcp/pool.d.ts

@@ -1,6 +1,6 @@
 import type { AgentManifest, McpServerManifest } from "@nylorun/core/define";
 import type { AuthorizeResult } from "../vault/service.js";
-import { callMcpTool, openMcpServer } from "./connect.js";
+import { callMcpTool, openMcpServer, type LiveConnection } from "./connect.js";
 import { type McpDiagnostic, type McpSnapshot, type McpToolRecord } from "./snapshot.js";
 /** A connection unused this long is closed by the sweep; the next call opens it again. */
 export declare const DEFAULT_MCP_IDLE_MS: number;
@@ -25,6 +25,13 @@ export declare class McpPool {
         readonly now?: () => number;
         /** Tests replace how a declared server is opened. */
         readonly open?: typeof openMcpServer;
+        /**
+         * Opens a remote (`streamable-http` or `sse`) server somewhere else: the gates service
+         * holds the connection and its credential, and the loop never sees either (F4.1).
+         * Absent: remote servers are opened in this process, with `authorize`. Stdio servers
+         * always run here.
+         */
+        readonly openRemote?: (server: McpServerRef) => Promise<LiveConnection>;
     });
     discover(input: {
         sessionId: string;
@@ -52,6 +59,9 @@ export declare class McpPool {
         args: unknown;
         manifest: AgentManifest;
         pluginRoots: Readonly<Record<string, string>>;
+        /** The effect id: a gate runs the call once under it (F4.1). */
+        effectId?: string;
+        signal?: AbortSignal;
     }): Promise<Awaited<ReturnType<typeof callMcpTool>>>;
     /**
      * Closes connections unused for the idle timeout (the Tenant sweep). A session that calls
@@ -64,7 +74,15 @@ export declare class McpPool {
     private liveKey;
     private connectDeclared;
 }
-interface DeclaredServer {
+/** One declared MCP server of a session: what a gate needs to find it in the pinned manifest. */
+export interface McpServerRef {
+    readonly sessionId: string;
+    /** The agent used as a tool that declares the server; absent for the session's root agent. */
+    readonly agentId?: string;
+    readonly capabilityId: string;
+    readonly serverName: string;
+}
+export interface DeclaredServer {
     /** Absent for the session's root agent. */
     readonly agentId?: string;
     /** The manifest of the agent that declares the server. */
@@ -74,4 +92,4 @@ interface DeclaredServer {
 }
 /** Servers of the root agent, then of each agent it uses as a tool. */
 export declare function serversOf(manifest: AgentManifest): DeclaredServer[];
-export {};
+export declare function findServer(manifest: AgentManifest, agentId: string | undefined, capabilityId: string, serverName: string): DeclaredServer | undefined;

package/dist/mcp/pool.js

@@ -37,6 +37,7 @@ export class McpPool {
                     capabilityId: declared.capabilityId,
                     serverName: declared.server.name,
                     taken: taken.get(declared.agentId),
+                    ...(input.signal ? { signal: input.signal } : {}),
                 });
                 tools.push(...listed.tools.map((tool) => owned(declared, tool)));
                 diagnostics.push({
@@ -118,7 +119,10 @@ export class McpPool {
         }
         live.active += 1;
         try {
-            return await callMcpTool(live.connection.client, input.serverToolName, input.args);
+            return await callMcpTool(live.connection.client, input.serverToolName, input.args, {
+                ...(input.effectId === undefined ? {} : { key: input.effectId }),
+                ...(input.signal ? { signal: input.signal } : {}),
+            });
         }
         finally {
             live.active -= 1;
@@ -169,6 +173,15 @@ export class McpPool {
     }
     async connectDeclared(input, declared) {
         try {
+            if (declared.server.type !== "stdio" && this.options.openRemote) {
+                const connection = await this.options.openRemote({
+                    sessionId: input.sessionId,
+                    ...ownerOf(declared),
+                    capabilityId: declared.capabilityId,
+                    serverName: declared.server.name,
+                });
+                return { ok: true, connection };
+            }
             const connection = await this.open({
                 server: declared.server,
                 pluginRoot: input.pluginRoots[pluginKey(declared)],
@@ -209,7 +222,7 @@ export function serversOf(manifest) {
         add(child.manifest, child.manifest.id);
     return servers;
 }
-function findServer(manifest, agentId, capabilityId, serverName) {
+export function findServer(manifest, agentId, capabilityId, serverName) {
     return serversOf(manifest).find((item) => item.agentId === agentId &&
         item.capabilityId === capabilityId &&
         item.server.name === serverName);