@mindstone/mcp-server-salesforce 0.2.1 → 0.2.3

package/README.md

@@ -9,7 +9,7 @@ Salesforce CRM MCP server — accounts, contacts, opportunities, leads, tasks, u
 
 ## Status
 
-- **Version:** [0.2.1](./CHANGELOG.md) · [npm](https://www.npmjs.com/package/@mindstone/mcp-server-salesforce)
+- **Version:** [0.2.3](./CHANGELOG.md) · [npm](https://www.npmjs.com/package/@mindstone/mcp-server-salesforce)
 - **Auth:** OAuth (local 127.0.0.1 callback) or static access token ([`SALESFORCE_CLIENT_SECRET`](./server.json), [`SALESFORCE_ACCESS_TOKEN`](./server.json))
 - **Tools:** [37](./src/tools/) (accounts, contacts, opportunities, leads, tasks, cases, events, search, notes, campaigns, reports, query)
 - **Surface:** cloud-api

package/dist/bridge.d.ts

@@ -4,8 +4,13 @@
 export declare const BRIDGE_STATE_PATH: string;
 /**
  * Send a request to the host app bridge.
+ *
+ * `timeoutMs` defaults to the ordinary per-call budget (REQUEST_TIMEOUT_MS);
+ * callers that trigger long host-side flows (e.g. interactive OAuth) can opt
+ * into a longer one. The abort itself is never removed — only widened — so a
+ * dead bridge still fails within the chosen bound.
  */
-export declare const bridgeRequest: (urlPath: string, body?: Record<string, unknown>) => Promise<{
+export declare const bridgeRequest: (urlPath: string, body?: Record<string, unknown>, timeoutMs?: number) => Promise<{
     success: boolean;
     username?: string;
     warning?: string;

package/dist/bridge.js

@@ -17,15 +17,20 @@ const loadBridgeState = () => {
 };
 /**
  * Send a request to the host app bridge.
+ *
+ * `timeoutMs` defaults to the ordinary per-call budget (REQUEST_TIMEOUT_MS);
+ * callers that trigger long host-side flows (e.g. interactive OAuth) can opt
+ * into a longer one. The abort itself is never removed — only widened — so a
+ * dead bridge still fails within the chosen bound.
  */
-export const bridgeRequest = async (urlPath, body = {}) => {
+export const bridgeRequest = async (urlPath, body = {}, timeoutMs = REQUEST_TIMEOUT_MS) => {
     const bridge = loadBridgeState();
     if (!bridge) {
         return { success: false, error: 'Bridge not available' };
     }
     const response = await fetch(`http://127.0.0.1:${bridge.port}${urlPath}`, {
         method: 'POST',
-        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        signal: AbortSignal.timeout(timeoutMs),
         headers: {
             'Content-Type': 'application/json',
             Authorization: `Bearer ${bridge.token}`,

package/dist/tools/accounts.js

@@ -1,12 +1,14 @@
 import { z } from 'zod';
-import { withErrorHandling, escapeSOQL, escapeSOQLLike, validateFields, validateAndMergeCustomFields, checkSaveResult, formatVendorErrors, sanitizeRecords } from '../utils.js';
+import { withErrorHandling, escapeSOQL, escapeSOQLLike, validateFields, validateAndMergeCustomFields, checkSaveResult, formatVendorErrors, sanitizeRecords, pickArg } from '../utils.js';
 import { withConnection } from '../client.js';
 export function registerAccountTools(server) {
     server.registerTool('salesforce_get_accounts', {
         description: `Get CRM accounts. Filters: name_contains, industry, account_type. Returns: Id, Name, Industry, Type, Phone, Website, Description. Max 200 records (default: 50).`,
         inputSchema: z.object({
             limit: z.number().int().min(1).max(200).optional().describe('Max results 1-200 (default: 50)'),
+            max_results: z.number().int().min(1).max(200).optional().describe('Alias of limit.'),
             name_contains: z.string().optional().describe('Filter by name (case-insensitive)'),
+            query: z.string().optional().describe('Alias of name_contains.'),
             industry: z.string().optional().describe('Filter by industry'),
             account_type: z.string().optional().describe('Filter by type (Customer, Partner, Competitor)'),
             fields: z.array(z.string()).optional().describe('Custom fields (must be valid API names)'),
@@ -18,15 +20,16 @@ export function registerAccountTools(server) {
             const fields = validateFields(args.fields || [], defaultFields);
             let query = `SELECT ${fields.join(', ')} FROM Account`;
             const conditions = [];
-            if (args.name_contains)
-                conditions.push(`Name LIKE '%${escapeSOQLLike(args.name_contains)}%'`);
+            const nameContains = pickArg({ name_contains: args.name_contains, query: args.query });
+            if (nameContains)
+                conditions.push(`Name LIKE '%${escapeSOQLLike(nameContains)}%'`);
             if (args.industry)
                 conditions.push(`Industry = '${escapeSOQL(args.industry)}'`);
             if (args.account_type)
                 conditions.push(`Type = '${escapeSOQL(args.account_type)}'`);
             if (conditions.length > 0)
                 query += ` WHERE ${conditions.join(' AND ')}`;
-            const limit = Math.min(Math.max(1, args.limit ?? 50), 200);
+            const limit = Math.min(Math.max(1, pickArg({ limit: args.limit, max_results: args.max_results }) ?? 50), 200);
             query += ` LIMIT ${limit}`;
             const result = await conn.query(query);
             return JSON.stringify({ ok: true, records: sanitizeRecords(result.records, 'salesforce:get_accounts:records'), totalSize: result.totalSize, done: result.done });

package/dist/tools/auth-tools.js

@@ -3,6 +3,7 @@ import { z } from 'zod';
 import { withErrorHandling, sanitizeExternalData } from '../utils.js';
 import { getAuthMode, loadToken, startStandaloneOAuth } from '../auth.js';
 import { bridgeRequest } from '../bridge.js';
+import { BRIDGE_OAUTH_TIMEOUT_MS } from '../types.js';
 import { listConnectedAccounts, removeAccount } from '../client.js';
 // Disconnect needs a raw handle the model can copy verbatim into
 // salesforce_disconnect_account, but the storage id is username-derived
@@ -50,7 +51,11 @@ After connecting, verify with salesforce_list_connected_accounts.`,
             });
         }
         if (mode === 'bridge') {
-            const result = await bridgeRequest(process.env.MCP_BRIDGE_CONFIGURE_ENDPOINT || '/mcp/configure', {});
+            // The host holds this response open until the user completes the
+            // interactive OAuth flow in their browser (up to 5 minutes), so this
+            // call needs the long budget — the default 30s abort would kill the
+            // connect mid-flow while the human is still signing in.
+            const result = await bridgeRequest(process.env.MCP_BRIDGE_CONFIGURE_ENDPOINT || '/mcp/configure', {}, BRIDGE_OAUTH_TIMEOUT_MS);
             if (result.success) {
                 // The bridge username is host/org-authored external text: envelope
                 // it before it reaches model-visible output (AGENTS.md invariant #6).

package/dist/tools/opportunities.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { withErrorHandling, escapeSOQL, escapeSOQLLike, validateFields, validateAndMergeCustomFields, formatSOQLDate, checkSaveResult, formatVendorErrors, sanitizeRecords } from '../utils.js';
+import { withErrorHandling, escapeSOQL, escapeSOQLLike, validateFields, validateAndMergeCustomFields, formatSOQLDate, checkSaveResult, formatVendorErrors, sanitizeRecords, pickArg } from '../utils.js';
 import { withConnection } from '../client.js';
 import { ConnectorError } from '../types.js';
 export function registerOpportunityTools(server) {
@@ -9,7 +9,9 @@ export function registerOpportunityTools(server) {
             limit: z.number().int().min(1).max(200).optional().describe('Max results 1-200 (default: 50)'),
             name_contains: z.string().optional().describe('Filter by name'),
             stage: z.string().optional().describe('Filter by stage'),
+            status: z.string().optional().describe('Alias of stage.'),
             related_account_id: z.string().optional().describe('Filter by Account ID'),
+            account_id: z.string().optional().describe('Alias of related_account_id.'),
             close_date_from: z.string().optional().describe('Closing on/after date (YYYY-MM-DD)'),
             close_date_to: z.string().optional().describe('Closing on/before date (YYYY-MM-DD)'),
             fields: z.array(z.string()).optional().describe('Custom fields'),
@@ -23,10 +25,12 @@ export function registerOpportunityTools(server) {
             const conditions = [];
             if (args.name_contains)
                 conditions.push(`Name LIKE '%${escapeSOQLLike(args.name_contains)}%'`);
-            if (args.stage)
-                conditions.push(`StageName = '${escapeSOQL(args.stage)}'`);
-            if (args.related_account_id)
-                conditions.push(`AccountId = '${escapeSOQL(args.related_account_id)}'`);
+            const stage = pickArg({ stage: args.stage, status: args.status });
+            const relatedAccountId = pickArg({ related_account_id: args.related_account_id, account_id: args.account_id });
+            if (stage)
+                conditions.push(`StageName = '${escapeSOQL(stage)}'`);
+            if (relatedAccountId)
+                conditions.push(`AccountId = '${escapeSOQL(relatedAccountId)}'`);
             if (args.close_date_from)
                 conditions.push(`CloseDate >= ${formatSOQLDate(args.close_date_from, 'close_date_from')}`);
             if (args.close_date_to)

package/dist/tools/query.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { withErrorHandling, validateObjectName, validateFields, isValidQueryFieldName, isValidFieldName, escapeSOQL, ALLOWED_FILTER_OPERATORS, validateAndMergeCustomFields, checkSaveResult, formatVendorErrors, sanitizeRecords } from '../utils.js';
+import { withErrorHandling, validateObjectName, validateFields, isValidQueryFieldName, isValidFieldName, escapeSOQL, ALLOWED_FILTER_OPERATORS, validateAndMergeCustomFields, checkSaveResult, formatVendorErrors, sanitizeRecords, requireArg } from '../utils.js';
 import { withConnection } from '../client.js';
 import { wrapUntrusted } from '../untrusted-content.js';
 import { ConnectorError } from '../types.js';
@@ -18,9 +18,14 @@ import { ConnectorError } from '../types.js';
 // corrupted to `WHERE Website = 'https:` (unterminated literal), since
 // the naive global regex would treat the `//` inside the quoted span as
 // a line comment.
+//
+// The walker also reports whether the input ended INSIDE an unterminated
+// string literal, which the caller needs to decide whether a trailing `;` is
+// a statement terminator or data the user typed.
 function stripSoqlComments(query) {
     let out = '';
     let i = 0;
+    let endedInLiteral = false;
     const n = query.length;
     while (i < n) {
         const ch = query[i];
@@ -30,6 +35,7 @@ function stripSoqlComments(query) {
         if (ch === "'") {
             out += ch;
             i++;
+            let closed = false;
             while (i < n) {
                 const c = query[i];
                 if (c === '\\' && i + 1 < n) {
@@ -48,11 +54,14 @@ function stripSoqlComments(query) {
                     // Closing quote.
                     out += "'";
                     i++;
+                    closed = true;
                     break;
                 }
                 out += c;
                 i++;
             }
+            if (!closed)
+                endedInLiteral = true;
             continue;
         }
         // Outside any quoted literal: strip block + line comments.
@@ -81,7 +90,7 @@ function stripSoqlComments(query) {
         out += ch;
         i++;
     }
-    return out;
+    return { text: out, endedInLiteral };
 }
 /**
  * Enforce a hard cap on the LIMIT clause of a caller-supplied SOQL query.
@@ -97,8 +106,14 @@ function stripSoqlComments(query) {
  * `OFFSET <n>` clause.
  */
 export function applyQueryLimitCap(rawQuery, maxLimit) {
-    const cleaned = stripSoqlComments(rawQuery).trim();
-    let base = cleaned;
+    const { text, endedInLiteral } = stripSoqlComments(rawQuery);
+    const cleaned = text.trim();
+    // Callers routinely paste a SQL-style statement terminator. SOQL has none,
+    // and a trailing `;` would otherwise defeat the LIMIT/OFFSET matchers below
+    // and reach Salesforce as a syntax error. A `;` inside a string literal is
+    // data, so only strip when the query did not end inside an unterminated one
+    // (a closed literal can never be the trailing run the pattern matches).
+    let base = endedInLiteral ? cleaned : cleaned.replace(/[;\s]*;[;\s]*$/, '').trimEnd();
     let offsetClause = '';
     const offsetMatch = base.match(/^([\s\S]*?)\s+OFFSET\s+(\d+)\s*$/i);
     if (offsetMatch) {
@@ -121,28 +136,33 @@ export function applyQueryLimitCap(rawQuery, maxLimit) {
 }
 export function registerQueryTools(server) {
     server.registerTool('salesforce_query', {
-        description: `Execute a raw SOQL query. For advanced queries only — prefer dedicated tools for standard operations. Max 200 records enforced.`,
+        description: `Execute a raw SOQL query. For advanced queries only — prefer dedicated tools for standard operations. Requires query (or its alias soql). Max 200 records enforced.`,
         inputSchema: z.object({
-            query: z.string().min(1).describe('SOQL query string'),
+            query: z.string().min(1).optional().describe('SOQL query string'),
+            soql: z.string().min(1).optional().describe('Alias of query.'),
         }),
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, withErrorHandling(async (args) => {
+        const rawQuery = requireArg({ query: args.query, soql: args.soql });
         return withConnection(undefined, async (conn) => {
             const MAX_LIMIT = 200;
-            const query = applyQueryLimitCap(args.query, MAX_LIMIT);
+            const query = applyQueryLimitCap(rawQuery, MAX_LIMIT);
             const result = await conn.query(query);
             return JSON.stringify({ ok: true, records: sanitizeRecords(result.records, 'salesforce:query:records'), totalSize: result.totalSize, done: result.done });
         });
     }));
     server.registerTool('salesforce_describe_object', {
-        description: `Get object metadata and field definitions. Returns field names, types, and required flags. Common objects: Account, Contact, Opportunity, Lead, Case, Task.`,
+        description: `Get object metadata and field definitions. Returns field names, types, and required flags. Requires object_name (or its alias object). Common objects: Account, Contact, Opportunity, Lead, Case, Task.`,
         inputSchema: z.object({
-            object_name: z.string().min(1).describe('Object API name (Account, Contact, Opportunity, Lead, CustomObject__c)'),
+            object_name: z.string().min(1).optional().describe('Object API name (Account, Contact, Opportunity, Lead, CustomObject__c)'),
+            object: z.string().min(1).optional().describe('Alias of object_name.'),
         }),
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, withErrorHandling(async (args) => {
+        const objectName = requireArg({ object_name: args.object_name, object: args.object });
+        validateObjectName(objectName);
         return withConnection(undefined, async (conn) => {
-            const metadata = await conn.sobject(args.object_name).describe();
+            const metadata = await conn.sobject(objectName).describe();
             // Labels and record-type names are org-authored text — envelope them;
             // field API names stay raw (they are identifiers, reused in queries).
             return JSON.stringify({
@@ -204,29 +224,33 @@ export function registerQueryTools(server) {
         });
     }));
     server.registerTool('salesforce_update_record', {
-        description: `Generic record update for any Salesforce object. For standard objects, prefer dedicated tools.`,
+        description: `Generic record update for any Salesforce object. For standard objects, prefer dedicated tools. Requires id (or its alias record_id).`,
         inputSchema: z.object({
             object_name: z.string().min(1).describe('sObject API name'),
-            id: z.string().min(1).describe('Salesforce record ID to update'),
+            id: z.string().min(1).optional().describe('Salesforce record ID to update'),
+            record_id: z.string().min(1).optional().describe('Alias of id.'),
             fields: z.record(z.unknown()).describe('Field-value pairs to update'),
         }),
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
     }, withErrorHandling(async (args) => {
         validateObjectName(args.object_name);
+        const recordId = requireArg({ id: args.id, record_id: args.record_id });
         return withConnection(undefined, async (conn) => {
-            const updateData = { Id: args.id };
+            const updateData = { Id: recordId };
             validateAndMergeCustomFields(updateData, args.fields);
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const result = await conn.sobject(args.object_name).update(updateData);
             checkSaveResult(result, `Failed to update ${args.object_name} record`);
-            return JSON.stringify({ ok: true, status: 'success', object: args.object_name, id: args.id });
+            return JSON.stringify({ ok: true, status: 'success', object: args.object_name, id: recordId });
         });
     }));
     server.registerTool('salesforce_get_records', {
-        description: `Generic record query for any Salesforce object. For standard objects, prefer dedicated get tools.`,
+        description: `Generic record query for any Salesforce object. Requires object_name (or its alias sobject). For standard objects, prefer dedicated get tools.`,
         inputSchema: z.object({
-            object_name: z.string().min(1).describe('sObject API name'),
-            fields: z.array(z.string()).optional().describe('Fields to SELECT (defaults to Id)'),
+            object_name: z.string().min(1).optional().describe('sObject API name'),
+            sobject: z.string().min(1).optional().describe('Alias of object_name.'),
+            fields: z.union([z.array(z.string()), z.string()]).optional().describe('Fields to SELECT (defaults to Id); array or comma-separated string'),
+            record_id: z.string().min(1).optional().describe('Fetch one record by ID (adds an Id = ... condition)'),
             filters: z.array(z.object({
                 field: z.string().describe('Field API name'),
                 operator: z.enum(['=', '!=', '<', '>', '<=', '>=', 'LIKE']).describe('Comparison operator'),
@@ -236,12 +260,20 @@ export function registerQueryTools(server) {
         }),
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, withErrorHandling(async (args) => {
-        validateObjectName(args.object_name);
+        const objectName = requireArg({ object_name: args.object_name, sobject: args.sobject });
+        validateObjectName(objectName);
         return withConnection(undefined, async (conn) => {
-            const fields = validateFields(args.fields || [], ['Id'], isValidQueryFieldName);
-            let soql = `SELECT ${fields.join(', ')} FROM ${args.object_name}`;
+            // Callers pass either a list or the comma-separated string they would
+            // type into a SELECT; both land in the same field-name validator.
+            const requestedFields = typeof args.fields === 'string'
+                ? args.fields.split(',').map((f) => f.trim()).filter((f) => f.length > 0)
+                : args.fields;
+            const fields = validateFields(requestedFields || [], ['Id'], isValidQueryFieldName);
+            let soql = `SELECT ${fields.join(', ')} FROM ${objectName}`;
+            const conditions = [];
+            if (args.record_id)
+                conditions.push(`Id = '${escapeSOQL(args.record_id)}'`);
             if (args.filters && args.filters.length > 0) {
-                const conditions = [];
                 for (const filter of args.filters) {
                     if (!isValidFieldName(filter.field)) {
                         throw new ConnectorError(`Invalid filter field name: "${filter.field}"`, 'INVALID_FIELD_NAMES', 'Field names must be valid API names');
@@ -258,8 +290,9 @@ export function registerQueryTools(server) {
                     }
                     conditions.push(`${filter.field} ${filter.operator} ${formattedValue}`);
                 }
-                soql += ` WHERE ${conditions.join(' AND ')}`;
             }
+            if (conditions.length > 0)
+                soql += ` WHERE ${conditions.join(' AND ')}`;
             const limit = Math.min(Math.max(1, args.limit ?? 50), 200);
             soql += ` LIMIT ${limit}`;
             const result = await conn.query(soql);

package/dist/tools/search.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { withErrorHandling, escapeSOSL, sanitizeRecords } from '../utils.js';
+import { withErrorHandling, escapeSOSL, sanitizeRecords, requireArg } from '../utils.js';
 import { withConnection } from '../client.js';
 // Allowlisted object names + fixed RETURNING field lists: the only caller
 // input reaching the SOSL string is the (escaped) search term, so object and
@@ -16,9 +16,11 @@ const SEARCHABLE_OBJECTS = {
 const DEFAULT_OBJECTS = ['Account', 'Contact', 'Lead', 'Opportunity'];
 export function registerSearchTools(server) {
     server.registerTool('salesforce_search', {
-        description: `Cross-object full-text search (SOSL). Use for "find anything mentioning X" requests — searches names, emails, and other indexed text fields at once. Defaults to Account, Contact, Lead, Opportunity; pass objects to widen or narrow. Max 200 results; the response's "truncated" flag is true when more matches exist beyond the limit.`,
+        description: `Cross-object full-text search (SOSL). Use for "find anything mentioning X" requests — searches names, emails, and other indexed text fields at once. Requires search_term (or its alias query). Defaults to Account, Contact, Lead, Opportunity; pass objects to widen or narrow. Max 200 results; the response's "truncated" flag is true when more matches exist beyond the limit.`,
         inputSchema: z.object({
-            search_term: z.string().min(2).describe('Text to search for (min 2 characters); reserved SOSL characters are escaped automatically'),
+            search_term: z.string().min(2).optional().describe('Text to search for (min 2 characters); reserved SOSL characters are escaped automatically'),
+            query: z.string().min(2).optional().describe('Alias of search_term.'),
+            returnJson: z.boolean().optional().describe('Accepted and ignored — output is always JSON.'),
             objects: z
                 .array(z.enum(['Account', 'Contact', 'Lead', 'Opportunity', 'Case', 'Task', 'Event']))
                 .optional()
@@ -27,13 +29,14 @@ export function registerSearchTools(server) {
         }),
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, withErrorHandling(async (args) => {
+        const searchTerm = requireArg({ search_term: args.search_term, query: args.query });
         return withConnection(undefined, async (conn) => {
             const objects = (args.objects && args.objects.length > 0 ? args.objects : DEFAULT_OBJECTS);
             const returning = objects.map((o) => SEARCHABLE_OBJECTS[o]).join(', ');
             const limit = Math.min(Math.max(1, args.limit ?? 200), 200);
             // Probe with one extra record so the caller can tell a complete result
             // apart from one clipped at the limit — SOSL returns no total count.
-            const sosl = `FIND {${escapeSOSL(args.search_term)}} IN ALL FIELDS RETURNING ${returning} LIMIT ${limit + 1}`;
+            const sosl = `FIND {${escapeSOSL(searchTerm)}} IN ALL FIELDS RETURNING ${returning} LIMIT ${limit + 1}`;
             const result = await conn.search(sosl);
             const allRecords = result.searchRecords ?? [];
             const truncated = allRecords.length > limit;

package/dist/types.d.ts

@@ -1,4 +1,15 @@
 export declare const REQUEST_TIMEOUT_MS = 30000;
+/**
+ * Bridge budget for the OAuth-initiating `/mcp/configure` call. The host
+ * holds that HTTP response open until the user finishes the interactive
+ * browser sign-in — both the host's own OAuth flow and this connector's
+ * standalone flow cap the wait at 5 minutes. The ordinary 30s
+ * REQUEST_TIMEOUT_MS therefore aborts mid-flow on any human-paced connect
+ * and reports a spurious failure. 5 minutes + 30s slack for the host's
+ * post-auth work (token exchange, config write, reload) — deliberately
+ * bounded so a genuinely dead bridge still fails instead of hanging forever.
+ */
+export declare const BRIDGE_OAUTH_TIMEOUT_MS: number;
 export declare const SERVER_NAME = "salesforce-mcp-server";
 /**
  * Salesforce REST API version the connector pins every request to. Pinned

package/dist/types.js

@@ -2,6 +2,17 @@ import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 export const REQUEST_TIMEOUT_MS = 30_000;
+/**
+ * Bridge budget for the OAuth-initiating `/mcp/configure` call. The host
+ * holds that HTTP response open until the user finishes the interactive
+ * browser sign-in — both the host's own OAuth flow and this connector's
+ * standalone flow cap the wait at 5 minutes. The ordinary 30s
+ * REQUEST_TIMEOUT_MS therefore aborts mid-flow on any human-paced connect
+ * and reports a spurious failure. 5 minutes + 30s slack for the host's
+ * post-auth work (token exchange, config write, reload) — deliberately
+ * bounded so a genuinely dead bridge still fails instead of hanging forever.
+ */
+export const BRIDGE_OAUTH_TIMEOUT_MS = 5 * 60 * 1000 + REQUEST_TIMEOUT_MS;
 export const SERVER_NAME = 'salesforce-mcp-server';
 /**
  * Salesforce REST API version the connector pins every request to. Pinned

package/dist/utils.d.ts

@@ -34,6 +34,25 @@ export declare function escapeSOSL(term: string): string;
  * `LIKE` site is unambiguously marked as wildcard-aware.
  */
 export declare function escapeSOQLLike(value: string): string;
+/**
+ * Resolve a tool argument that accepts more than one spelling.
+ *
+ * Callers reach for plausible synonyms of an argument name — `soql` for
+ * `query`, `sobject` for `object_name` — and the advertised JSON schema is
+ * strict (`additionalProperties: false`), so an undeclared key is rejected
+ * before the handler ever runs. Aliases are therefore declared in the schema
+ * and collapsed here. List the canonical spelling first: the first defined
+ * value wins, so the canonical name beats an alias when both are supplied.
+ * An empty string counts as undefined and is skipped, so an empty canonical
+ * spelling never silently swallows a non-empty alias value.
+ */
+export declare function pickArg<T>(candidates: Record<string, T | undefined>): T | undefined;
+/**
+ * `pickArg` for an argument that is required but has no single schema-required
+ * spelling. Throws a MISSING_ARGUMENT error naming every accepted spelling, so
+ * a caller that guessed wrong learns what would have worked.
+ */
+export declare function requireArg<T>(candidates: Record<string, T | undefined>): T;
 /**
  * Validate that a field name is safe (alphanumeric + underscore only).
  */

package/dist/utils.js

@@ -115,6 +115,41 @@ export function escapeSOSL(term) {
 export function escapeSOQLLike(value) {
     return escapeSOQL(value);
 }
+/**
+ * Resolve a tool argument that accepts more than one spelling.
+ *
+ * Callers reach for plausible synonyms of an argument name — `soql` for
+ * `query`, `sobject` for `object_name` — and the advertised JSON schema is
+ * strict (`additionalProperties: false`), so an undeclared key is rejected
+ * before the handler ever runs. Aliases are therefore declared in the schema
+ * and collapsed here. List the canonical spelling first: the first defined
+ * value wins, so the canonical name beats an alias when both are supplied.
+ * An empty string counts as undefined and is skipped, so an empty canonical
+ * spelling never silently swallows a non-empty alias value.
+ */
+export function pickArg(candidates) {
+    for (const value of Object.values(candidates)) {
+        if (value === undefined)
+            continue;
+        if (typeof value === 'string' && value === '')
+            continue;
+        return value;
+    }
+    return undefined;
+}
+/**
+ * `pickArg` for an argument that is required but has no single schema-required
+ * spelling. Throws a MISSING_ARGUMENT error naming every accepted spelling, so
+ * a caller that guessed wrong learns what would have worked.
+ */
+export function requireArg(candidates) {
+    const value = pickArg(candidates);
+    if (value === undefined) {
+        const names = Object.keys(candidates);
+        throw new ConnectorError(`Missing required argument: provide ${names.join(' or ')}`, 'MISSING_ARGUMENT', `Accepted argument names: ${names.join(', ')}`);
+    }
+    return value;
+}
 /**
  * Validate that a field name is safe (alphanumeric + underscore only).
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindstone/mcp-server-salesforce",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "mcpName": "io.github.mindstone/mcp-server-salesforce",
   "description": "Salesforce CRM MCP server — accounts, contacts, opportunities, leads, tasks, and custom objects via Salesforce API",
   "license": "FSL-1.1-MIT",