@agent-native/core 0.114.16 → 0.115.1

package/corpus/core/src/extensions/actions.ts

@@ -623,7 +623,7 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
     "update-extension": {
       tool: {
         description:
-          'Update an existing sandboxed Alpine.js mini-app extension. If the user is viewing the extension, use the extensionId from <current-screen> or <current-url> directly; do not list extensions first just to find the current id. Prefer granular edits for surgical changes; full-body replacement is blocked by default to preserve existing layout, CSS, copy, and interactions during data-only fixes. Use `patches` or `edits` for targeted changes; set `allowFullReplacement=true` only when the user explicitly asks for a visual rewrite or supplies a complete replacement body. Supported edits include literal replace, insert-before/after marker, replace-between markers, replace-section/wrap-section/remove-section for <!-- agent-native:section name --> blocks, and regex-replace. Pass format=true to run Prettier on the final HTML. To replace the whole body with a large pasted file, pass contentFromAttachment (the attachment name, or "latest") instead of copying the file into `content` — that avoids re-emitting thousands of tokens.',
+          'Update an existing sandboxed Alpine.js mini-app extension. Pass exactly three fields: `id`, `operation`, and `payloadJson`. `payloadJson` is a JSON object encoded as a string so model gateways cannot fill its optional members with invalid empty placeholders. For operation="edit", pass {"edits":[...]} or {"patches":[...]} and optional format=true. For operation="replace", pass exactly one of content, contentFromAttachment, or contentFromWorkspaceFile; use this operation only for a user-requested broad visual rewrite or complete replacement body. For operation="metadata", pass name, description, or icon. Change sharing through set-resource-visibility instead. If the user is viewing the extension, use the extensionId from <current-screen> or <current-url> directly.',
         parameters: {
           type: "object",
           properties: {
@@ -632,72 +632,35 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
               description:
                 "Extension id to update. Prefer the extensionId from <current-screen> or <current-url> for the current extension.",
             },
-            name: {
-              type: "string",
-              description: "Optional new display name.",
-            },
-            description: {
-              type: "string",
-              description: "Optional new description.",
-            },
-            content: {
-              type: "string",
-              description:
-                "Optional full replacement Alpine.js HTML body snippet.",
-            },
-            contentFromAttachment: {
+            operation: {
               type: "string",
+              enum: ["edit", "replace", "metadata"],
               description:
-                'Optional full replacement sourced from a pasted/attached file on the current turn, by attachment name (or the literal "latest" for the most recent pasted block). Use instead of `content` when replacing the whole body with a large pasted file so you do not have to re-type it. Ignored when `content` is provided.',
+                'The single update mode: "edit" for focused patches/edits, "replace" for an explicitly authorized complete body replacement, or "metadata" for name/description/icon.',
             },
-            contentFromWorkspaceFile: {
+            payloadJson: {
               type: "string",
+              minLength: 2,
               description:
-                'Optional full replacement sourced from a workspace/shared resource file, by resource path (e.g. "intuit-analytics-extension.html"). The server reads the full file and uses it as the replacement body. Use instead of `content` when replacing the whole body with a large file that exists as a workspace resource. Ignored when `content` is provided.',
-            },
-            allowFullReplacement: {
-              type: "boolean",
-              description:
-                "Explicitly allow replacing the entire existing body. Omit or set false for data-only repairs so the existing visual design is protected. Use true only when the user explicitly requested a broad visual rewrite or supplied a complete replacement body.",
-            },
-            patches: {
-              anyOf: [
-                { type: "string" },
-                { type: "array", items: { type: "object" } },
-              ],
-              description:
-                'Optional patches as a JSON-encoded string or native array of { "find": "...", "replace": "...", "all"?: true, "expectedMatches"?: 1, "required"?: true } objects. Missing required targets fail instead of silently no-oping.',
-            },
-            edits: {
-              anyOf: [
-                { type: "string" },
-                { type: "array", items: { type: "object" } },
-              ],
-              description:
-                'Preferred optional granular edit operations as a JSON-encoded string or native array. Examples: { "op": "insert-after", "marker": "<!-- section:metrics -->", "content": "..." }, { "op": "replace-section", "section": "npm-chart", "content": "..." }, { "op": "wrap-section", "section": "charts", "before": "<div>", "after": "</div>" }, { "op": "regex-replace", "pattern": "...", "replace": "...", "expectedMatches": 1 }.',
-            },
-            format: {
-              type: "boolean",
-              description:
-                "When true, format the final extension HTML with Prettier after applying content, patches, and edits.",
-            },
-            icon: {
-              type: "string",
-              description: "Optional icon name or short label.",
-            },
-            visibility: {
-              type: "string",
-              description:
-                "Optional sharing visibility. Public extension sharing is not supported; use private or org.",
-              enum: ["private", "org"],
+                'A non-empty JSON object encoded as a string. edit example: {"edits":[{"op":"replace","find":"old","replace":"new"}],"format":true}. replace example: {"contentFromAttachment":"latest"}. metadata example: {"name":"New name"}.',
             },
           },
-          required: ["id"],
+          required: ["id", "operation", "payloadJson"],
+          additionalProperties: false,
         },
       },
       run: async (args, ctx) => {
+        const normalizedUpdate = normalizeUpdateExtensionArgs(args);
+        if ("error" in normalizedUpdate) return normalizedUpdate.error;
+        args = normalizedUpdate.args;
         const id = String(args?.id ?? "").trim();
         if (!id) return "Error: id is required.";
+        if (
+          args?.name !== undefined &&
+          (typeof args.name !== "string" || args.name.trim().length === 0)
+        ) {
+          return "Error: extension name must be a non-empty string. No changes were applied.";
+        }
         const localMessage = await localExtensionEditMessage(id);
         if (localMessage) return localMessage;
 
@@ -722,11 +685,19 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
           });
         }
 
