salesforce-metadata-mcp 2.1.3 → 2.2.0

package/dist/tools/agentforce.js

@@ -1,66 +1,75 @@
-import { CreateAgentSchema, CreateAgentTopicSchema, CreateAgentActionSchema, CreateAgentPlannerSchema } from "../schemas/index.js";
-import { getAuth, createAgent, createAgentTopic, createAgentPlanner, activateAgent, deactivateAgent, API_VERSION } from "../services/salesforce.js";
+import {
+    CreateAgentSchema, CreateAgentTopicSchema, CreateAgentActionSchema, CreateAgentPlannerSchema,
+    ActivateAgentSchema, DeactivateAgentSchema, GetAgentSchema, UpdateAgentTopicSchema, UpdateAgentActionSchema, DeleteAgentSchema,
+    ListAgentsSchema, TestAgentSchema, GetAgentLogsSchema,
+} from "../schemas/index.js";
+import {
+    getAuth, createAgent, createAgentTopic, createAgentPlanner,
+    activateAgent, deactivateAgent, getAgent, listAgents,
+    updateAgentTopic, deleteAgent, testAgent, getAgentLogs, API_VERSION,
+} from "../services/salesforce.js";
 import { buildGenAiActionZip, deployZip, pollDeployStatus } from "../services/deployment.js";
 import { resultContent } from "./utils.js";
