salesforce-metadata-mcp 2.2.0 → 2.4.0

package/dist/tools/audit.js

@@ -0,0 +1,96 @@
+import {
+    GetSetupAuditTrailSchema, GetLoginHistorySchema, GetEventLogsSchema, GetFieldHistorySchema,
+} from "../schemas/index.js";
+import { getAuth, getSetupAuditTrail, getLoginHistory, getEventLogs, getFieldHistory } from "../services/salesforce.js";
+import { resultContent } from "./utils.js";
+
+export function registerAuditTools(server) {
+    server.registerTool("sf_get_setup_audit_trail", {
+        title: "Get Setup Audit Trail",
+        description: `Queries the SetupAuditTrail object to see who made what configuration changes to the org, and when. Covers the last 6 months of setup activity.
+
+Returns records with: date, username, section, action, display (human-readable description)
+
+section filter examples: 'Custom Fields', 'Profiles', 'Flows', 'Apex Classes', 'Permission Sets', 'Connected Apps', 'Users'
+
+Useful for:
+- Security audits (who changed profiles or permissions)
+- Debugging unexpected configuration changes
+- Compliance reporting on org configuration changes`,
+        inputSchema: GetSetupAuditTrailSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await getSetupAuditTrail(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_get_login_history", {
+        title: "Get Login History",
+        description: `Queries LoginHistory to see user login activity — who logged in, from where, and whether they succeeded.
+
+Returns records with: loginTime, username, sourceIp, browser, platform, status, loginType
+
+status values: 'Success', 'Failed', 'No Password', 'Blocked', 'No Cookie'
+loginType values: 'Application', 'API', 'SAML', 'OAuth', 'LightningLogin', 'Chatter'
+
+Useful for:
+- Security monitoring (failed logins, unusual IP addresses)
+- Compliance auditing (who accessed the org and when)
+- Investigating suspicious account activity
+
+Note: LoginHistory covers the past 6 months.`,
+        inputSchema: GetLoginHistorySchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await getLoginHistory(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_get_event_logs", {
+        title: "Get Event Log Files",
+        description: `Queries EventLogFile for detailed activity logs. Event logs capture granular org activity for security monitoring and performance analysis.
+
+Common eventType values:
+- Login — login attempts and results
+- API — SOAP/REST API calls
+- Report — report executions
+- Flow — Flow runs and executions
+- ApexExecution — Apex code executions
+- LightningPageView — Lightning page views
+- RestApi — REST API requests
+- VisualforceRequest — Visualforce page requests
+- URI — general HTTP requests
+- LightningError — Lightning component errors
+
+Returns parsed CSV log entries (up to 20 rows per log file, up to 3 files per call).
+
+Requires Event Monitoring add-on OR Agentforce debug logs to be enabled.`,
+        inputSchema: GetEventLogsSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await getEventLogs(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_get_field_history", {
+        title: "Get Field History for a Record",
+        description: `Queries the {Object}History object to retrieve a field-level change history for a specific record. Shows what changed, when, the old and new values, and who made the change.
+
+Returns records with: date, field, oldValue, newValue, changedBy
+
+objectApiName: the SObject with history tracking enabled, e.g. 'Account', 'Opportunity', 'Case'
+recordId: the specific record to retrieve history for
+
+Note: Field history tracking must be enabled for the object and for each field you want to track (Setup → Object Manager → {Object} → Fields & Relationships → Field History Tracking). History is retained for up to 18 months.`,
+        inputSchema: GetFieldHistorySchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await getFieldHistory(auth, params);
+        return resultContent(result);
+    });
+}
+//# sourceMappingURL=audit.js.map

package/dist/tools/data.js

@@ -1,5 +1,5 @@
-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 { CreateUserSchema, UpdateUserSchema, AssignQueueMemberSchema, CreatePublicGroupSchema, QueryRecordsSchema, CreateRecordSchema, UpdateRecordSchema, BulkImportRecordsSchema, DeleteRecordSchema, SendEmailSchema, } from "../schemas/index.js";
+import { getAuth, createUser, updateUser, assignQueueMember, createPublicGroup, queryRecords, createRecord, updateRecord, bulkImportRecords, deleteRecord, sendEmail, } from "../services/salesforce.js";
 import { resultContent } from "./utils.js";
 export function registerDataTools(server) {
     server.registerTool("sf_create_user", {
@@ -82,5 +82,36 @@ export function registerDataTools(server) {
         const result = await bulkImportRecords(auth, params);
         return resultContent(result);
     });
+    server.registerTool("sf_delete_record", {
+        title: "Delete SObject Record",
+        description: `Deletes a single SObject record by record ID via the Salesforce REST API. The deletion is permanent and cannot be undone (the record goes to the Recycle Bin for objects that support it, from where it can be undeleted within 15 days).
+
+Provide the object API name and the 15 or 18 character record ID. For bulk deletions (100+ records), use sf_bulk_import_records with operation='delete'.`,
+        inputSchema: DeleteRecordSchema,
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await deleteRecord(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_send_email", {
+        title: "Send Email via Salesforce",
+        description: `Sends an email from Salesforce using the emailSimple invocable action. The email is sent from the running user's email address through Salesforce's email infrastructure (respects org email deliverability settings).
+
+toAddresses: one or more recipient email addresses
+body / htmlBody: email body content (htmlBody takes precedence)
+templateName: use an existing email template instead of providing body text
+whatId: related record ID (e.g. Opportunity, Case) — links the email as an activity
+whoId: Contact or Lead ID — links the email to the person record
+saveAsActivity: saves the email as an EmailMessage activity (default: true)
+
+Note: Salesforce email limits apply (daily email limits based on org edition). Mass emails should use list email features instead.`,
+        inputSchema: SendEmailSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await sendEmail(auth, params);
+        return resultContent(result);
+    });
 }
 //# sourceMappingURL=data.js.map

package/dist/tools/deployment.js

@@ -1,5 +1,5 @@
-import { CreateOutboundChangeSetSchema, AddToChangeSetSchema, DeployMetadataSchema, CheckDeployStatusSchema, RetrieveMetadataSchema, ValidateDeploymentSchema, ListMetadataSchema, } from "../schemas/index.js";
-import { getAuth, listMetadataForTool } from "../services/salesforce.js";
+import { CreateOutboundChangeSetSchema, AddToChangeSetSchema, DeployMetadataSchema, CheckDeployStatusSchema, RetrieveMetadataSchema, ValidateDeploymentSchema, ListMetadataSchema, CompareOrgsSchema, } from "../schemas/index.js";
+import { getAuth, listMetadataForTool, compareOrgs } 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";
@@ -121,5 +121,25 @@ export function registerDeploymentTools(server) {
         const result = await listMetadataForTool(auth, params.metadataType);
         return resultContent(result);
     });
+    server.registerTool("sf_compare_orgs", {
+        title: "Compare Metadata Between Two Orgs",
+        description: `Compares metadata components of specified types between two Salesforce orgs using their SF CLI aliases. Returns components that exist only in the source, only in the target, or differ between both.
+
+Requires the Salesforce CLI to be installed and both org aliases to be authenticated (run: sf org list to see available aliases).
+
+sourceAlias / targetAlias: SF CLI org aliases (letters, numbers, hyphens, underscores only)
+metadataTypes: list of metadata types to compare — defaults to common types (ApexClass, Flow, CustomObject, PermissionSet, LightningComponentBundle)
+
+Returns:
+- onlyInSource: components in source that don't exist in target
+- onlyInTarget: components in target that don't exist in source
+- differentInBoth: components that exist in both but have different lastModifiedDate
+- summary: counts for each category`,
+        inputSchema: CompareOrgsSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const result = await compareOrgs(params);
+        return resultContent(result);
+    });
 }
 //# sourceMappingURL=deployment.js.map

package/dist/tools/einstein.js

@@ -0,0 +1,79 @@
+import {
+    CreateEinsteinPredictionSchema, CreateNextBestActionSchema, CreateEinsteinBotSchema,
+} from "../schemas/index.js";
+import { getAuth, createEinsteinPrediction, createNextBestAction, createEinsteinBot } from "../services/salesforce.js";
+import { resultContent } from "./utils.js";
+
+export function registerEinsteinTools(server) {
+    server.registerTool("sf_create_einstein_prediction", {
+        title: "Create Einstein Prediction (ML Prediction Definition)",
+        description: `Creates an Einstein Prediction Builder prediction definition (MLPredictionDefinition metadata type). Predictions analyze historical Salesforce data to score or classify records automatically.
+
+predictionType:
+- BinaryClassification: predict a yes/no outcome (e.g. Will this opportunity close? Is this lead likely to convert?)
+- Regression: predict a numeric value (e.g. Expected revenue, likelihood score)
+
+targetField: the field the prediction is based on (e.g. 'IsWon' for BinaryClassification on Opportunity)
+pushbackField: an existing custom field to write the prediction score to automatically
+
+IMPORTANT: Einstein Prediction Builder requires an Einstein Analytics license or the Einstein Platform add-on. If the org lacks this license, the metadata deployment will succeed but the prediction cannot be trained or activated. This tool creates the definition — training happens in Setup → Einstein → Prediction Builder.
+
+The prediction is created in Draft status. Activate it from Setup after training is complete.`,
+        inputSchema: CreateEinsteinPredictionSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createEinsteinPrediction(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_create_next_best_action", {
+        title: "Create Next Best Action Strategy",
+        description: `Creates a Next Best Action (NBA) recommendation strategy (RecommendationStrategy metadata type). NBA strategies surface contextual recommendations to agents and customers on record pages, communities, and chatbots.
+
+A strategy defines:
+- contextObjectApiName: the record type that provides context (e.g. 'Account', 'Case', 'Opportunity')
+- recommendations: a list of actions the agent can offer, each with Accept/Decline buttons and an optional Flow to execute on acceptance
+
+NBA strategies can be displayed via:
+- Einstein Next Best Action component on a Lightning Record Page
+- OmniScripts and FlexCards
+- Service Console
+
+After creating, add the "Einstein Next Best Action" Lightning component to a record page and configure it to use this strategy.`,
+        inputSchema: CreateNextBestActionSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createNextBestAction(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_create_einstein_bot", {
+        title: "Create Einstein Bot (Classic)",
+        description: `Creates a classic Einstein Bot (Bot + BotVersion metadata types) with one or more conversation dialogs. Classic Einstein Bots handle chat and messaging channels via rule-based and ML-powered conversation flows.
+
+Note: For AI-first agents using large language models, use sf_create_agent (Agentforce/Einstein Service Agent) instead. Classic Einstein Bots are best suited for:
+- Structured FAQ automation
+- Simple data collection workflows
+- Channels that don't support Agentforce (SMS, WhatsApp via classic routing)
+
+Each dialog defines:
+- name/label: the dialog identifier
+- utterances: training phrases that trigger this dialog
+- messages: bot responses shown to the user
+- type: Main (user-facing), System (internal), Rule (condition-based)
+
+The bot is created with an ML domain for intent classification. After creation:
+1. Train the bot in Setup → Einstein Bots → {BotName} → Train
+2. Activate the bot
+3. Connect it to a messaging channel or chat button`,
+        inputSchema: CreateEinsteinBotSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createEinsteinBot(auth, params);
+        return resultContent(result);
+    });
+}
+//# sourceMappingURL=einstein.js.map

package/dist/tools/index.js

@@ -12,6 +12,10 @@ 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";
+import { registerAuditTools } from "./audit.js";
+import { registerEinsteinTools } from "./einstein.js";
 export function registerTools(server) {
     registerMetadataTools(server);
     registerObjectTools(server);
@@ -27,5 +31,9 @@ export function registerTools(server) {
     registerIntegrationTools(server);
     registerReportTools(server);
     registerDataTools(server);
+    registerOmniStudioTools(server);
+    registerOmniChannelTools(server);
+    registerAuditTools(server);
+    registerEinsteinTools(server);
 }
 //# sourceMappingURL=index.js.map

package/dist/tools/integrations.js

@@ -1,5 +1,5 @@
-import { CreateConnectedAppSchema, CreateExternalDataSourceSchema, CreateExternalObjectSchema, CreateRemoteSiteSettingSchema, CreateCspSettingSchema, CreateOutboundMessageSchema, CreateAuthProviderSchema, } from "../schemas/index.js";
-import { getAuth, createConnectedApp, createExternalDataSource, createExternalObject, createRemoteSiteSetting, createCspSetting, createOutboundMessage, createAuthProvider, } from "../services/salesforce.js";
+import { CreateConnectedAppSchema, CreateExternalDataSourceSchema, CreateExternalObjectSchema, CreateRemoteSiteSettingSchema, CreateCspSettingSchema, CreateOutboundMessageSchema, CreateAuthProviderSchema, CreateCertificateSchema, CreateEventRelaySchema, } from "../schemas/index.js";
+import { getAuth, createConnectedApp, createExternalDataSource, createExternalObject, createRemoteSiteSetting, createCspSetting, createOutboundMessage, createAuthProvider, createCertificate, createEventRelay, } from "../services/salesforce.js";
 import { resultContent } from "./utils.js";
 export function registerIntegrationTools(server) {
     server.registerTool("sf_create_connected_app", {
@@ -112,5 +112,42 @@ export function registerIntegrationTools(server) {
         const result = await createAuthProvider(auth, params);
         return resultContent(result);
     });
+    server.registerTool("sf_create_certificate", {
+        title: "Create Self-Signed Certificate",
+        description: `Creates a self-signed certificate in Salesforce (Certificate metadata type). Certificates are used for:
+- Signing outbound callouts (mutual TLS / client certificate authentication)
+- Signing SAML assertions for SSO
+- Encrypting/decrypting data in Named Credentials
+
+keySize: 2048 (standard) or 4096 (high security)
+expirationDate: optional ISO date for the certificate expiry (e.g. '2030-01-01')
+privateKeyExportable: set true only if you need to export the private key (not recommended for production)
+
+After creation, the certificate can be referenced in Named Credentials and Connected Apps.`,
+        inputSchema: CreateCertificateSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createCertificate(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_event_relay", {
+        title: "Create Event Relay Configuration",
+        description: `Creates an EventRelayConfig that relays Salesforce Platform Events or Change Data Capture events to an external event bus (Amazon EventBridge or another Salesforce event bus).
+
+eventChannel: the Platform Event or CDC channel to relay, e.g. 'MyEvent__e', 'AccountChangeEvent', or 'data/ChangeEvents' for all CDC
+destinationType: AmazonEventBridge or EventBus
+destinationResourceName: ARN for Amazon EventBridge (e.g. 'arn:aws:events:us-east-1:123456789:event-bus/my-bus') or target event bus name
+
+state: RUN (immediately start relaying), STOP (create but don't relay), PAUSE (temporarily paused)
+
+Requires Event Relay entitlement in the org. For Amazon EventBridge, the AWS partner event source must be set up first.`,
+        inputSchema: CreateEventRelaySchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createEventRelay(auth, params);
+        return resultContent(result);
+    });
 }
 //# sourceMappingURL=integrations.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