+        const attachmentRef =
+          typeof args?.contentFromAttachment === "string"
+            ? args.contentFromAttachment.trim()
+            : "";
+        const workspaceFileRef =
+          typeof args?.contentFromWorkspaceFile === "string"
+            ? args.contentFromWorkspaceFile.trim()
+            : "";
         const fullReplacementRequested =
           (typeof args?.content === "string" &&
             args.content.trim().length > 0) ||
-          args?.contentFromAttachment !== undefined ||
-          args?.contentFromWorkspaceFile !== undefined;
+          attachmentRef.length > 0 ||
+          workspaceFileRef.length > 0;
         if (
           fullReplacementRequested &&
           !coerceBoolean(args?.allowFullReplacement)
@@ -748,8 +719,7 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
             : undefined;
         if (
           replacementContent === undefined &&
-          (args?.contentFromAttachment !== undefined ||
-            args?.contentFromWorkspaceFile !== undefined)
+          (attachmentRef.length > 0 || workspaceFileRef.length > 0)
         ) {
           const resolved = await resolveExtensionContentAsync(args, ctx);
           if ("error" in resolved) return resolved.error;
@@ -757,20 +727,20 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
         }
 
         let result = null;
+        const patches = parsePatches((args as any).patches);
+        if (args?.patches !== undefined && !patches) {
+          return "Error: patches must be a JSON array of { find, replace } objects.";
+        }
+        const edits = parseEdits((args as any).edits);
+        if (args?.edits !== undefined && !edits) {
+          return "Error: edits must be a JSON array of supported extension edit operations.";
+        }
         const hasContentUpdate =
           replacementContent !== undefined ||
-          args?.patches !== undefined ||
-          args?.edits !== undefined ||
-          args?.format !== undefined;
+          (patches?.length ?? 0) > 0 ||
+          (edits?.length ?? 0) > 0 ||
+          coerceBoolean(args?.format);
         if (hasContentUpdate) {
-          const patches = parsePatches((args as any).patches);
-          if (args?.patches !== undefined && !patches) {
-            return "Error: patches must be a JSON array of { find, replace } objects.";
-          }
-          const edits = parseEdits((args as any).edits);
-          if (args?.edits !== undefined && !edits) {
-            return "Error: edits must be a JSON array of supported extension edit operations.";
-          }
           try {
             result = await updateExtensionContent(id, {
               content: replacementContent,
@@ -806,13 +776,15 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
           meta.description = String(args.description).trim();
         }
         if (args?.icon !== undefined) meta.icon = String(args.icon);
-        if (args?.visibility !== undefined) {
+        if (args?.visibility !== undefined)
           meta.visibility = String(args.visibility);
-        }
         if (Object.keys(meta).length > 0) {
           result = await updateExtension(id, meta as any);
         }
 
+        if (!result && !hasContentUpdate && Object.keys(meta).length === 0) {
+          return "Error: update-extension received no actual changes. Choose one operation and provide a non-empty payloadJson object; empty placeholder fields are not an update.";
+        }
         if (!result) result = await getExtension(id);
         if (!result) return `Error: extension not found: ${id}`;
         const hiddenIds = await getHiddenExtensionIdsForCurrentUser();
@@ -1444,7 +1416,7 @@ async function summarizeExtensionForAgentRead(
       reason: "unchanged-content-already-returned-this-run",
       contentHash: fingerprint,
       contentLength: row.content.length,
-      next: "Use the content already returned earlier in this run and call update-extension with focused edits/patches. Set forceContent=true only if you truly need the full body again.",
+      next: 'Use the content already returned earlier in this run and call update-extension with operation="edit" plus focused edits/patches inside payloadJson. Set forceContent=true only if you truly need the full body again.',
     },
   };
 }
@@ -1746,6 +1718,160 @@ function coerceBoolean(value: unknown): boolean {
   return value === true || value === "true";
 }
 
+function normalizeUpdateExtensionArgs(
+  args: any,
+): { args: Record<string, unknown> } | { error: string } {
+  const hasCompactContract =
+    args?.operation !== undefined || args?.payloadJson !== undefined;
+  if (!hasCompactContract) {
+    const legacyArgs = { ...((args ?? {}) as Record<string, unknown>) };
+    const hasInvalidPlaceholderSignal =
+      (typeof legacyArgs.visibility === "string" &&
+        legacyArgs.visibility.trim().length === 0) ||
+      [legacyArgs.patches, legacyArgs.edits].some(
+        (value) =>
+          value !== null &&
+          typeof value === "object" &&
+          (Array.isArray(value)
+            ? value.length > 0 &&
+              value.every(
+                (item) =>
+                  item !== null &&
+                  typeof item === "object" &&
+                  !Array.isArray(item) &&
+                  Object.keys(item).length === 0,
+              )
+            : Object.keys(value).length === 0),
+      );
+    if (hasInvalidPlaceholderSignal) {
+      for (const [key, value] of Object.entries(legacyArgs)) {
+        if (key === "id") continue;
+        const empty =
+          value === false ||
+          value === null ||
+          (typeof value === "string" && value.trim().length === 0) ||
+          (Array.isArray(value) &&
+            (value.length === 0 ||
+              value.every(
+                (item) =>
+                  item !== null &&
+                  typeof item === "object" &&
+                  !Array.isArray(item) &&
+                  Object.keys(item).length === 0,
+              ))) ||
+          (typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value) &&
+            Object.keys(value).length === 0);
+        if (empty) delete legacyArgs[key];
+      }
+      delete legacyArgs.visibility;
+    }
+    return { args: legacyArgs };
+  }
+
+  const operation = String(args?.operation ?? "").trim();
+  if (!(["edit", "replace", "metadata"] as const).includes(operation as any)) {
+    return {
+      error:
+        'Error: operation must be "edit", "replace", or "metadata". No changes were applied.',
+    };
+  }
+
+  let payload: unknown;
+  try {
+    payload = JSON.parse(String(args?.payloadJson ?? ""));
+  } catch {
+    return {
+      error:
+        "Error: payloadJson must be a valid JSON object encoded as a string. No changes were applied.",
+    };
+  }
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return {
+      error:
+        "Error: payloadJson must decode to a non-empty JSON object. No changes were applied.",
+    };
+  }
+
+  const payloadRecord = payload as Record<string, unknown>;
+  const allowedByOperation: Record<string, Set<string>> = {
+    edit: new Set(["patches", "edits", "format"]),
+    replace: new Set([
+      "content",
+      "contentFromAttachment",
+      "contentFromWorkspaceFile",
+      "format",
+    ]),
+    metadata: new Set(["name", "description", "icon"]),
+  };
+  const unexpected = Object.keys(payloadRecord).filter(
+    (key) => !allowedByOperation[operation].has(key),
+  );
+  if (unexpected.length > 0) {
+    return {
+      error: `Error: operation=${operation} does not accept ${unexpected.join(", ")}. No changes were applied.`,
+    };
+  }
+
+  if (operation === "edit") {
+    const patches = parsePatches(payloadRecord.patches);
+    const edits = parseEdits(payloadRecord.edits);
+    const hasEdit =
+      (patches?.length ?? 0) > 0 ||
+      (edits?.length ?? 0) > 0 ||
+      coerceBoolean(payloadRecord.format);
+    if (!hasEdit) {
+      return {
+        error:
+          "Error: operation=edit requires at least one valid patch/edit or format=true. No changes were applied.",
+      };
+    }
+  }
+
+  if (operation === "replace") {
+    const replacementSources = [
+      payloadRecord.content,
+      payloadRecord.contentFromAttachment,
+      payloadRecord.contentFromWorkspaceFile,
+    ].filter((value) => typeof value === "string" && value.trim().length > 0);
+    if (replacementSources.length !== 1) {
+      return {
+        error:
+          "Error: operation=replace requires exactly one non-empty content, contentFromAttachment, or contentFromWorkspaceFile value. No changes were applied.",
+      };
+    }
+  }
+
+  if (operation === "metadata") {
+    const keys = Object.keys(payloadRecord);
+    if (keys.length === 0) {
+      return {
+        error:
+          "Error: operation=metadata requires name, description, or icon. No changes were applied.",
+      };
+    }
+    if (
+      payloadRecord.name !== undefined &&
+      (typeof payloadRecord.name !== "string" ||
+        payloadRecord.name.trim().length === 0)
+    ) {
+      return {
+        error:
+          "Error: extension name must be a non-empty string. No changes were applied.",
+      };
+    }
+  }
+
+  return {
+    args: {
+      id: String(args?.id ?? "").trim(),
+      ...payloadRecord,
+      ...(operation === "replace" ? { allowFullReplacement: true } : {}),
+    },
+  };
+}
+
 function parseInlineContext(
   value: unknown,
 ): Record<string, unknown> | undefined {

package/corpus/core/src/jobs/actions/list-recurring-jobs.ts

@@ -46,6 +46,7 @@ export interface RecurringJobActionItem {
   lastError: string | null;
   nextRun: string | null;
   createdBy: string | null;
+  mcpTools: string[];
   canUpdate: boolean;
 }
 
@@ -96,6 +97,7 @@ export default defineAction({
         lastError: meta.lastError ?? null,
         nextRun: nextRun(meta),
         createdBy: meta.createdBy ?? null,
+        mcpTools: meta.mcpTools ?? [],
         canUpdate,
       });
     }

