@praxis-ai/praxis 0.1.4 → 0.1.5

package/dist/agentCore/index.d.ts

@@ -193,6 +193,8 @@ export declare const baseTool: Readonly<{
             readonly contextLoad: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
             readonly mcpUse: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
             readonly mcpResources: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
+            readonly mcpPrompts: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
+            readonly mcpCompletions: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
         };
         readonly runtime: {
             readonly processWait: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
@@ -271,7 +273,7 @@ export declare const baseTool: Readonly<{
     baseToolCodingCoreDescriptor: {
         readonly surface: "basetool.core";
         readonly profileName: "agentCore";
-        readonly toolIds: readonly ["file.read", "file.search", "patch.apply", "web.search", "web.fetch", "shell.run", "skill.load", "context.load", "mcp.use", "mcp.resources", "media.viewImage", "process.wait", "process.kill", "plan.update", "user.ask", "tool.discover", "tool.describe", "agent.spawn", "agent.message", "agent.inbox", "agent.list", "agent.inspect", "agent.wait", "agent.stop", "agent.kill"];
+        readonly toolIds: readonly ["file.read", "file.search", "patch.apply", "web.search", "web.fetch", "shell.run", "skill.load", "context.load", "mcp.use", "mcp.resources", "mcp.prompts", "mcp.completions", "media.viewImage", "process.wait", "process.kill", "plan.update", "user.ask", "tool.discover", "tool.describe", "agent.spawn", "agent.message", "agent.inbox", "agent.list", "agent.inspect", "agent.wait", "agent.stop", "agent.kill"];
         readonly directHostAccess: false;
         readonly runtimePortRequired: true;
         readonly inspiredBy: "opencode tool execute core, adapted to Praxis BaseToolExecutorPort";
@@ -702,6 +704,8 @@ export declare const praxis: Readonly<{
             readonly contextLoad: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
             readonly mcpUse: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
             readonly mcpResources: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
+            readonly mcpPrompts: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
+            readonly mcpCompletions: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
         };
         readonly runtime: {
             readonly processWait: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
@@ -730,6 +734,8 @@ export declare const praxis: Readonly<{
             readonly contextLoad: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
             readonly mcpUse: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
             readonly mcpResources: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
+            readonly mcpPrompts: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
+            readonly mcpCompletions: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
         };
         readonly runtime: {
             readonly processWait: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
@@ -759,6 +765,8 @@ export declare const praxis: Readonly<{
                 readonly contextLoad: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
                 readonly mcpUse: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
                 readonly mcpResources: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
+                readonly mcpPrompts: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
+                readonly mcpCompletions: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
             };
             readonly runtime: {
                 readonly processWait: (input?: import("../basetool/types.js").BaseToolSpecInput) => import("../runtimeImplementation/runtimeAgentManifest.js").ToolSpec;
@@ -837,7 +845,7 @@ export declare const praxis: Readonly<{
         baseToolCodingCoreDescriptor: {
             readonly surface: "basetool.core";
             readonly profileName: "agentCore";
-            readonly toolIds: readonly ["file.read", "file.search", "patch.apply", "web.search", "web.fetch", "shell.run", "skill.load", "context.load", "mcp.use", "mcp.resources", "media.viewImage", "process.wait", "process.kill", "plan.update", "user.ask", "tool.discover", "tool.describe", "agent.spawn", "agent.message", "agent.inbox", "agent.list", "agent.inspect", "agent.wait", "agent.stop", "agent.kill"];
+            readonly toolIds: readonly ["file.read", "file.search", "patch.apply", "web.search", "web.fetch", "shell.run", "skill.load", "context.load", "mcp.use", "mcp.resources", "mcp.prompts", "mcp.completions", "media.viewImage", "process.wait", "process.kill", "plan.update", "user.ask", "tool.discover", "tool.describe", "agent.spawn", "agent.message", "agent.inbox", "agent.list", "agent.inspect", "agent.wait", "agent.stop", "agent.kill"];
             readonly directHostAccess: false;
             readonly runtimePortRequired: true;
             readonly inspiredBy: "opencode tool execute core, adapted to Praxis BaseToolExecutorPort";
@@ -904,7 +912,7 @@ export declare const praxis: Readonly<{
     baseToolCodingCoreDescriptor: {
         readonly surface: "basetool.core";
         readonly profileName: "agentCore";
-        readonly toolIds: readonly ["file.read", "file.search", "patch.apply", "web.search", "web.fetch", "shell.run", "skill.load", "context.load", "mcp.use", "mcp.resources", "media.viewImage", "process.wait", "process.kill", "plan.update", "user.ask", "tool.discover", "tool.describe", "agent.spawn", "agent.message", "agent.inbox", "agent.list", "agent.inspect", "agent.wait", "agent.stop", "agent.kill"];
+        readonly toolIds: readonly ["file.read", "file.search", "patch.apply", "web.search", "web.fetch", "shell.run", "skill.load", "context.load", "mcp.use", "mcp.resources", "mcp.prompts", "mcp.completions", "media.viewImage", "process.wait", "process.kill", "plan.update", "user.ask", "tool.discover", "tool.describe", "agent.spawn", "agent.message", "agent.inbox", "agent.list", "agent.inspect", "agent.wait", "agent.stop", "agent.kill"];
         readonly directHostAccess: false;
         readonly runtimePortRequired: true;
         readonly inspiredBy: "opencode tool execute core, adapted to Praxis BaseToolExecutorPort";

package/dist/applicationLayer/applicationRuntime.js

@@ -1160,6 +1160,7 @@ function summarizeMcpToolInput(toolCall) {
     const serverId = firstStringValue(target?.serverId, target?.connectionId, args.serverId, args.connectionId);
     const toolName = firstStringValue(target?.toolName, target?.name, args.toolName, args.name);
     const resourceUri = firstStringValue(target?.resourceUri, target?.uri, args.resourceUri, args.uri);
+    const promptName = firstStringValue(target?.promptName, target?.name, args.promptName, args.name);
     if (toolCall.toolId === "mcp.use")
         return `Calling MCP tool ${toolName ?? "tool"}${serverId ? ` on ${serverId}` : ""}`;
     if (toolCall.toolId === "mcp.resources") {
@@ -1167,6 +1168,11 @@ function summarizeMcpToolInput(toolCall) {
             ? `Reading MCP resource ${resourceUri}${serverId ? ` from ${serverId}` : ""}`
             : `Listing MCP resources${serverId ? ` from ${serverId}` : ""}`;
     }
+    if (toolCall.toolId === "mcp.prompts") {
+        return promptName
+            ? `Reading MCP prompt ${promptName}${serverId ? ` from ${serverId}` : ""}`
+            : `Listing MCP prompts${serverId ? ` from ${serverId}` : ""}`;
+    }
     return `${toolCall.toolId}${serverId ? ` on ${serverId}` : ""}`;
 }
 function summarizeMcpToolOutputForHumans(toolCall, output) {
@@ -2555,7 +2561,7 @@ function createApplicationMcpModule(options) {
         return options.mcpModule;
     const nativeServers = (options.mcpServers ?? []).map((server) => ({
         ...server,
-        mode: server.mode ?? "native",
+        mode: server.mode ?? (server.manifest === undefined ? "native" : "mcp-plus"),
     }));
     const plusServers = (options.mcpPlusServers ?? []).map((server) => ({
         ...server,

package/dist/basetool/authoring.d.ts

@@ -47,6 +47,8 @@ export declare const basetool: {
         readonly contextLoad: (input?: BaseToolSpecInput) => ToolSpec;
         readonly mcpUse: (input?: BaseToolSpecInput) => ToolSpec;
         readonly mcpResources: (input?: BaseToolSpecInput) => ToolSpec;
+        readonly mcpPrompts: (input?: BaseToolSpecInput) => ToolSpec;
+        readonly mcpCompletions: (input?: BaseToolSpecInput) => ToolSpec;
     };
     readonly runtime: {
         readonly processWait: (input?: BaseToolSpecInput) => ToolSpec;

package/dist/basetool/authoring.js

@@ -92,6 +92,8 @@ export const basetool = {
         contextLoad: (input) => knownTool("context.load", input),
         mcpUse: (input) => knownTool("mcp.use", input),
         mcpResources: (input) => knownTool("mcp.resources", input),
+        mcpPrompts: (input) => knownTool("mcp.prompts", input),
+        mcpCompletions: (input) => knownTool("mcp.completions", input),
     },
     runtime: {
         processWait: (input) => knownTool("process.wait", input),

package/dist/basetool/catalog.d.ts

@@ -1,4 +1,4 @@
 import type { BaseToolDefinition } from "./types.js";
-export declare const semanticBaseToolCatalog: readonly [BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition];
+export declare const semanticBaseToolCatalog: readonly [BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition, BaseToolDefinition];
 export declare function listSemanticBaseToolDefinitions(): readonly BaseToolDefinition[];
 export declare function getSemanticBaseToolDefinition(toolId: string): BaseToolDefinition | undefined;

package/dist/basetool/catalog.js

@@ -474,21 +474,103 @@ export const semanticBaseToolCatalog = [
         toolId: "mcp.resources",
         layer: "agent",
         title: "Read MCP Resources",
-        description: "List or read MCP resources through runtime-owned MCP clients.",
+        description: "List resources, list resource templates, read, subscribe to, or unsubscribe from MCP resources through runtime-owned MCP clients.",
         risk: "read",
-        runtimePorts: ["mcp.listResources", "mcp.readResource"],
-        permissionHints: ["mcp:resources", "mcp:read"],
+        runtimePorts: ["mcp.listResources", "mcp.listResourceTemplates", "mcp.readResource", "mcp.subscribe", "mcp.unsubscribe"],
+        permissionHints: ["mcp:resources", "mcp:read", "mcp:resource:template:list", "mcp:resource:subscribe"],
         inputSchema: schema({
             type: "object",
             properties: {
-                operation: { type: "string", enum: ["list", "read"] },
+                operation: { type: "string", enum: ["list", "templates", "read", "subscribe", "unsubscribe"] },
                 serverId: { type: "string" },
                 uri: { type: "string" },
+                uriPrefix: { type: "string" },
+                cursor: { type: "string" },
+                subscriptionId: { type: "string" },
             },
             required: ["operation"],
             additionalProperties: false,
         }),
     }),
+    define({
+        toolId: "mcp.prompts",
+        layer: "agent",
+        title: "Read MCP Prompts",
+        description: "List or get MCP prompts through runtime-owned MCP clients.",
+        risk: "read",
+        runtimePorts: ["mcp.listPrompts", "mcp.getPrompt"],
+        permissionHints: ["mcp:prompt:list", "mcp:prompt:get"],
+        inputSchema: schema({
+            type: "object",
+            properties: {
+                operation: { type: "string", enum: ["list", "get"] },
+                serverId: { type: "string" },
+                cursor: { type: "string" },
+                name: { type: "string" },
+                arguments: { type: "object" },
+            },
+            required: ["operation"],
+            additionalProperties: false,
+        }),
+    }),
+    define({
+        toolId: "mcp.completions",
+        layer: "agent",
+        title: "Complete MCP Arguments",
+        description: "Request MCP completion suggestions for prompt arguments or resource template variables through runtime-owned MCP clients.",
+        risk: "read",
+        runtimePorts: ["mcp.complete"],
+        permissionHints: ["mcp:completion"],
+        inputSchema: schema({
+            type: "object",
+            properties: {
+                serverId: { type: "string" },
+                ref: {
+                    oneOf: [
+                        {
+                            type: "object",
+                            properties: {
+                                type: { const: "ref/prompt" },
+                                name: { type: "string" },
+                            },
+                            required: ["type", "name"],
+                            additionalProperties: false,
+                        },
+                        {
+                            type: "object",
+                            properties: {
+                                type: { const: "ref/resource" },
+                                uri: { type: "string" },
+                            },
+                            required: ["type", "uri"],
+                            additionalProperties: false,
+                        },
+                    ],
+                },
+                argument: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string" },
+                        value: { type: "string" },
+                    },
+                    required: ["name", "value"],
+                    additionalProperties: false,
+                },
+                context: {
+                    type: "object",
+                    properties: {
+                        arguments: {
+                            type: "object",
+                            additionalProperties: { type: "string" },
+                        },
+                    },
+                    additionalProperties: false,
+                },
+            },
+            required: ["ref", "argument"],
+            additionalProperties: false,
+        }),
+    }),
     define({
         toolId: "media.viewImage",
         layer: "optional",

package/dist/basetool/core/index.d.ts

@@ -1,13 +1,13 @@
 import type { BaseToolDefinition, BaseToolInvokeRequest, BaseToolInvokeResult } from "../types.js";
 export type BaseToolCoreInvoker = (definition: BaseToolDefinition, request: BaseToolInvokeRequest) => Promise<BaseToolInvokeResult> | BaseToolInvokeResult;
-export declare const codingCoreToolIds: readonly ["file.read", "file.search", "patch.apply", "web.search", "web.fetch", "shell.run", "skill.load", "context.load", "mcp.use", "mcp.resources", "media.viewImage", "process.wait", "process.kill", "plan.update", "user.ask", "tool.discover", "tool.describe", "agent.spawn", "agent.message", "agent.inbox", "agent.list", "agent.inspect", "agent.wait", "agent.stop", "agent.kill"];
+export declare const codingCoreToolIds: readonly ["file.read", "file.search", "patch.apply", "web.search", "web.fetch", "shell.run", "skill.load", "context.load", "mcp.use", "mcp.resources", "mcp.prompts", "mcp.completions", "media.viewImage", "process.wait", "process.kill", "plan.update", "user.ask", "tool.discover", "tool.describe", "agent.spawn", "agent.message", "agent.inbox", "agent.list", "agent.inspect", "agent.wait", "agent.stop", "agent.kill"];
 export type CodingCoreToolId = (typeof codingCoreToolIds)[number];
 export declare const codingCoreInvokers: Readonly<Record<CodingCoreToolId, BaseToolCoreInvoker>>;
 export declare function lookupBaseToolCoreInvoker(toolId: string): BaseToolCoreInvoker | undefined;
 export declare const baseToolCodingCoreDescriptor: {
     readonly surface: "basetool.core";
     readonly profileName: "agentCore";
-    readonly toolIds: readonly ["file.read", "file.search", "patch.apply", "web.search", "web.fetch", "shell.run", "skill.load", "context.load", "mcp.use", "mcp.resources", "media.viewImage", "process.wait", "process.kill", "plan.update", "user.ask", "tool.discover", "tool.describe", "agent.spawn", "agent.message", "agent.inbox", "agent.list", "agent.inspect", "agent.wait", "agent.stop", "agent.kill"];
+    readonly toolIds: readonly ["file.read", "file.search", "patch.apply", "web.search", "web.fetch", "shell.run", "skill.load", "context.load", "mcp.use", "mcp.resources", "mcp.prompts", "mcp.completions", "media.viewImage", "process.wait", "process.kill", "plan.update", "user.ask", "tool.discover", "tool.describe", "agent.spawn", "agent.message", "agent.inbox", "agent.list", "agent.inspect", "agent.wait", "agent.stop", "agent.kill"];
     readonly directHostAccess: false;
     readonly runtimePortRequired: true;
     readonly inspiredBy: "opencode tool execute core, adapted to Praxis BaseToolExecutorPort";
@@ -24,6 +24,8 @@ export * from "./skillLoad.js";
 export * from "./contextLoad.js";
 export * from "./mcpUse.js";
 export * from "./mcpResources.js";
+export * from "./mcpPrompts.js";
+export * from "./mcpCompletions.js";
 export * from "./processWait.js";
 export * from "./processKill.js";
 export * from "./mediaViewImage.js";

package/dist/basetool/core/index.js

@@ -12,6 +12,8 @@ import { invokeSkillLoadCore } from "./skillLoad.js";
 import { invokeContextLoadCore } from "./contextLoad.js";
 import { invokeMcpUseCore } from "./mcpUse.js";
 import { invokeMcpResourcesCore } from "./mcpResources.js";
+import { invokeMcpPromptsCore } from "./mcpPrompts.js";
+import { invokeMcpCompletionsCore } from "./mcpCompletions.js";
 import { invokeMediaViewImageCore } from "./mediaViewImage.js";
 import { invokeToolDiscoverCore } from "./toolDiscover.js";
 import { invokeToolDescribeCore } from "./toolDescribe.js";
@@ -27,6 +29,8 @@ export const codingCoreToolIds = [
     "context.load",
     "mcp.use",
     "mcp.resources",
+    "mcp.prompts",
+    "mcp.completions",
     "media.viewImage",
     "process.wait",
     "process.kill",
@@ -54,6 +58,8 @@ export const codingCoreInvokers = {
     "context.load": invokeContextLoadCore,
     "mcp.use": invokeMcpUseCore,
     "mcp.resources": invokeMcpResourcesCore,
+    "mcp.prompts": invokeMcpPromptsCore,
+    "mcp.completions": invokeMcpCompletionsCore,
     "process.wait": invokeProcessWaitCore,
     "process.kill": invokeProcessKillCore,
     "media.viewImage": invokeMediaViewImageCore,
@@ -93,6 +99,8 @@ export * from "./skillLoad.js";
 export * from "./contextLoad.js";
 export * from "./mcpUse.js";
 export * from "./mcpResources.js";
+export * from "./mcpPrompts.js";
+export * from "./mcpCompletions.js";
 export * from "./processWait.js";
 export * from "./processKill.js";
 export * from "./mediaViewImage.js";

package/dist/basetool/core/mcpCompletions.d.ts

@@ -0,0 +1,2 @@
+import type { BaseToolDefinition, BaseToolInvokeRequest, BaseToolInvokeResult } from "../types.js";
+export declare function invokeMcpCompletionsCore(definition: BaseToolDefinition, request: BaseToolInvokeRequest): Promise<BaseToolInvokeResult>;

package/dist/basetool/core/mcpCompletions.js

@@ -0,0 +1,70 @@
+import { callRuntimePort, errorResult } from "./results.js";
+import { compactRecord, inputRecord, namespaceMethod, recordField, stringField } from "./validation.js";
+function stringRecordValue(value, key) {
+    const field = value[key];
+    return typeof field === "string" ? field : undefined;
+}
+function hasOnlyStringValues(value) {
+    return Object.values(value).every((field) => typeof field === "string");
+}
+export async function invokeMcpCompletionsCore(definition, request) {
+    const input = inputRecord(definition, request);
+    if (!input.ok)
+        return input.result;
+    const serverId = stringField(definition, input.value, "serverId");
+    if (!serverId.ok)
+        return serverId.result;
+    const ref = recordField(definition, input.value, "ref");
+    if (!ref.ok)
+        return ref.result;
+    const argument = recordField(definition, input.value, "argument");
+    if (!argument.ok)
+        return argument.result;
+    const context = recordField(definition, input.value, "context");
+    if (!context.ok)
+        return context.result;
+    if (ref.value === undefined) {
+        return errorResult(definition, "MISSING_REQUIRED_FIELD", "mcp.completions requires 'ref'.");
+    }
+    if (argument.value === undefined) {
+        return errorResult(definition, "MISSING_REQUIRED_FIELD", "mcp.completions requires 'argument'.");
+    }
+    const refType = stringRecordValue(ref.value, "type");
+    if (refType !== "ref/prompt" && refType !== "ref/resource") {
+        return errorResult(definition, "INVALID_FIELD_VALUE", "mcp.completions ref.type must be 'ref/prompt' or 'ref/resource'.");
+    }
+    if (refType === "ref/prompt" && (stringRecordValue(ref.value, "name")?.trim().length ?? 0) === 0) {
+        return errorResult(definition, "MISSING_REQUIRED_FIELD", "mcp.completions prompt ref requires 'name'.");
+    }
+    if (refType === "ref/resource" && (stringRecordValue(ref.value, "uri")?.trim().length ?? 0) === 0) {
+        return errorResult(definition, "MISSING_REQUIRED_FIELD", "mcp.completions resource ref requires 'uri'.");
+    }
+    const argumentName = stringRecordValue(argument.value, "name");
+    const argumentValue = stringRecordValue(argument.value, "value");
+    if ((argumentName?.trim().length ?? 0) === 0) {
+        return errorResult(definition, "MISSING_REQUIRED_FIELD", "mcp.completions argument requires non-empty 'name'.");
+    }
+    if (argumentValue === undefined) {
+        return errorResult(definition, "MISSING_REQUIRED_FIELD", "mcp.completions argument requires string 'value'.");
+    }
+    const contextArguments = context.value?.arguments;
+    if (contextArguments !== undefined && (typeof contextArguments !== "object" || contextArguments === null || Array.isArray(contextArguments) || !hasOnlyStringValues(contextArguments))) {
+        return errorResult(definition, "INVALID_FIELD_TYPE", "mcp.completions context.arguments must be a JSON object with string values.");
+    }
+    const complete = namespaceMethod(definition, request, "mcp", "complete");
+    if (!complete.ok)
+        return complete.result;
+    return callRuntimePort(definition, complete.value(compactRecord({
+        serverId: serverId.value,
+        ref: ref.value,
+        argument: argument.value,
+        context: context.value,
+    })), {
+        portPath: "mcp.complete",
+        metadata: {
+            serverId: serverId.value,
+            refType,
+            argumentName,
+        },
+    });
+}

package/dist/basetool/core/mcpPrompts.d.ts

@@ -0,0 +1,2 @@
+import type { BaseToolDefinition, BaseToolInvokeRequest, BaseToolInvokeResult } from "../types.js";
+export declare function invokeMcpPromptsCore(definition: BaseToolDefinition, request: BaseToolInvokeRequest): Promise<BaseToolInvokeResult>;

package/dist/basetool/core/mcpPrompts.js

@@ -0,0 +1,48 @@
+import { callRuntimePort, errorResult } from "./results.js";
+import { compactRecord, inputRecord, namespaceMethod, recordField, requiredStringField, stringField } from "./validation.js";
+export async function invokeMcpPromptsCore(definition, request) {
+    const input = inputRecord(definition, request);
+    if (!input.ok)
+        return input.result;
+    const operation = requiredStringField(definition, input.value, "operation", { minLength: 1 });
+    if (!operation.ok)
+        return operation.result;
+    const serverId = stringField(definition, input.value, "serverId");
+    if (!serverId.ok)
+        return serverId.result;
+    const cursor = stringField(definition, input.value, "cursor");
+    if (!cursor.ok)
+        return cursor.result;
+    const name = stringField(definition, input.value, "name");
+    if (!name.ok)
+        return name.result;
+    const args = recordField(definition, input.value, "arguments");
+    if (!args.ok)
+        return args.result;
+    if (operation.value !== "list" && operation.value !== "get") {
+        return errorResult(definition, "INVALID_FIELD_VALUE", "mcp.prompts operation must be 'list' or 'get'.");
+    }
+    if (operation.value === "get" && (name.value?.trim().length ?? 0) === 0) {
+        return errorResult(definition, "MISSING_REQUIRED_FIELD", "mcp.prompts get requires 'name'.");
+    }
+    if (operation.value === "list") {
+        const listPrompts = namespaceMethod(definition, request, "mcp", "listPrompts");
+        if (!listPrompts.ok)
+            return listPrompts.result;
+        return callRuntimePort(definition, listPrompts.value(compactRecord({ serverId: serverId.value, cursor: cursor.value })), {
+            portPath: "mcp.listPrompts",
+            metadata: { operation: operation.value, serverId: serverId.value, cursor: cursor.value },
+        });
+    }
+    const getPrompt = namespaceMethod(definition, request, "mcp", "getPrompt");
+    if (!getPrompt.ok)
+        return getPrompt.result;
+    return callRuntimePort(definition, getPrompt.value(compactRecord({
+        serverId: serverId.value,
+        name: name.value,
+        arguments: args.value ?? {},
+    })), {
+        portPath: "mcp.getPrompt",
+        metadata: { operation: operation.value, serverId: serverId.value, name: name.value },
+    });
+}

package/dist/basetool/core/mcpResources.js

@@ -13,18 +13,54 @@ export async function invokeMcpResourcesCore(definition, request) {
     const uri = stringField(definition, input.value, "uri");
     if (!uri.ok)
         return uri.result;
-    if (operation.value !== "list" && operation.value !== "read") {
-        return errorResult(definition, "INVALID_FIELD_VALUE", "mcp.resources operation must be 'list' or 'read'.");
+    const uriPrefix = stringField(definition, input.value, "uriPrefix");
+    if (!uriPrefix.ok)
+        return uriPrefix.result;
+    const cursor = stringField(definition, input.value, "cursor");
+    if (!cursor.ok)
+        return cursor.result;
+    const subscriptionId = stringField(definition, input.value, "subscriptionId");
+    if (!subscriptionId.ok)
+        return subscriptionId.result;
+    if (!["list", "templates", "read", "subscribe", "unsubscribe"].includes(operation.value)) {
+        return errorResult(definition, "INVALID_FIELD_VALUE", "mcp.resources operation must be 'list', 'templates', 'read', 'subscribe', or 'unsubscribe'.");
     }
     if (operation.value === "read" && (uri.value?.trim().length ?? 0) === 0) {
         return errorResult(definition, "MISSING_REQUIRED_FIELD", "mcp.resources read requires 'uri'.");
     }
-    const method = operation.value === "list" ? "listResources" : "readResource";
+    if (operation.value === "subscribe" && (uri.value?.trim().length ?? 0) === 0) {
+        return errorResult(definition, "MISSING_REQUIRED_FIELD", "mcp.resources subscribe requires 'uri'.");
+    }
+    if (operation.value === "unsubscribe" && (uri.value?.trim().length ?? 0) === 0 && (subscriptionId.value?.trim().length ?? 0) === 0) {
+        return errorResult(definition, "MISSING_REQUIRED_FIELD", "mcp.resources unsubscribe requires 'uri' or 'subscriptionId'.");
+    }
+    const method = operation.value === "list"
+        ? "listResources"
+        : operation.value === "templates"
+            ? "listResourceTemplates"
+            : operation.value === "read"
+                ? "readResource"
+                : operation.value;
     const resourcePort = namespaceMethod(definition, request, "mcp", method);
     if (!resourcePort.ok)
         return resourcePort.result;
-    return callRuntimePort(definition, resourcePort.value(compactRecord({ serverId: serverId.value, uri: uri.value })), {
+    return callRuntimePort(definition, resourcePort.value(compactRecord({
+        serverId: serverId.value,
+        uri: uri.value,
+        uriPrefix: uriPrefix.value,
+        cursor: cursor.value,
+        subjectType: operation.value === "subscribe" ? "resource" : undefined,
+        subject: operation.value === "subscribe" ? uri.value : undefined,
+        subscriptionId: subscriptionId.value,
+    })), {
         portPath: `mcp.${method}`,
-        metadata: { operation: operation.value, serverId: serverId.value, uri: uri.value },
+        metadata: {
+            operation: operation.value,
+            serverId: serverId.value,
+            uri: uri.value,
+            uriPrefix: uriPrefix.value,
+            cursor: cursor.value,
+            subscriptionId: subscriptionId.value,
+        },
     });
 }

package/dist/basetool/profiles.js

@@ -26,6 +26,8 @@ const researchCoreTools = [
     "file.search",
     "context.load",
     "mcp.resources",
+    "mcp.prompts",
+    "mcp.completions",
     "plan.update",
     "user.ask",
 ];
@@ -52,7 +54,7 @@ const runtimeCoreTools = [
     "plan.update",
     "user.ask",
 ];
-const agentExtensionTools = ["skill.load", "context.load", "mcp.use", "mcp.resources"];
+const agentExtensionTools = ["skill.load", "context.load", "mcp.use", "mcp.resources", "mcp.prompts", "mcp.completions"];
 const multiagentMeshTools = [
     "agent.spawn",
     "agent.message",
@@ -107,6 +109,12 @@ const researchDescribeOverlays = {
     "mcp.resources": overlay({
         summary: "Read external MCP resources without invoking arbitrary MCP tool actions.",
     }),
+    "mcp.prompts": overlay({
+        summary: "List or get reusable prompts exposed by mounted MCP servers.",
+    }),
+    "mcp.completions": overlay({
+        summary: "Ask mounted MCP servers for prompt argument or resource template variable completions.",
+    }),
 };
 const workDescribeOverlays = {
     "shell.run": overlay({
@@ -162,6 +170,12 @@ const agentDescribeOverlays = {
     "mcp.resources": overlay({
         summary: "List or read mounted MCP resources through runtime-owned clients.",
     }),
+    "mcp.prompts": overlay({
+        summary: "List or get mounted MCP prompts through runtime-owned clients.",
+    }),
+    "mcp.completions": overlay({
+        summary: "Request mounted MCP completion suggestions for prompt arguments and resource template variables.",
+    }),
     "skill.load": overlay({
         summary: "Load local skill instructions through the governed skill port.",
     }),

package/dist/basetool/registry.d.ts

@@ -12,6 +12,6 @@ export declare const builtinBaseToolHandlers: Readonly<{
 export declare const baseToolRegistryDescriptor: {
     readonly surface: "basetool.registry";
     readonly semanticCatalog: true;
-    readonly builtinToolCountTarget: 25;
+    readonly builtinToolCountTarget: 27;
     readonly dynamicToolsSupported: "future-mcp-plugin-registry";
 };

package/dist/basetool/supportCatalog.js

@@ -64,14 +64,31 @@ function toolInputRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
 function activeSupportsFor(entry, toolInput) {
-    if (entry.toolId !== "mcp.resources")
-        return entry.requiredSupports;
     const operation = toolInputRecord(toolInput).operation;
-    if (operation === "list") {
-        return entry.requiredSupports.filter((support) => support.portPath !== "mcp.readResource");
+    if (entry.toolId === "mcp.resources") {
+        const activePort = operation === "list"
+            ? "mcp.listResources"
+            : operation === "templates"
+                ? "mcp.listResourceTemplates"
+                : operation === "read"
+                    ? "mcp.readResource"
+                    : operation === "subscribe"
+                        ? "mcp.subscribe"
+                        : operation === "unsubscribe"
+                            ? "mcp.unsubscribe"
+                            : undefined;
+        if (activePort !== undefined) {
+            return entry.requiredSupports.filter((support) => support.portPath === activePort);
+        }
+        return entry.requiredSupports;
     }
-    if (operation === "read") {
-        return entry.requiredSupports.filter((support) => support.portPath !== "mcp.listResources");
+    if (entry.toolId === "mcp.prompts") {
+        if (operation === "list") {
+            return entry.requiredSupports.filter((support) => support.portPath !== "mcp.getPrompt");
+        }
+        if (operation === "get") {
+            return entry.requiredSupports.filter((support) => support.portPath !== "mcp.listPrompts");
+        }
     }
     return entry.requiredSupports;
 }