@praxis-ai/praxis 0.1.4 → 0.1.6

package/dist/agentCore/index.d.ts

@@ -29,6 +29,8 @@ import { buildMcpServerProfilesFromManifest, createMcpApplicationStateView, crea
 export { PromptPack, PraxisAgent, PraxisAgentArchetype, STATE_PLANE_STANDARD_CONTROLS, append, compileAgent, endpoint, harness, inspectAgentManifest, loop, mainLoop, markdown, markdownFile, model, modelFleet, overwrite, policy, prepend, replaceLastLines, sandbox, session, statePlane, storage, tool, toolPolicies, tools, validateAgentManifest, type AgentCompileErrorCode, type AgentCompileResult, type AgentIdentity, type AgentManifest, type AgentManifestInspection, type AgentManifestValidationResult, type BaseToolPolicyDecision, type BaseToolPolicyMatrixSpec, type BaseToolPolicyProfile, type BaseToolPolicyRisk, type BaseToolPolicyRule, type HarnessSpec, type FrameworkCoreContractSpec, type LoopSpec, type MainLoopSpec, type ModelEndpointSpec, type ModelFleetSpec, type ModelSpec, type PolicySpec, type PraxisAgentClass, type PraxisAgentInput, type PromptMaterialSource, type PromptPackSpec, type PromptPatchSpec, type SandboxSpec, type SandboxIsolationLevel, type SandboxMountPolicy, type SandboxNetworkRuntimePolicy, type SandboxPlatformSupport, type SandboxPlatformSupportStatus, type SandboxProcessPolicy, type SandboxProviderFamily, type SessionSpec, type StatePlaneSpec, type StorageSpec, type ToolSpec, type ToolPolicyCustomInput, } from "../runtimeImplementation/runtimeAgentManifest.js";
 export { buildMcpServerProfilesFromManifest, createMcpApplicationStateView, createFileMcpPlusProfileStore, createFileMcpPlusSkillStore, createInMemoryMcpPlusOverlayStore, createInMemoryMcpPlusProfileStore, createInMemoryMcpPlusSkillStore, mcp, planMcpHarnessExposure, };
 export type { McpApplicationServerView, McpApplicationServerInput, McpApplicationStateView, McpHarnessExposurePlan, McpHarnessModuleSpec, McpHarnessServerMode, McpHarnessServerSpec, McpPlusLearnedProfile, McpPlusApplicationServerInput, McpPlusOverlayStore, McpPlusOverlayStoreKey, McpPlusProfileProposal, McpPlusProfileStore, McpPlusProfileStoreKey, McpPlusRuntimeOverlay, McpPlusSkillNote, McpPlusSkillStore, McpTransportSpec, } from "../runtimeImplementation/runtime.mcpPlane/index.js";
+export { adviseSkillPromotion, createFileSkillPlaneStore, createInMemorySkillPlaneStore, createSkillWriteProposal, loadSkillHeadsFromSource, loadSkillHeadsFromSources, renderSkillIndexMaterial, skill, } from "../runtimeImplementation/runtime.skillPlane/index.js";
+export type { SkillBody, SkillHead, SkillPlaneBodyLoadPolicy, SkillPlaneIndexPolicy, SkillPlaneLifecyclePolicy, SkillPlaneModuleSpec, SkillPlanePromotionState, SkillPlaneSourceResolutionInput, SkillPlaneScope, SkillPlaneStore, SkillSourceSpec, SkillPromotionAdvice, SkillWriteProposal, } from "../runtimeImplementation/runtime.skillPlane/index.js";
 export { createMemoryPlane, memoryPlane, };
 export type { MemoryArtifactRef, MemoryIndexStatus, MemoryLayout, MemoryPlane, MemoryPlaneOptions, MemoryPolicyRisk, MemoryProfile, MemoryPromptGuide, MemoryReindexResult, MemoryRiskMetadata, MemoryScope, MemorySearchGuide, MemorySearchRequest, MemorySourceType, } from "../memory_managementPool/index.js";
 export { capabilities, capability, createProvisionPlan, dependencies, dependencyAuthoring, provisionRuntimeDescriptor, type CapabilityFallbackSpec, type CapabilityInput, type CapabilityKind, type CapabilityPolicySpec, type CapabilityReadiness, type CapabilitySpec, type CodeIntelligenceCapabilityInput, type ProvisionPlan, type SandboxCapabilityInput, } from "../runtimeImplementation/runtime.provisionPlane/index.js";
@@ -193,6 +195,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 +275,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";
@@ -668,6 +672,22 @@ export declare const praxis: Readonly<{
         sqlite(input?: Omit<import("../runtimeImplementation/runtimeAgentManifest.js").StorageSpec, "kind">): import("../runtimeImplementation/runtimeAgentManifest.js").StorageSpec;
         raxWorkspace(input?: Omit<import("../runtimeImplementation/runtimeAgentManifest.js").StorageSpec, "kind">): import("../runtimeImplementation/runtimeAgentManifest.js").StorageSpec;
     };
+    skill: {
+        readonly directory: (directoryPath: string, input?: {
+            scope?: import("../runtimeImplementation/runtime.skillPlane/index.js").SkillPlaneScope;
+        }) => import("../runtimeImplementation/runtime.skillPlane/index.js").SkillSourceSpec;
+        readonly package: (packageName: string, input?: {
+            scope?: import("../runtimeImplementation/runtime.skillPlane/index.js").SkillPlaneScope;
+        }) => import("../runtimeImplementation/runtime.skillPlane/index.js").SkillSourceSpec;
+        readonly inline: (heads: readonly import("../runtimeImplementation/runtime.skillPlane/index.js").SkillHead[]) => import("../runtimeImplementation/runtime.skillPlane/index.js").SkillSourceSpec;
+        readonly module: (input?: {
+            sources?: readonly import("../runtimeImplementation/runtime.skillPlane/index.js").SkillSourceSpec[];
+            indexPolicy?: Partial<import("../runtimeImplementation/runtime.skillPlane/index.js").SkillPlaneIndexPolicy>;
+            bodyLoadPolicy?: Partial<import("../runtimeImplementation/runtime.skillPlane/index.js").SkillPlaneBodyLoadPolicy>;
+            lifecycle?: Partial<import("../runtimeImplementation/runtime.skillPlane/index.js").SkillPlaneLifecyclePolicy>;
+            metadata?: Readonly<Record<string, unknown>>;
+        }) => import("../runtimeImplementation/runtime.skillPlane/index.js").SkillPlaneModuleSpec;
+    };
     memory: Readonly<{
         create: typeof createMemoryPlane;
         initialize: (options?: import("../memory_managementPool/types.js").MemoryPlaneOptions) => Promise<import("../memory_managementPool/types.js").MemoryIndexStatus>;
@@ -702,6 +722,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 +752,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 +783,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 +863,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 +930,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/agentCore/index.js

@@ -32,8 +32,10 @@ import { createObservationMaterial, } from "../executionEngine/coreLogic/observa
 import { runtimeAuth, } from "../runtimeImplementation/runtime.authPlane/index.js";
 import { createMemoryPlane, memoryPlane, } from "../memory_managementPool/index.js";
 import { buildMcpServerProfilesFromManifest, createMcpApplicationStateView, createFileMcpPlusProfileStore, createFileMcpPlusSkillStore, createInMemoryMcpPlusOverlayStore, createInMemoryMcpPlusProfileStore, createInMemoryMcpPlusSkillStore, mcp, planMcpHarnessExposure, } from "../runtimeImplementation/runtime.mcpPlane/index.js";
+import { skill, } from "../runtimeImplementation/runtime.skillPlane/index.js";
 export { PromptPack, PraxisAgent, PraxisAgentArchetype, STATE_PLANE_STANDARD_CONTROLS, append, compileAgent, endpoint, harness, inspectAgentManifest, loop, mainLoop, markdown, markdownFile, model, modelFleet, overwrite, policy, prepend, replaceLastLines, sandbox, session, statePlane, storage, tool, toolPolicies, tools, validateAgentManifest, } from "../runtimeImplementation/runtimeAgentManifest.js";
 export { buildMcpServerProfilesFromManifest, createMcpApplicationStateView, createFileMcpPlusProfileStore, createFileMcpPlusSkillStore, createInMemoryMcpPlusOverlayStore, createInMemoryMcpPlusProfileStore, createInMemoryMcpPlusSkillStore, mcp, planMcpHarnessExposure, };
+export { adviseSkillPromotion, createFileSkillPlaneStore, createInMemorySkillPlaneStore, createSkillWriteProposal, loadSkillHeadsFromSource, loadSkillHeadsFromSources, renderSkillIndexMaterial, skill, } from "../runtimeImplementation/runtime.skillPlane/index.js";
 export { createMemoryPlane, memoryPlane, };
 export { capabilities, capability, createProvisionPlan, dependencies, dependencyAuthoring, provisionRuntimeDescriptor, } from "../runtimeImplementation/runtime.provisionPlane/index.js";
 export { component, createRuntimeComponentRegistry, lookupRuntimeComponent, officialRuntimeComponents, } from "../runtimeImplementation/runtime.componentPlane/index.js";
@@ -288,6 +290,7 @@ export const praxis = Object.freeze({
     project: defineProject,
     statePlane,
     storage,
+    skill,
     memory,
     basetool,
     basetools: basetool,

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";
 };