package/corpus/core/src/jobs/scheduler.ts

@@ -42,6 +42,50 @@ export interface JobFrontmatter {
   deliveryThreadRef?: string;
   deliveryTenantId?: string;
   model?: string;
+  /** Explicit MCP tool capabilities available to this background run. */
+  mcpTools?: string[];
+}
+
+const MAX_JOB_MCP_TOOLS = 64;
+const JOB_MCP_TOOL_NAME_RE = /^mcp__[^\s]+__[^\s]+$/;
+
+/**
+ * Normalize the non-secret MCP capability references persisted with a job.
+ * Tool names are opaque framework identifiers; URLs and credentials never
+ * belong in job frontmatter.
+ */
+export function normalizeJobMcpTools(value: unknown): string[] | undefined {
+  if (value === undefined || value === null) return undefined;
+  const parsed =
+    typeof value === "string"
+      ? (() => {
+          try {
+            return JSON.parse(value);
+          } catch {
+            throw new Error("mcpTools must be a JSON array of tool names.");
+          }
+        })()
+      : value;
+  if (!Array.isArray(parsed)) {
+    throw new Error("mcpTools must be an array of MCP tool names.");
+  }
+  if (parsed.length > MAX_JOB_MCP_TOOLS) {
+    throw new Error(
+      `mcpTools may contain at most ${MAX_JOB_MCP_TOOLS} tool names.`,
+    );
+  }
+  const normalized = [...new Set(parsed)];
+  if (
+    normalized.some(
+      (toolName) =>
+        typeof toolName !== "string" || !JOB_MCP_TOOL_NAME_RE.test(toolName),
+    )
+  ) {
+    throw new Error(
+      "mcpTools must contain only framework MCP tool names such as mcp__server__tool.",
+    );
+  }
+  return normalized;
 }
 
 const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/;
