@praxis-ai/praxis 0.1.4 → 0.1.5

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

@@ -36,6 +36,7 @@ export type PromptContextAssemblyRequest = {
     sessionSummary?: PromptContextSessionSummary;
     conversationWindow?: readonly PromptContextConversationMessage[];
     projectContextGovernanceMaterials?: readonly PromptPackMaterialDraft[];
+    toolDeclarationPreludeMaterials?: readonly PromptPackMaterialDraft[];
     budget?: PromptContextAssemblyBudget;
     toolContextSelection?: BaseToolContextSelection;
     toolContextUsage?: readonly BaseToolContextUsageRecord[];

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

@@ -418,6 +418,22 @@ export function assemblePromptContextMaterials(input) {
         sandboxMode: input.manifest.sandbox?.profile,
         toolSpecificGuidance: PRAXIS_BASE_TOOL_CALLING_PROTOCOL,
     });
+    const toolDeclarationPreludeMaterials = (input.toolDeclarationPreludeMaterials ?? []).map((material, index) => ({
+        ...material,
+        id: material.id ?? `runtime:tool-declaration-prelude:${index + 1}`,
+        kind: material.kind,
+        source: material.source ?? "runtime.toolDeclarationPrelude",
+        sourceCategory: material.sourceCategory ?? "declared-built-in",
+        priority: material.priority ?? 95.5 - index,
+        trusted: material.trusted ?? true,
+        scope: material.scope ?? "runtime.toolCalling",
+        promptSegmentKind: "toolDeclarations",
+        metadata: {
+            ...(material.metadata ?? {}),
+            promptSegmentKind: "toolDeclarations",
+            toolMaterialType: "policy",
+        },
+    }));
     const sessionSummaryMaterial = input.sessionSummary === undefined
         ? []
         : [{
@@ -445,6 +461,7 @@ export function assemblePromptContextMaterials(input) {
         ...projectContextGovernanceMaterials,
         ...sessionSummaryMaterial,
         ...memoryContextMaterials,
+        ...toolDeclarationPreludeMaterials,
         {
             id: `task:${input.turnIndex}`,
             kind: "user",
@@ -526,6 +543,7 @@ export function assemblePromptContextMaterials(input) {
             ...manifestPromptMaterials,
             declaredRuntimeContextMaterial,
             toolDeclarationsMaterial,
+            ...toolDeclarationPreludeMaterials,
             ...projectContextGovernanceMaterials,
             ...sessionSummaryMaterial,
             ...memoryContextMaterials,

package/dist/runtimeImplementation/runtime.mcpPlane/index.d.ts

@@ -90,7 +90,7 @@ export type McpPlusProfileProposal = {
         title: string;
         summary: string;
     }[];
-    rationale?: string;
+    rationale?: string | Readonly<Record<string, string>>;
     metadata?: Readonly<Record<string, unknown>>;
 };
 export type McpPlusLearnedProfile = {
@@ -99,7 +99,7 @@ export type McpPlusLearnedProfile = {
     projectId: string;
     exposure: NonNullable<McpPlusManifest["exposure"]>;
     skills?: NonNullable<McpPlusManifest["skills"]>;
-    rationale?: string;
+    rationale?: string | Readonly<Record<string, string>>;
     createdAt: string;
     updatedAt: string;
     metadata?: Readonly<Record<string, unknown>>;
@@ -107,14 +107,26 @@ export type McpPlusLearnedProfile = {
 export type McpPlusRuntimeOverlay = {
     serverId: string;
     sessionId: string;
-    mode: ExposureMode;
-    activeTools: readonly string[];
-    pendingReprofile?: boolean;
-    counters: {
-        consecutiveIndexedToolCalls: Readonly<Record<string, number>>;
+    state: {
+        mode: ExposureMode;
+        activeTools: readonly string[];
+        pendingReprofile?: boolean;
+        counters: {
+            consecutiveIndexedToolCalls: Readonly<Record<string, number>>;
+        };
     };
     updatedAt: string;
     metadata?: Readonly<Record<string, unknown>>;
+    /** @deprecated Read-only migration support for pre-contract Praxis overlays. */
+    mode?: ExposureMode;
+    /** @deprecated Read-only migration support for pre-contract Praxis overlays. */
+    activeTools?: readonly string[];
+    /** @deprecated Read-only migration support for pre-contract Praxis overlays. */
+    pendingReprofile?: boolean;
+    /** @deprecated Read-only migration support for pre-contract Praxis overlays. */
+    counters?: {
+        consecutiveIndexedToolCalls: Readonly<Record<string, number>>;
+    };
 };
 export type McpPlusProfileStoreKey = {
     serverId: string;
@@ -206,6 +218,7 @@ export declare function learnedProfileFromProposal(input: {
     projectId: string;
     now: string;
     existing?: McpPlusLearnedProfile;
+    protectedAlwaysIndexTools?: readonly string[];
 }): {
     ok: true;
     profile: McpPlusLearnedProfile;

package/dist/runtimeImplementation/runtime.mcpPlane/index.js

@@ -5,7 +5,7 @@
  */
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { compileMcpPlusManifest, createExpandToolDeclaration, lowerExposurePlanToMcpSurface, planExposure, } from "@praxis-ai/mcp-plus";
+import { compileMcpPlusManifest, createExpandToolDeclaration, createInitToolDeclaration as createMcpPlusContractInitToolDeclaration, createLearnedProfileFromProposal as createContractLearnedProfileFromProposal, createReprofileToolDeclaration as createMcpPlusContractReprofileToolDeclaration, lowerExposurePlanToMcpSurface, mergeMcpPlusPolicy, normalizeProfileProposal, planExposure, validateProfileProposal, } from "@praxis-ai/mcp-plus";
 export function mcpServer(serverId, input) {
     return {
         ...input,
@@ -42,6 +42,14 @@ export const mcp = {
                 toolId: "mcp.resources",
                 metadata: { source: "praxis.mcp.recommendedTools", toolProviderKind: "mcp-static" },
             },
+            {
+                toolId: "mcp.prompts",
+                metadata: { source: "praxis.mcp.recommendedTools", toolProviderKind: "mcp-static" },
+            },
+            {
+                toolId: "mcp.completions",
+                metadata: { source: "praxis.mcp.recommendedTools", toolProviderKind: "mcp-static" },
+            },
         ];
     },
 };
@@ -113,18 +121,10 @@ function jsonObjectSchema(properties, required = []) {
     };
 }
 export function createMcpPlusInitToolDeclaration() {
-    return {
-        name: "mcp_plus.init",
-        description: "Submit the first MCP+ profile proposal for this standard MCP server after inspecting its full MCP tools/list surface.",
-        inputSchema: profileProposalInputSchema("init"),
-    };
+    return createMcpPlusContractInitToolDeclaration();
 }
 export function createMcpPlusReprofileToolDeclaration() {
-    return {
-        name: "mcp_plus.reprofile",
-        description: "Submit an updated MCP+ profile proposal for this standard MCP server when runtime usage shows the current profile is stale.",
-        inputSchema: profileProposalInputSchema("reprofile"),
-    };
+    return createMcpPlusContractReprofileToolDeclaration();
 }
 export function createMcpPlusSkillReadToolDeclaration() {
     return {
@@ -165,36 +165,6 @@ export function createMcpPlusFinishToolDeclaration() {
         }, ["serverId", "outcome"]),
     };
 }
-function profileProposalInputSchema(kind) {
-    return jsonObjectSchema({
-        serverId: { type: "string" },
-        pinnedTools: { type: "array", items: { type: "string" } },
-        warmTools: { type: "array", items: { type: "string" } },
-        indexedTools: { type: "array", items: { type: "string" } },
-        alwaysIndexTools: { type: "array", items: { type: "string" } },
-        toolCards: {
-            type: "object",
-            additionalProperties: {
-                type: "object",
-                properties: {
-                    title: { type: "string" },
-                    summary: { type: "string" },
-                    keywords: { type: "array", items: { type: "string" } },
-                },
-                additionalProperties: false,
-            },
-        },
-        skillChapters: {
-            type: "array",
-            items: jsonObjectSchema({
-                id: { type: "string" },
-                title: { type: "string" },
-                summary: { type: "string" },
-            }, ["id", "title", "summary"]),
-        },
-        rationale: { type: "string", description: `${kind} rationale for the host runtime.` },
-    }, ["serverId"]);
-}
 function dynamicToolSpecForNativeTool(serverId, tool) {
     return {
         toolId: `mcp.${toolIdPart(serverId)}.${toolIdPart(tool.name)}`,
@@ -362,6 +332,47 @@ function defaultToolCard(tool) {
         keywords: tool.name.split(/[^a-zA-Z0-9]+/u).filter(Boolean),
     };
 }
+function profileRationaleForContract(rationale) {
+    if (typeof rationale === "string") {
+        return rationale.trim().length === 0 ? undefined : { summary: rationale };
+    }
+    if (rationale === undefined)
+        return undefined;
+    return Object.fromEntries(Object.entries(rationale).filter(([, value]) => typeof value === "string"));
+}
+function toContractProfileProposal(proposal) {
+    const toolCards = Object.fromEntries(Object.entries(proposal.toolCards ?? {}).map(([toolName, card]) => [toolName, {
+            title: card.title,
+            summary: card.summary,
+            keywords: card.keywords === undefined ? undefined : [...card.keywords],
+        }]));
+    const contractProposal = {
+        serverId: proposal.serverId,
+        pinnedTools: uniqueStrings(proposal.pinnedTools),
+        warmTools: proposal.warmTools === undefined ? undefined : uniqueStrings(proposal.warmTools),
+        indexedTools: uniqueStrings(proposal.indexedTools),
+        alwaysIndexTools: proposal.alwaysIndexTools === undefined ? undefined : uniqueStrings(proposal.alwaysIndexTools),
+        toolCards,
+        skillChapters: proposal.skillChapters?.map((chapter) => ({ ...chapter })),
+        rationale: profileRationaleForContract(proposal.rationale),
+    };
+    if (Object.hasOwn(proposal, "modeHint")) {
+        contractProposal.modeHint = proposal.modeHint;
+    }
+    return Object.fromEntries(Object.entries(contractProposal).filter(([, value]) => value !== undefined));
+}
+function profileErrorCodeFromValidationIssue(code) {
+    switch (code) {
+        case "unknown_tool":
+            return "MCP_PLUS_PROFILE_UNKNOWN_TOOL";
+        case "always_index_pinned":
+            return "MCP_PLUS_PROFILE_ALWAYS_INDEX_PINNED";
+        case "reserved_runtime_field":
+            return "MCP_PLUS_PROFILE_MODE_HINT_UNSUPPORTED";
+        default:
+            return "MCP_PLUS_PROFILE_INVALID_PROPOSAL";
+    }
+}
 function learnedManifestFromProfile(profile, server) {
     return {
         server: {
@@ -373,6 +384,28 @@ function learnedManifestFromProfile(profile, server) {
         skills: profile.skills,
     };
 }
+function contractLearnedProfileFromPraxisProfile(profile) {
+    const toolCards = Object.fromEntries(Object.entries(profile.exposure.toolCards ?? {}).flatMap(([toolName, card]) => {
+        if (typeof card.summary !== "string" || card.summary.trim().length === 0)
+            return [];
+        return [[toolName, {
+                    title: card.title,
+                    summary: card.summary,
+                    keywords: card.keywords === undefined ? undefined : [...card.keywords],
+                }]];
+    }));
+    return {
+        schemaVersion: profile.schemaVersion,
+        serverId: profile.serverId,
+        pinnedTools: [...(profile.exposure.pinnedTools ?? [])],
+        warmTools: [...(profile.exposure.warmTools ?? [])],
+        indexedTools: [...(profile.exposure.indexedTools ?? [])],
+        alwaysIndexTools: [...(profile.exposure.alwaysIndexTools ?? [])],
+        toolCards,
+        skillChapters: profile.skills?.chapters?.map((chapter) => ({ ...chapter })),
+        rationale: profileRationaleForContract(profile.rationale),
+    };
+}
 function fallbackMcpPlusManifest(server, nativeTools) {
     const smallServer = nativeTools.length <= 8;
     return {
@@ -412,65 +445,41 @@ function bootstrapSurface(server, nativeTools) {
     };
 }
 export function learnedProfileFromProposal(input) {
-    if (Object.hasOwn(input.proposal, "modeHint")) {
-        return {
-            ok: false,
-            error: {
-                code: "MCP_PLUS_PROFILE_MODE_HINT_UNSUPPORTED",
-                message: "MCP+ profile proposals do not accept modeHint in v1; runtime overlays own exposure mode.",
-                publicSafe: true,
-            },
-        };
-    }
-    const nativeToolNames = new Set(input.nativeTools.map((tool) => tool.name));
-    const referenced = [
-        ...uniqueStrings(input.proposal.pinnedTools),
-        ...uniqueStrings(input.proposal.warmTools),
-        ...uniqueStrings(input.proposal.indexedTools),
-        ...uniqueStrings(input.proposal.alwaysIndexTools),
-        ...Object.keys(input.proposal.toolCards ?? {}),
-    ];
-    const unknown = referenced.filter((toolName) => !nativeToolNames.has(toolName));
-    if (unknown.length > 0) {
-        return {
-            ok: false,
-            error: {
-                code: "MCP_PLUS_PROFILE_UNKNOWN_TOOL",
-                message: `MCP+ profile proposal references unknown tool(s): ${unknown.join(", ")}`,
-                publicSafe: true,
-            },
-        };
-    }
-    const alwaysIndex = new Set(uniqueStrings(input.proposal.alwaysIndexTools));
-    const pinnedAlwaysIndex = uniqueStrings(input.proposal.pinnedTools).filter((toolName) => alwaysIndex.has(toolName));
-    if (pinnedAlwaysIndex.length > 0) {
+    const contractProposal = toContractProfileProposal(input.proposal);
+    const validation = validateProfileProposal(contractProposal, input.nativeTools, {
+        serverId: input.proposal.serverId,
+        alwaysIndexTools: [
+            ...(input.existing?.exposure.alwaysIndexTools ?? []),
+            ...(input.protectedAlwaysIndexTools ?? []),
+        ],
+    });
+    if (!validation.valid) {
+        const primary = validation.issues[0];
         return {
             ok: false,
             error: {
-                code: "MCP_PLUS_PROFILE_ALWAYS_INDEX_PINNED",
-                message: `alwaysIndexTools cannot be pinned: ${pinnedAlwaysIndex.join(", ")}`,
+                code: primary === undefined ? "MCP_PLUS_PROFILE_INVALID_PROPOSAL" : profileErrorCodeFromValidationIssue(primary.code),
+                message: validation.issues.map((issue) => issue.message).join(" "),
                 publicSafe: true,
             },
         };
     }
+    const normalizedProposal = normalizeProfileProposal(contractProposal);
+    const contractProfile = createContractLearnedProfileFromProposal(normalizedProposal);
     const profile = {
         schemaVersion: "mcp-plus.profile.v1",
-        serverId: input.proposal.serverId,
+        serverId: contractProfile.serverId,
         projectId: input.projectId,
         exposure: {
-            pinnedTools: uniqueStrings(input.proposal.pinnedTools),
-            warmTools: uniqueStrings(input.proposal.warmTools),
-            indexedTools: uniqueStrings(input.proposal.indexedTools),
-            alwaysIndexTools: uniqueStrings(input.proposal.alwaysIndexTools),
-            toolCards: input.proposal.toolCards === undefined ? undefined : Object.fromEntries(Object.entries(input.proposal.toolCards).map(([toolName, card]) => [toolName, {
-                    title: card.title,
-                    summary: card.summary,
-                    keywords: card.keywords === undefined ? undefined : [...card.keywords],
-                }])),
+            pinnedTools: contractProfile.pinnedTools ?? [],
+            warmTools: contractProfile.warmTools ?? [],
+            indexedTools: contractProfile.indexedTools ?? [],
+            alwaysIndexTools: contractProfile.alwaysIndexTools ?? [],
+            toolCards: contractProfile.toolCards,
         },
-        skills: input.proposal.skillChapters === undefined ? input.existing?.skills : {
+        skills: contractProfile.skillChapters === undefined ? input.existing?.skills : {
             ...(input.existing?.skills ?? {}),
-            chapters: input.proposal.skillChapters.map((chapter) => ({ ...chapter })),
+            chapters: contractProfile.skillChapters.map((chapter) => ({ ...chapter })),
         },
         rationale: input.proposal.rationale,
         createdAt: input.existing?.createdAt ?? input.now,
@@ -514,9 +523,15 @@ export function planMcpHarnessExposure(manifest, nativeToolInventoryByServerId,
                 dynamicToolSpecs: dynamicToolSpecsForSurface(server.serverId, surface),
             };
         }
-        const effectiveManifest = server.manifest ?? (learnedProfile === undefined
+        const baseManifest = server.manifest ?? (learnedProfile === undefined
             ? fallbackMcpPlusManifest(server, nativeTools)
             : learnedManifestFromProfile(learnedProfile, server));
+        const effectiveManifest = learnedProfile === undefined
+            ? baseManifest
+            : mergeMcpPlusPolicy({
+                manifest: baseManifest,
+                learnedProfile: contractLearnedProfileFromPraxisProfile(learnedProfile),
+            });
         const graph = compileMcpPlusManifest(effectiveManifest, nativeTools);
         const state = {
             serverId: server.serverId,
@@ -525,10 +540,11 @@ export function planMcpHarnessExposure(manifest, nativeToolInventoryByServerId,
         };
         const plan = planExposure(graph, state);
         const surface = lowerExposurePlanToMcpSurface(plan);
+        const shouldExposeExpandControl = state.mode === "frozen" || surface.sidecar.toolIndex.length > 0;
         const withNativeControls = {
             tools: [
                 ...surface.tools.filter((tool) => tool.name !== "mcp_plus.expand"),
-                createExpandToolDeclaration(),
+                ...(shouldExposeExpandControl ? [createExpandToolDeclaration()] : []),
                 ...(stateByServerId[server.serverId]?.mode === "frozen" ? [] : [
                     createMcpPlusSkillReadToolDeclaration(),
                     createMcpPlusSkillWriteToolDeclaration(),

package/dist/toolBase/catalog.d.ts

@@ -202,6 +202,30 @@ export declare const TOOL_BASE_CATALOG: ({
     aliases: string[];
     capabilityTags: string[];
     requiresRuntimePorts: string[];
+} | {
+    id: "mcp.prompts";
+    title: string;
+    layer: "agent";
+    visibility: "deferred";
+    risk: "read";
+    interaction: "inspect";
+    description: string;
+    inputSchema: Readonly<Record<string, unknown>>;
+    aliases: string[];
+    capabilityTags: string[];
+    requiresRuntimePorts: string[];
+} | {
+    id: "mcp.completions";
+    title: string;
+    layer: "agent";
+    visibility: "deferred";
+    risk: "read";
+    interaction: "inspect";
+    description: string;
+    inputSchema: Readonly<Record<string, unknown>>;
+    aliases: string[];
+    capabilityTags: string[];
+    requiresRuntimePorts: string[];
 } | {
     id: "lsp.query";
     title: string;

package/dist/toolBase/catalog.js

@@ -289,13 +289,51 @@ export const TOOL_BASE_CATALOG = [
         visibility: "deferred",
         risk: "read",
         interaction: "inspect",
-        description: "List or read resources exposed by mounted MCP servers.",
+        description: "List resources, list resource templates, read, subscribe to, or unsubscribe from resources exposed by mounted MCP servers.",
         inputSchema: objectSchema({
             server: { type: "string" },
             uri: { type: "string" },
-            action: { type: "string", enum: ["list", "read"] },
+            subscriptionId: { type: "string" },
+            action: { type: "string", enum: ["list", "templates", "read", "subscribe", "unsubscribe"] },
         }, ["action"]),
-        aliases: ["list_mcp_resources", "read_mcp_resource"],
+        aliases: ["list_mcp_resources", "list_mcp_resource_templates", "read_mcp_resource", "subscribe_mcp_resource", "unsubscribe_mcp_resource"],
+        capabilityTags: ["mcp", "external", "context"],
+        requiresRuntimePorts: ["mcp"],
+    },
+    {
+        id: "mcp.prompts",
+        title: "Read MCP Prompts",
+        layer: "agent",
+        visibility: "deferred",
+        risk: "read",
+        interaction: "inspect",
+        description: "List or get prompts exposed by mounted MCP servers.",
+        inputSchema: objectSchema({
+            server: { type: "string" },
+            name: { type: "string" },
+            cursor: { type: "string" },
+            action: { type: "string", enum: ["list", "get"] },
+            arguments: { type: "object" },
+        }, ["action"]),
+        aliases: ["list_mcp_prompts", "get_mcp_prompt"],
+        capabilityTags: ["mcp", "external", "context"],
+        requiresRuntimePorts: ["mcp"],
+    },
+    {
+        id: "mcp.completions",
+        title: "Complete MCP Arguments",
+        layer: "agent",
+        visibility: "deferred",
+        risk: "read",
+        interaction: "inspect",
+        description: "Request completion suggestions for prompt arguments or resource template variables exposed by mounted MCP servers.",
+        inputSchema: objectSchema({
+            server: { type: "string" },
+            ref: { type: "object" },
+            argument: { type: "object" },
+            context: { type: "object" },
+        }, ["ref", "argument"]),
+        aliases: ["complete_mcp_argument", "complete_mcp_resource_template"],
         capabilityTags: ["mcp", "external", "context"],
         requiresRuntimePorts: ["mcp"],
     },

package/dist/toolBase/profiles.d.ts

@@ -1,6 +1,6 @@
 export declare const MINIMAL_CODING_TOOL_IDS: readonly ["shell.run", "file.read", "file.search", "patch.apply", "plan.update", "user.ask"];
 export declare const STANDARD_AGENT_TOOL_IDS: readonly ["shell.run", "file.read", "file.search", "patch.apply", "plan.update", "user.ask", "web.search", "web.fetch", "skill.load", "mcp.use", "agent.spawn"];
-export declare const EXTENDED_AGENT_TOOL_IDS: readonly ["shell.run", "file.read", "file.search", "patch.apply", "plan.update", "user.ask", "web.search", "web.fetch", "skill.load", "mcp.use", "agent.spawn", "file.write", "file.edit", "agent.message", "agent.wait", "context.load", "mcp.resources", "lsp.query", "browser.use", "computer.use", "image.view", "image.generate", "audio.transcribe", "media.generate", "memory.use", "repo.inspect"];
+export declare const EXTENDED_AGENT_TOOL_IDS: readonly ["shell.run", "file.read", "file.search", "patch.apply", "plan.update", "user.ask", "web.search", "web.fetch", "skill.load", "mcp.use", "agent.spawn", "file.write", "file.edit", "agent.message", "agent.wait", "context.load", "mcp.resources", "mcp.prompts", "lsp.query", "browser.use", "computer.use", "image.view", "image.generate", "audio.transcribe", "media.generate", "memory.use", "repo.inspect"];
 export declare const TOOL_BASE_PROFILES: readonly [{
     readonly name: "minimalCoding";
     readonly description: "Pi/Codex-like small coding set for models that perform best with a short familiar tool list.";
@@ -19,9 +19,9 @@ export declare const TOOL_BASE_PROFILES: readonly [{
     readonly name: "extendedAgent";
     readonly description: "Large set for high-capability runtimes; uncommon tools remain deferred until the agent asks for them.";
     readonly defaultVisibility: "deferred";
-    readonly toolIds: readonly ["shell.run", "file.read", "file.search", "patch.apply", "plan.update", "user.ask", "web.search", "web.fetch", "skill.load", "mcp.use", "agent.spawn", "file.write", "file.edit", "agent.message", "agent.wait", "context.load", "mcp.resources", "lsp.query", "browser.use", "computer.use", "image.view", "image.generate", "audio.transcribe", "media.generate", "memory.use", "repo.inspect"];
+    readonly toolIds: readonly ["shell.run", "file.read", "file.search", "patch.apply", "plan.update", "user.ask", "web.search", "web.fetch", "skill.load", "mcp.use", "agent.spawn", "file.write", "file.edit", "agent.message", "agent.wait", "context.load", "mcp.resources", "mcp.prompts", "lsp.query", "browser.use", "computer.use", "image.view", "image.generate", "audio.transcribe", "media.generate", "memory.use", "repo.inspect"];
     readonly hiddenToolIds: readonly [];
-    readonly deferredToolIds: readonly ["file.write", "file.edit", "agent.message", "agent.wait", "context.load", "mcp.resources", "lsp.query", "browser.use", "computer.use", "image.view", "image.generate", "audio.transcribe", "media.generate", "memory.use", "repo.inspect"];
+    readonly deferredToolIds: readonly ["file.write", "file.edit", "agent.message", "agent.wait", "context.load", "mcp.resources", "mcp.prompts", "lsp.query", "browser.use", "computer.use", "image.view", "image.generate", "audio.transcribe", "media.generate", "memory.use", "repo.inspect"];
 }, {
     readonly name: "runtimeOnly";
     readonly description: "Runtime governance ports and internal operations; never sent directly to the model.";

package/dist/toolBase/profiles.js

@@ -22,6 +22,7 @@ export const EXTENDED_AGENT_TOOL_IDS = [
     "agent.wait",
     "context.load",
     "mcp.resources",
+    "mcp.prompts",
     "lsp.query",
     "browser.use",
     "computer.use",
@@ -62,6 +63,7 @@ export const TOOL_BASE_PROFILES = [
             "agent.wait",
             "context.load",
             "mcp.resources",
+            "mcp.prompts",
             "lsp.query",
             "browser.use",
             "computer.use",

package/dist/toolBase/types.d.ts

@@ -3,7 +3,7 @@ export type ToolBaseVisibility = "model" | "deferred" | "runtime" | "disabled";
 export type ToolBaseRisk = "safe" | "read" | "write" | "network" | "execute" | "dangerous";
 export type ToolBaseInteraction = "inspect" | "mutate" | "execute" | "delegate" | "ask" | "govern" | "generate";
 export type ToolBaseSchema = Readonly<Record<string, unknown>>;
-export type ToolBaseId = "shell.run" | "file.read" | "file.write" | "file.edit" | "file.search" | "patch.apply" | "web.search" | "web.fetch" | "plan.update" | "user.ask" | "agent.spawn" | "agent.message" | "agent.wait" | "skill.load" | "context.load" | "mcp.use" | "mcp.resources" | "lsp.query" | "browser.use" | "computer.use" | "image.view" | "image.generate" | "audio.transcribe" | "media.generate" | "memory.use" | "repo.inspect" | "approval.request" | "permission.check" | "sandbox.run" | "artifact.store" | "output.truncate" | "process.wait" | "process.kill" | "secret.resolve" | "tool.discover" | "tool.describe" | (string & {});
+export type ToolBaseId = "shell.run" | "file.read" | "file.write" | "file.edit" | "file.search" | "patch.apply" | "web.search" | "web.fetch" | "plan.update" | "user.ask" | "agent.spawn" | "agent.message" | "agent.wait" | "skill.load" | "context.load" | "mcp.use" | "mcp.resources" | "mcp.prompts" | "lsp.query" | "browser.use" | "computer.use" | "image.view" | "image.generate" | "audio.transcribe" | "media.generate" | "memory.use" | "repo.inspect" | "approval.request" | "permission.check" | "sandbox.run" | "artifact.store" | "output.truncate" | "process.wait" | "process.kill" | "secret.resolve" | "tool.discover" | "tool.describe" | (string & {});
 export type ToolBaseDefinition = {
     id: ToolBaseId;
     title: string;