@oomol-lab/open-connector 1.9.1 → 1.9.2

package/src/providers/salesforce/chatter-routes.js

@@ -0,0 +1,140 @@
+export const chatterFeedRoutes = {
+    favorites: {
+        path: "/chatter/feeds/favorites/{userId}/{favoriteId}/feed-elements",
+        communityRequired: false,
+        parameters: ["elementsPerBundle", "page", "pageSize", "recentCommentCount", "sort"],
+    },
+    filter: {
+        path: "/chatter/feeds/filter/{userId}/{keyPrefix}/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "q", "recentCommentCount", "sort", "updatedSince"],
+    },
+    bookmarks: {
+        path: "/chatter/feeds/bookmarks/{userId}/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "q", "recentCommentCount", "sort"],
+    },
+    company: {
+        path: "/chatter/feeds/company/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "q", "recentCommentCount", "sort", "updatedSince"],
+    },
+    "direct-messages": {
+        path: "/chatter/feeds/direct-messages/feed-elements",
+        communityRequired: false,
+        parameters: ["page", "pageSize", "recentCommentCount", "sort"],
+    },
+    draft: {
+        path: "/chatter/feeds/draft/{userId}/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "q", "recentCommentCount", "sort"],
+    },
+    files: {
+        path: "/chatter/feeds/files/{userId}/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "q", "recentCommentCount", "sort", "updatedSince"],
+    },
+    groups: {
+        path: "/chatter/feeds/groups/{userId}/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "q", "recentCommentCount", "sort", "updatedSince"],
+    },
+    isolated: {
+        path: "/chatter/feeds/isolated/feed-elements",
+        communityRequired: false,
+        parameters: ["page", "pageSize", "q", "sort"],
+    },
+    mute: {
+        path: "/chatter/feeds/mute/{userId}/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "q", "recentCommentCount", "sort"],
+    },
+    news: {
+        path: "/chatter/feeds/news/{userId}/feed-elements",
+        communityRequired: false,
+        parameters: [
+            "density",
+            "elementsPerBundle",
+            "filter",
+            "page",
+            "pageSize",
+            "q",
+            "recentCommentCount",
+            "sort",
+            "updatedSince",
+        ],
+    },
+    "pending-review": {
+        path: "/chatter/feeds/pending-review/feed-elements",
+        communityRequired: false,
+        parameters: ["page", "pageSize", "q", "sort"],
+    },
+    people: {
+        path: "/chatter/feeds/people/{userId}/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "q", "recentCommentCount", "sort", "updatedSince"],
+    },
+    record: {
+        path: "/chatter/feeds/record/{recordId}/feed-elements",
+        communityRequired: false,
+        parameters: [
+            "customFilter",
+            "density",
+            "elementsPerBundle",
+            "filter",
+            "page",
+            "pageSize",
+            "q",
+            "recentCommentCount",
+            "showInternalOnly",
+            "sort",
+            "threadedCommentsCollapsed",
+            "updatedSince",
+        ],
+    },
+    streams: {
+        path: "/chatter/feeds/streams/{streamId}/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "recentCommentCount", "sort", "updatedSince"],
+    },
+    to: {
+        path: "/chatter/feeds/to/{userId}/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "q", "recentCommentCount", "sort"],
+    },
+    topics: {
+        path: "/chatter/feeds/topics/{topicId}/feed-elements",
+        communityRequired: false,
+        parameters: ["filter", "page", "pageSize", "sort"],
+    },
+    "user-profile": {
+        path: "/chatter/feeds/user-profile/{userId}/feed-elements",
+        communityRequired: false,
+        parameters: [
+            "density",
+            "elementsPerBundle",
+            "filter",
+            "page",
+            "pageSize",
+            "q",
+            "recentCommentCount",
+            "sort",
+            "threadedCommentsCollapsed",
+        ],
+    },
+    "direct-message-moderation": {
+        path: "/chatter/feeds/direct-message-moderation/feed-elements",
+        communityRequired: true,
+        parameters: ["page", "pageSize", "q", "sort"],
+    },
+    home: {
+        path: "/chatter/feeds/home/feed-elements",
+        communityRequired: true,
+        parameters: ["filter", "page", "pageSize", "q", "sort", "threadedCommentsCollapsed"],
+    },
+    moderation: {
+        path: "/chatter/feeds/moderation/feed-elements",
+        communityRequired: true,
+        parameters: ["page", "pageSize", "q", "sort"],
+    },
+};