@@ -129,6 +173,14 @@ export function parseJobFrontmatter(content: string): {
       case "model":
         meta.model = value;
         break;
+      case "mcpTools":
+        try {
+          meta.mcpTools = normalizeJobMcpTools(value);
+        } catch {
+          // Ignore malformed optional capability metadata and keep the job
+          // readable; newly-created jobs are validated before persistence.
+        }
+        break;
     }
   }
 
@@ -166,6 +218,8 @@ export function buildJobContent(meta: JobFrontmatter, body: string): string {
   if (meta.deliveryTenantId)
     lines.push(`deliveryTenantId: ${meta.deliveryTenantId}`);
   if (meta.model) lines.push(`model: ${meta.model}`);
+  if (meta.mcpTools?.length)
+    lines.push(`mcpTools: ${JSON.stringify(meta.mcpTools)}`);
   lines.push(`---`);
   lines.push("");
   lines.push(body);
@@ -174,8 +228,15 @@ export function buildJobContent(meta: JobFrontmatter, body: string): string {
 
 // ─── Job execution ──────────────────────────────────────────────────────────
 
+export interface RecurringJobContext {
+  name: string;
+  meta: JobFrontmatter;
+  body: string;
+  resource: Resource;
+}
+
 export interface SchedulerDeps {
-  getActions: () => Record<string, ActionEntry>;
+  getActions: (job?: RecurringJobContext) => Record<string, ActionEntry>;
   getSystemPrompt: (owner: string) => Promise<string>;
   /**
    * Tool names to expose on the FIRST engine request for a job run. When
@@ -188,7 +249,7 @@ export interface SchedulerDeps {
    * merged actions are the app's own vs. framework additions, so this must
    * be supplied explicitly rather than inferred here.
    */
-  getInitialToolNames?: () => string[] | undefined;
+  getInitialToolNames?: (job?: RecurringJobContext) => string[] | undefined;
   /** Optional engine override. Defaults to the resolved request engine. */
   engine?: AgentEngine;
   apiKey?: string;
@@ -477,9 +538,15 @@ async function executeJob(
     },
     async () => {
       try {
-        const baseActions = deps.getActions();
+        const jobContext: RecurringJobContext = {
+          name: jobName,
+          meta,
+          body,
+          resource,
+        };
+        const baseActions = deps.getActions(jobContext);
         const systemPrompt = await deps.getSystemPrompt(jobUserEmail);
-        const initialToolNames = deps.getInitialToolNames?.();
+        const initialToolNames = deps.getInitialToolNames?.(jobContext);
         // Only attach tool-search (and pay its schema cost) when the caller
         // actually supplied an initial subset to filter down to — otherwise
         // this is byte-for-byte the prior unfiltered behavior.

package/corpus/core/src/jobs/tools.ts

@@ -18,6 +18,7 @@ import { isValidCron, nextOccurrence, describeCron } from "./cron.js";
 import {
   parseJobFrontmatter,
   buildJobContent,
+  normalizeJobMcpTools,
   type JobFrontmatter,
 } from "./scheduler.js";
 
@@ -106,6 +107,13 @@ async function runCreate(args: Record<string, any>): Promise<string> {
     });
   }
 
+  let mcpTools: string[] | undefined;
+  try {
+    mcpTools = normalizeJobMcpTools(args.mcpTools);
+  } catch (err) {
+    return JSON.stringify({ error: (err as Error).message });
+  }
+
   const owner = scope === "personal" ? getOwner() : getSharedOwner();
   const path = `jobs/${name}.md`;
   const now = new Date();
@@ -135,6 +143,7 @@ async function runCreate(args: Record<string, any>): Promise<string> {
     ...(typeof model === "string" && model.trim()
       ? { model: model.trim() }
       : {}),
+    ...(mcpTools?.length ? { mcpTools } : {}),
   };
 
   const content = buildJobContent(meta, instructions);
@@ -148,6 +157,7 @@ async function runCreate(args: Record<string, any>): Promise<string> {
     scheduleDescription: describeCron(schedule),
     nextRun: next.toISOString(),
     scope: scope || "shared",
+    ...(mcpTools?.length ? { mcpTools } : {}),
   });
 }
 
@@ -184,6 +194,7 @@ async function runList(args: Record<string, any>): Promise<string> {
         deliveryPlatform: meta.deliveryPlatform || null,
         deliveryDestination: meta.deliveryDestination || null,
         model: meta.model || null,
+        mcpTools: meta.mcpTools || [],
       };
     }),
   );
