adoptai-mcp 1.0.0

package/dist/integrations/salesforce/tools.js

@@ -0,0 +1,4544 @@
+import './env.js';
+import { createHash } from 'node:crypto';
+import { readFileSync, existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import axios from 'axios';
+import {
+  buildAuthHeaders,
+  ensureAccessToken,
+  getDefaultUserId,
+  getInstanceUrl,
+  getToken,
+} from './auth.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const manifest = JSON.parse(readFileSync(join(__dirname, 'endpoints.json'), 'utf8'));
+
+/** Postman split: Bulk API v2 (Section B — same repo path; optional if file missing). */
+const BULK_V2_POSTMAN = join(__dirname, '../../specs/split/salesforce-bulk-v2.json');
+
+/** Postman split: Bulk API v1 + Bulk query jobs (Section B). */
+const BULK_V1_POSTMAN = join(__dirname, '../../specs/split/salesforce-bulk-v1.json');
+
+/** Postman split: Metadata SOAP API (Section B). */
+const METADATA_POSTMAN = join(__dirname, '../../specs/split/salesforce-metadata.json');
+
+/** Postman split: Connect / Chatter API (Section B). */
+const CONNECT_POSTMAN = join(__dirname, '../../specs/split/salesforce-connect.json');
+
+/** Postman split: Tooling API (Section B). */
+const TOOLING_POSTMAN = join(__dirname, '../../specs/split/salesforce-tooling.json');
+
+/** Postman split: UI API (Section B). */
+const UI_POSTMAN = join(__dirname, '../../specs/split/salesforce-ui.json');
+
+/** Postman split: Einstein Prediction Service / Smart Data Discovery (Section B). */
+const EINSTEIN_PS_POSTMAN = join(__dirname, '../../specs/split/salesforce-einstein-prediction-service.json');
+
+/** Postman split: Event Platform (CDC, platform events, streaming; Section B). */
+const EVENT_PLATFORM_POSTMAN = join(__dirname, '../../specs/split/salesforce-event-platform.json');
+
+/** Postman split: GraphQL API (Section B). */
+const GRAPHQL_POSTMAN = join(__dirname, '../../specs/split/salesforce-graphql.json');
+
+/** Postman split: Subscription Management / commerce (Section B). */
+const SUBSCRIPTION_MGMT_POSTMAN = join(__dirname, '../../specs/split/salesforce-subscription-management.json');
+
+/** Postman split: Industries (CPQ, Loyalty, Health, FSC patterns; Section B). */
+const INDUSTRIES_POSTMAN = join(__dirname, '../../specs/split/salesforce-industries.json');
+
+/** Dynamic API base — never hardcode instance host (see setup env + OAuth). */
+function getBaseUrl() {
+  const inst =
+    process.env.SALESFORCE_INSTANCE_URL?.replace(/\/$/, '') || getInstanceUrl()?.replace(/\/$/, '');
+  if (!inst) {
+    throw new Error(
+      'SALESFORCE_INSTANCE_URL is not set. Run setup and ensure your MCP config includes SALESFORCE_INSTANCE_URL, or authenticate again.'
+    );
+  }
+  const verRaw = process.env.SALESFORCE_API_VERSION || 'v59.0';
+  const ver = verRaw.startsWith('v') ? verRaw : `v${verRaw}`;
+  return `${inst}/services/data/${ver}`;
+}
+
+/**
+ * Bulk API 1.0 async root: `{instance}/services/async/{numericVersion}` (no `v` prefix).
+ * Matches Salesforce `/services/async/59.0/...` style paths.
+ */
+function getBulkV1AsyncBaseUrl() {
+  const inst =
+    process.env.SALESFORCE_INSTANCE_URL?.replace(/\/$/, '') || getInstanceUrl()?.replace(/\/$/, '');
+  if (!inst) {
+    throw new Error(
+      'SALESFORCE_INSTANCE_URL is not set. Run setup and ensure your MCP config includes SALESFORCE_INSTANCE_URL, or authenticate again.'
+    );
+  }
+  const verRaw = process.env.SALESFORCE_API_VERSION || 'v59.0';
+  const numVer = String(verRaw).replace(/^v/i, '');
+  return `${inst}/services/async/${numVer}`;
+}
+
+/** Tooling API root: `{instance}/services/data/{version}/tooling`. */
+function getToolingBaseUrl() {
+  const inst =
+    process.env.SALESFORCE_INSTANCE_URL?.replace(/\/$/, '') || getInstanceUrl()?.replace(/\/$/, '');
+  if (!inst) {
+    throw new Error(
+      'SALESFORCE_INSTANCE_URL is not set. Run setup and ensure your MCP config includes SALESFORCE_INSTANCE_URL, or authenticate again.'
+    );
+  }
+  const verRaw = process.env.SALESFORCE_API_VERSION || 'v59.0';
+  const ver = verRaw.startsWith('v') ? verRaw : `v${verRaw}`;
+  return `${inst}/services/data/${ver}/tooling`;
+}
+
+/** UI API root: `{instance}/services/data/{version}/ui-api`. */
+function getUiApiBaseUrl() {
+  const inst =
+    process.env.SALESFORCE_INSTANCE_URL?.replace(/\/$/, '') || getInstanceUrl()?.replace(/\/$/, '');
+  if (!inst) {
+    throw new Error(
+      'SALESFORCE_INSTANCE_URL is not set. Run setup and ensure your MCP config includes SALESFORCE_INSTANCE_URL, or authenticate again.'
+    );
+  }
+  const verRaw = process.env.SALESFORCE_API_VERSION || 'v59.0';
+  const ver = verRaw.startsWith('v') ? verRaw : `v${verRaw}`;
+  return `${inst}/services/data/${ver}/ui-api`;
+}
+
+/** GraphQL API endpoint: `{instance}/services/data/{version}/graphql`. */
+function getGraphqlBaseUrl() {
+  const inst =
+    process.env.SALESFORCE_INSTANCE_URL?.replace(/\/$/, '') || getInstanceUrl()?.replace(/\/$/, '');
+  if (!inst) {
+    throw new Error(
+      'SALESFORCE_INSTANCE_URL is not set. Run setup and ensure your MCP config includes SALESFORCE_INSTANCE_URL, or authenticate again.'
+    );
+  }
+  const verRaw = process.env.SALESFORCE_API_VERSION || 'v59.0';
+  const ver = verRaw.startsWith('v') ? verRaw : `v${verRaw}`;
+  return `${inst}/services/data/${ver}/graphql`;
+}
+
+/**
+ * Einstein Vision/Language Platform API root (default `https://api.einstein.ai/v2`).
+ * Set `SALESFORCE_EINSTEIN_PLATFORM_URL` to override.
+ */
+function getEinsteinPlatformBaseUrl() {
+  const raw = process.env.SALESFORCE_EINSTEIN_PLATFORM_URL?.replace(/\/$/, '') || 'https://api.einstein.ai/v2';
+  return raw;
+}
+
+async function einsteinPlatformPostMultipart(pathSuffix, buildForm) {
+  const envTok = process.env.SALESFORCE_EINSTEIN_ACCESS_TOKEN?.trim() || process.env.EINSTEIN_ACCESS_TOKEN?.trim();
+  if (!envTok) await ensureAccessToken();
+  const token = envTok || getToken();
+  const base = getEinsteinPlatformBaseUrl().replace(/\/$/, '');
+  const path = pathSuffix.startsWith('/') ? pathSuffix : `/${pathSuffix}`;
+  const url = `${base}${path}`;
+  const form = new FormData();
+  buildForm(form);
+  let res;
+  try {
+    res = await fetch(url, { method: 'POST', headers: { Authorization: `Bearer ${token}` }, body: form });
+  } catch (e) {
+    throw new Error(e?.message || 'Einstein Platform request failed');
+  }
+  const txt = await res.text();
+  let data;
+  try {
+    data = txt ? JSON.parse(txt) : {};
+  } catch {
+    throw new Error(`Einstein Platform response not JSON (${res.status}): ${txt.slice(0, 500)}`);
+  }
+  if (!res.ok) {
+    handleError({ response: { status: res.status, data, statusText: res.statusText } });
+  }
+  return data;
+}
+
+function getDataCatalogUrl() {
+  const inst =
+    process.env.SALESFORCE_INSTANCE_URL?.replace(/\/$/, '') || getInstanceUrl()?.replace(/\/$/, '');
+  if (!inst) {
+    throw new Error('SALESFORCE_INSTANCE_URL is not set.');
+  }
+  return `${inst}/services/data`;
+}
+
+function getApexBaseUrl() {
+  const inst =
+    process.env.SALESFORCE_INSTANCE_URL?.replace(/\/$/, '') || getInstanceUrl()?.replace(/\/$/, '');
+  if (!inst) throw new Error('SALESFORCE_INSTANCE_URL is not set.');
+  return `${inst}/services/apexrest`;
+}
+
+function handleError(err) {
+  const status = err.response?.status;
+  const data = err.response?.data;
+  const msg =
+    data?.[0]?.message ||
+    data?.message ||
+    data?.error_description ||
+    data?.error ||
+    err.message;
+  if (status === 401) {
+    throw new Error(
+      'Token invalid or expired.\nRun: npx adoptai-salesforce-mcp --client cursor'
+    );
+  }
+  if (status === 403) throw new Error('Insufficient permissions. Check your connected app scopes.');
+  if (status === 404) throw new Error('Resource not found. Check your parameters.');
+  if (status === 429) throw new Error('Rate limit exceeded. Please wait and try again.');
+  throw new Error(msg || 'API request failed');
+}
+
+function applyPathTemplate(path, pathValues) {
+  let p = path;
+  for (const [k, v] of Object.entries(pathValues)) {
+    p = p.replace(`{${k}}`, encodeURIComponent(String(v)));
+  }
+  if (/\{[^}]+}/.test(p)) {
+    throw new Error(`Missing path parameters for: ${p}`);
+  }
+  return p;
+}
+
+function text(payload) {
+  return {
+    content: [{ type: 'text', text: JSON.stringify(payload ?? {}, null, 2) }],
+  };
+}
+
+function splitPathAndRest(path, params) {
+  const pathKeys = [...path.matchAll(/\{([^}]+)\}/g)].map((m) => m[1]);
+  const pathValues = {};
+  const rest = { ...params };
+  for (const k of pathKeys) {
+    if (rest[k] === undefined || rest[k] === null || rest[k] === '') {
+      throw new Error(`Missing required path parameter: ${k}`);
+    }
+    pathValues[k] = rest[k];
+    delete rest[k];
+  }
+  delete rest._rawBody;
+  return { pathValues, rest };
+}
+
+async function sfRequest(method, path, urlKind, params = {}) {
+  await ensureAccessToken();
+  const headers = { ...buildAuthHeaders(), 'Content-Type': 'application/json' };
+  const rawBody = params._rawBody;
+  const { pathValues, rest } = splitPathAndRest(path, params);
+  const resolvedPath = applyPathTemplate(path, pathValues);
+
+  let url;
+  if (urlKind === 'apex') {
+    url = getApexBaseUrl() + resolvedPath;
+  } else if (urlKind === 'data-catalog') {
+    url = getDataCatalogUrl() + (resolvedPath === '/' ? '' : resolvedPath);
+  } else if (urlKind === 'tooling') {
+    url = getToolingBaseUrl() + resolvedPath;
+  } else if (urlKind === 'ui-api') {
+    url = getUiApiBaseUrl() + resolvedPath;
+  } else if (urlKind === 'graphql') {
+    url = getGraphqlBaseUrl();
+  } else if (urlKind === 'bulk-v1-async') {
+    url = getBulkV1AsyncBaseUrl() + resolvedPath;
+  } else {
+    url = getBaseUrl() + resolvedPath;
+  }
+
+  const isGetLike = method === 'GET' || method === 'DELETE';
+  try {
+    const res = await axios({
+      method,
+      url,
+      headers,
+      params: isGetLike ? rest : undefined,
+      data: !isGetLike ? (rawBody !== undefined ? rawBody : Object.keys(rest).length ? rest : undefined) : undefined,
+      timeout: 120000,
+      validateStatus: () => true,
+    });
+    if (res.status < 200 || res.status >= 300) {
+      handleError({ response: res, message: res.statusText });
+    }
+    if (res.status === 204 || res.data === '' || res.data == null) {
+      return { success: true, status: res.status };
+    }
+    return res.data;
+  } catch (err) {
+    if (err.response) handleError(err);
+    throw err;
+  }
+}
+
+function escapeSoqlString(s) {
+  return String(s).replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+
+function soqlQueryUrl(q) {
+  return `${getBaseUrl()}/query/?q=${encodeURIComponent(q)}`;
+}
+
+async function soqlGet(queryString) {
+  await ensureAccessToken();
+  const headers = { ...buildAuthHeaders(), Accept: 'application/json' };
+  try {
+    const res = await axios.get(soqlQueryUrl(queryString), { headers, timeout: 120000 });
+    return res.data;
+  } catch (err) {
+    handleError(err);
+  }
+}
+
+async function fetchQueryAllPages(initialQuery, maxRecords) {
+  await ensureAccessToken();
+  const headers = { ...buildAuthHeaders(), Accept: 'application/json' };
+  let url = soqlQueryUrl(initialQuery);
+  const allRecords = [];
+  let done = false;
+  let totalFetched = 0;
+
+  while (!done && totalFetched < maxRecords) {
+    let res;
+    try {
+      res = await axios.get(url, { headers, timeout: 120000 });
+    } catch (e) {
+      handleError(e);
+    }
+    const data = res.data;
+    const batch = data.records || [];
+    for (const row of batch) {
+      if (totalFetched >= maxRecords) break;
+      allRecords.push(row);
+      totalFetched += 1;
+    }
+    done = data.done === true || !data.nextRecordsUrl;
+    if (!done && totalFetched < maxRecords) {
+      const next = data.nextRecordsUrl;
+      const inst = getInstanceUrl()?.replace(/\/$/, '');
+      if (!inst) throw new Error('SALESFORCE_INSTANCE_URL missing for pagination');
+      url = next.startsWith('http') ? next : `${inst}${next}`;
+    } else {
+      done = true;
+    }
+  }
+
+  return {
+    totalSize: allRecords.length,
+    maxRecords,
+    truncated: totalFetched >= maxRecords && !done,
+    records: allRecords,
+  };
+}
+
+function buildSearchWhere(conditions) {
+  const parts = [];
+  for (const [field, val] of Object.entries(conditions)) {
+    if (val == null || val === '') continue;
+    parts.push(`${field} LIKE '%${escapeSoqlString(val)}%'`);
+  }
+  return parts.length ? parts.join(' AND ') : null;
+}
+
+function pipelinePeriodClause(period) {
+  switch (period) {
+    case 'this_quarter':
+      return 'CloseDate = THIS_QUARTER';
+    case 'next_quarter':
+      return 'CloseDate = NEXT_QUARTER';
+    case 'this_month':
+    default:
+      return 'CloseDate = THIS_MONTH';
+  }
+}
+
+// ——— Bulk API v2 helpers & Section B extract (salesforce-bulk-v2.json) ———
+
+function chunkArray(arr, size) {
+  const n = Math.max(1, Number(size) || 200);
+  const chunks = [];
+  for (let i = 0; i < arr.length; i += n) {
+    chunks.push(arr.slice(i, i + n));
+  }
+  return chunks;
+}
+
+function csvEscapeCell(val) {
+  if (val == null) return '';
+  const s = String(val);
+  if (/[",\n\r]/.test(s)) return `"${s.replace(/"/g, '""')}"`;
+  return s;
+}
+
+function objectsToCsv(rows) {
+  if (!rows?.length) return '';
+  const headers = [...new Set(rows.flatMap((r) => Object.keys(r)))];
+  const lines = [headers.map(csvEscapeCell).join(',')];
+  for (const row of rows) {
+    lines.push(headers.map((h) => csvEscapeCell(row[h])).join(','));
+  }
+  return lines.join('\n');
+}
+
+function recordIdsToDeleteCsv(record_ids) {
+  if (!record_ids?.length) return '';
+  const ids = record_ids.map((id) => String(id).trim()).filter(Boolean);
+  return ['Id', ...ids].join('\n');
+}
+
+async function pollBulkIngestJob(jobId, options = {}) {
+  const maxWaitMs = options.maxWaitMs ?? 30 * 60 * 1000;
+  const intervalMs = options.intervalMs ?? 2000;
+  const base = getBaseUrl();
+  await ensureAccessToken();
+  const headers = { ...buildAuthHeaders(), Accept: 'application/json' };
+  const deadline = Date.now() + maxWaitMs;
+  while (Date.now() < deadline) {
+    const res = await axios.get(`${base}/jobs/ingest/${encodeURIComponent(jobId)}`, {
+      headers,
+      timeout: 120000,
+      validateStatus: () => true,
+    });
+    if (res.status < 200 || res.status >= 300) handleError({ response: res });
+    const state = res.data.state;
+    if (state === 'JobComplete' || state === 'Failed' || state === 'Aborted') {
+      return res.data;
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  throw new Error(`Bulk ingest job ${jobId} did not finish within ${maxWaitMs}ms`);
+}
+
+async function runBulkIngestOperation({
+  objectType,
+  operation,
+  externalIdFieldName,
+  records,
+  recordIds,
+  batch_size,
+}) {
+  await ensureAccessToken();
+  const base = getBaseUrl();
+  const auth = buildAuthHeaders();
+  const jobBody = {
+    object: objectType,
+    operation,
+    contentType: 'CSV',
+    lineEnding: 'LF',
+    columnDelimiter: 'COMMA',
+  };
+  if (externalIdFieldName) {
+    jobBody.externalIdFieldName = externalIdFieldName;
+  }
+
+  const jobRes = await axios.post(`${base}/jobs/ingest`, jobBody, {
+    headers: { ...auth, 'Content-Type': 'application/json' },
+    timeout: 120000,
+    validateStatus: () => true,
+  });
+  if (jobRes.status < 200 || jobRes.status >= 300) handleError({ response: jobRes });
+
+  const jobId = jobRes.data.id;
+  let payloads = [];
+
+  if (operation === 'delete') {
+    const csv = recordIdsToDeleteCsv(recordIds);
+    if (!csv) throw new Error('record_ids must be a non-empty array for delete');
+    payloads = [csv];
+  } else {
+    if (!records?.length) throw new Error('records must be a non-empty array');
+    payloads = chunkArray(records, batch_size).map(objectsToCsv);
+  }
+
+  for (const csv of payloads) {
+    const putRes = await axios.put(`${base}/jobs/ingest/${jobId}/batches`, csv, {
+      headers: { ...auth, 'Content-Type': 'text/csv', Accept: 'application/json' },
+      timeout: 120000,
+      validateStatus: () => true,
+    });
+    if (putRes.status < 200 || putRes.status >= 300) handleError({ response: putRes });
+  }
+
+  const patchRes = await axios.patch(
+    `${base}/jobs/ingest/${jobId}`,
+    { state: 'UploadComplete' },
+    {
+      headers: { ...auth, 'Content-Type': 'application/json' },
+      timeout: 120000,
+      validateStatus: () => true,
+    }
+  );
+  if (patchRes.status < 200 || patchRes.status >= 300) handleError({ response: patchRes });
+
+  const job = await pollBulkIngestJob(jobId);
+  return { jobId, job };
+}
+
+function bulkApiMultipliedTools() {
+  return [
+    {
+      name: 'bulk_create_records',
+      description:
+        'Creates multiple Salesforce records of the same object type in a single batch operation using Bulk API v2, automatically handling job creation, data upload, and completion polling to return success/failure results for each record. Use this instead of individual record creation when processing 10+ records for dramatically better performance, but note that all records must be of the same object type',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          object_type: { type: 'string', description: 'SObject API name (e.g. Account, Contact)' },
+          records: { type: 'array', description: 'Row objects; columns become CSV headers' },
+          batch_size: { type: 'number', description: 'Rows per upload batch (default 200)' },
+        },
+        required: ['object_type', 'records'],
+      },
+      handler: async ({ object_type, records, batch_size }) => {
+        const result = await runBulkIngestOperation({
+          objectType: object_type,
+          operation: 'insert',
+          records,
+          batch_size: batch_size ?? 200,
+        });
+        return text(result);
+      },
+    },
+    {
+      name: 'bulk_update_records',
+      description:
+        'Updates multiple existing Salesforce records in a single batch operation, requiring each record to include its Id field for identification. Use this for mass updates like changing record ownership, status fields, or other bulk modifications across many records when you know the record Ids.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          object_type: { type: 'string' },
+          records: {
+            type: 'array',
+            description: 'Objects including Id plus fields to update',
+          },
+          batch_size: { type: 'number', description: 'Default 200' },
+        },
+        required: ['object_type', 'records'],
+      },
+      handler: async ({ object_type, records, batch_size }) => {
+        for (const r of records) {
+          if (r.Id == null && r.id == null) {
+            throw new Error('Each record must include Id for update');
+          }
+        }
+        const normalized = records.map((r) => ({ ...r, Id: r.Id ?? r.id }));
+        const result = await runBulkIngestOperation({
+          objectType: object_type,
+          operation: 'update',
+          records: normalized,
+          batch_size: batch_size ?? 200,
+        });
+        return text(result);
+      },
+    },
+    {
+      name: 'bulk_upsert_records',
+      description:
+        'Creates new records or updates existing ones by matching an external ID field you specify, for sync and imports when you may not know if rows already exist. Requires an external ID field on the target object.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          object_type: { type: 'string' },
+          external_id_field: { type: 'string', description: 'External ID field API name' },
+          records: { type: 'array' },
+          batch_size: { type: 'number', description: 'Default 200' },
+        },
+        required: ['object_type', 'external_id_field', 'records'],
+      },
+      handler: async ({ object_type, external_id_field, records, batch_size }) => {
+        const result = await runBulkIngestOperation({
+          objectType: object_type,
+          operation: 'upsert',
+          externalIdFieldName: external_id_field,
+          records,
+          batch_size: batch_size ?? 200,
+        });
+        return text(result);
+      },
+    },
+    {
+      name: 'bulk_delete_records',
+      description:
+        'Permanently deletes multiple Salesforce records in a single batch operation, requiring only the Id field for each record to be deleted. WARNING: This operation is irreversible and bypasses the recycle bin, so use with extreme caution and ensure you have proper backups.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          object_type: { type: 'string', description: 'SObject API name' },
+          record_ids: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Salesforce record Ids to delete',
+          },
+        },
+        required: ['object_type', 'record_ids'],
+      },
+      handler: async ({ object_type, record_ids }) => {
+        const result = await runBulkIngestOperation({
+          objectType: object_type,
+          operation: 'delete',
+          recordIds: record_ids,
+          batch_size: 200,
+        });
+        return text(result);
+      },
+    },
+    {
+      name: 'get_bulk_job_status',
+      description:
+        'Retrieves the current status and progress of a running bulk ingest job, returning the job state (InProgress/JobComplete/Failed), number of records processed, and count of failed records. Use this to monitor long-running bulk operations and determine when results are ready for retrieval.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          job_id: { type: 'string', description: 'Bulk ingest job Id' },
+        },
+        required: ['job_id'],
+      },
+      handler: async ({ job_id }) => {
+        await ensureAccessToken();
+        const base = getBaseUrl();
+        const headers = { ...buildAuthHeaders(), Accept: 'application/json' };
+        try {
+          const res = await axios.get(`${base}/jobs/ingest/${encodeURIComponent(job_id)}`, {
+            headers,
+            timeout: 120000,
+            validateStatus: () => true,
+          });
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text(res.data);
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'get_bulk_job_results',
+      description:
+        'Downloads the detailed results of a completed bulk ingest job, including success/failure status for each record and specific error messages for failed records. Use this after a bulk job completes to identify which records failed and why, enabling you to correct and retry failed records.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          job_id: { type: 'string' },
+          result_type: {
+            type: 'string',
+            enum: ['successfulResults', 'failedResults', 'unprocessedRecords'],
+            description:
+              'successfulResults | failedResults | unprocessedRecords (CSV payload)',
+          },
+        },
+        required: ['job_id', 'result_type'],
+      },
+      handler: async ({ job_id, result_type }) => {
+        const map = {
+          successfulResults: 'successfulResults',
+          failedResults: 'failedResults',
+          unprocessedRecords: 'unprocessedrecords',
+        };
+        const suffix = map[result_type];
+        if (!suffix) throw new Error('Invalid result_type');
+        await ensureAccessToken();
+        const base = getBaseUrl();
+        const headers = { ...buildAuthHeaders(), Accept: 'text/csv' };
+        const url = `${base}/jobs/ingest/${encodeURIComponent(job_id)}/${suffix}`;
+        try {
+          const res = await axios.get(url, {
+            headers,
+            responseType: 'text',
+            timeout: 120000,
+            validateStatus: () => true,
+          });
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text({
+            job_id,
+            result_type,
+            format: 'text/csv',
+            body: res.data ?? '',
+          });
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+  ];
+}
+
+const SKIP_BULK_PATH_RE =
+  /\/oauth|\/token|\/login|\/logout|\/services\/oauth2|\/webhook|\/Soap\/|\/soap\//i;
+
+function bulkVarMap(collection) {
+  const m = {};
+  for (const v of collection.variable || []) {
+    m[v.key] = v.value ?? '';
+  }
+  return m;
+}
+
+function bulkResolve(str, map) {
+  if (str == null) return str;
+  let out = String(str);
+  for (const [k, v] of Object.entries(map)) {
+    out = out.split(`{{${k}}}`).join(v ?? '');
+  }
+  return out;
+}
+
+function bulkInferType(value) {
+  if (value == null) return 'string';
+  const v = String(value).toLowerCase().trim();
+  if (v === '<integer>' || v === '<number>') return 'number';
+  if (v === '<boolean>') return 'boolean';
+  if (!Number.isNaN(Number(v)) && v !== '') return 'number';
+  if (v === 'true' || v === 'false') return 'boolean';
+  return 'string';
+}
+
+function bulkDesc(req, itemName) {
+  const d = req.description;
+  if (typeof d === 'string') return d.slice(0, 400);
+  if (d && typeof d === 'object' && d.content) return String(d.content).slice(0, 400);
+  return itemName;
+}
+
+function bulkVersionedPath(req, varMap) {
+  const raw = typeof req.url === 'string' ? req.url : req.url?.raw || '';
+  const resolved = bulkResolve(raw, varMap);
+  const [pathPart, qs] = resolved.split('?');
+  if (SKIP_BULK_PATH_RE.test(pathPart)) return null;
+  const noHost = pathPart.replace(/^https?:\/\/[^/?#]+/i, '');
+  if (!noHost.startsWith('/services/data/')) return null;
+  const after = noHost.slice('/services/data/'.length);
+  const m = after.match(/^(v[0-9.]+)\/(.+)$/);
+  if (!m) return null;
+  let path = `/${m[2]}`;
+  path = path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, '{$1}');
+  path = path.replace(/\{\{_jobId\}\}/g, '{jobId}');
+  if (qs) path = `${path}?${qs}`;
+  return path;
+}
+
+function bulkBuildSchema(req, normalizedPath) {
+  const properties = {};
+  const required = [];
+
+  const pathNoQuery = normalizedPath.split('?')[0];
+  for (const [, name] of pathNoQuery.matchAll(/\{([^}]+)\}/g)) {
+    properties[name] = { type: 'string', description: `Path: ${name}` };
+    required.push(name);
+  }
+
+  const seen = new Set();
+  if (typeof req.url === 'object' && req.url?.query) {
+    for (const param of req.url.query) {
+      if (!param.key || param.disabled || seen.has(param.key)) continue;
+      seen.add(param.key);
+      if (properties[param.key]) continue;
+      properties[param.key] = {
+        type: bulkInferType(param.value),
+        description: param.description || `Query: ${param.key}`,
+      };
+    }
+  }
+
+  if (req.body?.mode === 'raw' && req.body.raw) {
+    try {
+      const bodyJson = JSON.parse(req.body.raw);
+      for (const [key, value] of Object.entries(bodyJson)) {
+        if (properties[key]) continue;
+        properties[key] = { type: bulkInferType(String(value)), description: `Body: ${key}` };
+      }
+    } catch {
+      /* non-JSON */
+    }
+  }
+
+  const isCsvPut =
+    req.method?.toUpperCase() === 'PUT' && pathNoQuery.includes('/jobs/ingest/') && pathNoQuery.endsWith('/batches');
+  if (isCsvPut) {
+    properties.csv_data = {
+      type: 'string',
+      description: 'CSV file contents (UTF-8) for this batch upload',
+    };
+    required.push('csv_data');
+  }
+
+  return { type: 'object', properties, required: [...new Set(required)] };
+}
+
+/** Like bulkBuildSchema plus Postman `formdata` fields (Connect file uploads). */
+function connectBuildSchema(req, normalizedPath) {
+  const base = bulkBuildSchema(req, normalizedPath);
+  if (req.body?.mode === 'formdata' && req.body.formdata) {
+    for (const item of req.body.formdata) {
+      if (!item.key || base.properties[item.key]) continue;
+      base.properties[item.key] = {
+        type: 'string',
+        description: `Multipart field “${item.key}” (${item.type || 'text'}). For files, pass base64 or use upload_file_to_record.`,
+      };
+    }
+  }
+  return base;
+}
+
+/** Postman `graphql` body → MCP tool schema (query + optional variables). */
+function graphqlBuildSchema(req) {
+  const g = req.body?.mode === 'graphql' ? req.body.graphql : null;
+  const exampleQuery = typeof g?.query === 'string' ? g.query : '';
+  let exampleVars;
+  if (g?.variables != null && String(g.variables).trim() !== '') {
+    try {
+      exampleVars = typeof g.variables === 'string' ? JSON.parse(g.variables) : g.variables;
+    } catch {
+      exampleVars = undefined;
+    }
+  }
+  const properties = {
+    query: {
+      type: 'string',
+      description: exampleQuery
+        ? 'GraphQL query string (Postman example provided as default).'
+        : 'GraphQL query string.',
+      ...(exampleQuery ? { default: exampleQuery } : {}),
+    },
+    variables: {
+      type: 'object',
+      description: 'Optional GraphQL variables object.',
+      additionalProperties: true,
+      ...(exampleVars && typeof exampleVars === 'object' ? { default: exampleVars } : {}),
+    },
+  };
+  return { type: 'object', properties, required: ['query'] };
+}
+
+/**
+ * Cursor MCP enforces combined `user-salesforce-adoptai:<tool>` length ≤ 60 (incl. colon).
+ * With a 23-char server id, tool names must be ≤ 36 chars.
+ */
+const MCP_TOOL_NAME_MAX_LEN = 60 - String('user-salesforce-adoptai').length - 1;
+
+/**
+ * Safe identifier from a Postman item name. Shortens to maxSlice and appends a stable
+ * hash suffix when truncated so collisions stay rare.
+ */
+function bulkSlug(name, maxSlice = MCP_TOOL_NAME_MAX_LEN) {
+  let s = String(name || '')
+    .replace(/[^a-zA-Z0-9_]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .toLowerCase();
+  if (s.length <= maxSlice) return s;
+  const h = createHash('sha256').update(String(name)).digest('hex').slice(0, 5);
+  const keep = Math.max(1, maxSlice - 6);
+  const head = s.slice(0, keep).replace(/_+$/g, '');
+  return `${head}_${h}`;
+}
+
+function bulkExtractRequests(items, varMap, acc) {
+  for (const item of items || []) {
+    if (Array.isArray(item.item)) {
+      bulkExtractRequests(item.item, varMap, acc);
+    } else if (item.request) {
+      const req = item.request;
+      const method = String(req.method || 'GET').toUpperCase();
+      if (['OPTIONS', 'HEAD', 'TRACE'].includes(method)) continue;
+
+      const path = bulkVersionedPath(req, varMap);
+      if (!path) continue;
+
+      const pathKey = path.split('?')[0];
+      const dedupeKey = `${method}|${pathKey}`;
+      const name = `bulk_v2_${bulkSlug(item.name, MCP_TOOL_NAME_MAX_LEN - 'bulk_v2_'.length)}`;
+
+      acc.push({
+        dedupeKey,
+        name,
+        description: bulkDesc(req, item.name),
+        method,
+        path,
+        inputSchema: bulkBuildSchema(req, path.split('?')[0]),
+      });
+    }
+  }
+}
+
+function bulkV2ManifestEndpoints() {
+  if (!existsSync(BULK_V2_POSTMAN)) return [];
+  const col = JSON.parse(readFileSync(BULK_V2_POSTMAN, 'utf8'));
+  const varMap = bulkVarMap(col);
+  const raw = [];
+  bulkExtractRequests(col.item, varMap, raw);
+
+  const seen = new Set();
+  const endpoints = [];
+  for (const ep of raw) {
+    if (seen.has(ep.dedupeKey)) continue;
+    seen.add(ep.dedupeKey);
+    const { dedupeKey: _d, ...rest } = ep;
+    endpoints.push(rest);
+  }
+  return endpoints;
+}
+
+function connectExtractRequests(items, varMap, acc) {
+  for (const item of items || []) {
+    if (Array.isArray(item.item)) {
+      connectExtractRequests(item.item, varMap, acc);
+    } else if (item.request) {
+      const req = item.request;
+      const method = String(req.method || 'GET').toUpperCase();
+      if (['OPTIONS', 'HEAD', 'TRACE'].includes(method)) continue;
+
+      const path = bulkVersionedPath(req, varMap);
+      if (!path) continue;
+
+      const pathKey = path.split('?')[0];
+      const dedupeKey = `${method}|${pathKey}`;
+      const name = `connect_${bulkSlug(item.name, MCP_TOOL_NAME_MAX_LEN - 'connect_'.length)}`;
+
+      acc.push({
+        dedupeKey,
+        name,
+        description: bulkDesc(req, item.name),
+        method,
+        path,
+        inputSchema: connectBuildSchema(req, path.split('?')[0]),
+      });
+    }
+  }
+}
+
+function connectManifestEndpoints() {
+  if (!existsSync(CONNECT_POSTMAN)) return [];
+  const col = JSON.parse(readFileSync(CONNECT_POSTMAN, 'utf8'));
+  const varMap = bulkVarMap(col);
+  const raw = [];
+  connectExtractRequests(col.item, varMap, raw);
+
+  const seen = new Set();
+  const endpoints = [];
+  for (const ep of raw) {
+    if (seen.has(ep.dedupeKey)) continue;
+    seen.add(ep.dedupeKey);
+    const { dedupeKey: _d, ...rest } = ep;
+    endpoints.push(rest);
+  }
+  return endpoints;
+}
+
+function connectGeneratedToolsFromPostman() {
+  const endpoints = connectManifestEndpoints();
+  const toolsOut = [];
+
+  for (const ep of endpoints) {
+    toolsOut.push({
+      name: ep.name,
+      description: ep.description,
+      method: ep.method,
+      path: ep.path,
+      urlKind: 'versioned',
+      inputSchema: enrichSchemaForWrite(ep.inputSchema, ep.method),
+      handler: async (params) => {
+        const [pbase, pq] = ep.path.split('?');
+        const merged = { ...params };
+        if (pq) {
+          for (const [k, v] of new URLSearchParams(pq)) {
+            if (merged[k] === undefined) merged[k] = v;
+          }
+        }
+        const data = await sfRequest(ep.method, pbase, 'versioned', merged);
+        return text(data);
+      },
+    });
+  }
+
+  toolsOut.sort((a, b) => {
+    const ea = endpoints.find((e) => e.name === a.name);
+    const eb = endpoints.find((e) => e.name === b.name);
+    const ra = methodRank(ea?.method);
+    const rb = methodRank(eb?.method);
+    if (ra !== rb) return ra - rb;
+    return a.name.localeCompare(b.name);
+  });
+
+  return toolsOut;
+}
+
+/** Path under `/tooling` (leading slash), e.g. `/query/?q=...`, from Postman `{_endpoint}/services/data/v{{version}}/tooling/...`. */
+function toolingVersionedPath(req, varMap) {
+  const full = bulkVersionedPath(req, varMap);
+  if (!full) return null;
+  const [pathPart, qs] = full.split('?');
+  if (!pathPart.startsWith('/tooling/') && pathPart !== '/tooling') return null;
+  const rel = pathPart === '/tooling' ? '' : pathPart.slice('/tooling'.length);
+  return qs != null && qs !== '' ? `${rel}?${qs}` : rel;
+}
+
+function toolingExtractRequests(items, varMap, acc) {
+  for (const item of items || []) {
+    if (Array.isArray(item.item)) {
+      toolingExtractRequests(item.item, varMap, acc);
+    } else if (item.request) {
+      const req = item.request;
+      const method = String(req.method || 'GET').toUpperCase();
+      if (['OPTIONS', 'HEAD', 'TRACE'].includes(method)) continue;
+
+      const path = toolingVersionedPath(req, varMap);
+      if (!path) continue;
+
+      const pathKey = path.split('?')[0];
+      const dedupeKey = `${method}|${pathKey}`;
+      const name = `tooling_${bulkSlug(item.name, MCP_TOOL_NAME_MAX_LEN - 'tooling_'.length)}`;
+
+      acc.push({
+        dedupeKey,
+        name,
+        description: bulkDesc(req, item.name),
+        method,
+        path,
+        inputSchema: connectBuildSchema(req, path.split('?')[0] || '/'),
+      });
+    }
+  }
+}
+
+function toolingManifestEndpoints() {
+  if (!existsSync(TOOLING_POSTMAN)) return [];
+  const col = JSON.parse(readFileSync(TOOLING_POSTMAN, 'utf8'));
+  const varMap = bulkVarMap(col);
+  const raw = [];
+  toolingExtractRequests(col.item, varMap, raw);
+
+  const seen = new Set();
+  const endpoints = [];
+  for (const ep of raw) {
+    if (seen.has(ep.dedupeKey)) continue;
+    seen.add(ep.dedupeKey);
+    const { dedupeKey: _d, ...rest } = ep;
+    endpoints.push(rest);
+  }
+  return endpoints;
+}
+
+function toolingGeneratedToolsFromPostman() {
+  const endpoints = toolingManifestEndpoints();
+  const toolsOut = [];
+
+  for (const ep of endpoints) {
+    toolsOut.push({
+      name: ep.name,
+      description: ep.description,
+      method: ep.method,
+      path: ep.path,
+      urlKind: 'tooling',
+      inputSchema: enrichSchemaForWrite(ep.inputSchema, ep.method),
+      handler: async (params) => {
+        const pathWithQ = ep.path.startsWith('/') ? ep.path : `/${ep.path}`;
+        const [pbase, pq] = pathWithQ.split('?');
+        const merged = { ...params };
+        if (pq) {
+          for (const [k, v] of new URLSearchParams(pq)) {
+            if (merged[k] === undefined) merged[k] = v;
+          }
+        }
+        const data = await sfRequest(ep.method, pbase, 'tooling', merged);
+        return text(data);
+      },
+    });
+  }
+
+  toolsOut.sort((a, b) => {
+    const ea = endpoints.find((e) => e.name === a.name);
+    const eb = endpoints.find((e) => e.name === b.name);
+    const ra = methodRank(ea?.method);
+    const rb = methodRank(eb?.method);
+    if (ra !== rb) return ra - rb;
+    return a.name.localeCompare(b.name);
+  });
+
+  return toolsOut;
+}
+
+/** Path under `/ui-api` from Postman `{_endpoint}/services/data/v{{version}}/ui-api/...`. */
+function uiVersionedPath(req, varMap) {
+  const full = bulkVersionedPath(req, varMap);
+  if (!full) return null;
+  const [pathPart, qs] = full.split('?');
+  if (!pathPart.startsWith('/ui-api/') && pathPart !== '/ui-api') return null;
+  const rel = pathPart === '/ui-api' ? '' : pathPart.slice('/ui-api'.length);
+  return qs != null && qs !== '' ? `${rel}?${qs}` : rel;
+}
+
+function uiExtractRequests(items, varMap, acc) {
+  for (const item of items || []) {
+    if (Array.isArray(item.item)) {
+      uiExtractRequests(item.item, varMap, acc);
+    } else if (item.request) {
+      const req = item.request;
+      const method = String(req.method || 'GET').toUpperCase();
+      if (['OPTIONS', 'HEAD', 'TRACE'].includes(method)) continue;
+
+      const path = uiVersionedPath(req, varMap);
+      if (!path) continue;
+
+      const pathKey = path.split('?')[0];
+      const dedupeKey = `${method}|${pathKey}`;
+      const name = `ui_${bulkSlug(item.name, MCP_TOOL_NAME_MAX_LEN - 'ui_'.length)}`;
+
+      acc.push({
+        dedupeKey,
+        name,
+        description: bulkDesc(req, item.name),
+        method,
+        path,
+        inputSchema: connectBuildSchema(req, path.split('?')[0] || '/'),
+      });
+    }
+  }
+}
+
+function uiManifestEndpoints() {
+  if (!existsSync(UI_POSTMAN)) return [];
+  const col = JSON.parse(readFileSync(UI_POSTMAN, 'utf8'));
+  const varMap = bulkVarMap(col);
+  const raw = [];
+  uiExtractRequests(col.item, varMap, raw);
+
+  const seen = new Set();
+  const endpoints = [];
+  for (const ep of raw) {
+    if (seen.has(ep.dedupeKey)) continue;
+    seen.add(ep.dedupeKey);
+    const { dedupeKey: _d, ...rest } = ep;
+    endpoints.push(rest);
+  }
+  return endpoints;
+}
+
+function uiGeneratedToolsFromPostman() {
+  const endpoints = uiManifestEndpoints();
+  const toolsOut = [];
+
+  for (const ep of endpoints) {
+    toolsOut.push({
+      name: ep.name,
+      description: ep.description,
+      method: ep.method,
+      path: ep.path,
+      urlKind: 'ui-api',
+      inputSchema: enrichSchemaForWrite(ep.inputSchema, ep.method),
+      handler: async (params) => {
+        const pathWithQ = ep.path.startsWith('/') ? ep.path : `/${ep.path}`;
+        const [pbase, pq] = pathWithQ.split('?');
+        const merged = { ...params };
+        if (pq) {
+          for (const [k, v] of new URLSearchParams(pq)) {
+            if (merged[k] === undefined) merged[k] = v;
+          }
+        }
+        const data = await sfRequest(ep.method, pbase, 'ui-api', merged);
+        return text(data);
+      },
+    });
+  }
+
+  toolsOut.sort((a, b) => {
+    const ea = endpoints.find((e) => e.name === a.name);
+    const eb = endpoints.find((e) => e.name === b.name);
+    const ra = methodRank(ea?.method);
+    const rb = methodRank(eb?.method);
+    if (ra !== rb) return ra - rb;
+    return a.name.localeCompare(b.name);
+  });
+
+  return toolsOut;
+}
+
+/** Smart Data Discovery paths: `/services/data/v…/smartdatadiscovery/…` (same base as `getBaseUrl`). */
+function einsteinPsVersionedPath(req, varMap) {
+  const full = bulkVersionedPath(req, varMap);
+  if (!full) return null;
+  const pathPart = full.split('?')[0];
+  if (!pathPart.startsWith('/smartdatadiscovery/') && pathPart !== '/smartdatadiscovery') return null;
+  return full;
+}
+
+function einsteinPsExtractRequests(items, varMap, acc) {
+  for (const item of items || []) {
+    if (Array.isArray(item.item)) {
+      einsteinPsExtractRequests(item.item, varMap, acc);
+    } else if (item.request) {
+      const req = item.request;
+      const method = String(req.method || 'GET').toUpperCase();
+      if (['OPTIONS', 'HEAD', 'TRACE'].includes(method)) continue;
+
+      const path = einsteinPsVersionedPath(req, varMap);
+      if (!path) continue;
+
+      const pathKey = path.split('?')[0];
+      const dedupeKey = `${method}|${pathKey}`;
+      const name = `einstein_ps_${bulkSlug(item.name, MCP_TOOL_NAME_MAX_LEN - 'einstein_ps_'.length)}`;
+
+      acc.push({
+        dedupeKey,
+        name,
+        description: bulkDesc(req, item.name),
+        method,
+        path,
+        inputSchema: connectBuildSchema(req, path.split('?')[0] || '/'),
+      });
+    }
+  }
+}
+
+function einsteinPsManifestEndpoints() {
+  if (!existsSync(EINSTEIN_PS_POSTMAN)) return [];
+  const col = JSON.parse(readFileSync(EINSTEIN_PS_POSTMAN, 'utf8'));
+  const varMap = bulkVarMap(col);
+  const raw = [];
+  einsteinPsExtractRequests(col.item, varMap, raw);
+
+  const seen = new Set();
+  const endpoints = [];
+  for (const ep of raw) {
+    if (seen.has(ep.dedupeKey)) continue;
+    seen.add(ep.dedupeKey);
+    const { dedupeKey: _d, ...rest } = ep;
+    endpoints.push(rest);
+  }
+  return endpoints;
+}
+
+function einsteinPsGeneratedToolsFromPostman() {
+  const endpoints = einsteinPsManifestEndpoints();
+  const toolsOut = [];
+
+  for (const ep of endpoints) {
+    toolsOut.push({
+      name: ep.name,
+      description: ep.description,
+      method: ep.method,
+      path: ep.path,
+      urlKind: 'versioned',
+      inputSchema: enrichSchemaForWrite(ep.inputSchema, ep.method),
+      handler: async (params) => {
+        const pathWithQ = ep.path.startsWith('/') ? ep.path : `/${ep.path}`;
+        const [pbase, pq] = pathWithQ.split('?');
+        const merged = { ...params };
+        if (pq) {
+          for (const [k, v] of new URLSearchParams(pq)) {
+            if (merged[k] === undefined) merged[k] = v;
+          }
+        }
+        const data = await sfRequest(ep.method, pbase, 'versioned', merged);
+        return text(data);
+      },
+    });
+  }
+
+  toolsOut.sort((a, b) => {
+    const ea = endpoints.find((e) => e.name === a.name);
+    const eb = endpoints.find((e) => e.name === b.name);
+    const ra = methodRank(ea?.method);
+    const rb = methodRank(eb?.method);
+    if (ra !== rb) return ra - rb;
+    return a.name.localeCompare(b.name);
+  });
+
+  return toolsOut;
+}
+
+/** Event Platform: Tooling-relative paths vs standard `/services/data/v…` paths. */
+function eventPlatformPathAndKind(req, varMap) {
+  const full = bulkVersionedPath(req, varMap);
+  if (!full) return null;
+  const [pathPart, qs] = full.split('?');
+  if (SKIP_BULK_PATH_RE.test(pathPart)) return null;
+  const qstr = qs !== undefined && qs !== '' ? `?${qs}` : '';
+  if (pathPart.startsWith('/tooling/') || pathPart === '/tooling') {
+    const rel = pathPart === '/tooling' ? '' : pathPart.slice('/tooling'.length);
+    return { path: rel + qstr, urlKind: 'tooling' };
+  }
+  return { path: pathPart + qstr, urlKind: 'versioned' };
+}
+
+function eventPlatformExtractRequests(items, varMap, acc) {
+  for (const item of items || []) {
+    if (Array.isArray(item.item)) {
+      eventPlatformExtractRequests(item.item, varMap, acc);
+    } else if (item.request) {
+      const req = item.request;
+      const method = String(req.method || 'GET').toUpperCase();
+      if (['OPTIONS', 'HEAD', 'TRACE'].includes(method)) continue;
+
+      const pk = eventPlatformPathAndKind(req, varMap);
+      if (!pk) continue;
+
+      const pathKey = pk.path.split('?')[0];
+      const dedupeKey = `${method}|${pathKey}|${pk.urlKind}`;
+      const name = `evt_pf_${bulkSlug(item.name, MCP_TOOL_NAME_MAX_LEN - 'evt_pf_'.length)}`;
+
+      acc.push({
+        dedupeKey,
+        name,
+        description: bulkDesc(req, item.name),
+        method,
+        path: pk.path,
+        urlKind: pk.urlKind,
+        inputSchema: connectBuildSchema(req, pathKey || '/'),
+      });
+    }
+  }
+}
+
+function eventPlatformManifestEndpoints() {
+  if (!existsSync(EVENT_PLATFORM_POSTMAN)) return [];
+  const col = JSON.parse(readFileSync(EVENT_PLATFORM_POSTMAN, 'utf8'));
+  const varMap = bulkVarMap(col);
+  const raw = [];
+  eventPlatformExtractRequests(col.item, varMap, raw);
+
+  const seen = new Set();
+  const endpoints = [];
+  for (const ep of raw) {
+    if (seen.has(ep.dedupeKey)) continue;
+    seen.add(ep.dedupeKey);
+    const { dedupeKey: _d, ...rest } = ep;
+    endpoints.push(rest);
+  }
+  return endpoints;
+}
+
+function eventPlatformGeneratedToolsFromPostman() {
+  const endpoints = eventPlatformManifestEndpoints();
+  const toolsOut = [];
+
+  for (const ep of endpoints) {
+    toolsOut.push({
+      name: ep.name,
+      description: ep.description,
+      method: ep.method,
+      path: ep.path,
+      urlKind: ep.urlKind,
+      inputSchema: enrichSchemaForWrite(ep.inputSchema, ep.method),
+      handler: async (params) => {
+        const pathWithQ = ep.path.startsWith('/') ? ep.path : `/${ep.path}`;
+        const [pbase, pq] = pathWithQ.split('?');
+        const merged = { ...params };
+        if (pq) {
+          for (const [k, v] of new URLSearchParams(pq)) {
+            if (merged[k] === undefined) merged[k] = v;
+          }
+        }
+        const data = await sfRequest(ep.method, pbase, ep.urlKind, merged);
+        return text(data);
+      },
+    });
+  }
+
+  toolsOut.sort((a, b) => {
+    const ea = endpoints.find((e) => e.name === a.name);
+    const eb = endpoints.find((e) => e.name === b.name);
+    const ra = methodRank(ea?.method);
+    const rb = methodRank(eb?.method);
+    if (ra !== rb) return ra - rb;
+    return a.name.localeCompare(b.name);
+  });
+
+  return toolsOut;
+}
+
+function graphqlExtractRequests(items, varMap, acc) {
+  for (const item of items || []) {
+    if (Array.isArray(item.item)) {
+      graphqlExtractRequests(item.item, varMap, acc);
+    } else if (item.request) {
+      const req = item.request;
+      const method = String(req.method || 'GET').toUpperCase();
+      if (['OPTIONS', 'HEAD', 'TRACE'].includes(method)) continue;
+
+      const path = bulkVersionedPath(req, varMap);
+      if (!path || path.split('?')[0] !== '/graphql') continue;
+
+      const slug = bulkSlug(item.name, MCP_TOOL_NAME_MAX_LEN - 'gql_'.length);
+      const dedupeKey = `${method}|/graphql|${slug}`;
+      acc.push({
+        dedupeKey,
+        name: `gql_${slug}`,
+        description: bulkDesc(req, item.name) || item.name,
+        method,
+        inputSchema: graphqlBuildSchema(req),
+      });
+    }
+  }
+}
+
+function graphqlManifestEndpoints() {
+  if (!existsSync(GRAPHQL_POSTMAN)) return [];
+  const col = JSON.parse(readFileSync(GRAPHQL_POSTMAN, 'utf8'));
+  const varMap = bulkVarMap(col);
+  const raw = [];
+  graphqlExtractRequests(col.item, varMap, raw);
+
+  const seen = new Set();
+  const endpoints = [];
+  for (const ep of raw) {
+    if (seen.has(ep.dedupeKey)) continue;
+    seen.add(ep.dedupeKey);
+    const { dedupeKey: _d, ...rest } = ep;
+    endpoints.push(rest);
+  }
+  return endpoints;
+}
+
+function graphqlGeneratedToolsFromPostman() {
+  const endpoints = graphqlManifestEndpoints();
+  const toolsOut = [];
+
+  for (const ep of endpoints) {
+    toolsOut.push({
+      name: ep.name,
+      description: ep.description,
+      method: ep.method,
+      path: '',
+      urlKind: 'graphql',
+      inputSchema: enrichSchemaForWrite(ep.inputSchema, ep.method),
+      handler: async (params) => {
+        const body = { query: params.query };
+        if (
+          params.variables != null &&
+          typeof params.variables === 'object' &&
+          !Array.isArray(params.variables) &&
+          Object.keys(params.variables).length > 0
+        ) {
+          body.variables = params.variables;
+        }
+        const data = await sfRequest(ep.method, '/', 'graphql', { _rawBody: body });
+        return text(data);
+      },
+    });
+  }
+
+  toolsOut.sort((a, b) => {
+    const ea = endpoints.find((e) => e.name === a.name);
+    const eb = endpoints.find((e) => e.name === b.name);
+    const ra = methodRank(ea?.method);
+    const rb = methodRank(eb?.method);
+    if (ra !== rb) return ra - rb;
+    return a.name.localeCompare(b.name);
+  });
+
+  return toolsOut;
+}
+
+function subMgmtExtractRequests(items, varMap, acc) {
+  for (const item of items || []) {
+    if (Array.isArray(item.item)) {
+      subMgmtExtractRequests(item.item, varMap, acc);
+    } else if (item.request) {
+      const req = item.request;
+      const method = String(req.method || 'GET').toUpperCase();
+      if (['OPTIONS', 'HEAD', 'TRACE'].includes(method)) continue;
+
+      const path = bulkVersionedPath(req, varMap);
+      if (!path) continue;
+      const pathPart = path.split('?')[0];
+      if (SKIP_BULK_PATH_RE.test(pathPart)) continue;
+
+      const slug = bulkSlug(item.name, MCP_TOOL_NAME_MAX_LEN - 'sub_mgmt_'.length);
+      const dedupeKey = `${method}|${path}|${slug}`;
+      acc.push({
+        dedupeKey,
+        name: `sub_mgmt_${slug}`,
+        description: bulkDesc(req, item.name) || item.name,
+        method,
+        path,
+        inputSchema: connectBuildSchema(req, pathPart || '/'),
+      });
+    }
+  }
+}
+
+function subMgmtManifestEndpoints() {
+  if (!existsSync(SUBSCRIPTION_MGMT_POSTMAN)) return [];
+  const col = JSON.parse(readFileSync(SUBSCRIPTION_MGMT_POSTMAN, 'utf8'));
+  const varMap = bulkVarMap(col);
+  const raw = [];
+  subMgmtExtractRequests(col.item, varMap, raw);
+
+  const seen = new Set();
+  const endpoints = [];
+  for (const ep of raw) {
+    if (seen.has(ep.dedupeKey)) continue;
+    seen.add(ep.dedupeKey);
+    const { dedupeKey: _d, ...rest } = ep;
+    endpoints.push(rest);
+  }
+  return endpoints;
+}
+
+function subMgmtGeneratedToolsFromPostman() {
+  const endpoints = subMgmtManifestEndpoints();
+  const toolsOut = [];
+
+  for (const ep of endpoints) {
+    toolsOut.push({
+      name: ep.name,
+      description: ep.description,
+      method: ep.method,
+      path: ep.path,
+      urlKind: 'versioned',
+      inputSchema: enrichSchemaForWrite(ep.inputSchema, ep.method),
+      handler: async (params) => {
+        const pathWithQ = ep.path.startsWith('/') ? ep.path : `/${ep.path}`;
+        const [pbase, pq] = pathWithQ.split('?');
+        const merged = { ...params };
+        if (pq) {
+          for (const [k, v] of new URLSearchParams(pq)) {
+            if (merged[k] === undefined) merged[k] = v;
+          }
+        }
+        const data = await sfRequest(ep.method, pbase, 'versioned', merged);
+        return text(data);
+      },
+    });
+  }
+
+  toolsOut.sort((a, b) => {
+    const ea = endpoints.find((e) => e.name === a.name);
+    const eb = endpoints.find((e) => e.name === b.name);
+    const ra = methodRank(ea?.method);
+    const rb = methodRank(eb?.method);
+    if (ra !== rb) return ra - rb;
+    return a.name.localeCompare(b.name);
+  });
+
+  return toolsOut;
+}
+
+/** Apex REST or platform REST path for Industries Postman items. */
+function industriesPathAndKind(req, varMap) {
+  const raw = typeof req.url === 'string' ? req.url : req.url?.raw || '';
+  const resolved = bulkResolve(raw, varMap);
+  const [pathPart, qs] = resolved.split('?');
+  const noHost = pathPart.replace(/^https?:\/\/[^/?#]+/i, '');
+
+  if (noHost.startsWith('/services/apexrest')) {
+    let after = noHost.slice('/services/apexrest'.length);
+    if (!after.startsWith('/')) after = `/${after}`;
+    const qstr = qs !== undefined && qs !== '' ? `?${qs}` : '';
+    return { path: after + qstr, urlKind: 'apex' };
+  }
+
+  const full = bulkVersionedPath(req, varMap);
+  if (!full) return null;
+  const pp = full.split('?')[0];
+  if (SKIP_BULK_PATH_RE.test(pp)) return null;
+  return { path: full, urlKind: 'versioned' };
+}
+
+function industriesUseCasePrefix(trail, itemName, pk) {
+  const blob = [...trail, itemName || ''].join(' ').toLowerCase();
+  const pathLow = (pk.path || '').toLowerCase();
+  const nameLow = (itemName || '').toLowerCase();
+  if (
+    pathLow.includes('sbqq') ||
+    (pathLow.includes('servicerouter') &&
+      /quote|config|contract|product|proposal|save|calculate|validate|read|amend|renew|add.product/i.test(nameLow + blob))
+  ) {
+    return 'CPQ / Revenue (configure-price-quote, contracts, product rules) — ';
+  }
+  if (
+    /loyalty|member|voucher|promotion|points|enroll|ledger|journal|benefit|tier|game|redeem|cart|wallet/i.test(
+      blob
+    )
+  ) {
+    return 'Loyalty & programs (member lifecycle, offers, wallets) — ';
+  }
+  if (/integration procedure|omnistudio/i.test(blob) || /integration procedure/i.test(nameLow)) {
+    return 'Omnistudio (Integration Procedures, guided flows) — ';
+  }
+  if (pk.urlKind === 'versioned') {
+    return 'Industries REST (platform / data) — ';
+  }
+  return 'Salesforce Industries — ';
+}
+
+function industriesExtractRequests(items, varMap, acc, trail = []) {
+  for (const item of items || []) {
+    if (Array.isArray(item.item)) {
+      const label = item.name ? String(item.name) : '';
+      industriesExtractRequests(item.item, varMap, acc, label ? [...trail, label] : trail);
+    } else if (item.request) {
+      const req = item.request;
+      const method = String(req.method || 'GET').toUpperCase();
+      if (['OPTIONS', 'HEAD', 'TRACE'].includes(method)) continue;
+
+      const pk = industriesPathAndKind(req, varMap);
+      if (!pk) continue;
+      const pathPart = pk.path.split('?')[0];
+      if (SKIP_BULK_PATH_RE.test(pathPart)) continue;
+
+      const slug = bulkSlug(item.name, MCP_TOOL_NAME_MAX_LEN - 'industries_'.length);
+      const dedupeKey = `${method}|${pk.path}|${pk.urlKind}|${slug}`;
+      const baseDesc = bulkDesc(req, item.name) || item.name;
+      const breadcrumbs = trail.length ? ` Context: ${trail.join(' › ')}.` : '';
+      const description = (
+        industriesUseCasePrefix(trail, item.name, pk) +
+        baseDesc +
+        breadcrumbs
+      ).slice(0, 500);
+
+      acc.push({
+        dedupeKey,
+        name: `industries_${slug}`,
+        description,
+        method,
+        path: pk.path,
+        urlKind: pk.urlKind,
+        inputSchema: connectBuildSchema(req, pathPart || '/'),
+      });
+    }
+  }
+}
+
+function industriesManifestEndpoints() {
+  if (!existsSync(INDUSTRIES_POSTMAN)) return [];
+  const col = JSON.parse(readFileSync(INDUSTRIES_POSTMAN, 'utf8'));
+  const varMap = bulkVarMap(col);
+  const raw = [];
+  industriesExtractRequests(col.item, varMap, raw);
+
+  const seen = new Set();
+  const endpoints = [];
+  for (const ep of raw) {
+    if (seen.has(ep.dedupeKey)) continue;
+    seen.add(ep.dedupeKey);
+    const { dedupeKey: _d, ...rest } = ep;
+    endpoints.push(rest);
+  }
+  return endpoints;
+}
+
+function industriesGeneratedToolsFromPostman() {
+  const endpoints = industriesManifestEndpoints();
+  const toolsOut = [];
+
+  for (const ep of endpoints) {
+    toolsOut.push({
+      name: ep.name,
+      description: ep.description,
+      method: ep.method,
+      path: ep.path,
+      urlKind: ep.urlKind,
+      inputSchema: enrichSchemaForWrite(ep.inputSchema, ep.method),
+      handler: async (params) => {
+        const pathWithQ = ep.path.startsWith('/') ? ep.path : `/${ep.path}`;
+        const [pbase, pq] = pathWithQ.split('?');
+        const merged = { ...params };
+        if (pq) {
+          for (const [k, v] of new URLSearchParams(pq)) {
+            if (merged[k] === undefined) merged[k] = v;
+          }
+        }
+        const data = await sfRequest(ep.method, pbase, ep.urlKind, merged);
+        return text(data);
+      },
+    });
+  }
+
+  toolsOut.sort((a, b) => {
+    const ea = endpoints.find((e) => e.name === a.name);
+    const eb = endpoints.find((e) => e.name === b.name);
+    const ra = methodRank(ea?.method);
+    const rb = methodRank(eb?.method);
+    if (ra !== rb) return ra - rb;
+    return a.name.localeCompare(b.name);
+  });
+
+  return toolsOut;
+}
+
+function bulkV2IsCsvResultGet(method, path) {
+  return (
+    method === 'GET' &&
+    /\/jobs\/ingest\/\{jobId\}\/(successfulResults|failedResults|unprocessedrecords)$/.test(
+      path.split('?')[0]
+    )
+  );
+}
+
+function bulkV2GeneratedTools() {
+  const endpoints = bulkV2ManifestEndpoints();
+  const toolsOut = [];
+
+  for (const ep of endpoints) {
+    const pathNoQuery = ep.path.split('?')[0];
+    const isCsvPut = ep.method === 'PUT' && pathNoQuery.endsWith('/batches');
+    const isCsvGet = bulkV2IsCsvResultGet(ep.method, pathNoQuery);
+
+    if (isCsvPut) {
+      toolsOut.push({
+        name: ep.name,
+        description: ep.description,
+        inputSchema: enrichSchemaForWrite(ep.inputSchema, ep.method),
+        handler: async (params) => {
+          const basePath = ep.path.split('?')[0];
+          const { pathValues, rest } = splitPathAndRest(basePath, params);
+          const csv = rest.csv_data;
+          if (csv == null) throw new Error('csv_data is required for batch upload');
+          await ensureAccessToken();
+          const url = getBaseUrl() + applyPathTemplate(basePath, pathValues);
+          const headers = { ...buildAuthHeaders(), 'Content-Type': 'text/csv', Accept: 'application/json' };
+          try {
+            const res = await axios.put(url, csv, {
+              headers,
+              timeout: 120000,
+              validateStatus: () => true,
+            });
+            if (res.status < 200 || res.status >= 300) handleError({ response: res });
+            return text(res.data && Object.keys(res.data).length ? res.data : { success: true, status: res.status });
+          } catch (e) {
+            handleError(e);
+          }
+        },
+      });
+      continue;
+    }
+
+    if (isCsvGet) {
+      toolsOut.push({
+        name: ep.name,
+        description: ep.description,
+        inputSchema: enrichSchemaForWrite(ep.inputSchema, ep.method),
+        handler: async (params) => {
+          const queryPath = ep.path.includes('?') ? ep.path.split('?')[1] : '';
+          const staticQuery = queryPath ? Object.fromEntries(new URLSearchParams(queryPath)) : {};
+          const basePath = ep.path.split('?')[0];
+          const { pathValues, rest } = splitPathAndRest(basePath, params);
+          await ensureAccessToken();
+          const url = getBaseUrl() + applyPathTemplate(basePath, pathValues);
+          const headers = { ...buildAuthHeaders(), Accept: 'text/csv' };
+          try {
+            const res = await axios.get(url, {
+              headers,
+              params: { ...staticQuery, ...rest },
+              responseType: 'text',
+              timeout: 120000,
+              validateStatus: () => true,
+            });
+            if (res.status < 200 || res.status >= 300) handleError({ response: res });
+            return text({ format: 'text/csv', body: res.data ?? '' });
+          } catch (e) {
+            handleError(e);
+          }
+        },
+      });
+      continue;
+    }
+
+    toolsOut.push({
+      name: ep.name,
+      description: ep.description,
+      method: ep.method,
+      path: ep.path,
+      urlKind: 'versioned',
+      inputSchema: enrichSchemaForWrite(ep.inputSchema, ep.method),
+      handler: async (params) => {
+        const [pbase, pq] = ep.path.split('?');
+        const merged = { ...params };
+        if (pq) {
+          for (const [k, v] of new URLSearchParams(pq)) {
+            if (merged[k] === undefined) merged[k] = v;
+          }
+        }
+        const data = await sfRequest(ep.method, pbase, 'versioned', merged);
+        return text(data);
+      },
+    });
+  }
+
+  toolsOut.sort((a, b) => {
+    const ea = endpoints.find((e) => e.name === a.name);
+    const eb = endpoints.find((e) => e.name === b.name);
+    const ra = methodRank(ea?.method);
+    const rb = methodRank(eb?.method);
+    if (ra !== rb) return ra - rb;
+    return a.name.localeCompare(b.name);
+  });
+
+  return toolsOut;
+}
+
+const BULK_V1_PATH_MARK_JOB = '\uE000\uE001JOB\uE000\uE002';
+const BULK_V1_PATH_MARK_BATCH = '\uE000\uE001BATCH\uE000\uE002';
+
+/** Preserve `{{_jobId}}` / `{{_batchId}}` as `{jobId}` / `{batchId}` after resolving `_endpoint` / `version`. */
+function bulkPathAwareResolve(raw, varMap) {
+  let pre = String(raw);
+  pre = pre.replace(/\{\{_jobId\}\}/g, BULK_V1_PATH_MARK_JOB);
+  pre = pre.replace(/\{\{_batchId\}\}/g, BULK_V1_PATH_MARK_BATCH);
+  let resolved = bulkResolve(pre, varMap);
+  resolved = resolved.split(BULK_V1_PATH_MARK_JOB).join('{jobId}');
+  resolved = resolved.split(BULK_V1_PATH_MARK_BATCH).join('{batchId}');
+  return resolved;
+}
+
+/** Paths under Bulk v1 split: REST bulk query jobs (`versioned`) or Async Bulk 1.0 (`bulk-v1-async`). */
+function bulkV1PathAndKind(req, varMap) {
+  const raw = typeof req.url === 'string' ? req.url : req.url?.raw || '';
+  const resolved = bulkPathAwareResolve(raw, varMap);
+  const [pathPart, qs] = resolved.split('?');
+  if (SKIP_BULK_PATH_RE.test(pathPart)) return null;
+  const noHost = pathPart.replace(/^https?:\/\/[^/?#]+/i, '');
+
+  if (noHost.startsWith('/services/data/')) {
+    const after = noHost.slice('/services/data/'.length);
+    const m = after.match(/^(v[0-9.]+)\/(.+)$/);
+    if (!m) return null;
+    let path = `/${m[2]}`;
+    path = path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, '{$1}');
+    if (qs) path = `${path}?${qs}`;
+    return { path, urlKind: 'versioned' };
+  }
+
+  if (noHost.startsWith('/services/async/')) {
+    const after = noHost.slice('/services/async/'.length);
+    const m = after.match(/^([0-9.]+)\/(.+)$/);
+    if (!m) return null;
+    let path = `/${m[2]}`;
+    path = path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, '{$1}');
+    if (qs) path = `${path}?${qs}`;
+    return { path, urlKind: 'bulk-v1-async' };
+  }
+
+  return null;
+}
+
+function bulkV1BuildSchema(req, normalizedPath) {
+  const base = bulkBuildSchema(req, normalizedPath);
+  const pathNoQuery = normalizedPath.split('?')[0];
+  const method = String(req.method || 'GET').toUpperCase();
+  const isV1BatchPost = method === 'POST' && /\/job\/\{jobId\}\/batch$/.test(pathNoQuery);
+  const isV1SpecPost = method === 'POST' && /\/job\/\{jobId\}\/spec$/.test(pathNoQuery);
+  if (isV1BatchPost || isV1SpecPost) {
+    base.properties.csv_data = {
+      type: 'string',
+      description: 'Request body as text/csv (UTF-8)',
+    };
+    base.required = [...new Set([...(base.required || []), 'csv_data'])];
+  }
+  return base;
+}
+
+function bulkV1ExtractRequests(items, varMap, acc) {
+  for (const item of items || []) {
+    if (Array.isArray(item.item)) {
+      bulkV1ExtractRequests(item.item, varMap, acc);
+    } else if (item.request) {
+      const req = item.request;
+      const method = String(req.method || 'GET').toUpperCase();
+      if (['OPTIONS', 'HEAD', 'TRACE'].includes(method)) continue;
+
+      const parsed = bulkV1PathAndKind(req, varMap);
+      if (!parsed) continue;
+
+      const { path, urlKind } = parsed;
+      const pathKey = path.split('?')[0];
+      const dedupeKey = `${method}|${pathKey}|${urlKind}`;
+
+      acc.push({
+        dedupeKey,
+        name: `bulk_v1_${bulkSlug(item.name, MCP_TOOL_NAME_MAX_LEN - 'bulk_v1_'.length)}`,
+        description: bulkDesc(req, item.name),
+        method,
+        path,
+        urlKind,
+        inputSchema: bulkV1BuildSchema(req, path.split('?')[0]),
+      });
+    }
+  }
+}
+
+function bulkV1ManifestEndpoints() {
+  if (!existsSync(BULK_V1_POSTMAN)) return [];
+  const col = JSON.parse(readFileSync(BULK_V1_POSTMAN, 'utf8'));
+  const varMap = bulkVarMap(col);
+  const raw = [];
+  bulkV1ExtractRequests(col.item, varMap, raw);
+
+  const seen = new Set();
+  const endpoints = [];
+  for (const ep of raw) {
+    if (seen.has(ep.dedupeKey)) continue;
+    seen.add(ep.dedupeKey);
+    const { dedupeKey: _d, ...rest } = ep;
+    endpoints.push(rest);
+  }
+  return endpoints;
+}
+
+function bulkV1IsCsvQueryResultGet(method, pathNoQuery) {
+  return method === 'GET' && /\/jobs\/query\/\{jobId\}\/results$/.test(pathNoQuery);
+}
+
+function bulkV1IsCsvAsyncResultGet(method, pathNoQuery) {
+  return (
+    method === 'GET' &&
+    /\/job\/\{jobId\}\/batch\/\{batchId\}\/result(\/\{batchResultId\})?$/.test(pathNoQuery)
+  );
+}
+
+function bulkV1IsCsvPost(method, pathNoQuery) {
+  return (
+    method === 'POST' &&
+    (/\/job\/\{jobId\}\/batch$/.test(pathNoQuery) || /\/job\/\{jobId\}\/spec$/.test(pathNoQuery))
+  );
+}
+
+function bulkV1GeneratedTools() {
+  const endpoints = bulkV1ManifestEndpoints();
+  const toolsOut = [];
+
+  for (const ep of endpoints) {
+    const pathNoQuery = ep.path.split('?')[0];
+    const isCsvPost = bulkV1IsCsvPost(ep.method, pathNoQuery);
+    const isCsvGetQuery = bulkV1IsCsvQueryResultGet(ep.method, pathNoQuery);
+    const isCsvGetAsync = bulkV1IsCsvAsyncResultGet(ep.method, pathNoQuery);
+
+    if (isCsvPost) {
+      toolsOut.push({
+        name: ep.name,
+        description: ep.description,
+        inputSchema: enrichSchemaForWrite(ep.inputSchema, ep.method),
+        handler: async (params) => {
+          const [pbase, pq] = ep.path.split('?');
+          const { pathValues, rest } = splitPathAndRest(pbase, params);
+          const csv = rest.csv_data;
+          if (csv == null) throw new Error('csv_data is required');
+          await ensureAccessToken();
+          const url = getBulkV1AsyncBaseUrl() + applyPathTemplate(pbase, pathValues);
+          const staticQ = pq ? Object.fromEntries(new URLSearchParams(pq)) : {};
+          const restQuery = { ...rest };
+          delete restQuery.csv_data;
+          delete restQuery._rawBody;
+          const headers = {
+            ...buildAuthHeaders(),
+            'Content-Type': 'text/csv',
+            Accept: 'application/json',
+          };
+          try {
+            const res = await axios.post(url, csv, {
+              headers,
+              params: { ...staticQ, ...restQuery },
+              timeout: 120000,
+              validateStatus: () => true,
+            });
+            if (res.status < 200 || res.status >= 300) handleError({ response: res });
+            const d = res.data;
+            if (d == null || (typeof d === 'object' && !Object.keys(d).length)) {
+              return text({ success: true, status: res.status });
+            }
+            return text(
+              typeof d === 'string' ? { format: 'text', body: d } : d
+            );
+          } catch (e) {
+            handleError(e);
+          }
+        },
+      });
+      continue;
+    }
+
+    if (isCsvGetQuery) {
+      toolsOut.push({
+        name: ep.name,
+        description: ep.description,
+        inputSchema: enrichSchemaForWrite(ep.inputSchema, ep.method),
+        handler: async (params) => {
+          const queryPath = ep.path.includes('?') ? ep.path.split('?')[1] : '';
+          const staticQuery = queryPath ? Object.fromEntries(new URLSearchParams(queryPath)) : {};
+          const basePath = ep.path.split('?')[0];
+          const { pathValues, rest } = splitPathAndRest(basePath, params);
+          await ensureAccessToken();
+          const url = getBaseUrl() + applyPathTemplate(basePath, pathValues);
+          const headers = { ...buildAuthHeaders(), Accept: 'text/csv' };
+          const restQ = { ...rest };
+          delete restQ._rawBody;
+          try {
+            const res = await axios.get(url, {
+              headers,
+              params: { ...staticQuery, ...restQ },
+              responseType: 'text',
+              timeout: 120000,
+              validateStatus: () => true,
+            });
+            if (res.status < 200 || res.status >= 300) handleError({ response: res });
+            return text({ format: 'text/csv', body: res.data ?? '' });
+          } catch (e) {
+            handleError(e);
+          }
+        },
+      });
+      continue;
+    }
+
+    if (isCsvGetAsync) {
+      toolsOut.push({
+        name: ep.name,
+        description: ep.description,
+        inputSchema: enrichSchemaForWrite(ep.inputSchema, ep.method),
+        handler: async (params) => {
+          const basePath = ep.path.split('?')[0];
+          const { pathValues, rest } = splitPathAndRest(basePath, params);
+          await ensureAccessToken();
+          const url = getBulkV1AsyncBaseUrl() + applyPathTemplate(basePath, pathValues);
+          const headers = { ...buildAuthHeaders(), Accept: 'text/csv' };
+          const restQ = { ...rest };
+          delete restQ._rawBody;
+          try {
+            const res = await axios.get(url, {
+              headers,
+              params: restQ,
+              responseType: 'text',
+              timeout: 120000,
+              validateStatus: () => true,
+            });
+            if (res.status < 200 || res.status >= 300) handleError({ response: res });
+            return text({ format: 'text/csv', body: res.data ?? '' });
+          } catch (e) {
+            handleError(e);
+          }
+        },
+      });
+      continue;
+    }
+
+    toolsOut.push({
+      name: ep.name,
+      description: ep.description,
+      method: ep.method,
+      path: ep.path,
+      urlKind: ep.urlKind,
+      inputSchema: enrichSchemaForWrite(ep.inputSchema, ep.method),
+      handler: async (params) => {
+        const [pbase, pq] = ep.path.split('?');
+        const merged = { ...params };
+        if (pq) {
+          for (const [k, v] of new URLSearchParams(pq)) {
+            if (merged[k] === undefined) merged[k] = v;
+          }
+        }
+        const data = await sfRequest(ep.method, pbase, ep.urlKind, merged);
+        return text(data);
+      },
+    });
+  }
+
+  toolsOut.sort((a, b) => {
+    const ea = endpoints.find((e) => e.name === a.name);
+    const eb = endpoints.find((e) => e.name === b.name);
+    const ra = methodRank(ea?.method);
+    const rb = methodRank(eb?.method);
+    if (ra !== rb) return ra - rb;
+    return a.name.localeCompare(b.name);
+  });
+
+  return toolsOut;
+}
+
+/** Pathname e.g. /services/data/v59.0 for Composite sub-request URLs. */
+function compositeDataPath() {
+  const base = getBaseUrl();
+  try {
+    const pathname = new URL(base).pathname.replace(/\/$/, '');
+    if (!pathname.includes('/services/data/')) {
+      throw new Error('expected /services/data/ in base URL');
+    }
+    return pathname;
+  } catch (e) {
+    throw new Error(`Composite API: invalid instance base URL (${e.message})`);
+  }
+}
+
+function compositeBatchUrlSegment(urlIn) {
+  const u = String(urlIn || '').trim();
+  if (!u) throw new Error('Each batch request needs a non-empty url');
+  if (/^v[0-9.]+\//i.test(u)) return u;
+  if (u.startsWith('/services/data/')) {
+    const m = u.match(/\/services\/data\/(v[0-9.]+)\/(.+)$/i);
+    if (m) return `${m[1]}/${m[2]}`;
+  }
+  const verRaw = process.env.SALESFORCE_API_VERSION || 'v59.0';
+  const v = verRaw.startsWith('v') ? verRaw : `v${verRaw}`;
+  return `${v}/${u.replace(/^\//, '')}`;
+}
+
+function compositeSmartTools() {
+  return [
+    {
+      name: 'composite_create_acct_with_contact',
+      description:
+        'Creates an Account and a linked Contact in a single atomic API call using Salesforce Composite API, ensuring both records are created together or neither is created if any step fails. Use this instead of separate create_account and create_contact calls when onboarding new customers to maintain data integrity and reduce API call consumption.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          account: {
+            type: 'object',
+            description: 'Account fields (e.g. Name, Industry, BillingCity)',
+            additionalProperties: true,
+          },
+          contact: {
+            type: 'object',
+            description:
+              'Contact fields (e.g. LastName, FirstName, Email); AccountId is set automatically from the new account',
+            additionalProperties: true,
+          },
+        },
+        required: ['account', 'contact'],
+      },
+      handler: async ({ account, contact }) => {
+        const root = compositeDataPath();
+        const payload = {
+          compositeRequest: [
+            {
+              method: 'POST',
+              url: `${root}/sobjects/Account`,
+              referenceId: 'refAccount',
+              body: { ...account },
+            },
+            {
+              method: 'POST',
+              url: `${root}/sobjects/Contact`,
+              referenceId: 'refContact',
+              body: { ...contact, AccountId: '@{refAccount.id}' },
+            },
+          ],
+        };
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), 'Content-Type': 'application/json', Accept: 'application/json' };
+        try {
+          const res = await axios.post(`${getBaseUrl()}/composite/`, payload, {
+            headers,
+            timeout: 120000,
+            validateStatus: () => true,
+          });
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text(res.data);
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'comp_opp_with_contact_role',
+      description:
+        'Creates an Opportunity record and simultaneously assigns a Contact Role to link a contact to that opportunity in one atomic operation. Use this when you know the primary contact for a new deal upfront, rather than creating the opportunity first and then adding contact roles separately.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          opportunity: {
+            type: 'object',
+            description: 'Opportunity fields (e.g. Name, StageName, CloseDate, AccountId, Amount)',
+            additionalProperties: true,
+          },
+          contact_id: { type: 'string', description: 'Contact Id for the opportunity contact role' },
+          role: {
+            type: 'string',
+            description: 'Role name (e.g. Decision Maker). Default: Primary Contact',
+          },
+          is_primary: { type: 'boolean', description: 'Optional IsPrimary on OpportunityContactRole' },
+        },
+        required: ['opportunity', 'contact_id'],
+      },
+      handler: async ({ opportunity, contact_id, role, is_primary }) => {
+        const root = compositeDataPath();
+        const ocr = {
+          OpportunityId: '@{refOpp.id}',
+          ContactId: contact_id,
+          Role: role || 'Primary Contact',
+        };
+        if (is_primary === true) ocr.IsPrimary = true;
+
+        const payload = {
+          compositeRequest: [
+            {
+              method: 'POST',
+              url: `${root}/sobjects/Opportunity`,
+              referenceId: 'refOpp',
+              body: { ...opportunity },
+            },
+            {
+              method: 'POST',
+              url: `${root}/sobjects/OpportunityContactRole`,
+              referenceId: 'refOcr',
+              body: ocr,
+            },
+          ],
+        };
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), 'Content-Type': 'application/json', Accept: 'application/json' };
+        try {
+          const res = await axios.post(`${getBaseUrl()}/composite/`, payload, {
+            headers,
+            timeout: 120000,
+            validateStatus: () => true,
+          });
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text(res.data);
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'batch_get_records',
+      description:
+        'Retrieves multiple records of different Salesforce object types (up to 25) in a single API call using Composite Batch, returning all requested records in one response. Use this instead of multiple individual GET requests when you need records from different objects to significantly reduce API call usage.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          requests: {
+            type: 'array',
+            description:
+              'Each entry: { method (default GET), url } — url is the path after /services/data/, e.g. v59.0/sobjects/Account/001xxx or v59.0/query/?q=SELECT+Id+FROM+Contact+LIMIT+1',
+            items: {
+              type: 'object',
+              properties: {
+                method: { type: 'string' },
+                url: { type: 'string' },
+              },
+              required: ['url'],
+            },
+          },
+          halt_on_error: {
+            type: 'boolean',
+            description: 'Maps to haltOnError (default true)',
+          },
+        },
+        required: ['requests'],
+      },
+      handler: async ({ requests, halt_on_error }) => {
+        if (!Array.isArray(requests) || !requests.length) {
+          throw new Error('requests must be a non-empty array');
+        }
+        const batchRequests = requests.map((r) => ({
+          method: (r.method || 'GET').toUpperCase(),
+          url: compositeBatchUrlSegment(r.url),
+        }));
+        const payload = {
+          haltOnError: halt_on_error !== false,
+          batchRequests,
+        };
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), 'Content-Type': 'application/json', Accept: 'application/json' };
+        try {
+          const res = await axios.post(`${getBaseUrl()}/composite/batch`, payload, {
+            headers,
+            timeout: 120000,
+            validateStatus: () => true,
+          });
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text(res.data);
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'mass_transfer_ownership',
+      description:
+        'Transfers ownership of multiple Salesforce records to a new user in a single composite operation, processing up to 200 records at once. Use this instead of individual record updates when reassigning territories, handling user departures, or bulk ownership changes to minimize API calls and processing time.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          object_type: { type: 'string', description: 'SObject API name (same type for all ids)' },
+          record_ids: { type: 'array', items: { type: 'string' } },
+          new_owner_id: { type: 'string', description: 'User Id (005...) to assign as OwnerId' },
+          all_or_none: { type: 'boolean', description: 'Default false' },
+        },
+        required: ['object_type', 'record_ids', 'new_owner_id'],
+      },
+      handler: async ({ object_type, record_ids, new_owner_id, all_or_none }) => {
+        if (!record_ids?.length) throw new Error('record_ids must be non-empty');
+        const records = record_ids.map((id) => ({
+          attributes: { type: object_type },
+          id: String(id).trim(),
+          OwnerId: new_owner_id,
+        }));
+        const payload = { allOrNone: all_or_none === true, records };
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), 'Content-Type': 'application/json', Accept: 'application/json' };
+        try {
+          const res = await axios.patch(`${getBaseUrl()}/composite/sobjects`, payload, {
+            headers,
+            timeout: 120000,
+            validateStatus: () => true,
+          });
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text(res.data);
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+  ];
+}
+
+function getSalesforceApiVersionNumber() {
+  const verRaw = process.env.SALESFORCE_API_VERSION || 'v59.0';
+  return String(verRaw).replace(/^v/i, '');
+}
+
+function getSoapMetadataEndpointUrl() {
+  const inst =
+    process.env.SALESFORCE_INSTANCE_URL?.replace(/\/$/, '') || getInstanceUrl()?.replace(/\/$/, '');
+  if (!inst) {
+    throw new Error('SALESFORCE_INSTANCE_URL is not set.');
+  }
+  return `${inst}/services/Soap/m/${getSalesforceApiVersionNumber()}`;
+}
+
+function escapeXmlText(s) {
+  return String(s)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+function metadataWalkSoapRequests(items, out) {
+  for (const item of items || []) {
+    if (Array.isArray(item.item)) {
+      metadataWalkSoapRequests(item.item, out);
+    } else if (item.request) {
+      const r = item.request;
+      const hdrs = {};
+      for (const h of r.header || []) {
+        if (h.disabled || !h.key) continue;
+        hdrs[h.key] = h.value || '';
+      }
+      out.push({
+        itemName: item.name,
+        body: r.body?.mode === 'raw' ? r.body.raw || '' : '',
+        headers: hdrs,
+      });
+    }
+  }
+}
+
+function loadMetadataPostmanSoapRequests() {
+  if (!existsSync(METADATA_POSTMAN)) return [];
+  const col = JSON.parse(readFileSync(METADATA_POSTMAN, 'utf8'));
+  const out = [];
+  metadataWalkSoapRequests(col.item, out);
+  return out;
+}
+
+async function postMetadataSoapXml(xmlBody, headerTemplate) {
+  await ensureAccessToken();
+  const token = getToken();
+  if (!token) {
+    throw new Error('Not authenticated. Run: npx adoptai-salesforce-mcp --client cursor');
+  }
+  const xml = xmlBody.replace(/\{\{_accessToken\}\}/g, token);
+  const url = getSoapMetadataEndpointUrl();
+  const headers = {
+    'Content-Type': 'text/xml; charset=UTF-8',
+    Accept: 'text/xml',
+    ...headerTemplate,
+  };
+  try {
+    const res = await axios.post(url, xml, {
+      headers,
+      timeout: 120000,
+      validateStatus: () => true,
+    });
+    if (res.status < 200 || res.status >= 300) handleError({ response: res });
+    const payload = typeof res.data === 'string' ? { format: 'text/xml', body: res.data } : res.data;
+    return text(payload);
+  } catch (e) {
+    handleError(e);
+  }
+}
+
+function metadataSoapSlug(itemName) {
+  const base = itemName
+    .replace(/^SOAP\s+/i, '')
+    .replace(/[^a-zA-Z0-9_]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .toLowerCase();
+  return `metadata_soap_${bulkSlug(base, MCP_TOOL_NAME_MAX_LEN - 'metadata_soap_'.length)}`;
+}
+
+/** Section B: all Metadata API requests in the Postman split (SOAP to /services/Soap/m/). */
+function metadataSoapToolsFromPostman() {
+  const reqs = loadMetadataPostmanSoapRequests();
+  const tools = [];
+  for (const req of reqs) {
+    const slug = metadataSoapSlug(req.itemName);
+    if (/describe\s*metadata/i.test(req.itemName)) {
+      tools.push({
+        name: slug,
+        description:
+          'Salesforce Metadata SOAP describeMetadata — metadata component types available for this org. From Postman collection salesforce-metadata.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            as_of_version: {
+              type: 'string',
+              description: 'asOfVersion e.g. 59.0 (defaults to SALESFORCE_API_VERSION without leading v)',
+            },
+          },
+        },
+        handler: async ({ as_of_version }) => {
+          const ver = as_of_version || getSalesforceApiVersionNumber();
+          let xml = req.body.replace(/\{\{version\}\}/g, ver);
+          return postMetadataSoapXml(xml, req.headers);
+        },
+      });
+    } else if (/describe\s*value\s*type/i.test(req.itemName)) {
+      tools.push({
+        name: slug,
+        description:
+          'Salesforce Metadata SOAP describeValueType — details for a metadata type QName. From Postman collection salesforce-metadata.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            metadata_type: {
+              type: 'string',
+              description: 'Type name e.g. CustomObject, Layout, ApexClass',
+            },
+          },
+          required: ['metadata_type'],
+        },
+        handler: async ({ metadata_type }) => {
+          let xml = req.body.replace(/\{\{version\}\}/g, getSalesforceApiVersionNumber());
+          xml = xml.replace(/INSERT_METADATA_TYPE_NAME/g, metadata_type);
+          return postMetadataSoapXml(xml, req.headers);
+        },
+      });
+    } else if (/list\s*metadata/i.test(req.itemName)) {
+      tools.push({
+        name: slug,
+        description:
+          'Salesforce Metadata SOAP listMetadata — list components of a metadata type. From Postman collection salesforce-metadata.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            metadata_type: {
+              type: 'string',
+              description: 'e.g. CustomObject, ApexClass, Dashboard',
+            },
+            folder: { type: 'string', description: 'Folder name when the type uses folders' },
+            as_of_version: { type: 'string' },
+          },
+          required: ['metadata_type'],
+        },
+        handler: async ({ metadata_type, folder, as_of_version }) => {
+          const ver = as_of_version || getSalesforceApiVersionNumber();
+          let xml = req.body.replace(/\{\{version\}\}/g, ver);
+          xml = xml.replace(/<type>[^<]*<\/type>/, `<type>${escapeXmlText(metadata_type)}</type>`);
+          const folderXml = folder != null && folder !== '' ? escapeXmlText(folder) : '';
+          xml = xml.replace(/<folder>[^<]*<\/folder>/, `<folder>${folderXml}</folder>`);
+          return postMetadataSoapXml(xml, req.headers);
+        },
+      });
+    }
+  }
+  return tools;
+}
+
+function findDescribeField(describe, fieldApiName) {
+  const want = String(fieldApiName || '').toLowerCase();
+  const fields = describe?.fields || [];
+  return fields.find((f) => (f.name || '').toLowerCase() === want);
+}
+
+function extractPicklistEntries(field) {
+  if (!field) return null;
+  const out = [];
+  if (Array.isArray(field.picklistValues)) {
+    for (const p of field.picklistValues) {
+      if (p.active !== false) {
+        out.push({ label: p.label, value: p.value, defaultValue: p.defaultValue });
+      }
+    }
+    return out.length ? out : null;
+  }
+  const vs = field.valueSet;
+  if (vs?.valueSetDefinition?.value && Array.isArray(vs.valueSetDefinition.value)) {
+    for (const v of vs.valueSetDefinition.value) {
+      out.push({ label: v.label, value: v.value, default: v.default });
+    }
+    return out.length ? out : null;
+  }
+  if (vs?.controllingField) {
+    return {
+      message: 'Dependent picklist — use describe_sobject and controlling field context',
+      controllingField: vs.controllingField,
+    };
+  }
+  return null;
+}
+
+function metadataRestSmartTools() {
+  return [
+    {
+      name: 'list_sobjects',
+      description:
+        'Returns a comprehensive list of all available Salesforce objects in the org including standard objects (Account, Contact, etc.) and custom objects with their API names and metadata URLs. Use this discovery tool before querying or describing objects to understand what data structures are available in the org.',
+      method: 'GET',
+      path: '/sobjects/',
+      urlKind: 'versioned',
+      inputSchema: { type: 'object', properties: {} },
+      handler: async () => {
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), Accept: 'application/json' };
+        try {
+          const res = await axios.get(`${getBaseUrl()}/sobjects/`, {
+            headers,
+            timeout: 120000,
+            validateStatus: () => true,
+          });
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text(res.data);
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'describe_sobject',
+      description:
+        'Returns complete metadata schema for a specific Salesforce object including all field names, data types, field properties, picklist values, and relationship information. Use this before building SOQL queries or creating records to understand the object structure and available fields.',
+      method: 'GET',
+      path: '/sobjects/{object_type}/describe',
+      urlKind: 'versioned',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          object_type: {
+            type: 'string',
+            description: 'SObject API name e.g. Account, Custom__c',
+          },
+        },
+        required: ['object_type'],
+      },
+      handler: async ({ object_type }) => {
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), Accept: 'application/json' };
+        try {
+          const res = await axios.get(
+            `${getBaseUrl()}/sobjects/${encodeURIComponent(object_type)}/describe`,
+            { headers, timeout: 120000, validateStatus: () => true }
+          );
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text(res.data);
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'get_picklist_values',
+      description:
+        'Returns all valid picklist values and their labels for a specific picklist field on any Salesforce object, including dependent picklist logic if applicable. Use this before creating or updating records to ensure you\'re using valid values for fields like Opportunity Stage, Lead Status, or Account Industry.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          object_type: { type: 'string' },
+          field_name: { type: 'string', description: 'Field API name e.g. StageName, Industry' },
+        },
+        required: ['object_type', 'field_name'],
+      },
+      handler: async ({ object_type, field_name }) => {
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), Accept: 'application/json' };
+        let describe;
+        try {
+          const res = await axios.get(
+            `${getBaseUrl()}/sobjects/${encodeURIComponent(object_type)}/describe`,
+            { headers, timeout: 120000, validateStatus: () => true }
+          );
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          describe = res.data;
+        } catch (e) {
+          handleError(e);
+        }
+        const field = findDescribeField(describe, field_name);
+        if (!field) {
+          return text({ error: 'Field not found', object_type, field_name });
+        }
+        const values = extractPicklistEntries(field);
+        return text({
+          object_type,
+          field_name: field.name,
+          label: field.label,
+          type: field.type,
+          values,
+        });
+      },
+    },
+    {
+      name: 'get_org_limits',
+      description:
+        'Returns current API usage statistics and limits for the Salesforce org including daily API calls used/remaining, data storage limits, and other consumption metrics. Use this to monitor integration health and avoid hitting API limits that could disrupt operations.',
+      method: 'GET',
+      path: '/limits',
+      urlKind: 'versioned',
+      inputSchema: { type: 'object', properties: {} },
+      handler: async () => {
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), Accept: 'application/json' };
+        try {
+          const res = await axios.get(`${getBaseUrl()}/limits`, {
+            headers,
+            timeout: 60000,
+            validateStatus: () => true,
+          });
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text(res.data);
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'get_record_types',
+      description:
+        'Returns all available record types for a specific Salesforce object including their names, IDs, and default field values. Use this before creating records in orgs that implement record types to ensure you\'re specifying the correct record type ID.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          object_type: { type: 'string' },
+        },
+        required: ['object_type'],
+      },
+      handler: async ({ object_type }) => {
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), Accept: 'application/json' };
+        let describe;
+        try {
+          const res = await axios.get(
+            `${getBaseUrl()}/sobjects/${encodeURIComponent(object_type)}/describe`,
+            { headers, timeout: 120000, validateStatus: () => true }
+          );
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          describe = res.data;
+        } catch (e) {
+          handleError(e);
+        }
+        const infos = describe?.recordTypeInfos || [];
+        return text({
+          object_type,
+          recordTypeInfos: infos,
+          count: infos.length,
+        });
+      },
+    },
+  ];
+}
+
+function multipliedTools() {
+  return [
+    {
+      name: 'get_account',
+      description:
+        'Retrieves a single Account record by ID returning standard fields like Name, Industry, Type, Phone, Website, and BillingAddress. Use this for basic account information only; for accounts with related data use get_account_with_contacts or get_account_with_opportunities instead.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          account_id: { type: 'string', description: 'Salesforce Account Id' },
+          fields: {
+            type: 'string',
+            description: 'Optional comma-separated API field names (e.g. Name,Industry,BillingCity)',
+          },
+        },
+        required: ['account_id'],
+      },
+      handler: async ({ account_id, fields }) => {
+        const q = fields
+          ? `?fields=${encodeURIComponent(fields)}`
+          : '';
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), Accept: 'application/json' };
+        try {
+          const res = await axios.get(`${getBaseUrl()}/sobjects/Account/${encodeURIComponent(account_id)}${q}`, {
+            headers,
+            timeout: 60000,
+          });
+          return text(res.data);
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'get_account_with_contacts',
+      description:
+        'Retrieves an account record along with all its related contacts in a single SOQL query, returning account details plus contact information like names, emails, and phone numbers. Use this instead of separate get_account and get_contacts calls when you need both datasets together for relationship mapping or communication planning.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          account_id: { type: 'string', description: 'Salesforce Account Id' },
+        },
+        required: ['account_id'],
+      },
+      handler: async ({ account_id }) => {
+        const id = escapeSoqlString(account_id);
+        const q = `SELECT Id,Name,Industry,Type,Phone,Website,BillingStreet,BillingCity,BillingState,BillingPostalCode,BillingCountry,(SELECT Id,FirstName,LastName,Email,Phone FROM Contacts) FROM Account WHERE Id='${id}'`;
+        return text(await soqlGet(q));
+      },
+    },
+    {
+      name: 'get_account_with_opportunities',
+      description:
+        'Fetches an account and all its associated opportunities with key sales fields (stage, amount, close date) in one query. Use this for sales pipeline reviews or account revenue analysis rather than making separate account and opportunity API calls.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          account_id: { type: 'string' },
+        },
+        required: ['account_id'],
+      },
+      handler: async ({ account_id }) => {
+        const id = escapeSoqlString(account_id);
+        const q = `SELECT Id,Name,Industry,(SELECT Id,Name,StageName,Amount,CloseDate,Probability FROM Opportunities) FROM Account WHERE Id='${id}'`;
+        return text(await soqlGet(q));
+      },
+    },
+    {
+      name: 'get_account_with_cases',
+      description:
+        'Retrieves an account along with all its open support cases, showing case numbers, subjects, priorities, and status. Use this for customer health assessments or before support escalation calls instead of querying accounts and cases separately.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          account_id: { type: 'string' },
+        },
+        required: ['account_id'],
+      },
+      handler: async ({ account_id }) => {
+        const id = escapeSoqlString(account_id);
+        const q = `SELECT Id,Name,(SELECT Id,CaseNumber,Subject,Status,Priority,CreatedDate FROM Cases WHERE IsClosed=false) FROM Account WHERE Id='${id}'`;
+        return text(await soqlGet(q));
+      },
+    },
+    {
+      name: 'get_account_full_profile',
+      description:
+        'Fetches a comprehensive account view including all related contacts, opportunities, and cases in a single API call. Use this for complete customer profiles before meetings or account reviews, but avoid for focused workflows where you only need specific related data to minimize response size.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          account_id: { type: 'string' },
+        },
+        required: ['account_id'],
+      },
+      handler: async ({ account_id }) => {
+        const id = escapeSoqlString(account_id);
+        const q = `SELECT Id,Name,Industry,Type,Phone,Website,BillingCity,BillingCountry,(SELECT Id,FirstName,LastName,Email,Phone FROM Contacts),(SELECT Id,Name,StageName,Amount,CloseDate FROM Opportunities),(SELECT Id,CaseNumber,Subject,Status FROM Cases WHERE IsClosed=false) FROM Account WHERE Id='${id}'`;
+        return text(await soqlGet(q));
+      },
+    },
+    {
+      name: 'update_opportunity',
+      description:
+        'Updates multiple fields on an opportunity record by passing any combination of field-value pairs in the request. Use this for complex updates involving several fields simultaneously, but prefer the specific single-field update tools (stage, amount, close_date) for focused changes to avoid unnecessary field overwrites.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          opportunity_id: { type: 'string' },
+          fields: {
+            type: 'object',
+            description: 'JSON object of Opportunity fields to PATCH (e.g. StageName, Amount, CloseDate)',
+            additionalProperties: true,
+          },
+        },
+        required: ['opportunity_id', 'fields'],
+      },
+      handler: async ({ opportunity_id, fields }) => {
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), 'Content-Type': 'application/json' };
+        try {
+          const res = await axios.patch(
+            `${getBaseUrl()}/sobjects/Opportunity/${encodeURIComponent(opportunity_id)}`,
+            fields,
+            { headers, timeout: 60000, validateStatus: () => true }
+          );
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text(res.data && Object.keys(res.data).length ? res.data : { success: true });
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'update_opportunity_stage',
+      description:
+        'Updates only the stage field of an opportunity (e.g., from \'Prospecting\' to \'Proposal\'), which is the most frequent sales action. Use this instead of the generic update_opportunity when only moving deals through the sales process to ensure clean stage progression tracking.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          opportunity_id: { type: 'string' },
+          stage: { type: 'string', description: 'StageName value' },
+          close_date: { type: 'string', description: 'Optional CloseDate (YYYY-MM-DD)' },
+          probability: { type: 'number', description: 'Optional Probability percent' },
+        },
+        required: ['opportunity_id', 'stage'],
+      },
+      handler: async ({ opportunity_id, stage, close_date, probability }) => {
+        const body = { StageName: stage };
+        if (close_date != null) body.CloseDate = close_date;
+        if (probability != null) body.Probability = probability;
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), 'Content-Type': 'application/json' };
+        try {
+          const res = await axios.patch(
+            `${getBaseUrl()}/sobjects/Opportunity/${encodeURIComponent(opportunity_id)}`,
+            body,
+            { headers, timeout: 60000, validateStatus: () => true }
+          );
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text({ success: true });
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'update_opportunity_amount',
+      description:
+        'Updates only the Amount field of an opportunity to reflect changed deal value during negotiations. Use this focused tool instead of update_opportunity when deal size changes but other fields remain unchanged to maintain accurate opportunity history.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          opportunity_id: { type: 'string' },
+          amount: { type: 'number' },
+        },
+        required: ['opportunity_id', 'amount'],
+      },
+      handler: async ({ opportunity_id, amount }) => {
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), 'Content-Type': 'application/json' };
+        try {
+          const res = await axios.patch(
+            `${getBaseUrl()}/sobjects/Opportunity/${encodeURIComponent(opportunity_id)}`,
+            { Amount: amount },
+            { headers, timeout: 60000, validateStatus: () => true }
+          );
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text({ success: true });
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'update_opportunity_close_date',
+      description:
+        'Updates only the CloseDate field to reflect when an opportunity is expected to close, typically used when deals slip or accelerate. Use this instead of update_opportunity for timeline adjustments to preserve accurate forecasting data without touching other fields.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          opportunity_id: { type: 'string' },
+          close_date: { type: 'string', description: 'CloseDate (YYYY-MM-DD)' },
+        },
+        required: ['opportunity_id', 'close_date'],
+      },
+      handler: async ({ opportunity_id, close_date }) => {
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), 'Content-Type': 'application/json' };
+        try {
+          const res = await axios.patch(
+            `${getBaseUrl()}/sobjects/Opportunity/${encodeURIComponent(opportunity_id)}`,
+            { CloseDate: close_date },
+            { headers, timeout: 60000, validateStatus: () => true }
+          );
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text({ success: true });
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'close_won_opportunity',
+      description:
+        'Sets an opportunity to Closed Won with probability 100% and CloseDate set to today or the date you provide. Use when a deal is confirmed won instead of a generic stage update.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          opportunity_id: { type: 'string' },
+          close_date: {
+            type: 'string',
+            description: 'Optional YYYY-MM-DD; defaults to today (UTC date)',
+          },
+        },
+        required: ['opportunity_id'],
+      },
+      handler: async ({ opportunity_id, close_date }) => {
+        const today = new Date().toISOString().slice(0, 10);
+        const body = {
+          StageName: 'Closed Won',
+          Probability: 100,
+          CloseDate: close_date || today,
+        };
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), 'Content-Type': 'application/json' };
+        try {
+          const res = await axios.patch(
+            `${getBaseUrl()}/sobjects/Opportunity/${encodeURIComponent(opportunity_id)}`,
+            body,
+            { headers, timeout: 60000, validateStatus: () => true }
+          );
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text({ success: true });
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'close_lost_opportunity',
+      description:
+        'Sets an opportunity to \'Closed Lost\' stage, automatically sets probability to 0%, and optionally captures the loss reason for reporting. Use this instead of manual updates when deals are confirmed lost to ensure complete loss tracking and proper probability reset.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          opportunity_id: { type: 'string' },
+          loss_reason: { type: 'string', description: 'Optional custom loss reason field if configured' },
+        },
+        required: ['opportunity_id'],
+      },
+      handler: async ({ opportunity_id, loss_reason }) => {
+        const body = { StageName: 'Closed Lost', Probability: 0 };
+        if (loss_reason) {
+          body.Description = loss_reason;
+        }
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), 'Content-Type': 'application/json' };
+        try {
+          const res = await axios.patch(
+            `${getBaseUrl()}/sobjects/Opportunity/${encodeURIComponent(opportunity_id)}`,
+            body,
+            { headers, timeout: 60000, validateStatus: () => true }
+          );
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text({ success: true });
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'run_soql_query',
+      description:
+        'Executes any raw SOQL query and returns matching records with all requested fields, limited to 2000 records per call. Use when you need custom field combinations or complex WHERE clauses that the specialized search tools don\'t support, but prefer specific search tools for common lookups since they\'re simpler.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'Raw SOQL string' },
+          limit: {
+            type: 'number',
+            description:
+              'If the query has no LIMIT clause, append this LIMIT (optional). Leave unset if your query already includes LIMIT.',
+          },
+        },
+        required: ['query'],
+      },
+      handler: async ({ query, limit }) => {
+        let q = query.trim();
+        if (limit != null && !/\blimit\s+\d+/i.test(q)) {
+          q = `${q} LIMIT ${Number(limit)}`;
+        }
+        return text(await soqlGet(q));
+      },
+    },
+    {
+      name: 'run_soql_query_all_pages',
+      description:
+        'Executes a SOQL query and automatically handles pagination to return the complete dataset of all matching records, regardless of size. Use when you need full data exports or comprehensive analysis where missing records would compromise results, but avoid for large datasets unless truly necessary due to performance impact.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'SOQL without automatic LIMIT' },
+          max_records: { type: 'number', description: 'Safety cap (default 10000)' },
+        },
+        required: ['query'],
+      },
+      handler: async ({ query, max_records }) => {
+        const cap = max_records != null ? Number(max_records) : 10000;
+        return text(await fetchQueryAllPages(query.trim(), cap));
+      },
+    },
+    {
+      name: 'search_accounts',
+      description:
+        'Searches Account records by name, industry, type, or location fields and returns basic account information including IDs. Use this instead of writing SOQL for common account lookups, then use the returned ID with get_account for full record details.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          industry: { type: 'string' },
+          type: { type: 'string' },
+          city: { type: 'string', description: 'BillingCity' },
+          limit: { type: 'number', description: 'Default 20' },
+        },
+        required: [],
+      },
+      handler: async (p) => {
+        const lim = p.limit != null ? Number(p.limit) : 20;
+        const where = buildSearchWhere({
+          Name: p.name,
+          Industry: p.industry,
+          Type: p.type,
+          BillingCity: p.city,
+        });
+        if (!where) {
+          throw new Error('Provide at least one of name, industry, type, or city');
+        }
+        const q = `SELECT Id,Name,Industry,Type,BillingCity FROM Account WHERE ${where} LIMIT ${lim}`;
+        return text(await soqlGet(q));
+      },
+    },
+    {
+      name: 'search_contacts',
+      description:
+        'Searches Contact records by name, email, phone, or associated account and returns basic contact information including IDs. Use this for finding contacts without writing SOQL, then retrieve full contact details using the returned ID with direct read operations.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          name: { type: 'string', description: 'Matches FirstName or LastName' },
+          email: { type: 'string' },
+          phone: { type: 'string' },
+          account_name: { type: 'string', description: 'Account.Name via subquery filter — uses AccountId in LIKE' },
+          title: { type: 'string' },
+          limit: { type: 'number' },
+        },
+        required: [],
+      },
+      handler: async (p) => {
+        const lim = p.limit != null ? Number(p.limit) : 20;
+        const parts = [];
+        if (p.name) {
+          const x = escapeSoqlString(p.name);
+          parts.push(`(FirstName LIKE '%${x}%' OR LastName LIKE '%${x}%')`);
+        }
+        if (p.email) parts.push(`Email LIKE '%${escapeSoqlString(p.email)}%'`);
+        if (p.phone) parts.push(`Phone LIKE '%${escapeSoqlString(p.phone)}%'`);
+        if (p.title) parts.push(`Title LIKE '%${escapeSoqlString(p.title)}%'`);
+        if (p.account_name) {
+          parts.push(
+            `AccountId IN (SELECT Id FROM Account WHERE Name LIKE '%${escapeSoqlString(p.account_name)}%')`
+          );
+        }
+        if (!parts.length) throw new Error('Provide at least one search criterion');
+        const q = `SELECT Id,FirstName,LastName,Email,Phone,Title,AccountId FROM Contact WHERE ${parts.join(' AND ')} LIMIT ${lim}`;
+        return text(await soqlGet(q));
+      },
+    },
+    {
+      name: 'search_leads',
+      description:
+        'Searches Lead records by name, company, email, or status fields and returns basic lead information including IDs. Use this to locate leads without SOQL knowledge, then use get_lead with the returned ID for complete lead record access.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          company: { type: 'string' },
+          email: { type: 'string' },
+          status: { type: 'string' },
+          lead_source: { type: 'string' },
+          limit: { type: 'number' },
+        },
+        required: [],
+      },
+      handler: async (p) => {
+        const lim = p.limit != null ? Number(p.limit) : 20;
+        const parts = [];
+        if (p.name) {
+          const x = escapeSoqlString(p.name);
+          parts.push(`(FirstName LIKE '%${x}%' OR LastName LIKE '%${x}%')`);
+        }
+        if (p.company) parts.push(`Company LIKE '%${escapeSoqlString(p.company)}%'`);
+        if (p.email) parts.push(`Email LIKE '%${escapeSoqlString(p.email)}%'`);
+        if (p.status) parts.push(`Status LIKE '%${escapeSoqlString(p.status)}%'`);
+        if (p.lead_source) parts.push(`LeadSource LIKE '%${escapeSoqlString(p.lead_source)}%'`);
+        if (!parts.length) throw new Error('Provide at least one search criterion');
+        const q = `SELECT Id,FirstName,LastName,Company,Email,Status,LeadSource FROM Lead WHERE ${parts.join(' AND ')} LIMIT ${lim}`;
+        return text(await soqlGet(q));
+      },
+    },
+    {
+      name: 'search_opportunities',
+      description:
+        'Searches Opportunity records by stage, amount, close date, or other criteria and returns matching opportunities with key sales fields. Use this for finding deals by sales criteria without writing SOQL, ideal for pipeline analysis and deal research.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          account_name: { type: 'string' },
+          stage: { type: 'string', description: 'StageName' },
+          min_amount: { type: 'number' },
+          max_amount: { type: 'number' },
+          closing_before: { type: 'string', description: 'CloseDate < date (YYYY-MM-DD)' },
+          closing_after: { type: 'string', description: 'CloseDate > date' },
+          limit: { type: 'number' },
+        },
+        required: [],
+      },
+      handler: async (p) => {
+        const lim = p.limit != null ? Number(p.limit) : 20;
+        const parts = [];
+        if (p.name) parts.push(`Name LIKE '%${escapeSoqlString(p.name)}%'`);
+        if (p.account_name) {
+          parts.push(
+            `AccountId IN (SELECT Id FROM Account WHERE Name LIKE '%${escapeSoqlString(p.account_name)}%')`
+          );
+        }
+        if (p.stage) parts.push(`StageName LIKE '%${escapeSoqlString(p.stage)}%'`);
+        if (p.min_amount != null) parts.push(`Amount >= ${Number(p.min_amount)}`);
+        if (p.max_amount != null) parts.push(`Amount <= ${Number(p.max_amount)}`);
+        if (p.closing_before) parts.push(`CloseDate < ${escapeSoqlString(p.closing_before)}`);
+        if (p.closing_after) parts.push(`CloseDate > ${escapeSoqlString(p.closing_after)}`);
+        if (!parts.length) throw new Error('Provide at least one search criterion');
+        const q = `SELECT Id,Name,StageName,Amount,CloseDate,AccountId FROM Opportunity WHERE ${parts.join(' AND ')} LIMIT ${lim}`;
+        return text(await soqlGet(q));
+      },
+    },
+    {
+      name: 'get_pipeline_summary',
+      description:
+        'Returns an aggregated view of the sales pipeline showing deal count and total value grouped by opportunity stage. Use this for quick pipeline health checks and forecasting instead of writing complex GROUP BY SOQL queries.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          owner_id: { type: 'string', description: 'Optional OwnerId filter' },
+          period: {
+            type: 'string',
+            enum: ['this_month', 'this_quarter', 'next_quarter'],
+            description: 'Filters on CloseDate relative period (open opps)',
+          },
+        },
+        required: [],
+      },
+      handler: async ({ owner_id, period }) => {
+        const per = period || 'this_month';
+        const clauses = ['IsClosed = false', pipelinePeriodClause(per)];
+        if (owner_id) clauses.push(`OwnerId = '${escapeSoqlString(owner_id)}'`);
+        const q = `SELECT StageName, COUNT(Id), SUM(Amount) FROM Opportunity WHERE ${clauses.join(' AND ')} GROUP BY StageName`;
+        return text(await soqlGet(q));
+      },
+    },
+    {
+      name: 'global_search',
+      description:
+        'Runs SOSL across Accounts, Contacts, Leads, and Opportunities and returns matches from each type. Use when you have a name, email, or keyword but are not sure which object holds the record.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          search_term: { type: 'string' },
+          objects: {
+            type: 'array',
+            items: { type: 'string' },
+            description:
+              'Optional API names to RETURNING (default Account,Contact,Lead,Opportunity)',
+          },
+          limit: { type: 'number', description: 'Per-object row limit (default 10)' },
+        },
+        required: ['search_term'],
+      },
+      handler: async ({ search_term, objects, limit }) => {
+        const lim = limit != null ? Number(limit) : 10;
+        const term = escapeSoqlString(search_term);
+        const objs = Array.isArray(objects) && objects.length
+          ? objects
+          : ['Account', 'Contact', 'Lead', 'Opportunity'];
+        const returning = objs.map((o) => `${o}(Id,Name)`).join(',');
+        const sosl = `FIND {${term}} IN ALL FIELDS RETURNING ${returning} LIMIT ${lim}`;
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), Accept: 'application/json' };
+        const url = `${getBaseUrl()}/search/?q=${encodeURIComponent(sosl)}`;
+        try {
+          const res = await axios.get(url, { headers, timeout: 60000 });
+          return text(res.data);
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'create_task',
+      description: 'Creates a new Task record with complete control over all available fields including subject, description, priority, due date, and related record associations. Use when you need to set specific task fields that the specialized task creation tools don\'t support.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          fields: {
+            type: 'object',
+            description:
+              'Task fields (Subject, ActivityDate, OwnerId, WhoId, WhatId, Status, Priority, Description, etc.)',
+            additionalProperties: true,
+          },
+        },
+        required: ['fields'],
+      },
+      handler: async ({ fields }) => {
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), 'Content-Type': 'application/json' };
+        try {
+          const res = await axios.post(`${getBaseUrl()}/sobjects/Task`, fields, {
+            headers,
+            timeout: 60000,
+            validateStatus: () => true,
+          });
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text(res.data);
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'log_call',
+      description:
+        'Creates a Task record specifically for logging completed phone calls, automatically setting Type=\'Call\' and Status=\'Completed\' while linking to a Contact or Lead. Use this after sales or support calls instead of generic task creation since it pre-fills call-specific fields and ensures proper activity tracking.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          subject: { type: 'string' },
+          who_id: { type: 'string', description: 'WhoId (Contact or Lead Id)' },
+          what_id: { type: 'string', description: 'Optional WhatId (Account, Opportunity, etc.)' },
+          description: { type: 'string' },
+          duration_minutes: { type: 'number' },
+          call_disposition: { type: 'string' },
+          call_type: { type: 'string' },
+        },
+        required: ['subject'],
+      },
+      handler: async (p) => {
+        const task = {
+          Subject: p.subject,
+          Type: 'Call',
+          Status: 'Completed',
+          TaskSubtype: 'Call',
+        };
+        if (p.who_id) task.WhoId = p.who_id;
+        if (p.what_id) task.WhatId = p.what_id;
+        if (p.description) task.Description = p.description;
+        if (p.duration_minutes != null) task.CallDurationInSeconds = Number(p.duration_minutes) * 60;
+        if (p.call_disposition) task.CallDisposition = p.call_disposition;
+        if (p.call_type) task.CallType = p.call_type;
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), 'Content-Type': 'application/json' };
+        try {
+          const res = await axios.post(`${getBaseUrl()}/sobjects/Task`, task, {
+            headers,
+            timeout: 60000,
+            validateStatus: () => true,
+          });
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text(res.data);
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'log_email',
+      description:
+        'Creates an EmailMessage activity record in Salesforce to log outbound emails sent to Contacts or Leads, preserving email communication history in the CRM. Use this instead of manual activity logging when you need to formally document important email correspondence for compliance or sales tracking purposes.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          subject: { type: 'string' },
+          to_address: { type: 'string' },
+          who_id: { type: 'string', description: 'Related Contact or Lead Id' },
+          what_id: { type: 'string', description: 'Optional related record Id' },
+          body: { type: 'string' },
+          sent_date: { type: 'string', description: 'ISO or Salesforce datetime string' },
+        },
+        required: ['subject'],
+      },
+      handler: async (p) => {
+        const msg = {
+          Subject: p.subject,
+          Status: '3',
+          Incoming: false,
+          TextBody: p.body || '',
+        };
+        if (p.to_address) msg.ToAddress = p.to_address;
+        if (p.sent_date) msg.MessageDate = p.sent_date;
+        if (p.what_id) msg.RelatedToId = p.what_id;
+        else if (p.who_id) msg.RelatedToId = p.who_id;
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), 'Content-Type': 'application/json' };
+        try {
+          const res = await axios.post(`${getBaseUrl()}/sobjects/EmailMessage`, msg, {
+            headers,
+            timeout: 60000,
+            validateStatus: () => true,
+          });
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text(res.data);
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'create_followup_task',
+      description:
+        'Creates a Task record with a specified due date and links it to a Contact, Lead, or Opportunity to set follow-up reminders. This is the primary tool for sales workflow management - use after any customer interaction to ensure timely follow-up and avoid missed opportunities.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          subject: { type: 'string' },
+          who_id: { type: 'string' },
+          what_id: { type: 'string' },
+          due_date: { type: 'string', description: 'ActivityDate (YYYY-MM-DD)' },
+          priority: { type: 'string' },
+          assigned_to_id: { type: 'string', description: 'OwnerId' },
+          description: { type: 'string' },
+        },
+        required: ['subject', 'due_date'],
+      },
+      handler: async (p) => {
+        const task = {
+          Subject: p.subject,
+          ActivityDate: p.due_date,
+          Status: 'Not Started',
+        };
+        if (p.who_id) task.WhoId = p.who_id;
+        if (p.what_id) task.WhatId = p.what_id;
+        if (p.priority) task.Priority = p.priority;
+        if (p.assigned_to_id) task.OwnerId = p.assigned_to_id;
+        if (p.description) task.Description = p.description;
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), 'Content-Type': 'application/json' };
+        try {
+          const res = await axios.post(`${getBaseUrl()}/sobjects/Task`, task, {
+            headers,
+            timeout: 60000,
+            validateStatus: () => true,
+          });
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text(res.data);
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'get_todays_tasks',
+      description:
+        'Retrieves all open Task records assigned to the current user with today\'s due date, with an option to include overdue tasks for comprehensive daily planning. Use this at the beginning of each workday to get a prioritized list of follow-ups and activities that need immediate attention.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          user_id: {
+            type: 'string',
+            description: 'OwnerId — defaults to connected user from login',
+          },
+          include_overdue: {
+            type: 'boolean',
+            description: 'If true, includes tasks with ActivityDate < TODAY',
+          },
+        },
+        required: [],
+      },
+      handler: async ({ user_id, include_overdue }) => {
+        const uid = user_id || getDefaultUserId();
+        if (!uid) {
+          throw new Error('user_id required (no user id stored from OAuth — pass user_id explicitly)');
+        }
+        const dateClause = include_overdue
+          ? '(ActivityDate = TODAY OR ActivityDate < TODAY)'
+          : 'ActivityDate = TODAY';
+        const q = `SELECT Id,Subject,ActivityDate,Status,Priority,WhoId,WhatId FROM Task WHERE OwnerId='${escapeSoqlString(uid)}' AND IsClosed=false AND ${dateClause} ORDER BY ActivityDate ASC`;
+        return text(await soqlGet(q));
+      },
+    },
+    {
+      name: 'get_overdue_tasks',
+      description:
+        'Retrieves all open Task records assigned to the current user that are past their due date, helping identify missed follow-ups requiring urgent action. Use this specifically when you need to focus on overdue items rather than today\'s full task list from get_todays_tasks.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          user_id: { type: 'string' },
+          limit: { type: 'number', description: 'Default 50' },
+        },
+        required: [],
+      },
+      handler: async ({ user_id, limit }) => {
+        const uid = user_id || getDefaultUserId();
+        if (!uid) {
+          throw new Error('user_id required (no user id stored from OAuth — pass user_id explicitly)');
+        }
+        const lim = limit != null ? Number(limit) : 50;
+        const q = `SELECT Id,Subject,ActivityDate,Status,Priority FROM Task WHERE OwnerId='${escapeSoqlString(uid)}' AND IsClosed=false AND ActivityDate < TODAY ORDER BY ActivityDate ASC LIMIT ${lim}`;
+        return text(await soqlGet(q));
+      },
+    },
+    {
+      name: 'update_lead',
+      description: 'Updates multiple fields on a Lead record in a single operation, allowing comprehensive lead data modification including contact details, company information, and custom fields. Use this for bulk lead updates rather than update_lead_status when you need to modify fields beyond just the lead status.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          lead_id: { type: 'string' },
+          fields: { type: 'object', additionalProperties: true },
+        },
+        required: ['lead_id', 'fields'],
+      },
+      handler: async ({ lead_id, fields }) => {
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), 'Content-Type': 'application/json' };
+        try {
+          const res = await axios.patch(
+            `${getBaseUrl()}/sobjects/Lead/${encodeURIComponent(lead_id)}`,
+            fields,
+            { headers, timeout: 60000, validateStatus: () => true }
+          );
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text({ success: true });
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'update_lead_status',
+      description:
+        'Updates only the Status field on a Lead record to move it through the qualification pipeline (New, Working, Qualified, etc.). Use this focused tool instead of update_lead when you only need to change lead status, as it\'s more efficient and maintains proper status workflow validation.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          lead_id: { type: 'string' },
+          status: {
+            type: 'string',
+            description: 'Status picklist value (e.g. New, Working, Nurturing, Qualified, Unqualified)',
+          },
+        },
+        required: ['lead_id', 'status'],
+      },
+      handler: async ({ lead_id, status }) => {
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), 'Content-Type': 'application/json' };
+        try {
+          const res = await axios.patch(
+            `${getBaseUrl()}/sobjects/Lead/${encodeURIComponent(lead_id)}`,
+            { Status: status },
+            { headers, timeout: 60000, validateStatus: () => true }
+          );
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text({ success: true });
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+    {
+      name: 'convert_lead',
+      description:
+        'Transforms a qualified Lead into separate Account, Contact, and optionally Opportunity records, completing the lead-to-customer conversion process. This is a one-way operation that should only be used when a lead is fully sales-qualified, as it fundamentally changes the data structure and cannot be easily reversed.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          lead_id: { type: 'string' },
+          create_opportunity: { type: 'boolean', description: 'Default true' },
+          opportunity_name: { type: 'string' },
+          account_id: { type: 'string' },
+          contact_id: { type: 'string' },
+          converted_status: {
+            type: 'string',
+            description: 'Converted status label (org-specific)',
+          },
+        },
+        required: ['lead_id'],
+      },
+      handler: async (p) => {
+        const createOpp = p.create_opportunity !== false;
+        const inputs = [
+          {
+            leadId: p.lead_id,
+            convertedStatus: p.converted_status || 'Qualified - Converted',
+            doNotCreateOpportunity: !createOpp,
+            opportunityName: createOpp ? p.opportunity_name || null : null,
+            accountId: p.account_id || null,
+            contactId: p.contact_id || null,
+            sendEmailToOwner: false,
+          },
+        ];
+        await ensureAccessToken();
+        const headers = { ...buildAuthHeaders(), 'Content-Type': 'application/json' };
+        const url = `${getBaseUrl()}/sobjects/Lead/${encodeURIComponent(p.lead_id)}/actions/standard/convert`;
+        try {
+          const res = await axios.post(url, { inputs }, { headers, timeout: 120000, validateStatus: () => true });
+          if (res.status < 200 || res.status >= 300) handleError({ response: res });
+          return text(res.data);
+        } catch (e) {
+          handleError(e);
+        }
+      },
+    },
+  ];
+}
+
+function connectSmartTools() {
+  return [
+    {
+      name: 'post_chatter_message',
+      description:
+        'Creates a new post on a Salesforce Chatter feed for a specific record, user, or group, enabling team collaboration and @mentions within the CRM. Use this to share updates, ask questions, or notify team members about important record changes directly in the Salesforce social collaboration layer.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          feed_element_type: {
+            type: 'string',
+            description: 'Usually FeedItem for a standard post.',
+            default: 'FeedItem',
+          },
+          subject_id: {
+            type: 'string',
+            description: 'Record, group or user ID the feed belongs to.',
+          },
+          message_text: {
+            type: 'string',
+            description: 'Plain text body (before @mentions).',
+          },
+          mentions: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Salesforce user IDs to @mention (order is appended after message_text).',
+          },
+        },
+        required: ['subject_id', 'feed_element_type'],
+      },
+      handler: async (p) => {
+        const feedElementType = p.feed_element_type || 'FeedItem';
+        const subjectId = p.subject_id;
+        const textPart = p.message_text != null ? String(p.message_text) : '';
+        const mentionIds = Array.isArray(p.mentions) ? p.mentions.filter(Boolean) : [];
+        if (!textPart.trim() && mentionIds.length === 0) {
+          throw new Error('Provide message_text and/or mentions');
+        }
+        const messageSegments = [];
+        if (textPart.length) messageSegments.push({ type: 'Text', text: textPart });
+        for (const id of mentionIds) {
+          messageSegments.push({ type: 'Mention', id: String(id) });
+        }
+        const body = {
+          feedElementType,
+          subjectId,
+          body: { messageSegments },
+        };
+        const data = await sfRequest('POST', '/chatter/feed-elements', 'versioned', body);
+        return text(data);
+      },
+    },
+    {
+      name: 'get_record_feed',
+      description:
+        'Retrieves all Chatter feed items (posts, comments, file shares) associated with a specific Salesforce record like Account, Opportunity, or Case. Use this to review the complete collaboration history and team communications related to a particular customer or deal.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          record_id: { type: 'string' },
+          page_size: { type: 'number', description: 'Default 25', default: 25 },
+        },
+        required: ['record_id'],
+      },
+      handler: async ({ record_id, page_size }) => {
+        const ps = page_size != null && Number.isFinite(Number(page_size)) ? Number(page_size) : 25;
+        const data = await sfRequest(
+          'GET',
+          '/chatter/feeds/record/{RECORD_GROUP_ID}/feed-elements',
+          'versioned',
+          { RECORD_GROUP_ID: record_id, pageSize: ps }
+        );
+        return text(data);
+      },
+    },
+    {
+      name: 'upload_file_to_record',
+      description:
+        'Uploads a file from your local system and attaches it directly to any Salesforce record using the Files Connect API, creating a ContentDocument relationship. Use this to attach contracts, proposals, images, or other documents to Accounts, Opportunities, Cases, or any custom object record.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          record_id: { type: 'string' },
+          file_name: { type: 'string' },
+          file_content_base64: { type: 'string', description: 'File bytes as base64 (no data: URL prefix).' },
+          description: {
+            type: 'string',
+            description: 'Optional feed text shown with the attachment.',
+          },
+        },
+        required: ['record_id', 'file_name', 'file_content_base64'],
+      },
+      handler: async ({ record_id, file_name, file_content_base64, description }) => {
+        await ensureAccessToken();
+        const headers = buildAuthHeaders();
+        const buf = Buffer.from(String(file_content_base64), 'base64');
+        const form = new FormData();
+        form.append('fileData', new Blob([buf]), file_name);
+        const upUrl = `${getBaseUrl()}/connect/files/users/me`;
+        let upRes;
+        try {
+          upRes = await fetch(upUrl, { method: 'POST', headers, body: form });
+        } catch (e) {
+          throw new Error(e?.message || 'File upload request failed');
+        }
+        const upText = await upRes.text();
+        let fileMeta;
+        try {
+          fileMeta = upText ? JSON.parse(upText) : {};
+        } catch {
+          throw new Error(`Upload response not JSON (${upRes.status}): ${upText.slice(0, 500)}`);
+        }
+        if (!upRes.ok) {
+          handleError({ response: { status: upRes.status, data: fileMeta, statusText: upRes.statusText } });
+        }
+        const fileId = fileMeta.id;
+        if (!fileId) throw new Error('Upload succeeded but no file id in response');
+        const feedBody = {
+          feedElementType: 'FeedItem',
+          subjectId: record_id,
+          capabilities: { files: { items: [{ id: fileId }] } },
+        };
+        if (description != null && String(description).trim()) {
+          feedBody.body = {
+            messageSegments: [{ type: 'Text', text: String(description).trim() }],
+          };
+        }
+        const data = await sfRequest('POST', '/chatter/feed-elements', 'versioned', feedBody);
+        return text({ upload: fileMeta, feedElement: data });
+      },
+    },
+    {
+      name: 'get_user_profile',
+      description:
+        'Loads Chatter user profile (name, title, department, email, photo URL) for context before assignments or handoffs.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          user_id: {
+            type: 'string',
+            description: 'User id or me for the connected user (default me).',
+          },
+        },
+        required: [],
+      },
+      handler: async ({ user_id }) => {
+        const uid =
+          user_id === undefined || user_id === null || String(user_id).trim() === ''
+            ? 'me'
+            : String(user_id).trim();
+        const path =
+          uid === 'me' ? '/chatter/users/me' : `/chatter/users/${encodeURIComponent(uid)}`;
+        const data = await sfRequest('GET', path, 'versioned', {});
+        return text(data);
+      },
+    },
+    {
+      name: 'list_groups',
+      description:
+        'Returns Chatter groups that the current user belongs to or searches all groups by name, providing group IDs and metadata needed for posting to group feeds. Use this before posting content to groups to ensure proper group targeting and access permissions.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'Optional search string (group name).' },
+          limit: { type: 'number', description: 'Default 25 (pageSize).', default: 25 },
+        },
+        required: [],
+      },
+      handler: async ({ query, limit }) => {
+        const pageSize = limit != null && Number.isFinite(Number(limit)) ? Number(limit) : 25;
+        const params = { pageSize };
+        if (query != null && String(query).trim() !== '') params.q = String(query).trim();
+        const data = await sfRequest('GET', '/chatter/groups', 'versioned', params);
+        return text(data);
+      },
+    },
+  ];
+}
+
+function toolingSmartTools() {
+  return [
+    {
+      name: 'execute_apex',
+      description:
+        'Executes anonymous Apex code directly against the Salesforce org and returns compilation results, debug log pointers, and any execution errors without requiring deployment. Ideal for testing code snippets, running one-off data fixes, or prototyping custom logic using the Tooling API\'s executeAnonymous endpoint.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          apex_body: {
+            type: 'string',
+            description: 'Apex source to run anonymously (e.g. `System.debug(\\\'x\\\');`).',
+          },
+        },
+        required: ['apex_body'],
+      },
+      handler: async ({ apex_body }) => {
+        const data = await sfRequest('GET', '/executeAnonymous', 'tooling', {
+          anonymousBody: apex_body,
+        });
+        return text(data);
+      },
+    },
+    {
+      name: 'get_apex_logs',
+      description:
+        'Retrieves recent Apex debug logs from the organization to help diagnose failed integrations, custom code execution issues, or performance problems. Use after executing Apex code or when troubleshooting unexpected behavior in custom development.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          limit: { type: 'number', description: 'Default 10', default: 10 },
+          user_id: {
+            type: 'string',
+            description: 'Optional: filter logs to this Salesforce user Id (LogUserId).',
+          },
+        },
+        required: [],
+      },
+      handler: async ({ limit, user_id }) => {
+        const limRaw = limit != null && Number.isFinite(Number(limit)) ? Number(limit) : 10;
+        const lim = Math.max(1, Math.min(2000, Math.trunc(limRaw)));
+        let q =
+          'SELECT Id, Application, DurationMilliseconds, Location, LogLength, LogUserId, Operation, Request, StartTime, Status FROM ApexLog';
+        if (user_id != null && String(user_id).trim() !== '') {
+          q += ` WHERE LogUserId='${escapeSoqlString(String(user_id).trim())}'`;
+        }
+        q += ` ORDER BY StartTime DESC LIMIT ${lim}`;
+        const data = await sfRequest('GET', '/query', 'tooling', { q });
+        return text(data);
+      },
+    },
+    {
+      name: 'run_apex_tests',
+      description:
+        'Triggers asynchronous execution of Apex test classes via the Tooling API and returns the job ID for polling test results. Essential for validating org health and code coverage before deployments, though you\'ll need to poll separately for completion status.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          class_names: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Apex test class API names (e.g. MyClassTest).',
+          },
+        },
+        required: ['class_names'],
+      },
+      handler: async ({ class_names }) => {
+        const names = Array.isArray(class_names) ? class_names.map((s) => String(s).trim()).filter(Boolean) : [];
+        if (!names.length) throw new Error('class_names must include at least one class name');
+        const data = await sfRequest('POST', '/runTestsAsynchronous', 'tooling', {
+          classNames: names.join(','),
+        });
+        return text(data);
+      },
+    },
+    {
+      name: 'query_tooling_api',
+      description:
+        'Executes SOQL queries against Tooling API metadata objects like ApexClass, CustomField, ValidationRule, and other development artifacts. Use this instead of standard SOQL when you need to inspect org configuration, custom code, or metadata rather than business data.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'Full SOQL string (Tooling entities only).' },
+        },
+        required: ['query'],
+      },
+      handler: async ({ query }) => {
+        const data = await sfRequest('GET', '/query', 'tooling', { q: query });
+        return text(data);
+      },
+    },
+    {
+      name: 'list_apex_classes',
+      description:
+        'Returns a list of all Apex classes in the org with their names, compilation status, and last modified dates. Use this to discover available custom code before executing methods or understanding the org\'s development landscape.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          name_filter: {
+            type: 'string',
+            description: 'Optional substring match on Name (SOQL LIKE).',
+          },
+          limit: { type: 'number', description: 'Default 50', default: 50 },
+        },
+        required: [],
+      },
+      handler: async ({ name_filter, limit }) => {
+        const limRaw = limit != null && Number.isFinite(Number(limit)) ? Number(limit) : 50;
+        const lim = Math.max(1, Math.min(2000, Math.trunc(limRaw)));
+        let q = 'SELECT Id, Name, Status, LastModifiedDate FROM ApexClass';
+        if (name_filter != null && String(name_filter).trim() !== '') {
+          q += ` WHERE Name LIKE '%${escapeSoqlString(String(name_filter).trim())}%'`;
+        }
+        q += ` ORDER BY LastModifiedDate DESC LIMIT ${lim}`;
+        const data = await sfRequest('GET', '/query', 'tooling', { q });
+        return text(data);
+      },
+    },
+  ];
+}
+
+function uiApiCommaQuery(value) {
+  if (value == null) return undefined;
+  if (Array.isArray(value)) return value.map((x) => String(x).trim()).filter(Boolean).join(',');
+  return String(value).trim();
+}
+
+function uiSmartTools() {
+  return [
+    {
+      name: 'get_record_ui',
+      description:
+        'Returns record data formatted for UI: labels, formatted values, and layout sections. Prefer over raw REST when showing records to users.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          record_id: {
+            type: 'string',
+            description: 'Salesforce record Id (or comma-separated Ids per UI API).',
+          },
+          layout_types: {
+            description:
+              'Optional. Layout types: Compact, Full. Comma-separated string or array of strings.',
+            oneOf: [
+              { type: 'string' },
+              { type: 'array', items: { type: 'string' } },
+            ],
+          },
+          modes: {
+            description: 'Optional. Create, Edit, View. Comma-separated string or array of strings.',
+            oneOf: [
+              { type: 'string' },
+              { type: 'array', items: { type: 'string' } },
+            ],
+          },
+        },
+        required: ['record_id'],
+      },
+      handler: async ({ record_id, layout_types, modes }) => {
+        const q = {
+          RECORD_IDS: record_id,
+        };
+        const lt = uiApiCommaQuery(layout_types);
+        const md = uiApiCommaQuery(modes);
+        if (lt) q.layoutTypes = lt;
+        if (md) q.modes = md;
+        const data = await sfRequest('GET', '/record-ui/{RECORD_IDS}', 'ui-api', q);
+        return text(data);
+      },
+    },
+    {
+      name: 'get_object_info',
+      description:
+        'Returns UI-friendly metadata for any Salesforce object including field labels, data types, required fields, and default record type information. Essential before building forms, validating data, or displaying object information to users.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          object_api_name: { type: 'string', description: 'sObject API name (e.g. Account, CustomObject__c).' },
+        },
+        required: ['object_api_name'],
+      },
+      handler: async ({ object_api_name }) => {
+        const data = await sfRequest(
+          'GET',
+          '/object-info/{SOBJECT_API_NAME}',
+          'ui-api',
+          { SOBJECT_API_NAME: object_api_name }
+        );
+        return text(data);
+      },
+    },
+    {
+      name: 'get_picklist_values_ui',
+      description:
+        'Returns all picklist field values for a specified object with proper labels and valid options per record type in UI-ready format. Use this before creating forms or validating picklist selections to ensure data integrity and proper user experience.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          object_api_name: { type: 'string' },
+          record_type_id: {
+            type: 'string',
+            description: 'Optional; defaults to defaultRecordTypeId from object-info when omitted.',
+          },
+        },
+        required: ['object_api_name'],
+      },
+      handler: async ({ object_api_name, record_type_id }) => {
+        let rtid =
+          record_type_id != null && String(record_type_id).trim() !== ''
+            ? String(record_type_id).trim()
+            : null;
+        if (!rtid) {
+          const info = await sfRequest(
+            'GET',
+            '/object-info/{SOBJECT_API_NAME}',
+            'ui-api',
+            { SOBJECT_API_NAME: object_api_name }
+          );
+          rtid = info?.defaultRecordTypeId || null;
+          if (!rtid && Array.isArray(info?.recordTypeInfos) && info.recordTypeInfos.length) {
+            rtid = info.recordTypeInfos[0].recordTypeId || info.recordTypeInfos[0].id;
+          }
+        }
+        if (!rtid) {
+          throw new Error(
+            'record_type_id is required for this org/object (could not resolve defaultRecordTypeId).'
+          );
+        }
+        const data = await sfRequest(
+          'GET',
+          '/object-info/{SOBJECT_API_NAME}/picklist-values/{RECORD_TYPE_ID}',
+          'ui-api',
+          { SOBJECT_API_NAME: object_api_name, RECORD_TYPE_ID: rtid }
+        );
+        return text(data);
+      },
+    },
+    {
+      name: 'get_layout',
+      description:
+        'Returns the page layout configuration for a Salesforce object, including which fields appear in which sections and their display order. Use this to understand how records are structured and displayed to users, rather than just getting field metadata.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          object_api_name: { type: 'string' },
+          layout_type: {
+            type: 'string',
+            description: 'Full or Compact (maps to layoutTypes query param).',
+            enum: ['Full', 'Compact'],
+          },
+          record_type_id: { type: 'string', description: 'Record type Id for the layout.' },
+        },
+        required: ['object_api_name', 'layout_type', 'record_type_id'],
+      },
+      handler: async ({ object_api_name, layout_type, record_type_id }) => {
+        const data = await sfRequest('GET', '/layout/{SOBJECT_API_NAME}', 'ui-api', {
+          SOBJECT_API_NAME: object_api_name,
+          layoutTypes: String(layout_type).trim(),
+          recordTypeId: String(record_type_id).trim(),
+          modes: 'View',
+        });
+        return text(data);
+      },
+    },
+  ];
+}
+
+function einsteinSmartTools() {
+  return [
+    {
+      name: 'analyze_sentiment',
+      description:
+        'Scores text sentiment (positive, negative, neutral) via Einstein Language (multipart sentiment API). Set SALESFORCE_EINSTEIN_ACCESS_TOKEN or EINSTEIN_ACCESS_TOKEN when needed; the org session token may be rejected by api.einstein.ai. Default model is CommunitySentiment.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          text: {
+            description: 'Text to analyze, or an array of strings for batch calls.',
+            oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }],
+          },
+          model_id: {
+            type: 'string',
+            description: 'Einstein Language model id. Omit to use CommunitySentiment.',
+          },
+        },
+        required: ['text'],
+      },
+      handler: async (p) => {
+        const modelId =
+          p.model_id != null && String(p.model_id).trim() !== '' ? String(p.model_id).trim() : 'CommunitySentiment';
+        const raw = p.text;
+        const texts = Array.isArray(raw) ? raw.map((t) => String(t)) : [String(raw)];
+        if (!texts.length || texts.every((t) => !t.trim())) throw new Error('text must be non-empty');
+        const results = [];
+        for (const doc of texts) {
+          const row = await einsteinPlatformPostMultipart('/language/sentiment', (f) => {
+            f.append('modelId', modelId);
+            f.append('document', doc);
+          });
+          results.push(row);
+        }
+        return text(results.length === 1 ? results[0] : { results });
+      },
+    },
+    {
+      name: 'classify_intent',
+      description:
+        'Classifies customer intent from text input using trained Einstein Language models to automatically route messages, emails, or cases to appropriate teams or processes. Requires a pre-trained Einstein Language model and Einstein Platform authentication.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          text: { type: 'string' },
+          model_id: { type: 'string', description: 'Your trained intent model id.' },
+        },
+        required: ['text', 'model_id'],
+      },
+      handler: async ({ text, model_id }) => {
+        const mid = String(model_id).trim();
+        if (!mid) throw new Error('model_id is required');
+        const data = await einsteinPlatformPostMultipart('/language/intent', (f) => {
+          f.append('modelId', mid);
+          f.append('document', String(text));
+        });
+        return text(data);
+      },
+    },
+    {
+      name: 'predict_image',
+      description:
+        'Classifies images using trained Einstein Vision models, returning prediction labels with confidence scores for visual content analysis. Accepts either image_url or image_base64 parameters and requires Einstein Platform authentication.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          image_url: { type: 'string', description: 'Public URL of the image.' },
+          image_base64: { type: 'string', description: 'Image bytes as base64.' },
+          model_id: { type: 'string', description: 'Einstein Vision model id.' },
+        },
+        required: ['model_id'],
+      },
+      handler: async ({ image_url, image_base64, model_id }) => {
+        const mid = String(model_id).trim();
+        if (!mid) throw new Error('model_id is required');
+        const url = image_url != null && String(image_url).trim() !== '' ? String(image_url).trim() : null;
+        const b64 = image_base64 != null && String(image_base64).trim() !== '' ? String(image_base64).trim() : null;
+        if (!url && !b64) throw new Error('Provide image_url or image_base64');
+        const data = await einsteinPlatformPostMultipart('/vision/predict', (f) => {
+          f.append('modelId', mid);
+          if (url) f.append('sampleLocation', url);
+          else f.append('sampleBase64Content', b64);
+        });
+        return text(data);
+      },
+    },
+  ];
+}
+
+function toPlatformEventApiName(event_name) {
+  const s = String(event_name ?? '').trim();
+  if (!s) throw new Error('event_name is required');
+  if (s.endsWith('__e')) return s;
+  return `${s}__e`;
+}
+
+function eventPlatformSmartTools() {
+  return [
+    {
+      name: 'publish_platform_event',
+      description:
+        'Publishes custom Platform Events to Salesforce\'s event bus to trigger real-time integrations, notifications, or automated workflows that subscribe to these events. Use this to initiate event-driven processes across your Salesforce ecosystem.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          event_name: {
+            type: 'string',
+            description: 'Platform event API name (with or without __e suffix).',
+          },
+          event_data: {
+            type: 'object',
+            additionalProperties: true,
+            description: 'Field API names → values for the event payload.',
+          },
+        },
+        required: ['event_name'],
+      },
+      handler: async ({ event_name, event_data }) => {
+        const apiName = toPlatformEventApiName(event_name);
+        const body = event_data != null && typeof event_data === 'object' ? event_data : {};
+        const data = await sfRequest('POST', '/sobjects/{EventApiName}/', 'versioned', {
+          EventApiName: apiName,
+          _rawBody: body,
+        });
+        return text(data);
+      },
+    },
+    {
+      name: 'list_platform_events',
+      description:
+        'Lists all available Platform Event types in your org by querying EntityDefinition records with __e suffix. Use this to discover what events you can publish before using publish_platform_event.',
+      inputSchema: { type: 'object', properties: {}, required: [] },
+      handler: async () => {
+        const q =
+          "SELECT QualifiedApiName, Label, DeveloperName, DurableId FROM EntityDefinition WHERE QualifiedApiName LIKE '%__e' ORDER BY QualifiedApiName LIMIT 500";
+        const data = await sfRequest('GET', '/query', 'tooling', { q });
+        return text(data);
+      },
+    },
+    {
+      name: 'create_streaming_topic',
+      description:
+        'Creates a PushTopic for the Streaming API to monitor real-time changes to Salesforce records based on SOQL criteria. Use this to set up live data synchronization with external systems that need immediate updates.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          name: { type: 'string', description: 'Unique PushTopic name.' },
+          query: { type: 'string', description: 'SOQL query (Id, fields must be valid for streaming).' },
+          notify_for_fields: {
+            type: 'string',
+            description: 'PushTopic NotifyForFields: Referenced (default), Select, Where, or All.',
+            enum: ['Referenced', 'Select', 'Where', 'All'],
+          },
+        },
+        required: ['name', 'query'],
+      },
+      handler: async ({ name, query, notify_for_fields }) => {
+        const verRaw = process.env.SALESFORCE_API_VERSION || 'v59.0';
+        const apiNum = Number.parseFloat(String(verRaw).replace(/^v/i, '')) || 59;
+        const notify = notify_for_fields != null && String(notify_for_fields).trim() !== ''
+          ? String(notify_for_fields).trim()
+          : 'Referenced';
+        const data = await sfRequest('POST', '/sobjects/PushTopic', 'versioned', {
+          _rawBody: {
+            Name: String(name).trim(),
+            Query: String(query),
+            NotifyForFields: notify,
+            ApiVersion: apiNum,
+          },
+        });
+        return text(data);
+      },
+    },
+  ];
+}
+
+const GQL_ACCOUNTS_WITH_CONTACTS = `query accountsWithContacts {
+  uiapi {
+    query {
+      Account {
+        edges {
+          node {
+            Id
+            Name { value }
+            Contacts {
+              edges {
+                node {
+                  Id
+                  Name { value }
+                  Email { value }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}`;
+
+function graphqlSmartTools() {
+  return [
+    {
+      name: 'graphql_query',
+      description:
+        'Executes GraphQL queries against Salesforce data for more efficient retrieval of complex, nested relationships in a single request. Use this instead of multiple REST API calls when you need related data from multiple objects simultaneously.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'GraphQL query string.' },
+          variables: {
+            type: 'object',
+            description: 'Optional GraphQL variables object.',
+            additionalProperties: true,
+          },
+        },
+        required: ['query'],
+      },
+      handler: async ({ query, variables }) => {
+        const body = { query };
+        if (
+          variables != null &&
+          typeof variables === 'object' &&
+          !Array.isArray(variables) &&
+          Object.keys(variables).length > 0
+        ) {
+          body.variables = variables;
+        }
+        const data = await sfRequest('POST', '/', 'graphql', { _rawBody: body });
+        return text(data);
+      },
+    },
+    {
+      name: 'graphql_query_accounts_with_contacts',
+      description:
+        'Retrieves accounts with their related contacts in one efficient GraphQL request, returning only specified fields to minimize data transfer. Use this instead of separate SOQL queries when you need account-contact hierarchical data.',
+      inputSchema: { type: 'object', properties: {}, required: [] },
+      handler: async () => {
+        const data = await sfRequest('POST', '/', 'graphql', {
+          _rawBody: { query: GQL_ACCOUNTS_WITH_CONTACTS },
+        });
+        return text(data);
+      },
+    },
+  ];
+}
+
+async function resolvePricebook2Id(pricebook_id) {
+  if (pricebook_id != null && String(pricebook_id).trim() !== '') return String(pricebook_id).trim();
+  const q =
+    "SELECT Id FROM Pricebook2 WHERE Name = 'Standard Price Book' AND IsActive = true LIMIT 1";
+  const d = await sfRequest('GET', '/query/', 'versioned', { q });
+  return d.records?.[0]?.Id || null;
+}
+
+function subscriptionMgmtSmartTools() {
+  return [
+    {
+      name: 'get_product_catalog',
+      description:
+        'Retrieves products from a Salesforce price book with names, product codes, and pricing information needed for creating opportunities or orders. Defaults to Standard Price Book if no pricebook_id is specified.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          pricebook_id: { type: 'string', description: 'Optional Pricebook2 Id (defaults to Standard Price Book).' },
+          active_only: {
+            type: 'boolean',
+            description: 'If true (default), only active PricebookEntry and Product2 rows.',
+            default: true,
+          },
+        },
+        required: [],
+      },
+      handler: async ({ pricebook_id, active_only }) => {
+        const pbId = await resolvePricebook2Id(pricebook_id);
+        if (!pbId) throw new Error('Could not resolve price book (set pricebook_id or ensure Standard Price Book exists).');
+        const active = active_only !== false;
+        let q = `SELECT Id, Name, Product2Id, Product2.Name, Product2.ProductCode, Product2.IsActive, UnitPrice, IsActive, UseStandardPrice FROM PricebookEntry WHERE Pricebook2Id='${escapeSoqlString(pbId)}'`;
+        if (active) q += ' AND IsActive = true AND Product2.IsActive = true';
+        q += ' ORDER BY Product2.Name LIMIT 2000';
+        const data = await sfRequest('GET', '/query/', 'versioned', { q });
+        return text({ pricebook_id: pbId, ...data });
+      },
+    },
+    {
+      name: 'create_order_from_opportunity',
+      description:
+        'Creates an Order from an Opportunity and copies opportunity line items to order products. Use when lines have valid PricebookEntryId for the order price book; satisfy required Order fields (e.g. BillToContactId) via org automation or follow-up updates.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          opportunity_id: { type: 'string' },
+          pricebook_id: { type: 'string', description: "Used if the opportunity has no price book; else opportunity's price book is used." },
+          effective_date: {
+            type: 'string',
+            description: 'Order effective date (YYYY-MM-DD).',
+          },
+        },
+        required: ['opportunity_id', 'pricebook_id', 'effective_date'],
+      },
+      handler: async ({ opportunity_id, pricebook_id, effective_date }) => {
+        const oid = escapeSoqlString(opportunity_id);
+        const oppRes = await sfRequest('GET', '/query/', 'versioned', {
+          q: `SELECT Id, AccountId, Pricebook2Id, CurrencyIsoCode FROM Opportunity WHERE Id='${oid}' LIMIT 1`,
+        });
+        const opp = oppRes.records?.[0];
+        if (!opp) throw new Error('Opportunity not found');
+        const pbFromParam = pricebook_id != null && String(pricebook_id).trim() !== '' ? String(pricebook_id).trim() : null;
+        const pbId = pbFromParam || opp.Pricebook2Id;
+        if (!pbId) throw new Error('No price book on opportunity and pricebook_id not provided');
+        const eff = String(effective_date).trim().slice(0, 10);
+
+        const oliRes = await sfRequest('GET', '/query/', 'versioned', {
+          q: `SELECT Id, Product2Id, Quantity, UnitPrice, PricebookEntryId, Description FROM OpportunityLineItem WHERE OpportunityId='${oid}'`,
+        });
+        const lines = oliRes.records || [];
+        if (!lines.length) throw new Error('No opportunity line items to convert');
+
+        const orderBody = {
+          AccountId: opp.AccountId,
+          OpportunityId: opp.Id,
+          Pricebook2Id: pbId,
+          EffectiveDate: eff,
+          Status: 'Draft',
+        };
+        if (opp.CurrencyIsoCode) orderBody.CurrencyIsoCode = opp.CurrencyIsoCode;
+
+        const order = await sfRequest('POST', '/sobjects/Order', 'versioned', { _rawBody: orderBody });
+        const orderId = order.id;
+        if (!orderId) throw new Error('Order create failed (check required Order fields for your org)');
+
+        const createdItems = [];
+        for (const line of lines) {
+          if (!line.PricebookEntryId) {
+            throw new Error(`Opportunity line ${line.Id} has no PricebookEntryId; refresh lines with the order price book`);
+          }
+          const oiBody = {
+            OrderId: orderId,
+            PricebookEntryId: line.PricebookEntryId,
+            Quantity: line.Quantity,
+            UnitPrice: line.UnitPrice,
+          };
+          if (line.Description) oiBody.Description = line.Description;
+          const oi = await sfRequest('POST', '/sobjects/OrderItem', 'versioned', { _rawBody: oiBody });
+          createdItems.push(oi);
+        }
+
+        return text({ order, orderItems: createdItems });
+      },
+    },
+    {
+      name: 'get_subscription_status',
+      description:
+        'Lists recent Orders for an account with nested OrderItems (product, quantity, prices, dates). Useful when subscriptions or renewals are modeled on Order; patterns differ by org and edition.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          account_id: { type: 'string', description: 'Salesforce Account Id.' },
+        },
+        required: ['account_id'],
+      },
+      handler: async ({ account_id }) => {
+        const aid = escapeSoqlString(account_id);
+        const q = `SELECT Id, OrderNumber, Status, EffectiveDate, TotalAmount,
+          (SELECT Id, Product2Id, Product2.Name, Quantity, UnitPrice, ListPrice, ServiceDate FROM OrderItems ORDER BY CreatedDate)
+          FROM Order WHERE AccountId='${aid}' ORDER BY EffectiveDate DESC LIMIT 200`;
+        const data = await sfRequest('GET', '/query/', 'versioned', { q });
+        return text(data);
+      },
+    },
+  ];
+}
+
+function enrichSchemaForWrite(schema, method) {
+  const s = structuredClone(schema);
+  s.properties = s.properties || {};
+  if (['POST', 'PUT', 'PATCH'].includes(method)) {
+    s.properties._rawBody = {
+      type: 'object',
+      description:
+        'Optional: full JSON body. When set, replaces inferred body fields from other arguments.',
+      additionalProperties: true,
+    };
+  }
+  return s;
+}
+
+function shouldSkipManifestEndpoint(ep) {
+  if (ep.method === 'GET' && ep.path === '/query/') return true;
+  if (ep.method === 'GET' && ep.path === '/search') return true;
+  return false;
+}
+
+function methodRank(m) {
+  return (
+    { GET: 0, POST: 1, PATCH: 2, PUT: 3, DELETE: 4 }[m] ?? 99
+  );
+}
+
+function generatedToolsFromManifest() {
+  const out = [];
+  for (const ep of manifest.endpoints) {
+    if (shouldSkipManifestEndpoint(ep)) continue;
+    out.push({
+      name: ep.name,
+      description: ep.description,
+      method: ep.method,
+      path: ep.path,
+      urlKind: ep.urlKind,
+      inputSchema: enrichSchemaForWrite(ep.inputSchema, ep.method),
+      handler: async (params) => {
+        const data = await sfRequest(ep.method, ep.path, ep.urlKind, params);
+        return text(data);
+      },
+    });
+  }
+  out.sort((a, b) => {
+    const ea = manifest.endpoints.find((e) => e.name === a.name);
+    const eb = manifest.endpoints.find((e) => e.name === b.name);
+    const ra = methodRank(ea?.method);
+    const rb = methodRank(eb?.method);
+    if (ra !== rb) return ra - rb;
+    return a.name.localeCompare(b.name);
+  });
+  return out;
+}
+
+const mult = multipliedTools();
+const gen = generatedToolsFromManifest();
+const bulkWrappers = bulkApiMultipliedTools();
+const bulkGen = bulkV2GeneratedTools();
+const bulkV1Gen = bulkV1GeneratedTools();
+const compositeTools = compositeSmartTools();
+const metadataSmart = metadataRestSmartTools();
+const metadataSoap = metadataSoapToolsFromPostman();
+const connectGen = connectGeneratedToolsFromPostman();
+const connectSmart = connectSmartTools();
+const toolingGen = toolingGeneratedToolsFromPostman();
+const toolingSmart = toolingSmartTools();
+const uiGen = uiGeneratedToolsFromPostman();
+const uiSmart = uiSmartTools();
+const einsteinPsGen = einsteinPsGeneratedToolsFromPostman();
+const einsteinSmart = einsteinSmartTools();
+const evtPfGen = eventPlatformGeneratedToolsFromPostman();
+const evtPfSmart = eventPlatformSmartTools();
+const gqlGen = graphqlGeneratedToolsFromPostman();
+const gqlSmart = graphqlSmartTools();
+const subMgmtGen = subMgmtGeneratedToolsFromPostman();
+const subMgmtSmart = subscriptionMgmtSmartTools();
+const industriesGen = industriesGeneratedToolsFromPostman();
+
+const seen = new Set(mult.map((t) => t.name));
+for (const t of gen) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_rest`;
+  }
+  seen.add(t.name);
+}
+for (const t of bulkWrappers) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_wrap`;
+  }
+  seen.add(t.name);
+}
+for (const t of bulkGen) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_bulk`;
+  }
+  seen.add(t.name);
+}
+for (const t of bulkV1Gen) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_bv1`;
+  }
+  seen.add(t.name);
+}
+for (const t of compositeTools) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_comp`;
+  }
+  seen.add(t.name);
+}
+for (const t of metadataSmart) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_meta`;
+  }
+  seen.add(t.name);
+}
+for (const t of metadataSoap) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_soap`;
+  }
+  seen.add(t.name);
+}
+for (const t of connectGen) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_conn`;
+  }
+  seen.add(t.name);
+}
+for (const t of connectSmart) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_conn`;
+  }
+  seen.add(t.name);
+}
+for (const t of toolingGen) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_tl`;
+  }
+  seen.add(t.name);
+}
+for (const t of toolingSmart) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_tl`;
+  }
+  seen.add(t.name);
+}
+for (const t of uiGen) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_uia`;
+  }
+  seen.add(t.name);
+}
+for (const t of uiSmart) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_uia`;
+  }
+  seen.add(t.name);
+}
+for (const t of einsteinPsGen) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_eps`;
+  }
+  seen.add(t.name);
+}
+for (const t of einsteinSmart) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_eps`;
+  }
+  seen.add(t.name);
+}
+for (const t of evtPfGen) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_evp`;
+  }
+  seen.add(t.name);
+}
+for (const t of evtPfSmart) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_evp`;
+  }
+  seen.add(t.name);
+}
+for (const t of gqlGen) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_gql`;
+  }
+  seen.add(t.name);
+}
+for (const t of gqlSmart) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_gql`;
+  }
+  seen.add(t.name);
+}
+for (const t of subMgmtGen) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_subm`;
+  }
+  seen.add(t.name);
+}
+for (const t of subMgmtSmart) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_subm`;
+  }
+  seen.add(t.name);
+}
+for (const t of industriesGen) {
+  if (seen.has(t.name)) {
+    t.name = `${t.name}_ind`;
+  }
+  seen.add(t.name);
+}
+
+export const tools = [
+  ...mult,
+  ...gen,
+  ...bulkWrappers,
+  ...bulkGen,
+  ...bulkV1Gen,
+  ...compositeTools,
+  ...metadataSmart,
+  ...metadataSoap,
+  ...connectGen,
+  ...connectSmart,
+  ...toolingGen,
+  ...toolingSmart,
+  ...uiGen,
+  ...uiSmart,
+  ...einsteinPsGen,
+  ...einsteinSmart,
+  ...evtPfGen,
+  ...evtPfSmart,
+  ...gqlGen,
+  ...gqlSmart,
+  ...subMgmtGen,
+  ...subMgmtSmart,
+  ...industriesGen,
+];