adoptai-mcp 1.0.0

package/dist/integrations/salesforce/tools.original.js

@@ -0,0 +1,4487 @@
+import './env.js';
+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 in one batch using Bulk API v2. Handles job creation, data upload and completion polling automatically. Much faster than individual creates for 10+ records.',
+      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 records in one batch. Each record must include an Id. Use for mass updates like reassigning ownership or updating status across many records.',
+      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 or updates records based on an external ID field. Use for data sync when you don't know if records already exist.",
+      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 records in one batch. Each item needs only an Id. WARNING: irreversible. Use with caution.',
+      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:
+        'Checks the status of a running bulk ingest job. Returns state (InProgress/JobComplete/Failed), records processed and failed count.',
+      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 results of a completed bulk ingest job including which records succeeded or failed with error messages.',
+      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'] };
+}
+
+function bulkSlug(name) {
+  return name
+    .replace(/[^a-zA-Z0-9_]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .toLowerCase()
+    .slice(0, 55);
+}
+
+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)}`;
+
+      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)}`;
+
+      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,
+      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)}`;
+
+      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,
+      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)}`;
+
+      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,
+      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)}`;
+
+      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,
+      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)}`;
+
+      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,
+      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);
+      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,
+      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);
+      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,
+      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);
+      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,
+      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,
+      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)}`,
+        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,
+      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_account_with_contact',
+      description:
+        'Creates an Account and a linked Contact in a single atomic API call using Composite. If account creation fails, contact is not created. Use instead of two separate create calls for new customer onboarding.',
+      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: 'composite_create_opportunity_with_contact_role',
+      description:
+        'Creates an Opportunity and assigns a Contact Role in one call. Use when adding a new deal and you already know the key contact.',
+      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 types in a single API call using Composite Batch. More efficient than sequential GET requests.',
+      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 records to a new owner in one composite operation. Faster than individual updates.',
+      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_${base}`;
+}
+
+/** 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:
+        'Lists ALL available Salesforce objects (standard and custom). Use to discover what objects exist before querying or describing them.',
+      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 full metadata for a Salesforce object: all field names, types, picklist values and relationships. Use before building SOQL to know what fields are available.',
+      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 for a specific field on a Salesforce object. Use before creating/updating records to know valid values for Stage, Status, Industry etc.',
+      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 and remaining limits for the org. Includes daily API calls used/remaining. Use to monitor integration health.',
+      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 record types for a Salesforce object. Required before creating records in orgs that use record types.',
+      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 basic Salesforce account details by ID including name, industry, type, phone, website and billing address. Use when you need account metadata. For related records use get_account_with_contacts or get_account_with_opportunities.',
+      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 AND all its related contacts in one SOQL relationship query. Use when you need both account details and contact list without making two separate API calls.',
+      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:
+        'Retrieves an account AND all associated opportunities with stage, amount and close date. Use for account pipeline review in one call.',
+      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 AND all open support cases. Use for customer health checks and service review.',
+      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:
+        'Retrieves a complete 360-degree account profile including contacts, opportunities and cases in a single call. Use when you need everything about an account at once, such as before a customer meeting.',
+      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:
+        'Generic opportunity update — pass any fields to update. Use for multi-field updates. For focused single-field updates use the specific tools like update_opportunity_stage.',
+      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 an opportunity stage (e.g. Prospecting → Proposal → Negotiation). The most common opportunity update in sales workflows. Use instead of update_opportunity when only changing stage.',
+      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 the monetary value of an opportunity. Use when deal size changes during negotiation.',
+      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 the expected close date of an opportunity. Use when a deal slips or accelerates without other field changes.',
+      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:
+        "Marks an opportunity as Closed Won with today's date or a specified close date. Sets probability to 100 automatically. Use when a deal is confirmed won — faster than update_opportunity.",
+      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:
+        'Marks an opportunity as Closed Lost and optionally records the loss reason. Sets probability to 0 automatically. Use when a deal is definitively lost.',
+      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. The most flexible tool for power users who know SOQL. Use when no specific tool covers your need. For common lookups prefer the specific search tools.',
+      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:
+        'Runs a SOQL query and automatically paginates through ALL results. Use when you need complete datasets over 2000 records.',
+      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 accounts by name, industry, type or location without writing SOQL. Use to find account IDs before get_account.',
+      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 contacts by name, email, phone or account without writing SOQL. Use to find contact IDs before direct reads.',
+      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 leads by name, company, email or status without writing SOQL. Use to find lead IDs before get_lead.',
+      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 opportunities by multiple criteria without writing SOQL. Use to find opportunities by stage, value or close date.',
+      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 the sales pipeline grouped by stage with deal count and total value per stage. Use for pipeline reviews and forecasting without writing aggregate SOQL.',
+      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:
+        "Searches across ALL Salesforce objects simultaneously using SOSL. Returns matches from Accounts, Contacts, Leads and Opportunities by default. Use when you don't know which object has the data.",
+      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: 'Generic task creation with full control over all fields.',
+      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:
+        'Logs a completed phone call as a Task linked to a Contact or Lead. Automatically sets Type=Call and Status=Completed. Use after finishing a sales or support call.',
+      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:
+        'Logs an outbound email as activity in Salesforce. Creates an EmailMessage record linked to a Contact or Lead. Use after sending an important email to record it in CRM.',
+      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 follow-up reminder task linked to a Contact, Lead or Opportunity with a due date. The most common activity in sales workflows — use after calls or meetings to set next steps.',
+      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 tasks due today for a user. Optionally includes overdue tasks. Use at the start of a workday to review priorities.",
+      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 tasks past their due date. Use to identify missed follow-ups that need immediate attention.',
+      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: 'Generic lead update for multiple fields.',
+      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 a lead status in the qualification pipeline. Use instead of update_lead when only changing lead status.',
+      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:
+        'Converts a qualified lead into an Account, Contact and optional Opportunity. This is a critical CRM workflow — use when a lead is sales-qualified and ready to enter the pipeline.',
+      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:
+        'Posts a message to a Chatter feed on a record, group or user profile. Use to share updates or @mention team members directly from the CRM.',
+      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 the Chatter feed for a specific record (Account, Opportunity, Case etc). Returns all posts, comments and file shares on that record.',
+      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 and attaches it to a Salesforce record using the Connect API. Use to attach documents, images or reports to Accounts, Opportunities or Cases.',
+      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:
+        "Retrieves a Salesforce user's profile including name, title, department, email and photo. Use to get user context before assigning records.",
+      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:
+        'Lists Chatter groups the current user belongs to or searches all groups by name. Use to find group IDs before posting to a group feed.',
+      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 against the Salesforce org. Use for running custom logic, data fixes or testing code snippets without deploying. Returns compilation result, logs pointer and any errors. Uses Tooling executeAnonymous (GET with anonymousBody query parameter).',
+      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 org. Use for debugging failed integrations or custom code execution.',
+      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 Apex test class execution via asynchronous Tooling and returns the API result (includes job id for polling). Use to verify org health before deployments.',
+      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 a SOQL query against Tooling API objects like ApexClass, CustomField, ValidationRule etc. Use for org metadata inspection.',
+      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:
+        'Lists Apex classes in the org with name, status and last modified date. Use to discover available Apex classes before executing.',
+      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:
+        "Retrieves a record's data formatted for UI display including field labels, formatted values and layout sections. Better than raw REST for displaying data to users as it includes human-readable labels.",
+      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 a Salesforce object including field labels, required fields, and default record type. Use before building forms or displaying records.',
+      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 an object in UI-friendly format with labels and valid values per record type. Use before creating or editing records.',
+      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 for a Salesforce object showing which fields appear in which sections and their order. Use to understand record structure.',
+      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:
+        'Analyzes the sentiment (positive/negative/neutral) of text using Einstein Language. Use to automatically classify customer emails, case descriptions or survey responses. Calls the Einstein Platform `language/sentiment` endpoint (multipart). Use a Language JWT in SALESFORCE_EINSTEIN_ACCESS_TOKEN or EINSTEIN_ACCESS_TOKEN; if unset, the Salesforce session token is sent (may not be accepted by api.einstein.ai). Default model_id is CommunitySentiment when omitted.',
+      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 the intent of a text input using a trained Einstein Language model. Use to automatically route incoming messages, emails or cases based on customer intent. Requires Einstein Platform auth (see analyze_sentiment).',
+      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 an image using a trained Einstein Vision model. Returns prediction labels and confidence scores. Pass image_url or image_base64 (raw base64, no data: prefix). Requires Einstein Platform auth (see analyze_sentiment).',
+      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 a Platform Event to the Salesforce event bus. Use to trigger real-time integrations, notifications or downstream automations that subscribe to this event.',
+      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 Platform Event types in the org (EntityDefinition where API name ends with __e). Use to discover available events before publishing.',
+      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 streaming real-time record changes via the Streaming API. Use to set up real-time data sync integrations.',
+      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 a GraphQL query against Salesforce data. More efficient than REST for fetching related records in one request. Use when you need nested related data without multiple API calls.',
+      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:
+        'Fetches accounts with their related contacts using GraphQL in a single request. Returns only the fields you need. More efficient than SOQL relationship queries for nested 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:
+        'Lists products in a Salesforce price book with names, codes and prices. Use before adding products to opportunities or orders. Defaults to the Standard Price Book when pricebook_id is omitted.',
+      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 its opportunity line items to order products in one flow. Use when converting a won deal to an order. Requires Product2/pricebook alignment on line items; add BillToContactId etc. via org automation if your Order rules require it.',
+      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:
+        'Retrieves recent orders for an account with nested order line items (product, quantity, dates). Use for renewal-style views where subscriptions are represented on Orders (Subscription Management / Revenue Cloud patterns vary by org).',
+      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,
+      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,
+];