@@ -243,6 +254,16 @@ async function runUpdate(args: Record<string, any>): Promise<string> {
   }
   if (typeof model === "string" && model.trim()) meta.model = model.trim();
 
+  if (args.mcpTools !== undefined) {
+    try {
+      const mcpTools = normalizeJobMcpTools(args.mcpTools) ?? [];
+      if (mcpTools.length) meta.mcpTools = mcpTools;
+      else delete meta.mcpTools;
+    } catch (err) {
+      return JSON.stringify({ error: (err as Error).message });
+    }
+  }
+
   const newBody = instructions || body;
   const content = buildJobContent(meta, newBody);
   await resourcePut(resource.owner, resource.path, content);
@@ -254,6 +275,7 @@ async function runUpdate(args: Record<string, any>): Promise<string> {
     scheduleDescription: describeCron(meta.schedule),
     enabled: meta.enabled,
     nextRun: meta.nextRun,
+    mcpTools: meta.mcpTools || [],
   });
 }
 
@@ -295,7 +317,9 @@ Actions:
 - "update": Update a job's schedule, instructions, or enabled state. Requires name.
 - "delete": Delete a recurring job. Requires name. Always confirm with the user first.
 
-Cron format is 5 fields: minute hour day-of-month month day-of-week. Common patterns: '0 9 * * *' (daily 9am), '0 9 * * 1-5' (weekdays 9am), '0 * * * *' (every hour), '0 9 * * 1' (Mondays 9am), '*/30 * * * *' (every 30 min).`,
+Cron format is 5 fields: minute hour day-of-month month day-of-week. Common patterns: '0 9 * * *' (daily 9am), '0 9 * * 1-5' (weekdays 9am), '0 * * * *' (every hour), '0 9 * * 1' (Mondays 9am), '*/30 * * * *' (every 30 min).
+
+For jobs that use a connected MCP, pass the exact tool names in mcpTools. This binds only those tools to the background run; OAuth credentials remain in the connector and are resolved for the job's user/org context.`,
         parameters: {
           type: "object",
           properties: {
@@ -342,6 +366,12 @@ Cron format is 5 fields: minute hour day-of-month month day-of-week. Common patt
               description:
                 "Optional model id for this routine. The channel/app/engine default is used when omitted.",
             },
+            mcpTools: {
+              type: "array",
+              items: { type: "string" },
+              description:
+                'Optional explicit MCP capabilities for this job. Use the connected tool names exactly as advertised, for example ["mcp__meeting-notes__list_meetings", "mcp__meeting-notes__get_transcript"]. The job runs only with these tools; credentials remain in the connector.',
+            },
           },
           required: ["action"],
         },

