salesforce-metadata-mcp 2.2.0 → 2.3.0

package/dist/tools/index.js

@@ -12,6 +12,8 @@ import { registerMcpTools } from "./mcp.js";
 import { registerIntegrationTools } from "./integrations.js";
 import { registerReportTools } from "./reports.js";
 import { registerDataTools } from "./data.js";
+import { registerOmniStudioTools } from "./omnistudio.js";
+import { registerOmniChannelTools } from "./omnichannel.js";
 export function registerTools(server) {
     registerMetadataTools(server);
     registerObjectTools(server);
@@ -27,5 +29,7 @@ export function registerTools(server) {
     registerIntegrationTools(server);
     registerReportTools(server);
     registerDataTools(server);
+    registerOmniStudioTools(server);
+    registerOmniChannelTools(server);
 }
 //# sourceMappingURL=index.js.map

package/dist/tools/omnichannel.js

@@ -0,0 +1,279 @@
+import {
+    CreateServiceChannelSchema, CreateRoutingConfigurationSchema, CreateQueueRoutingConfigSchema,
+    CreatePresenceConfigurationSchema, CreatePresenceStatusSchema, AssignPresenceStatusSchema,
+    CreateSkillSchema, AssignSkillToAgentSchema, CreateServiceTerritorySchema, CreateWorkTypeSchema,
+    CreateMessagingChannelSchema, CreateChatButtonSchema, CreateEmbeddedServiceSchema, CreateBotRoutingSchema,
+} from "../schemas/index.js";
+import {
+    getAuth,
+    createServiceChannel, createRoutingConfiguration, createQueueRoutingConfig,
+    createPresenceConfiguration, createPresenceStatus, assignPresenceStatus,
+    createSkill, assignSkillToAgent, createServiceTerritory, createWorkType,
+    createMessagingChannel, createChatButton, createEmbeddedService, createBotRouting,
+} from "../services/salesforce.js";
+import { resultContent } from "./utils.js";
+
+export function registerOmniChannelTools(server) {
+    // ─── SERVICE CHANNELS & ROUTING ───────────────────────────────────────────
+    server.registerTool("sf_create_service_channel", {
+        title: "Create OmniChannel Service Channel",
+        description: `Creates an OmniChannel Service Channel that connects work items from a Salesforce object to the OmniChannel routing engine.
+
+channelType options: Case, Chat, Messaging, Voice, Email, SocialPost, Custom
+
+relatedObjectApiName: the Salesforce object this channel routes (e.g. "Case", "LiveChatTranscript", "MessagingSession"). Required for Custom type.
+
+capacity: maximum number of simultaneous work items an agent can handle on this channel (default 1).
+
+Service Channels are referenced by Routing Configurations and Presence Configurations.`,
+        inputSchema: CreateServiceChannelSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createServiceChannel(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_create_routing_configuration", {
+        title: "Create OmniChannel Routing Configuration",
+        description: `Creates a Routing Configuration that defines how work items are assigned to agents.
+
+routingModel options:
+- LeastActive: routes to the agent with the fewest active work items
+- MostAvailable: routes to the agent with the most available capacity
+- ExternalRouting: custom routing via Apex or external system
+
+capacity: agent capacity consumed per work item (1–100)
+priority: routing priority (lower number = higher priority, range 1–10)
+unitType: Percentage or Throughput (how capacity is measured)
+pushTimeout: seconds before a declined/unanswered item is re-queued (optional)
+
+After creating, link it to a queue with sf_create_queue_routing_config.`,
+        inputSchema: CreateRoutingConfigurationSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createRoutingConfiguration(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_create_queue_routing_config", {
+        title: "Link Routing Configuration to Queue",
+        description: `Associates a Routing Configuration with an existing Queue, enabling OmniChannel routing for that queue.
+
+After creating a Routing Configuration (sf_create_routing_configuration), use this tool to link it to the Queue that holds the work items. Work items assigned to the queue will then be routed to agents using the specified routing model.
+
+queueDeveloperName: the API name of the Queue (DeveloperName, not label)
+routingConfigName: the API name of the Routing Configuration to link`,
+        inputSchema: CreateQueueRoutingConfigSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createQueueRoutingConfig(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_create_presence_configuration", {
+        title: "Create OmniChannel Presence Configuration",
+        description: `Creates a Presence Configuration (PresenceUserConfig) that controls which Service Channels agents can handle and their total work capacity.
+
+capacity: total capacity units available to agents with this configuration
+serviceChannels: list of Service Channel API names the agents can work on
+allowAgentsToChangeStatus: whether agents can manually change their presence status
+
+Assign this configuration to agents via their Profile or Permission Set.`,
+        inputSchema: CreatePresenceConfigurationSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createPresenceConfiguration(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_create_presence_status", {
+        title: "Create OmniChannel Presence Status",
+        description: `Creates a Presence Status that agents can set to indicate their availability.
+
+statusType:
+- Online: agent is available for all assigned channels
+- Busy: agent is limited to specific channels
+- Offline: agent receives no work items
+
+serviceChannels: for Busy status, list which channels remain active.
+
+After creating, assign the status to profiles/permission sets with sf_assign_presence_status.`,
+        inputSchema: CreatePresenceStatusSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createPresenceStatus(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_assign_presence_status", {
+        title: "Assign Presence Status to Profiles/Permission Sets",
+        description: `Grants access to a Presence Status for the specified Profiles and/or Permission Sets. Agents can only select presence statuses that are assigned to their profile or permission set.
+
+profiles: list of Profile names (e.g. ["Standard User", "Service Agent"])
+permissionSets: list of Permission Set API names
+
+Either profiles or permissionSets must be provided (or both).`,
+        inputSchema: AssignPresenceStatusSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await assignPresenceStatus(auth, params);
+        return resultContent(result);
+    });
+
+    // ─── SKILLS & FIELD SERVICE ───────────────────────────────────────────────
+    server.registerTool("sf_create_skill", {
+        title: "Create OmniChannel / Field Service Skill",
+        description: `Creates a Skill that can be assigned to service agents. Skills are used for:
+- OmniChannel skill-based routing (route work to agents with required skills)
+- Field Service Lightning (assign skills to resources, skills to work types)
+
+After creating a skill, assign it to agents with sf_assign_skill_to_agent.`,
+        inputSchema: CreateSkillSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createSkill(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_assign_skill_to_agent", {
+        title: "Assign Skill to Service Agent",
+        description: `Assigns a Skill to a Salesforce user (service agent) with a skill level rating. Creates a ServiceResource for the user if one does not already exist, then creates a ServiceResourceSkill record.
+
+skillName: the API name (DeveloperName) of the skill to assign
+username: the Salesforce username (e.g. agent@example.com) or user ID
+skillLevel: proficiency level from 0 to 10 (default 5)
+
+ServiceResource is the Field Service / OmniChannel representation of a user as a workable resource.`,
+        inputSchema: AssignSkillToAgentSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await assignSkillToAgent(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_create_service_territory", {
+        title: "Create Field Service Service Territory",
+        description: `Creates a Service Territory for Field Service Lightning. Territories define the geographic areas or organizational divisions where field service resources operate.
+
+isActive: set true to make the territory immediately available for scheduling
+operatingHoursName: API name of an existing OperatingHours record to set business hours
+Address fields (street, city, state, country, postalCode): optional location for the territory center`,
+        inputSchema: CreateServiceTerritorySchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createServiceTerritory(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_create_work_type", {
+        title: "Create Field Service Work Type",
+        description: `Creates a Work Type that defines a category of field service job. Work Types set default durations, block times, and skill requirements for work orders.
+
+estimatedDuration: expected time to complete the work
+durationType: Minutes, Hours, or Days
+blockTimeBeforeWork: travel/prep time before the appointment
+blockTimeAfterWork: cleanup/travel time after the appointment
+skillRequirements: array of { skillName, skillLevel } — skills required on the resource to perform this work type`,
+        inputSchema: CreateWorkTypeSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createWorkType(auth, params);
+        return resultContent(result);
+    });
+
+    // ─── MESSAGING, CHAT & VOICE ──────────────────────────────────────────────
+    server.registerTool("sf_create_messaging_channel", {
+        title: "Create Messaging Channel",
+        description: `Creates a Messaging Channel for Salesforce digital engagement (SMS, WhatsApp, Facebook Messenger, Apple Messages for Business, etc.).
+
+channelType options: SMS, WhatsApp, Facebook, AppleBusinessChat, Line, GoogleBusinessMessages, EinsteinBotChannel, WebChat
+
+phoneNumber: E.164 format phone number for SMS/WhatsApp channels (e.g. +15551234567)
+pageId: Facebook Page ID or equivalent external platform identifier
+
+routingType: Queue (route to a queue) or Bot (route to an Einstein Bot first)
+queueName: required when routingType=Queue
+botName: required when routingType=Bot (bot handles initial messages)
+
+After creating, configure the channel with sf_create_embedded_service to add it to a site.`,
+        inputSchema: CreateMessagingChannelSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createMessagingChannel(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_create_chat_button", {
+        title: "Create Live Agent Chat Button",
+        description: `Creates a Live Chat button (LiveChatButton) that can be embedded on websites to start chat sessions with agents.
+
+routingType: Choice (skills-based) or Queue (queue-based routing)
+queueName: the Queue to route chats to (for Queue routing)
+botName: an Einstein Bot to handle chats initially (optional)
+windowLanguage: display language for the chat window (e.g. "en_US", "fr", "de")
+inviteRenderer: name of a custom Visualforce page for chat invitations
+customAgentName: agent display name shown to website visitors
+optionsHasTimeoutAlert: show alert if no agent available within timeout period
+
+After creating, embed the chat button on a site with sf_create_embedded_service.`,
+        inputSchema: CreateChatButtonSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createChatButton(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_create_embedded_service", {
+        title: "Create Embedded Service Deployment",
+        description: `Creates an Embedded Service deployment (EmbeddedServiceConfig) that bundles a chat button or messaging channel into a web snippet for embedding on websites or Experience Cloud sites.
+
+channelType: Chat (uses a LiveChatButton) or Messaging (uses a MessagingChannel)
+chatButtonName: required for Chat type — the LiveChatButton API name
+messagingChannelName: required for Messaging type — the MessagingChannel API name
+site: the Experience Cloud site or Salesforce Site API name to associate with
+
+Branding:
+- primaryColor: main brand color (hex, e.g. "#0070D2")
+- secondaryColor: secondary/header color
+- fontName: web font name (e.g. "Salesforce Sans")
+
+After creation, get the deployment code snippet from Setup → Embedded Service Deployments.`,
+        inputSchema: CreateEmbeddedServiceSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createEmbeddedService(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_create_bot_routing", {
+        title: "Configure Bot Escalation Routing",
+        description: `Configures an Einstein Bot to transfer conversations to a human agent queue when escalation conditions are met. Updates the BotVersion with a Transfer dialog.
+
+botName: the Bot API name (DeveloperName)
+transferToQueueName: the Queue API name to transfer escalated conversations to
+transferMessage: message shown to the customer during transfer (default: "Connecting you to an agent...")
+escalationConditions: array of { trigger, action } pairs. Triggers: agentRequested, noResponse, fallback. Actions: TransferToQueue.
+
+This tool finds the latest BotVersion for the specified bot and adds the transfer dialog. The bot must already exist (created via Setup or sf_create_agent).`,
+        inputSchema: CreateBotRoutingSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createBotRouting(auth, params);
+        return resultContent(result);
+    });
+}
+//# sourceMappingURL=omnichannel.js.map

package/dist/tools/omnistudio.js

@@ -0,0 +1,280 @@
+import {
+    CreateFlexCardSchema, UpdateFlexCardSchema, ActivateFlexCardSchema, GetFlexCardSchema,
+    CreateOmniScriptSchema, UpdateOmniScriptSchema, ActivateOmniScriptSchema, GetOmniScriptSchema,
+    CreateDataRaptorSchema, GetDataRaptorSchema,
+    CreateIntegrationProcedureSchema, UpdateIntegrationProcedureSchema,
+    GetIntegrationProcedureSchema, ActivateIntegrationProcedureSchema,
+    CreateCalculationMatrixSchema, CreateCalculationProcedureSchema,
+} from "../schemas/index.js";
+import {
+    getAuth,
+    createFlexCard, updateFlexCard, activateFlexCard, getFlexCard,
+    createOmniScript, updateOmniScript, activateOmniScript, getOmniScript,
+    createDataRaptor, getDataRaptor,
+    createIntegrationProcedure, updateIntegrationProcedure, activateIntegrationProcedure, getIntegrationProcedure,
+    createCalculationMatrix, createCalculationProcedure,
+} from "../services/salesforce.js";
+import { resultContent } from "./utils.js";
+
+export function registerOmniStudioTools(server) {
+    // ─── FLEXCARDS ────────────────────────────────────────────────────────────
+    server.registerTool("sf_create_flexcard", {
+        title: "Create OmniStudio FlexCard",
+        description: `Creates an OmniStudio FlexCard (OmniUiCard metadata type). FlexCards display contextual data on Lightning pages and Experience Cloud sites.
+
+A FlexCard defines:
+- A data source (SOQL query, DataRaptor, Integration Procedure, Apex, or None)
+- Fields to display from the data source
+- Actions the user can take (navigate, launch OmniScript, open URL, start Flow)
+- States (card variations based on data conditions)
+
+The card is created in inactive state. Use sf_activate_flexcard to activate it after creation.
+
+dataSourceType options:
+- SOQL: provide a dataSourceName with a SOQL query string
+- DataRaptor: provide the DataRaptor interface name
+- IntegrationProcedure: provide the Integration Procedure key (Type_SubType)
+- Apex: provide the Apex class name
+- None: no data source (static card)`,
+        inputSchema: CreateFlexCardSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createFlexCard(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_update_flexcard", {
+        title: "Update OmniStudio FlexCard",
+        description: `Updates an existing OmniStudio FlexCard (OmniUiCard). Reads the current definition, merges the provided changes, and redeploys.
+
+Provide only the fields you want to change. The card will be deactivated automatically if active — use sf_activate_flexcard to reactivate after the update.
+
+All fields arrays (fields, actions, states) are replaced entirely if provided.`,
+        inputSchema: UpdateFlexCardSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await updateFlexCard(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_activate_flexcard", {
+        title: "Activate OmniStudio FlexCard",
+        description: `Activates an OmniStudio FlexCard so it is visible on Lightning pages and Experience Cloud sites.
+
+Reads the existing FlexCard definition and redeploys it with isActive=true. The card must already exist (created with sf_create_flexcard).`,
+        inputSchema: ActivateFlexCardSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await activateFlexCard(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_get_flexcard", {
+        title: "Get OmniStudio FlexCard",
+        description: `Retrieves the configuration of an OmniStudio FlexCard including its data source, fields, actions, states, and activation status.`,
+        inputSchema: GetFlexCardSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await getFlexCard(auth, params);
+        return resultContent(result);
+    });
+
+    // ─── OMNISCRIPTS ──────────────────────────────────────────────────────────
+    server.registerTool("sf_create_omniscript", {
+        title: "Create OmniStudio OmniScript",
+        description: `Creates an OmniStudio OmniScript — a guided interaction flow for collecting data or performing processes.
+
+OmniScripts are identified by Type + SubType + Language (e.g. AccountOpening / Personal / English). The fullName becomes Type_SubType_Language.
+
+The script is created inactive with the specified elements. Complex element configuration (branching logic, custom LWC overrides, remote actions) should be finalized in the OmniScript Designer after creation.
+
+isLwcEnabled: true deploys the script as a Lightning Web Component (recommended for performance).
+isOmniScriptEmbeddable: true allows embedding this script inside other OmniScripts.
+
+Use sf_activate_omniscript to activate after creation.`,
+        inputSchema: CreateOmniScriptSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createOmniScript(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_update_omniscript", {
+        title: "Update OmniStudio OmniScript",
+        description: `Updates an existing OmniScript's metadata properties (description, LWC mode, embeddable flag). Identified by Type + SubType + Language.
+
+Note: OmniScript element/step editing is best done in the OmniScript Designer. This tool updates the container metadata only. The script will be deactivated if currently active — reactivate with sf_activate_omniscript.`,
+        inputSchema: UpdateOmniScriptSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await updateOmniScript(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_activate_omniscript", {
+        title: "Activate OmniStudio OmniScript",
+        description: `Activates an OmniScript so it can be launched from FlexCards, Experience Cloud, or standalone pages. Identified by Type + SubType + Language.`,
+        inputSchema: ActivateOmniScriptSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await activateOmniScript(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_get_omniscript", {
+        title: "Get OmniStudio OmniScript",
+        description: `Retrieves the configuration of an OmniScript including its elements, activation status, and LWC settings. Identified by Type + SubType + Language.`,
+        inputSchema: GetOmniScriptSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await getOmniScript(auth, params);
+        return resultContent(result);
+    });
+
+    // ─── DATARAPTORS ─────────────────────────────────────────────────────────
+    server.registerTool("sf_create_dataraptor", {
+        title: "Create OmniStudio DataRaptor",
+        description: `Creates a DataRaptor interface for OmniStudio data transformation. DataRaptors handle Extract (read from Salesforce), Transform (convert data formats), and Load (write to Salesforce) operations.
+
+interfaceType:
+- Extract: reads data from Salesforce objects using SOQL-like field mappings
+- Transform: converts/maps data between formats (JSON path transformations)
+- Load: writes data to Salesforce objects
+
+Each field mapping defines:
+- sourceField: source JSON path or Salesforce field API name
+- targetField: target JSON path or Salesforce field API name
+- dataType: data type (Text, Number, Boolean, Date, etc.)
+- formula: optional transformation formula
+
+filterCriteria: SOQL WHERE clause for Extract DataRaptors (e.g. "Id = ':AccountId'")`,
+        inputSchema: CreateDataRaptorSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createDataRaptor(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_get_dataraptor", {
+        title: "Get OmniStudio DataRaptor",
+        description: `Retrieves the configuration of a DataRaptor interface including its type, field mappings, and filter criteria.`,
+        inputSchema: GetDataRaptorSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await getDataRaptor(auth, params);
+        return resultContent(result);
+    });
+
+    // ─── INTEGRATION PROCEDURES ───────────────────────────────────────────────
+    server.registerTool("sf_create_integration_procedure", {
+        title: "Create OmniStudio Integration Procedure",
+        description: `Creates an OmniStudio Integration Procedure — a server-side process that orchestrates data integration without UI. Integration Procedures run in Apex context and can be invoked from OmniScripts, FlexCards, or APIs.
+
+Integration Procedures use the OmniScript metadata type with omniProcessType=IntegrationProcedure. The fullName is ProcedureName_SubType.
+
+Element types:
+- DataRaptor: call a DataRaptor for Salesforce CRUD
+- HTTPAction: call an external REST/SOAP API
+- Response: return data to the caller
+- Loop: iterate over a collection
+- Conditional: branch based on conditions
+- SetValues: set variables
+- ExceptionBlock: handle errors
+- Matrix: call a Calculation Matrix
+- OmniScript: call a nested OmniScript
+- Aggregate: combine multiple data sources
+
+Set isActive: true to activate immediately after creation.`,
+        inputSchema: CreateIntegrationProcedureSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createIntegrationProcedure(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_update_integration_procedure", {
+        title: "Update OmniStudio Integration Procedure",
+        description: `Updates an existing Integration Procedure's metadata (description, active status). Identified by procedureName + subType (fullName = procedureName_subType).
+
+For element/step changes, use the OmniStudio Integration Procedure Designer. Set isActive: false to deactivate, then make changes, then sf_activate_integration_procedure.`,
+        inputSchema: UpdateIntegrationProcedureSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await updateIntegrationProcedure(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_get_integration_procedure", {
+        title: "Get OmniStudio Integration Procedure",
+        description: `Retrieves the configuration of an Integration Procedure including its elements and activation status. Identified by procedureName + subType.`,
+        inputSchema: GetIntegrationProcedureSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await getIntegrationProcedure(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_activate_integration_procedure", {
+        title: "Activate OmniStudio Integration Procedure",
+        description: `Activates an Integration Procedure so it can be invoked from OmniScripts, FlexCards, and APIs. Identified by procedureName + subType.`,
+        inputSchema: ActivateIntegrationProcedureSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await activateIntegrationProcedure(auth, params);
+        return resultContent(result);
+    });
+
+    // ─── CALCULATION MATRIX & PROCEDURE ──────────────────────────────────────
+    server.registerTool("sf_create_calculation_matrix", {
+        title: "Create OmniStudio Calculation Matrix",
+        description: `Creates a Calculation Matrix for rule-based lookups and calculations. Matrices map input combinations to output values — useful for pricing, eligibility, scoring, and decision tables.
+
+inputVariables: list of input variable names (columns used for lookups)
+outputVariables: list of output variable names (columns returned)
+rows: array of { inputs: {var: value}, outputs: {var: value} } defining the lookup table
+
+Example: a pricing matrix with inputs [ProductType, Region] and outputs [Price, Discount].`,
+        inputSchema: CreateCalculationMatrixSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createCalculationMatrix(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_create_calculation_procedure", {
+        title: "Create OmniStudio Calculation Procedure",
+        description: `Creates a Calculation Procedure that orchestrates multi-step calculations using Calculation Matrices, formulas, and logic steps.
+
+steps array — each step has:
+- name: step identifier
+- type: MatrixLookup (call a matrix), Formula (expression), Condition (branch), Assignment (set variable)
+- matrixName: required for MatrixLookup steps
+- expression: required for Formula/Condition steps
+- inputMap: maps procedure variables to step inputs
+- outputMap: maps step outputs back to procedure variables
+
+Use Calculation Procedures to build complex pricing engines, eligibility calculators, or multi-factor scoring systems.`,
+        inputSchema: CreateCalculationProcedureSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createCalculationProcedure(auth, params);
+        return resultContent(result);
+    });
+}
+//# sourceMappingURL=omnistudio.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "salesforce-metadata-mcp",
-  "version": "2.2.0",
-  "description": "The most comprehensive Salesforce MCP server: 110+ tools for metadata, Apex, LWC, Agentforce agents, Experience Cloud, bulk data, users, reports, security, and more",
+  "version": "2.3.0",
+  "description": "The most comprehensive Salesforce MCP server: 140+ tools for metadata, Apex, LWC, Agentforce, OmniStudio, OmniChannel, Experience Cloud, Field Service, Messaging, bulk data, users, reports, security, and more",
   "license": "MIT",
   "private": false,
   "type": "module",
@@ -58,7 +58,19 @@
     "bulk-api",
     "visualforce",
     "aura",
-    "formula-fields"
+    "formula-fields",
+    "omnistudio",
+    "omniscript",
+    "flexcard",
+    "dataraptor",
+    "integration-procedure",
+    "omnichannel",
+    "service-cloud",
+    "field-service",
+    "messaging",
+    "live-chat",
+    "skill-routing",
+    "presence"
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.29.0",