@praxis-ai/praxis 0.1.3 → 0.1.5

package/dist/runtimeImplementation/runtime.execEngine/baseToolApprovalScope.js

@@ -116,6 +116,17 @@ export function createBaseToolApprovalScope(input) {
         const key = `${normalize(text(args.serverId)) || "default"}:${normalize(text(args.operation)) || "unknown-operation"}:${normalize(text(args.uri)) || "*"}`;
         return scope(toolId, "mcp", key);
     }
+    if (toolId === "mcp.prompts") {
+        const key = `${normalize(text(args.serverId)) || "default"}:${normalize(text(args.operation)) || "unknown-operation"}:${normalize(text(args.name)) || "*"}`;
+        return scope(toolId, "mcp", key);
+    }
+    if (toolId === "mcp.completions") {
+        const argument = args.argument;
+        const argumentName = typeof argument === "object" && argument !== null && !Array.isArray(argument)
+            ? normalize(text(argument.name)) || "unknown-argument"
+            : "unknown-argument";
+        return scope(toolId, "mcp", `${normalize(text(args.serverId)) || "default"}:${argumentName}`);
+    }
     if (toolId === "skill.load") {
         const key = normalize(text(args.name)) || normalize(text(args.path)) || "unknown-skill";
         return scope(toolId, "registered-source", key);

package/dist/runtimeImplementation/runtime.execEngine/baseToolExecutorPortFactory.js

@@ -645,9 +645,13 @@ function createMcpExecutor(context) {
         "call",
         "stream",
         "listResources",
+        "listResourceTemplates",
         "readResource",
+        "subscribe",
+        "unsubscribe",
         "listPrompts",
         "getPrompt",
+        "complete",
         "setRoots",
         "reportProgress",
         "createSamplingMessage",
@@ -656,12 +660,16 @@ function createMcpExecutor(context) {
     ]);
     const callTool = base.callTool ?? base.call;
     const streamTool = base.streamTool ?? base.stream;
-    return {
+    const namespace = {
         ...base,
         ...(callTool === undefined ? {} : { call: callTool, callTool }),
         ...(streamTool === undefined ? {} : { stream: streamTool, streamTool }),
         ...(context.adapters?.mcp ?? {}),
     };
+    if (configured?.shutdown !== undefined && namespace.__praxisRuntimeOwnedShutdown === undefined) {
+        namespace.__praxisRuntimeOwnedShutdown = configured.shutdown;
+    }
+    return namespace;
 }
 export function listRuntimeBaseToolImplementedPortPaths(context = {}) {
     const ports = new Set(baseToolExecutorPortFactoryDescriptor.implementedAdapters);
@@ -672,9 +680,13 @@ export function listRuntimeBaseToolImplementedPortPaths(context = {}) {
             "mcp.callTool",
             "mcp.listTools",
             "mcp.listResources",
+            "mcp.listResourceTemplates",
             "mcp.readResource",
+            "mcp.subscribe",
+            "mcp.unsubscribe",
             "mcp.listPrompts",
             "mcp.getPrompt",
+            "mcp.complete",
             "mcp.setRoots",
             "mcp.reportProgress",
             "mcp.createSamplingMessage",

package/dist/runtimeImplementation/runtime.execEngine/baseToolPolicyAdjudicator.js

@@ -115,6 +115,20 @@ const toolCells = {
         standard: { risk: "risky", human: "once", agent: "afterFirstHuman" },
         restricted: { risk: "dangerous", human: "always", agent: "never" },
     },
+    "mcp.prompts": {
+        bapr: { risk: "none", human: "never", agent: "never" },
+        yolo: { risk: "safe", human: "never", agent: "never" },
+        permissive: { risk: "safe", human: "never", agent: "never" },
+        standard: { risk: "risky", human: "once", agent: "afterFirstHuman" },
+        restricted: { risk: "dangerous", human: "always", agent: "never" },
+    },
+    "mcp.completions": {
+        bapr: { risk: "none", human: "never", agent: "never" },
+        yolo: { risk: "safe", human: "never", agent: "never" },
+        permissive: { risk: "safe", human: "never", agent: "never" },
+        standard: { risk: "risky", human: "once", agent: "afterFirstHuman" },
+        restricted: { risk: "dangerous", human: "always", agent: "never" },
+    },
     "process.kill": {
         bapr: { risk: "none", human: "never", agent: "never" },
         yolo: { risk: "safe", human: "never", agent: "never" },

package/dist/runtimeImplementation/runtime.execEngine/mcpRuntimeAdapter.d.ts

@@ -1,4 +1,5 @@
 import type { BaseToolExecutorPort } from "../../basetool/types.js";
+type JsonObject = Record<string, unknown>;
 export type McpRuntimeTransportKind = "stdio" | "http" | "sse";
 export type McpRuntimeServerProfile = {
     serverId: string;
@@ -17,7 +18,33 @@ export type McpRuntimeServerProfile = {
     headers?: Readonly<Record<string, string>>;
     timeoutMs?: number;
 };
+export type McpRuntimeRoot = {
+    uri: string;
+    name?: string;
+    _meta?: Readonly<Record<string, unknown>>;
+};
+export type McpRuntimeHostRequest = {
+    serverId: string;
+    connectionId: string;
+    method: string;
+    requestId?: string | number | null;
+    params: JsonObject;
+};
+export type McpRuntimeHostNotification = {
+    serverId: string;
+    connectionId: string;
+    method: string;
+    params: JsonObject;
+};
+export type McpRuntimeHostHooks = {
+    listRoots?: (request: McpRuntimeHostRequest) => Promise<readonly McpRuntimeRoot[]> | readonly McpRuntimeRoot[];
+    createSamplingMessage?: (request: McpRuntimeHostRequest) => Promise<unknown> | unknown;
+    elicit?: (request: McpRuntimeHostRequest) => Promise<unknown> | unknown;
+    onNotification?: (notification: McpRuntimeHostNotification) => Promise<void> | void;
+};
 export type McpRuntimeAdapterOptions = {
     servers: readonly McpRuntimeServerProfile[];
+    host?: McpRuntimeHostHooks;
 };
 export declare function createMcpRuntimeAdapter(options: McpRuntimeAdapterOptions): NonNullable<BaseToolExecutorPort["mcp"]>;
+export {};