package/corpus/core/src/localization/default-messages.ts

@@ -453,6 +453,7 @@ const messages = {
     cancel: "Cancel",
     recurringDetails: "Recurring job details",
     instructions: "Instructions",
+    mcpTools: "Connected MCP tools",
     automationsLoadError: "Could not load automations.",
     automationsEmpty: "No automations yet.",
     automationEventTrigger: "On {{event}}",

package/corpus/core/src/mcp-client/index.ts

@@ -166,6 +166,8 @@ import {
 
 export interface McpActionEntryOptions {
   invocationPolicy?: McpToolInvocationPolicy;
+  /** Restrict the generated entries to an explicit background capability set. */
+  toolNames?: readonly string[];
 }
 
 export function mcpToolsToActionEntries(
@@ -173,7 +175,11 @@ export function mcpToolsToActionEntries(
   options: McpActionEntryOptions = {},
 ): Record<string, ActionEntry> {
   const entries: Record<string, ActionEntry> = {};
+  const selectedToolNames = options.toolNames
+    ? new Set(options.toolNames)
+    : undefined;
   for (const tool of manager.getTools().filter(isVisibleToModel)) {
+    if (selectedToolNames && !selectedToolNames.has(tool.name)) continue;
     entries[tool.name] = mcpToolToActionEntry(manager, tool, options);
   }
   return entries;

package/corpus/core/src/provider-api/actions/provider-api.ts

@@ -177,7 +177,7 @@ export function createProviderApiRequestSchema(
       .string()
       .optional()
       .describe(
-        "Optional shared workspace connection id to use when the provider has multiple granted connections.",
+        "Shared workspace connection id to use when the provider has multiple granted connections. Required when provider-api-catalog marks requiresConnectionId.",
       ),
     accountId: z
       .string()