package/src/providers/salesforce/context.d.ts

@@ -3,8 +3,8 @@ export interface SalesforceContext extends OAuthProviderContext {
     base: string;
     version: string;
     origin: string;
-    request(path: string, method?: string, body?: unknown): Promise<unknown>;
-    object(path: string, method?: string, body?: unknown): Promise<Record<string, unknown>>;
+    request(path: string, method?: string, body?: unknown, extraHeaders?: HeadersInit): Promise<unknown>;
+    object(path: string, method?: string, body?: unknown, extraHeaders?: HeadersInit): Promise<Record<string, unknown>>;
     items(path: string, method?: string, body?: unknown): Promise<{
         results: unknown[];
     }>;

package/src/providers/salesforce/context.js

@@ -16,10 +16,13 @@ export function createSalesforceContext(context, data) {
         headers.set("authorization", `Bearer ${context.accessToken}`);
         return { ...init, headers };
     }
-    async function request(path, method = "GET", body) {
+    async function request(path, method = "GET", body, extraHeaders) {
+        const headers = new Headers(extraHeaders);
+        if (body !== undefined)
+            headers.set("content-type", "application/json");
         return (await salesforceRequest(url(path), initWithAuth({
             method,
-            headers: body === undefined ? undefined : { "content-type": "application/json" },
+            headers,
             body: body === undefined ? undefined : JSON.stringify(body),
         }), context.fetcher, context.signal)).body;
     }
@@ -29,8 +32,8 @@ export function createSalesforceContext(context, data) {
         version,
         origin,
         request,
-        async object(path, method = "GET", body) {
-            return requiredResponseRecord(await request(path, method, body), "Salesforce response");
+        async object(path, method = "GET", body, extraHeaders) {
+            return requiredResponseRecord(await request(path, method, body, extraHeaders), "Salesforce response");
         },
         async items(path, method = "GET", body) {
             const results = await request(path, method, body);

package/src/providers/salesforce/executors.js

@@ -2,15 +2,25 @@ import { optionalString } from "../../core/cast.js";
 import { defineOAuthProviderExecutors, defineProviderProxy, providerInputError, providerResponseError, requiredInputString, requiredResponseRecord, } from "../provider-runtime.js";
 import { createSalesforceContext } from "./context.js";
 import { salesforceAnalyticsHandlers } from "./runtime-analytics.js";
+import { salesforceApprovalHandlers } from "./runtime-approvals.js";
 import { salesforceAutomationHandlers } from "./runtime-automation.js";
 import { salesforceBaseHandlers } from "./runtime-base.js";
 import { salesforceBulkHandlers } from "./runtime-bulk.js";
+import { salesforceChatterHandlers } from "./runtime-chatter.js";
 import { salesforceDataHandlers } from "./runtime-data.js";
 import { salesforceFileHandlers } from "./runtime-files.js";
+import { salesforceKnowledgeHandlers } from "./runtime-knowledge.js";
+import { salesforceLeadHandlers } from "./runtime-leads.js";
+import { salesforcePlatformHandlers } from "./runtime-platform.js";
 import { readSalesforceError, salesforceOrigin, salesforceRequest } from "./transport.js";
 export { oauth } from "./oauth.js";
 const handlers = {};
 for (const [name, handler] of Object.entries({
+    ...salesforceApprovalHandlers,
+    ...salesforceChatterHandlers,
+    ...salesforceKnowledgeHandlers,
+    ...salesforceLeadHandlers,
+    ...salesforcePlatformHandlers,
     ...salesforceBaseHandlers,
     ...salesforceDataHandlers,
     ...salesforceAnalyticsHandlers,

package/src/providers/salesforce/runtime-approvals.d.ts

@@ -0,0 +1,2 @@
+import type { SalesforceHandler } from "./context.ts";
+export declare const salesforceApprovalHandlers: Record<string, SalesforceHandler>;

package/src/providers/salesforce/runtime-approvals.js

@@ -0,0 +1,52 @@
+import { providerInputError, providerResponseError, requiredResponseRecord, requiredInputString, } from "../provider-runtime.js";
+import { queryPath } from "./context.js";
+export const salesforceApprovalHandlers = {
+    async list_approval_processes(d, c) {
+        const response = await c.object(`${c.base}/process/approvals/`);
+        const processes = requiredResponseRecord(response.approvals, "Salesforce approval processes");
+        return {
+            processes: d.objectName === undefined
+                ? processes
+                : Object.fromEntries(Object.entries(processes).filter(([name]) => name === d.objectName)),
+        };
+    },
+    async submit_for_approval(d, c) {
+        return c.items(`${c.base}/process/approvals/`, "POST", {
+            requests: d.requests.map(({ recordId, submitterId, ...rest }) => ({
+                ...rest,
+                actionType: "Submit",
+                contextId: recordId,
+                contextActorId: submitterId,
+            })),
+        });
+    },
+    async review_approval_requests(d, c) {
+        return c.items(`${c.base}/process/approvals/`, "POST", {
+            requests: d.requests.map(({ workItemId, decision, ...rest }) => ({
+                ...rest,
+                actionType: decision === "approve" ? "Approve" : "Reject",
+                contextId: workItemId,
+            })),
+        });
+    },
+    async list_pending_approvals(d, c) {
+        if ((d.scope === "actor") !== (d.actorId !== undefined))
+            throw providerInputError("actorId is required only for actor scope");
+        let actorId = d.actorId;
+        if (d.scope === "mine") {
+            actorId = requiredInputString(c.providerSecret?.userId, "Salesforce user ID");
+            if (!/^[A-Za-z0-9]{15}([A-Za-z0-9]{3})?$/.test(String(actorId)))
+                throw providerResponseError("Salesforce returned an invalid user ID");
+        }
+        const filters = [];
+        if (actorId)
+            filters.push(`ActorId = '${actorId}'`);
+        if (d.recordId)
+            filters.push(`ProcessInstance.TargetObjectId = '${d.recordId}'`);
+        const soql = "SELECT Id, ProcessInstanceId, ProcessInstance.TargetObjectId, ActorId, OriginalActorId, CreatedDate FROM ProcessInstanceWorkitem" +
+            (d.scope === "mineAndGroups" ? " USING SCOPE mine_and_my_groups" : "") +
+            (filters.length ? ` WHERE ${filters.join(" AND ")}` : "") +
+            " ORDER BY CreatedDate DESC, Id DESC";
+        return c.object(queryPath(`${c.base}/query`, { q: soql }));
+    },
+};

package/src/providers/salesforce/runtime-base.js

@@ -26,10 +26,10 @@ export const salesforceBaseHandlers = {
         };
     },
     async create_record(d, c) {
-        return c.object(`${c.base}/sobjects/${segment(d.objectName)}`, "POST", d.fields);
+        return c.object(`${c.base}/sobjects/${segment(d.objectName)}`, "POST", d.fields, writeHeaders(d));
     },
     async update_record(d, c) {
-        const result = await c.request(`${c.base}/sobjects/${segment(d.objectName)}/${segment(d.recordId)}`, "PATCH", d.fields);
+        const result = await c.request(`${c.base}/sobjects/${segment(d.objectName)}/${segment(d.recordId)}`, "PATCH", d.fields, writeHeaders(d));
         return result === undefined
             ? { success: true, id: d.recordId }
             : requiredResponseRecord(result, "Salesforce response");
@@ -43,9 +43,20 @@ export const salesforceBaseHandlers = {
     async upsert_record(d, c) {
         const result = await c.request(queryPath(`${c.base}/sobjects/${segment(d.objectName)}/${segment(d.externalIdField)}/${segment(d.externalId)}`, {
             updateOnly: d.updateOnly,
-        }), "PATCH", d.fields);
+        }), "PATCH", d.fields, writeHeaders(d));
         return result === undefined
             ? { success: true, created: false }
             : requiredResponseRecord(result, "Salesforce response");
     },
 };
+function writeHeaders(input) {
+    const headers = new Headers();
+    if (input.assignmentRule !== undefined)
+        headers.set("Sforce-Auto-Assign", String(input.assignmentRule));
+    if (input.duplicateRule !== undefined) {
+        const options = Object.entries(input.duplicateRule);
+        if (options.length)
+            headers.set("Sforce-Duplicate-Rule-Header", options.map(([name, value]) => `${name}=${value}`).join("; "));
+    }
+    return headers;
+}

package/src/providers/salesforce/runtime-chatter.d.ts

@@ -0,0 +1,2 @@
+import type { SalesforceHandler } from "./context.ts";
+export declare const salesforceChatterHandlers: Record<string, SalesforceHandler>;

package/src/providers/salesforce/runtime-chatter.js

@@ -0,0 +1,78 @@
+import { recordOrEmpty } from "../../core/cast.js";
+import { providerInputError } from "../provider-runtime.js";
+import { chatterFeedRoutes } from "./chatter-routes.js";
+import { queryPath, segment } from "./context.js";
+function chatterBase(d, c) {
+    return c.base + (d.communityId === undefined ? "" : `/connect/communities/${segment(d.communityId)}`);
+}
+function elementPath(d, c) {
+    return `${chatterBase(d, c)}/chatter/feed-elements/${segment(d.feedElementId)}`;
+}
+export const salesforceChatterHandlers = {
+    async list_chatter_feed_elements(d, c) {
+        const route = chatterFeedRoutes[d.feedType];
+        if (route.communityRequired && d.communityId === undefined)
+            throw providerInputError("communityId is required for this feed");
+        let path = route.path;
+        for (const name of ["userId", "recordId", "topicId", "streamId", "favoriteId", "keyPrefix"]) {
+            const inputName = ["favoriteId", "keyPrefix"].includes(name) ? name : "subjectId";
+            if (path.includes(`{${name}}`)) {
+                if (d[inputName] === undefined)
+                    throw providerInputError(`${inputName} is required for ${d.feedType}`);
+                path = path.replace(`{${name}}`, segment(d[inputName]));
+            }
+        }
+        if (!route.path.includes("{") && d.subjectId !== undefined)
+            throw providerInputError("This feed does not accept subjectId");
+        if (d.favoriteId !== undefined && d.feedType !== "favorites")
+            throw providerInputError("favoriteId requires favorites feed");
+        if (d.keyPrefix !== undefined && d.feedType !== "filter")
+            throw providerInputError("keyPrefix requires filter feed");
+        const { apiVersion: _version, feedType: _type, subjectId: _subject, communityId: _community, favoriteId: _favorite, keyPrefix: _prefix, ...params } = d;
+        for (const name of Object.keys(params))
+            if (!route.parameters.includes(name))
+                throw providerInputError(`${name} is not supported by ${d.feedType} feed`);
+        return c.object(queryPath(chatterBase(d, c) + path, params));
+    },
+    async get_chatter_feed_element(d, c) {
+        return {
+            element: await c.object(queryPath(elementPath(d, c), {
+                commentSort: d.commentSort,
+                elementsPerBundle: d.elementsPerBundle,
+                recentCommentCount: d.recentCommentCount,
+                threadedCommentsCollapsed: d.threadedCommentsCollapsed,
+            })),
+        };
+    },
+    async list_chatter_comments(d, c) {
+        return c.object(queryPath(`${elementPath(d, c)}/capabilities/comments/items`, {
+            page: d.page,
+            pageSize: d.pageSize,
+            sort: d.sort,
+            threadedCommentsCollapsed: d.threadedCommentsCollapsed,
+        }));
+    },
+    async create_chatter_comment(d, c) {
+        return {
+            comment: await c.object(`${elementPath(d, c)}/capabilities/comments/items`, "POST", {
+                body: d.body,
+                capabilities: d.capabilities,
+                threadParentId: d.threadParentId,
+            }),
+        };
+    },
+    async create_chatter_feed_element(d, c) {
+        const capabilities = recordOrEmpty(d.capabilities);
+        if (d.body === undefined && !capabilities.files && !capabilities.link && !capabilities.feedEntityShare)
+            throw providerInputError("Provide body or a file, link or feed sharing capability");
+        return {
+            element: await c.object(`${chatterBase(d, c)}/chatter/feed-elements`, "POST", {
+                feedElementType: "FeedItem",
+                subjectId: d.subjectId,
+                body: d.body,
+                capabilities: d.capabilities,
+                visibility: d.visibility,
+            }),
+        };
+    },
+};

package/src/providers/salesforce/runtime-knowledge.d.ts

@@ -0,0 +1,2 @@
+import type { SalesforceHandler } from "./context.ts";
+export declare const salesforceKnowledgeHandlers: Record<string, SalesforceHandler>;

package/src/providers/salesforce/runtime-knowledge.js

@@ -0,0 +1,34 @@
+import { recordOrEmpty } from "../../core/cast.js";
+import { providerInputError } from "../provider-runtime.js";
+import { queryPath, segment } from "./context.js";
+export const salesforceKnowledgeHandlers = {
+    async list_knowledge_articles(d, c) {
+        if (d.queryMethod && !Object.keys(recordOrEmpty(d.categories)).length)
+            throw providerInputError("queryMethod requires categories");
+        if (d.order && !d.sort)
+            throw providerInputError("order requires sort");
+        if (d.sort === "ViewScore" && (d.searchText || d.pageNumber !== undefined))
+            throw providerInputError("ViewScore does not support searchText or pageNumber");
+        return c.object(queryPath(`${c.base}/support/knowledgeArticles`, {
+            q: d.searchText,
+            channel: d.channel,
+            categories: d.categories === undefined ? undefined : JSON.stringify(d.categories),
+            queryMethod: d.queryMethod,
+            sort: d.sort,
+            order: d.order,
+            pageSize: d.pageSize,
+            pageNumber: d.pageNumber,
+        }), "GET", undefined, { "Accept-Language": String(d.language) });
+    },
+    async get_knowledge_article(d, c) {
+        if ((d.articleId !== undefined) === (d.urlName !== undefined))
+            throw providerInputError("Provide exactly one of articleId or urlName");
+        return {
+            article: await c.object(queryPath(`${c.base}/support/knowledgeArticles/${segment(d.articleId ?? d.urlName)}`, {
+                channel: d.channel,
+                isUrlName: d.urlName === undefined ? undefined : true,
+                updateViewStat: d.updateViewStat ?? false,
+            }), "GET", undefined, { "Accept-Language": String(d.language) }),
+        };
+    },
+};

package/src/providers/salesforce/runtime-leads.d.ts

@@ -0,0 +1,2 @@
+import type { SalesforceHandler } from "./context.ts";
+export declare const salesforceLeadHandlers: Record<string, SalesforceHandler>;

package/src/providers/salesforce/runtime-leads.js

@@ -0,0 +1,117 @@
+import XMLBuilder from "fast-xml-builder";
+import { XMLParser, XMLValidator } from "fast-xml-parser";
+import { optionalString, recordOrEmpty } from "../../core/cast.js";
+import { ProviderRequestError, providerInputError, providerResponseError, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+const builder = new XMLBuilder({ ignoreAttributes: false });
+const parser = new XMLParser({
+    ignoreAttributes: false,
+    removeNSPrefix: true,
+    parseTagValue: false,
+    processEntities: true,
+});
+const conversionFields = [
+    "accountId",
+    "contactId",
+    "convertedStatus",
+    "doNotCreateOpportunity",
+    "leadId",
+    "opportunityId",
+    "opportunityName",
+    "overwriteLeadSource",
+    "ownerId",
+    "relatedPersonAccountId",
+    "relatedPersonAccountRecord",
+    "sendNotificationEmail",
+];
+export const salesforceLeadHandlers = {
+    async convert_leads(d, c) {
+        const conversions = d.conversions;
+        const leadConverts = conversions.map((entry) => {
+            if ((entry.opportunityId !== undefined && entry.opportunityName !== undefined) ||
+                (entry.doNotCreateOpportunity === true &&
+                    (entry.opportunityId !== undefined || entry.opportunityName !== undefined)))
+                throw providerInputError("Opportunity ID, name and doNotCreateOpportunity conflict");
+            if ((entry.contactId !== undefined || entry.overwriteLeadSource === true) && entry.accountId === undefined)
+                throw providerInputError("An existing contact requires accountId");
+            if (entry.overwriteLeadSource === true && entry.contactId === undefined)
+                throw providerInputError("overwriteLeadSource requires contactId");
+            if (entry.relatedPersonAccountId !== undefined && entry.relatedPersonAccountRecord !== undefined)
+                throw providerInputError("Choose an existing or new related Person Account");
+            const result = {};
+            for (const key of conversionFields) {
+                if (entry[key] === undefined &&
+                    !["doNotCreateOpportunity", "overwriteLeadSource", "sendNotificationEmail"].includes(key))
+                    continue;
+                if (key === "relatedPersonAccountRecord") {
+                    const fields = recordOrEmpty(recordOrEmpty(entry[key]).fields);
+                    const entity = {
+                        "obj:type": "Account",
+                        "obj:fieldsToNull": Object.entries(fields)
+                            .filter(([, value]) => value === null)
+                            .map(([name]) => name),
+                    };
+                    for (const [name, value] of Object.entries(fields)) {
+                        if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(name) || name === "type" || name === "fieldsToNull")
+                            throw providerInputError("Invalid Person Account field API name");
+                        if (value !== null)
+                            entity[`obj:${name}`] = value;
+                    }
+                    result[key] = entity;
+                }
+                else
+                    result[key] = entry[key] ?? false;
+            }
+            return result;
+        });
+        const xml = builder.build({
+            "env:Envelope": {
+                "@_xmlns:env": "http://schemas.xmlsoap.org/soap/envelope/",
+                "@_xmlns": "urn:partner.soap.sforce.com",
+                "@_xmlns:obj": "urn:sobject.partner.soap.sforce.com",
+                "env:Header": { SessionHeader: { sessionId: c.accessToken } },
+                "env:Body": { convertLead: { leadConverts } },
+            },
+        });
+        return runProviderRequest({ label: "Salesforce", signal: c.signal }, async (signal) => {
+            const response = await c.fetcher(new URL(`/services/Soap/u/${c.version}`, c.origin), {
+                method: "POST",
+                headers: {
+                    "content-type": "text/xml; charset=UTF-8",
+                    accept: "text/xml",
+                    SOAPAction: "convertLead",
+                },
+                body: xml,
+                signal,
+                redirect: "manual",
+            });
+            const text = await response.text();
+            if (text.includes("<!DOCTYPE") || text.includes("<!ENTITY") || XMLValidator.validate(text) !== true)
+                throw new ProviderRequestError(response.ok ? 502 : response.status, "Salesforce returned invalid SOAP XML", undefined, "provider_error");
+            const body = recordOrEmpty(recordOrEmpty(parser.parse(text)).Envelope).Body;
+            const envelope = requiredResponseRecord(body, "Salesforce SOAP body");
+            const fault = recordOrEmpty(envelope.Fault);
+            if (envelope.Fault || !response.ok) {
+                const message = [optionalString(fault.faultcode), optionalString(fault.faultstring)].filter(Boolean).join(": ");
+                throw new ProviderRequestError(response.ok ? 502 : response.status, `Salesforce: ${message || `HTTP ${response.status}`}`.split(c.accessToken).join("[REDACTED]"), undefined, "provider_error");
+            }
+            const raw = recordOrEmpty(envelope.convertLeadResponse).result;
+            if (raw === undefined)
+                throw providerResponseError("Salesforce SOAP response is missing conversion results");
+            const results = (Array.isArray(raw) ? raw : [raw]).map((value) => {
+                const result = requiredResponseRecord(value, "Salesforce conversion result");
+                if (!["true", "false", "1", "0"].includes(String(result.success)))
+                    throw providerResponseError("Salesforce conversion result is missing success");
+                return {
+                    ...result,
+                    success: result.success === "true" || result.success === "1",
+                    leadId: optionalString(result.leadId) ?? null,
+                    accountId: optionalString(result.accountId) ?? null,
+                    contactId: optionalString(result.contactId) ?? null,
+                    opportunityId: optionalString(result.opportunityId) ?? null,
+                    errors: result.errors === undefined ? [] : Array.isArray(result.errors) ? result.errors : [result.errors],
+                };
+            });
+            return { results };
+        });
+    },
+};

package/src/providers/salesforce/runtime-platform.d.ts

@@ -0,0 +1,2 @@
+import type { SalesforceHandler } from "./context.ts";
+export declare const salesforcePlatformHandlers: Record<string, SalesforceHandler>;

package/src/providers/salesforce/runtime-platform.js

@@ -0,0 +1,67 @@
+import { providerInputError } from "../provider-runtime.js";
+import { queryPath, segment } from "./context.js";
+export const salesforcePlatformHandlers = {
+    async get_record_create_defaults(d, c) {
+        return c.object(queryPath(`${c.base}/ui-api/record-defaults/create/${segment(d.objectName)}`, {
+            recordTypeId: d.recordTypeId,
+            formFactor: d.formFactor,
+            optionalFields: d.optionalFields,
+        }));
+    },
+    async get_record_layout(d, c) {
+        return {
+            layout: await c.object(queryPath(`${c.base}/ui-api/layout/${segment(d.objectName)}`, {
+                recordTypeId: d.recordTypeId,
+                formFactor: d.formFactor,
+                layoutType: d.layoutType,
+                mode: d.mode,
+            })),
+        };
+    },
+    async get_lookup_suggestions(d, c) {
+        const q = String(d.q ?? "");
+        if ((d.searchType === "Search" && q.length < 2) ||
+            (d.searchType === "TypeAhead" && (q.length < 3 || q.includes("?"))))
+            throw providerInputError("Lookup search text does not meet the selected searchType requirements");
+        if (Number(c.version) < 60 || (d.orderBy !== undefined && Number(c.version) < 63))
+            throw providerInputError("Lookup POST requires API 60.0; orderBy requires API 63.0");
+        return {
+            result: await c.object(queryPath(`${c.base}/ui-api/lookups/${segment(d.objectName)}/${segment(d.fieldName)}`, {
+                searchType: d.searchType,
+                q: d.q,
+                page: d.page,
+                pageSize: d.pageSize,
+                targetApiName: d.targetApiName,
+            }), "POST", { sourceRecord: { fields: d.sourceFields }, orderBy: d.orderBy }),
+        };
+    },
+    async create_report(d, c) {
+        return c.object(`${c.base}/analytics/reports`, "POST", { reportMetadata: d.reportMetadata });
+    },
+    async clone_report(d, c) {
+        return c.object(queryPath(`${c.base}/analytics/reports`, { cloneId: d.reportId }), "POST", {
+            reportMetadata: d.reportMetadata ?? {},
+        });
+    },
+    async save_report(d, c) {
+        return c.object(`${c.base}/analytics/reports/${segment(d.reportId)}`, "PATCH", {
+            reportMetadata: d.reportMetadata,
+        });
+    },
+    async tooling_query(d, c) {
+        return c.object(queryPath(`${c.base}/tooling/query`, { q: d.soql }));
+    },
+    async tooling_query_more(d, c) {
+        return c.object(String(d.nextRecordsUrl));
+    },
+    async get_tooling_record(d, c) {
+        return {
+            record: await c.object(queryPath(`${c.base}/tooling/sobjects/${segment(d.objectName)}/${segment(d.recordId)}`, {
+                fields: d.fields,
+            })),
+        };
+    },
+    async get_apex_log(d, c) {
+        return c.response(`${c.base}/tooling/sobjects/ApexLog/${segment(d.logId)}/Body`, { headers: { accept: "text/plain" } }, async (response) => ({ body: await response.text() }));
+    },
+};

package/src/providers/saperly/actions.d.ts

@@ -0,0 +1,17 @@
+import type { ActionDefinition, JsonSchema } from "../../core/types.ts";
+export interface SaperlyEndpoint {
+    name: string;
+    method: "GET" | "POST" | "PATCH" | "DELETE";
+    path: string;
+    pathKeys: string[];
+    queryKeys: string[];
+    outputKind: "object" | "list" | "recording" | "transcript";
+    operationType: ActionDefinition["operationType"];
+    description: string;
+    inputSchema: JsonSchema;
+    outputSchema: JsonSchema;
+}
+declare const saperlyEndpoints: SaperlyEndpoint[];
+export declare const saperlyActions: ActionDefinition[];
+export declare const saperlyEndpointByName: Map<string, (typeof saperlyEndpoints)[number]>;
+export {};