+
 export function registerAgentforceTools(server) {
+    // ─── CREATE ──────────────────────────────────────────────────────────────
     server.registerTool("sf_create_agent", {
         title: "Create Agentforce Agent",
         description: `Creates an Agentforce Agent (Einstein Copilot / Service Agent) in Salesforce using the Bot metadata type.
 
 IMPORTANT: Follow this exact creation order for a fully working agent:
-1. Create flows (sf_create_flow) — the AutoLaunchedFlows that perform actions
-2. Create agent actions (sf_create_agent_action) — link each flow as a GenAiFunction
+1. Create flows (sf_create_flow) — AutoLaunchedFlows that perform actions, must be Active with runInMode=SystemModeWithoutSharing
+2. Create agent actions (sf_create_agent_action) — link each flow as a GenAiFunction with LLM-facing schemas
 3. Create agent topics (sf_create_agent_topic) — create GenAiPlugin topics referencing the actions
-4. Create agent planner (sf_create_agent_planner) — create GenAiPlannerBundle linking all topics
+4. Create agent planner (sf_create_agent_planner) — create GenAiPlannerBundle linking all topics (CRITICAL link)
 5. Create agent (sf_create_agent) — create the Bot referencing the planner
 6. Activate the agent (sf_activate_agent)
 
-The agent type is IMMUTABLE after creation — choose carefully (EinsteinCopilot for internal, ExternalCopilot for customer-facing).`,
+The agent type is IMMUTABLE after creation — choose carefully:
+- EinsteinCopilot: internal employee-facing (Lightning sidebar)
+- ExternalCopilot: customer-facing Agentforce Service Agent`,
         inputSchema: CreateAgentSchema,
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, async (params) => {
         const auth = await getAuth();
-        const result = await createAgent(auth, {
-            agentName: params.agentName,
-            label: params.label,
-            description: params.description,
-            type: params.type,
-        });
+        const result = await createAgent(auth, params);
         return resultContent(result);
     });
+
     server.registerTool("sf_create_agent_topic", {
         title: "Create Agentforce Topic (GenAiPlugin)",
-        description: `Creates a Topic (GenAiPlugin) for an Agentforce Agent. Topics define the agent's areas of expertise — what types of user requests it handles. Each topic has a description (routing criteria), scope (what it covers), step-by-step instructions, and references to agent actions.
+        description: `Creates a Topic (GenAiPlugin) for an Agentforce Agent. Topics define the agent's areas of expertise — what types of user requests it handles. Each topic has a routing description, scope, step-by-step instructions, and references to agent actions.
 
 Create topics AFTER creating agent actions (sf_create_agent_action) since topics reference actions by API name.
-Then create the planner bundle (sf_create_agent_planner) to link all topics to the agent.`,
+Then create the planner bundle (sf_create_agent_planner) to link all topics to the agent.
+
+Set escalationEnabled: true to allow this topic to escalate to a human agent.
+Set fallbackTopic to route to another topic when this one cannot handle the request.`,
         inputSchema: CreateAgentTopicSchema,
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, async (params) => {
         const auth = await getAuth();
-        const result = await createAgentTopic(auth, {
-            topicName: params.topicName,
-            label: params.label,
-            description: params.description,
-            scope: params.scope,
-            instructions: params.instructions,
-            actions: params.actions,
-        });
+        const result = await createAgentTopic(auth, params);
         return resultContent(result);
     });
+
     server.registerTool("sf_create_agent_action", {
         title: "Create Agentforce Action (GenAiFunction)",
-        description: `Creates an Agentforce Action (GenAiFunction) linked to a Flow. Actions are the concrete steps an agent takes when handling a topic. The LLM invokes actions based on the topic's instructions and the user's request.
+        description: `Creates an Agentforce Action (GenAiFunction) linked to a Flow or Apex class. Actions are the concrete steps an agent takes when handling a topic.
 
-IMPORTANT: This deploys a complete GenAiFunction bundle including:
+IMPORTANT: Deploys a complete GenAiFunction bundle including:
 - The GenAiFunction metadata (invocationTarget, invocationTargetType, mappingAttributes)
-- input/schema.json — the LLM-facing JSON schema for input parameters (REQUIRED for action invocation)
+- input/schema.json — the LLM-facing JSON schema for input parameters (REQUIRED for invocation)
 - output/schema.json — the LLM-facing JSON schema for output parameters
 
-Without the schema files, the LLM cannot invoke the action. This tool handles all three files automatically.
+Without schema files the LLM cannot invoke the action. This tool generates all three files automatically.
+
+Set invocationTargetType to "ApexClass" for Apex-backed actions (provide apexClassName instead of flowApiName).
+For Flow actions (default): the flow must be Active with runInMode=SystemModeWithoutSharing.
 
-Create actions BEFORE topics (topics reference actions by API name).
-The referenced flow MUST exist and be Active with runInMode=SystemModeWithoutSharing.`,
+Type matching: inputs/outputs type MUST match the flow variable type — use "Currency" for Currency fields, "Date" for Date fields, etc. Using "Text" for a Currency field causes "incorrect format" errors.
+
+Create actions BEFORE topics (topics reference actions by API name).`,
         inputSchema: CreateAgentActionSchema,
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, async (params) => {
@@ -70,7 +79,9 @@ The referenced flow MUST exist and be Active with runInMode=SystemModeWithoutSha
                 actionName: params.actionName,
                 label: params.label,
                 description: params.description,
+                invocationTargetType: params.invocationTargetType,
                 flowApiName: params.flowApiName,
+                apexClassName: params.apexClassName,
                 inputs: params.inputs ?? [],
                 outputs: params.outputs ?? [],
             }, API_VERSION);
@@ -82,6 +93,7 @@ The referenced flow MUST exist and be Active with runInMode=SystemModeWithoutSha
             return resultContent({ success: false, message: err instanceof Error ? err.message : String(err) });
         }
     });
+
     server.registerTool("sf_create_agent_planner", {
         title: "Create Agentforce Planner Bundle (GenAiPlannerBundle)",
         description: `Creates a GenAiPlannerBundle that connects topics to the agent's planning engine.
@@ -89,38 +101,185 @@ The referenced flow MUST exist and be Active with runInMode=SystemModeWithoutSha
 The planner bundle is the CRITICAL link between the Bot and its topics (GenAiPlugins). Without it, the agent will have 0 topics visible and cannot route requests or invoke actions.
 
 Create the planner bundle AFTER creating all topics (sf_create_agent_topic) and BEFORE creating the agent (sf_create_agent).
-Then reference this planner's API name when calling sf_create_agent.`,
+Then reference this planner's API name when calling sf_create_agent.
+
+For Knowledge-grounded agents, set dataLibraryName to the API name of a Data Library (Knowledge Base).`,
         inputSchema: CreateAgentPlannerSchema,
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, async (params) => {
         const auth = await getAuth();
-        const result = await createAgentPlanner(auth, {
-            plannerName: params.plannerName,
-            label: params.label,
-            description: params.description,
-            topicNames: params.topicNames,
-        });
+        const result = await createAgentPlanner(auth, params);
         return resultContent(result);
     });
+
     server.registerTool("sf_activate_agent", {
         title: "Activate Agentforce Agent",
-        description: `Activates an Agentforce Agent so it is available to users. The agent must be inactive (deactivated) before you can make configuration changes like adding/removing topics or actions. After making changes, re-activate with this tool.`,
-        inputSchema: { type: "object", properties: { agentApiName: { type: "string", description: "API name of the agent to activate, e.g. 'CRM_Record_Creator'" } }, required: ["agentApiName"] },
+        description: `Activates an Agentforce Agent so it is available to users. After making configuration changes (adding/removing topics or actions), re-activate with this tool.`,
+        inputSchema: ActivateAgentSchema,
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, async (params) => {
         const auth = await getAuth();
         const result = await activateAgent(auth, params.agentApiName);
         return resultContent(result);
     });
+
     server.registerTool("sf_deactivate_agent", {
         title: "Deactivate Agentforce Agent",
         description: `Deactivates an Agentforce Agent so configuration changes can be made. You must deactivate an agent before modifying its topics, actions, or planner configuration. After making changes, re-activate with sf_activate_agent.`,
-        inputSchema: { type: "object", properties: { agentApiName: { type: "string", description: "API name of the agent to deactivate, e.g. 'CRM_Record_Creator'" } }, required: ["agentApiName"] },
+        inputSchema: DeactivateAgentSchema,
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, async (params) => {
         const auth = await getAuth();
         const result = await deactivateAgent(auth, params.agentApiName);
         return resultContent(result);
     });
+
+    // ─── READ ────────────────────────────────────────────────────────────────
+    server.registerTool("sf_get_agent", {
+        title: "Get Agentforce Agent Configuration",
+        description: `Retrieves the full configuration of an Agentforce Agent including activation status, all GenAiPlugin topics, GenAiFunction actions, and GenAiPlannerBundle planners in the org.
+
+Returns:
+- agent.status: Active / Inactive / Unknown
+- topics[]: all GenAiPlugin topics (name, label, lastModified)
+- actions[]: all GenAiFunction actions (name, label, lastModified)
+- planners[]: all GenAiPlannerBundle planners (name, label, lastModified)
+
+Note: topics/actions/planners list all components in the org (not filtered to this agent). Use sf_get_agent_logs to see which are actively routing.`,
+        inputSchema: GetAgentSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await getAgent(auth, params.agentApiName);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_list_agents", {
+        title: "List All Agentforce Agents",
+        description: `Lists all Agentforce Agents (Bots) in the org with their API name, label, activation status, and last modified date.
+
+Use this to discover agents before updating, testing, or deleting them.`,
+        inputSchema: ListAgentsSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (_params) => {
+        const auth = await getAuth();
+        const result = await listAgents(auth);
+        return resultContent(result);
+    });
+
+    // ─── UPDATE ──────────────────────────────────────────────────────────────
+    server.registerTool("sf_update_agent_topic", {
+        title: "Update Agentforce Topic (GenAiPlugin)",
+        description: `Updates an existing GenAiPlugin topic in-place without deleting and recreating it. Automatically deactivates the agent before the update and reactivates it after.
+
+Use this to change a topic's routing description, scope, instructions, or linked actions.
+All fields provided replace the existing values (instructions and actions arrays are replaced entirely).
+
+The agent must exist and be accessible — provide agentApiName for automatic deactivate/reactivate.`,
+        inputSchema: UpdateAgentTopicSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const { agentApiName, ...topicParams } = params;
+        const result = await updateAgentTopic(auth, topicParams, agentApiName);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_update_agent_action", {
+        title: "Update Agentforce Action (GenAiFunction)",
+        description: `Updates an existing GenAiFunction action and regenerates its LLM-facing input/output schema files. Uses zip-based metadata deploy (same as sf_create_agent_action) since GenAiFunction bundles require schema files.
+
+Use this to change an action's description, input/output parameters, or switch from one flow to another.
+All fields provided replace the existing values.
+
+After updating an action, the topics that reference it will automatically use the new schema on the next agent invocation.`,
+        inputSchema: UpdateAgentActionSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        try {
+            const base64Zip = await buildGenAiActionZip({
+                actionName: params.actionName,
+                label: params.label,
+                description: params.description,
+                invocationTargetType: params.invocationTargetType,
+                flowApiName: params.flowApiName,
+                apexClassName: params.apexClassName,
+                inputs: params.inputs ?? [],
+                outputs: params.outputs ?? [],
+            }, API_VERSION);
+            const deployId = await deployZip(auth, base64Zip);
+            const result = await pollDeployStatus(auth, deployId, 120_000);
+            return resultContent(result);
+        }
+        catch (err) {
+            return resultContent({ success: false, message: err instanceof Error ? err.message : String(err) });
+        }
+    });
+
+    // ─── DELETE ──────────────────────────────────────────────────────────────
+    server.registerTool("sf_delete_agent", {
+        title: "Delete Agentforce Agent",
+        description: `Cleanly deletes an Agentforce Agent (Bot) and optionally its related GenAiPlugin topics and GenAiFunction actions.
+
+Deletion order (to avoid dependency errors):
+1. Deactivates the agent
+2. Reads the Bot → finds GenAiPlannerBundle name
+3. Reads the GenAiPlannerBundle → finds GenAiPlugin topic names (if deleteTopics: true)
+4. Reads each GenAiPlugin → finds GenAiFunction action names (if deleteActions: true)
+5. Deletes GenAiFunctions → GenAiPlugins → GenAiPlannerBundle → Bot
+
+Set deleteTopics: true to also delete the agent's topics.
+Set deleteActions: true to also delete the actions (requires deleteTopics: true since action names are discovered via topics).
+
+WARNING: Deleting actions/topics affects all agents that reference them.`,
+        inputSchema: DeleteAgentSchema,
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await deleteAgent(auth, params);
+        return resultContent(result);
+    });
+
+    // ─── TEST & DEBUG ─────────────────────────────────────────────────────────
+    server.registerTool("sf_test_agent", {
+        title: "Send Test Message to Agentforce Agent",
+        description: `Sends a test message to an Agentforce Agent via the Einstein Agent API and returns the agent's response. Useful for end-to-end testing without opening the Salesforce UI.
+
+Flow:
+1. Bootstraps an Agentforce session (POST /agentforce/bootstrap/nameduser)
+2. Creates a session (POST /einstein/ai-agent/v1/agents/{id}/sessions)
+3. Sends the message and returns the agent's reply text
+
+The agent must be Active. Set orgUrl if your My Domain URL differs from SF_INSTANCE_URL.
+
+Returns: response text, sessionId, and success status.`,
+        inputSchema: TestAgentSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await testAgent(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_get_agent_logs", {
+        title: "Get Agentforce Debug Logs",
+        description: `Queries ConversationDefinitionEventLog for Agentforce agent debug information. Shows topic routing decisions, action executions, and errors.
+
+Key event types to look for:
+- TopicClassificationSuccess — agent routed to a topic (routing is working)
+- ActionExecuted — agent invoked an action (full pipeline working)
+- TopicClassificationFail / Error — routing or execution failed
+
+If you see TopicClassificationSuccess but NO ActionExecuted events, the agent is routing correctly but cannot invoke actions — check that GenAiFunction schema files exist (redeploy with sf_create_agent_action).
+
+Requires ConversationDefinitionEventLog access (Event Monitoring or Agentforce debug enabled in the org).`,
+        inputSchema: GetAgentLogsSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await getAgentLogs(auth, params);
+        return resultContent(result);
+    });
 }
 //# sourceMappingURL=agentforce.js.map

package/dist/tools/apex.js

@@ -1,6 +1,6 @@
-import { CreateApexClassSchema, CreateApexTriggerSchema, CreateApexTestClassSchema, RunApexTestsSchema, ExecuteAnonymousApexSchema, } from "../schemas/index.js";
-import { getAuth } from "../services/salesforce.js";
-import { buildApexClassZip, buildApexTriggerZip, deployZip, pollDeployStatus, } from "../services/deployment.js";
+import { CreateApexClassSchema, CreateApexTriggerSchema, CreateApexTestClassSchema, RunApexTestsSchema, ExecuteAnonymousApexSchema, UpdateApexClassSchema, GetApexClassSchema, GetCodeCoverageSchema, CreateVisualforcePageSchema, CreateAuraComponentSchema, } from "../schemas/index.js";
+import { getAuth, getApexClass, getCodeCoverage, API_VERSION } from "../services/salesforce.js";
+import { buildApexClassZip, buildApexTriggerZip, buildVFPageZip, buildAuraZip, deployZip, pollDeployStatus, } from "../services/deployment.js";
 import { executeAnonymousApex, runApexTests, } from "../services/tooling.js";
 import { resultContent } from "./utils.js";
 export function registerApexTools(server) {
@@ -91,5 +91,73 @@ export function registerApexTools(server) {
         const result = await executeAnonymousApex(auth, params.apexCode);
         return resultContent(result);
     });
+    server.registerTool("sf_update_apex_class", {
+        title: "Update Apex Class",
+        description: `Updates an existing Apex class by redeploying it with new source code. The class body is fully replaced — provide the complete class source. The deploy uses zip-based Metadata API for immediate deployment.`,
+        inputSchema: UpdateApexClassSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        try {
+            const base64Zip = await buildApexClassZip(params.className, params.classBody, API_VERSION);
+            const deployId = await deployZip(auth, base64Zip);
+            const result = await pollDeployStatus(auth, deployId, 120_000);
+            return resultContent(result);
+        } catch (err) {
+            return resultContent({ success: false, message: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    server.registerTool("sf_get_apex_class", {
+        title: "Get Apex Class Source",
+        description: `Retrieves the source code and metadata of an Apex class from the org using the Tooling API. Returns the class body, API version, and status. Useful for reviewing existing code before making changes.`,
+        inputSchema: GetApexClassSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await getApexClass(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_get_code_coverage", {
+        title: "Get Apex Code Coverage",
+        description: `Retrieves Apex code coverage percentages from the last test run using the Tooling API. Returns covered lines, uncovered lines, and coverage percentage per class. Filter by class name or retrieve all classes.`,
+        inputSchema: GetCodeCoverageSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await getCodeCoverage(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_visualforce_page", {
+        title: "Create Visualforce Page",
+        description: `Deploys a Visualforce page to the org using zip-based Metadata API. Provide the page name (no spaces) and the full Visualforce markup. Visualforce pages use the apex: and c: tag libraries and can reference Apex controllers.`,
+        inputSchema: CreateVisualforcePageSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        try {
+            const base64Zip = await buildVFPageZip(params.pageName, params.markup, API_VERSION);
+            const deployId = await deployZip(auth, base64Zip);
+            const result = await pollDeployStatus(auth, deployId, 120_000);
+            return resultContent(result);
+        } catch (err) {
+            return resultContent({ success: false, message: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    server.registerTool("sf_create_aura_component", {
+        title: "Create Aura Component Bundle",
+        description: `Deploys an Aura (Lightning) component bundle using zip-based Metadata API. Provide the component name and markup (.cmp file). Optionally include a controller, helper, and CSS style. Aura components are the predecessor to LWC and still supported for complex use cases.`,
+        inputSchema: CreateAuraComponentSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        try {
+            const base64Zip = await buildAuraZip(params.componentName, params.markup, params.controller, params.helper, params.style, API_VERSION);
+            const deployId = await deployZip(auth, base64Zip);
+            const result = await pollDeployStatus(auth, deployId, 120_000);
+            return resultContent(result);
+        } catch (err) {
+            return resultContent({ success: false, message: err instanceof Error ? err.message : String(err) });
+        }
+    });
 }
 //# sourceMappingURL=apex.js.map

package/dist/tools/automation.js

@@ -1,5 +1,5 @@
-import { CreateEmailAlertSchema, CreatePlatformEventSchema, CreateAssignmentRuleSchema, CreateEscalationRuleSchema, CreateAutoResponseRuleSchema, CreateMatchingRuleSchema, CreateDuplicateRuleSchema, CreateApexEmailServiceSchema, CreateScheduledJobSchema, } from "../schemas/index.js";
-import { getAuth, createEmailAlert, createPlatformEvent, createAssignmentRule, createAutoResponseRule, createMatchingRule, createDuplicateRule, } from "../services/salesforce.js";
+import { CreateEmailAlertSchema, CreatePlatformEventSchema, CreateAssignmentRuleSchema, CreateEscalationRuleSchema, CreateAutoResponseRuleSchema, CreateMatchingRuleSchema, CreateDuplicateRuleSchema, CreateApexEmailServiceSchema, CreateScheduledJobSchema, ActivateFlowSchema, CreateQuickActionSchema, } from "../schemas/index.js";
+import { getAuth, createEmailAlert, createPlatformEvent, createAssignmentRule, createAutoResponseRule, createMatchingRule, createDuplicateRule, activateFlow, createQuickAction, } from "../services/salesforce.js";
 import { createApexEmailService, createScheduledJob, } from "../services/tooling.js";
 import { resultContent } from "./utils.js";
 export function registerAutomationTools(server) {
@@ -182,5 +182,28 @@ export function registerAutomationTools(server) {
         const result = await createScheduledJob(auth, params.className, params.jobName, params.cronExpression);
         return resultContent(result);
     });
+    server.registerTool("sf_activate_flow", {
+        title: "Activate a Flow",
+        description: `Activates the latest version of a Flow via the Tooling API. Flow must already exist in the org. The flow's latest version will be set as the active version. Use after creating or updating a flow to make it available.`,
+        inputSchema: ActivateFlowSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await activateFlow(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_quick_action", {
+        title: "Create Quick Action",
+        description: `Creates a Quick Action (global or object-specific) for record creation, updates, logging calls, sending emails, or launching flows from record pages and the global action bar.
+
+Action types: Create, Update, LogACall, SendEmail, Flow, Visualforce.
+For object-specific actions, provide objectApiName. For global actions, omit it.`,
+        inputSchema: CreateQuickActionSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createQuickAction(auth, params);
+        return resultContent(result);
+    });
 }
 //# sourceMappingURL=automation.js.map

package/dist/tools/data.js

@@ -0,0 +1,86 @@
+import { CreateUserSchema, UpdateUserSchema, AssignQueueMemberSchema, CreatePublicGroupSchema, QueryRecordsSchema, CreateRecordSchema, UpdateRecordSchema, BulkImportRecordsSchema, } from "../schemas/index.js";
+import { getAuth, createUser, updateUser, assignQueueMember, createPublicGroup, queryRecords, createRecord, updateRecord, bulkImportRecords, } from "../services/salesforce.js";
+import { resultContent } from "./utils.js";
+export function registerDataTools(server) {
+    server.registerTool("sf_create_user", {
+        title: "Create Salesforce User",
+        description: `Creates a new Salesforce user via the REST API. Requires username (must be unique and email-like), lastName, email, and profileName. The profile must already exist. Optionally assign a role by roleApiName (DeveloperName of the UserRole). The user will receive a welcome email unless email confirmations are suppressed in org settings.`,
+        inputSchema: CreateUserSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createUser(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_update_user", {
+        title: "Update Salesforce User",
+        description: `Updates an existing Salesforce user's properties via the REST API. Look up the user by username and update fields like firstName, lastName, email, title, department, phone, or isActive (to deactivate/reactivate). Only fields you provide are updated.`,
+        inputSchema: UpdateUserSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await updateUser(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_assign_queue_member", {
+        title: "Add User to Queue",
+        description: `Adds a user to an existing Queue (GroupMember SObject) by username and queue DeveloperName. The queue must already exist (create via sf_create_queue). Users in queues can be assigned records and receive queue notification emails.`,
+        inputSchema: AssignQueueMemberSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await assignQueueMember(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_public_group", {
+        title: "Create Public Group",
+        description: `Creates a Public Group (Group SObject with Type=Regular) for sharing rules, email distribution, or queue membership. Public groups can include users, roles, and other groups. Use as a sharing target in sf_create_sharing_rule.`,
+        inputSchema: CreatePublicGroupSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createPublicGroup(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_query_records", {
+        title: "Query Records (SOQL)",
+        description: `Executes a SOQL query against the org and returns matching records. Provide either a full SOQL string (soql param) or individual parameters (objectApiName, fields, whereClause, orderBy, limit). Use for reading data, checking existing records before creating, or verifying changes.`,
+        inputSchema: QueryRecordsSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await queryRecords(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_record", {
+        title: "Create SObject Record",
+        description: `Creates a single SObject record via the Salesforce REST API. Provide the object API name and a fields object with field API names and values. For bulk creation (100+ records), use sf_bulk_import_records instead.`,
+        inputSchema: CreateRecordSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createRecord(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_update_record", {
+        title: "Update SObject Record",
+        description: `Updates an existing SObject record by record ID via the Salesforce REST API. Provide the object API name, the 15 or 18 character record ID, and the fields to update. Only provided fields are changed — omitted fields retain their current values.`,
+        inputSchema: UpdateRecordSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await updateRecord(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_bulk_import_records", {
+        title: "Bulk Import Records (Bulk API 2.0)",
+        description: `Bulk imports records using the Salesforce Bulk API 2.0. Supports insert, upsert, update, and delete operations on large datasets (thousands to millions of records). Provide CSV data with a header row. For upsert, set externalIdField to the field used for matching. Polls until the job completes and returns success/failure counts.`,
+        inputSchema: BulkImportRecordsSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await bulkImportRecords(auth, params);
+        return resultContent(result);
+    });
+}
+//# sourceMappingURL=data.js.map

package/dist/tools/deployment.js

@@ -1,5 +1,5 @@
-import { CreateOutboundChangeSetSchema, AddToChangeSetSchema, DeployMetadataSchema, CheckDeployStatusSchema, RetrieveMetadataSchema, } from "../schemas/index.js";
-import { getAuth } from "../services/salesforce.js";
+import { CreateOutboundChangeSetSchema, AddToChangeSetSchema, DeployMetadataSchema, CheckDeployStatusSchema, RetrieveMetadataSchema, ValidateDeploymentSchema, ListMetadataSchema, } from "../schemas/index.js";
+import { getAuth, listMetadataForTool } from "../services/salesforce.js";
 import { buildGenericDeployZip, deployZip, pollDeployStatus, checkDeployStatus, retrieveMetadata, } from "../services/deployment.js";
 import { createOutboundChangeSet, addComponentsToChangeSet, } from "../services/tooling.js";
 import { resultContent } from "./utils.js";
@@ -33,17 +33,18 @@ export function registerDeploymentTools(server) {
     });
     server.registerTool("sf_deploy_metadata", {
         title: "Deploy Metadata",
-        description: `Deploys a set of metadata components directly to the org using the Metadata API SOAP deploy operation. Builds a package.xml and deployment zip in memory. Supports validate-only (checkOnly:true) for pre-deployment validation without making changes. Specify runTests to execute test classes during deployment (required for production). Polls until complete or timeout.`,
+        description: `Deploys a set of metadata components directly to the org using the Metadata API SOAP deploy operation. Builds a package.xml and deployment zip in memory. Supports validate-only (checkOnly:true) for pre-deployment validation without making changes. Specify runTests to execute test classes during deployment (required for production). Set testLevel to RunSpecifiedTests, RunLocalTests, or RunAllTestsInOrg. Polls until complete or timeout.`,
         inputSchema: DeployMetadataSchema,
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, async (params) => {
         const auth = await getAuth();
         try {
-            const base64Zip = await buildGenericDeployZip(params.components, "62.0");
+            const base64Zip = await buildGenericDeployZip(params.components, "66.0");
             const deployId = await deployZip(auth, base64Zip, {
                 checkOnly: params.checkOnly,
                 runTests: params.runTests,
                 rollbackOnError: params.rollbackOnError,
+                testLevel: params.testLevel,
             });
             const result = await pollDeployStatus(auth, deployId, params.waitMinutes * 60 * 1000);
             return resultContent({
@@ -85,5 +86,40 @@ export function registerDeploymentTools(server) {
         const result = await retrieveMetadata(auth, params.components);
         return resultContent(result);
     });
+    server.registerTool("sf_validate_deployment", {
+        title: "Validate Deployment (Check-Only)",
+        description: `Runs a check-only deployment that validates metadata components against the org without making any changes. Equivalent to sf_deploy_metadata with checkOnly:true. Use before deploying to production to catch errors and test failures without risk. Specify testLevel to control which tests run during validation.`,
+        inputSchema: ValidateDeploymentSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        try {
+            const base64Zip = await buildGenericDeployZip(params.components, "66.0");
+            const deployId = await deployZip(auth, base64Zip, {
+                checkOnly: true,
+                runTests: params.runTests,
+                rollbackOnError: true,
+                testLevel: params.testLevel,
+            });
+            const result = await pollDeployStatus(auth, deployId, (params.waitMinutes ?? 10) * 60 * 1000);
+            return resultContent({
+                success: result.success,
+                message: `[VALIDATE ONLY] ${result.message}`,
+                ...(result.success ? { fullName: deployId, created: false } : {})
+            });
+        } catch (err) {
+            return resultContent({ success: false, message: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    server.registerTool("sf_list_metadata", {
+        title: "List Metadata Components",
+        description: `Lists all metadata components of a given type in the org (e.g., ApexClass, CustomObject, Flow, PermissionSet). Returns full names, file names, and last modified dates. Useful for discovering what metadata exists in the org before retrieving or deploying.`,
+        inputSchema: ListMetadataSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await listMetadataForTool(auth, params.metadataType);
+        return resultContent(result);
+    });
 }
 //# sourceMappingURL=deployment.js.map