@oomol-lab/open-connector 1.6.2 → 1.6.3

package/src/providers/slack/actions.js

@@ -15,6 +15,23 @@ const sortDirectionSchema = s.stringEnum(["asc", "desc"], {
 const conversationTypeSchema = s.stringEnum([...slackConversationTypes], {
     description: "A Slack conversation type.",
 });
+// `conversations.history` and `conversations.replies` take the same time
+// window, so it is declared once. The bounds are Slack `ts` strings
+// ("<epoch seconds>.<6 digits>"), NOT epoch integers: Slack compares them
+// against the message `ts` lexically-as-decimal, and a bare integer is a
+// legal value for that same field. Left as `string` rather than a pattern
+// so a caller can pass a `ts` it read back from a message verbatim.
+const historyWindowProperties = {
+    oldest: s.string({
+        description: "Only return messages after this Slack timestamp, for example '1700000000.123456'. The message at exactly this timestamp is included only when inclusive is true.",
+    }),
+    latest: s.string({
+        description: "Only return messages before this Slack timestamp. Defaults to now. The message at exactly this timestamp is included only when inclusive is true.",
+    }),
+    inclusive: s.boolean({
+        description: "Include messages whose timestamp equals oldest or latest. Slack ignores this unless one of those bounds is set.",
+    }),
+};
 const slackBlockSchema = s.unknownObject("A Slack Block Kit block object. Pass the block exactly as Slack documents it.");
 const slackAttachmentSchema = s.unknownObject("A Slack legacy attachment object. Prefer blocks for new messages when possible.");
 const messageContentProperties = {
@@ -33,10 +50,42 @@ const messageContentProperties = {
     unfurlMedia: s.boolean({ description: "Whether Slack should unfurl media in the message." }),
     metadata: s.unknownObject("Slack message metadata to attach to the message."),
 };
+const slackReactionSchema = s.looseObject({
+    name: s.string({ description: "The emoji name of the reaction." }),
+    count: s.integer({ description: "How many users added this reaction." }),
+    userIds: s.array(s.string({ description: "A Slack user ID." }), {
+        description: "The users who added this reaction, as far as Slack reports them.",
+    }),
+}, { description: "A reaction summary on a Slack message." });
+// Only fields the executor actually normalizes are declared. The object is
+// loose, but that permits extras it does NOT make them appear: the executor
+// builds each row explicitly, so an undeclared Slack field is simply not
+// emitted. Deliberately absent: `blocks`, `attachments` and `files`. Those
+// are unbounded nested payloads on a row shape that ETL reads in bulk, and
+// each wants its own normalized contract rather than a raw passthrough.
 const slackMessageSchema = s.looseObject({
     ts: s.string({ description: "The message timestamp identifier." }),
+    type: s.string({ description: "The Slack message type, normally 'message'." }),
+    subtype: s.string({
+        description: "The Slack message subtype ('channel_join', 'bot_message', …) when the message has one.",
+    }),
     userId: s.string({ description: "The user ID of the message author." }),
+    botId: s.string({ description: "The bot ID of the message author when a bot posted it." }),
+    appId: s.string({ description: "The Slack app ID that posted the message when an app posted it." }),
+    username: s.string({ description: "The display username Slack attached to a bot or app message." }),
+    teamId: s.string({ description: "The Slack team ID the message belongs to." }),
+    clientMsgId: s.string({ description: "The client-generated message identifier when Slack returns one." }),
     text: s.string({ description: "The text content of the message." }),
+    editedTs: s.string({ description: "The timestamp of the most recent edit, when the message was edited." }),
+    threadTs: s.string({
+        description: "The timestamp of the thread parent. Equal to ts on a thread parent, and absent on a message that is not in a thread.",
+    }),
+    parentUserId: s.string({ description: "The author of the thread parent, on a threaded reply." }),
+    replyCount: s.integer({ description: "The number of replies to this thread parent." }),
+    replyUsersCount: s.integer({ description: "The number of distinct users who replied to this thread parent." }),
+    latestReply: s.string({ description: "The timestamp of the most recent reply to this thread parent." }),
+    isLocked: s.boolean({ description: "Whether the thread is locked." }),
+    reactions: s.array(slackReactionSchema, { description: "Reaction summaries attached to the message." }),
 }, { description: "A Slack message record." });
 const searchMessageMatchSchema = s.looseObject({
     matchId: s.string({ description: "Slack's search result item identifier." }),
@@ -103,6 +152,18 @@ const fileSchema = s.looseObject({
 }, { description: "A Slack file object returned by the Web API." });
 const reactionItemSchema = s.unknownObject("A Slack item with reactions.");
 export const slackActions = [
+    action({
+        name: "get_current_user",
+        operationType: "read",
+        description: "Get the workspace and user identity of the connected Slack credential, including whether it belongs to a bot.",
+        requiredScopes: [],
+        inputSchema: s.object({}),
+        outputSchema: s.object({
+            teamId: s.nonEmptyString("The Slack workspace ID."),
+            userId: userIdSchema,
+            isBot: s.boolean({ description: "Whether auth.test identifies this credential with a bot_id." }),
+        }, { required: ["teamId", "userId", "isBot"] }),
+    }),
     action({
         name: "list_channels",
         operationType: "read",
@@ -120,12 +181,46 @@ export const slackActions = [
         requiredScopes: ["channels:history", "groups:history", "im:history", "mpim:history"],
         inputSchema: s.object({
             channelId: channelIdSchema,
-            limit: s.integer({ minimum: 1, maximum: 100, description: "The maximum number of messages to return." }),
+            // 999 is `conversations.history`'s documented ceiling. The former 100
+            // was this action's own invention and cost a request per 100 messages.
+            limit: s.integer({ minimum: 1, maximum: 999, description: "The maximum number of messages to return." }),
+            cursor: s.string({
+                description: "The Slack pagination cursor from a previous page. Omit for the first page.",
+            }),
+            ...historyWindowProperties,
         }, { required: ["channelId"], description: "Input parameters for reading Slack conversation history." }),
         outputSchema: s.object({
             messages: s.array(slackMessageSchema, { description: "The list of messages in the conversation." }),
             hasMore: s.boolean({ description: "Whether more messages are available beyond this page." }),
-        }, { required: ["messages", "hasMore"], description: "The output payload for this action." }),
+            nextCursor: s.string({
+                description: "The cursor for the next page, or an empty string when this is the last page.",
+            }),
+        }, { required: ["messages", "hasMore", "nextCursor"], description: "The output payload for this action." }),
+    }),
+    action({
+        name: "conversations_members",
+        operationType: "read",
+        description: "List the member user IDs of a Slack conversation. Returns one page; pass the cursor from nextCursor until it comes back empty.",
+        requiredScopes: ["channels:read", "groups:read", "im:read", "mpim:read"],
+        inputSchema: s.object({
+            channelId: channelIdSchema,
+            cursor: s.string({
+                description: "The Slack pagination cursor from a previous page. Omit for the first page.",
+            }),
+            limit: s.integer({
+                minimum: 1,
+                maximum: 1000,
+                description: "The maximum number of members to return per page.",
+            }),
+        }, { required: ["channelId"], description: "Input parameters for listing Slack conversation members." }),
+        outputSchema: s.object({
+            memberIds: s.array(userIdSchema, {
+                description: "The Slack user IDs that are members of the conversation.",
+            }),
+            nextCursor: s.string({
+                description: "The cursor for the next page, or an empty string when this is the last page.",
+            }),
+        }, { required: ["memberIds", "nextCursor"], description: "The output payload for this action." }),
     }),
     action({
         name: "search_messages",
@@ -223,11 +318,19 @@ export const slackActions = [
         inputSchema: s.object({
             channelId: channelIdSchema,
             threadTs: s.nonEmptyString("The timestamp of the parent message."),
+            limit: s.integer({ minimum: 1, maximum: 999, description: "The maximum number of messages to return." }),
+            cursor: s.string({
+                description: "The Slack pagination cursor from a previous page. Omit for the first page.",
+            }),
+            ...historyWindowProperties,
         }, { required: ["channelId", "threadTs"], description: "Input parameters for reading a Slack thread." }),
         outputSchema: s.object({
             messages: s.array(slackMessageSchema, { description: "The list of messages in the thread." }),
             hasMore: s.boolean({ description: "Whether more messages are available beyond this page." }),
-        }, { required: ["messages", "hasMore"], description: "The output payload for this action." }),
+            nextCursor: s.string({
+                description: "The cursor for the next page, or an empty string when this is the last page.",
+            }),
+        }, { required: ["messages", "hasMore", "nextCursor"], description: "The output payload for this action." }),
     }),
     action({
         name: "list_conversations",

package/src/providers/slack/runtime.js

@@ -1,6 +1,6 @@
-import { compactObject, optionalBoolean, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
+import { compactObject, optionalBoolean, optionalInteger, optionalRecord, optionalString, requiredString, } from "../../core/cast.js";
 import { assertPublicHttpUrl, readBoundedResponseBytes } from "../../core/request.js";
-import { createProviderTimeout, defineProviderExecutors, isAbortLikeError, ProviderRequestError, providerUserAgent, requireOAuthCredential, } from "../provider-runtime.js";
+import { createProviderTimeout, defineProviderExecutors, isAbortLikeError, ProviderRequestError, providerUserAgent, } from "../provider-runtime.js";
 import { slackConversationTypes } from "./constants.js";
 export const slackApiBaseUrl = "https://slack.com/api";
 const slackFileUrlMaxBytes = 100 * 1024 * 1024;
@@ -10,12 +10,26 @@ export function defineSlackProviderExecutors(service, tokenKind, handlers) {
         service,
         handlers,
         async createContext(context, fetcher) {
-            const credential = await requireOAuthCredential(context, service);
-            if (readSlackTokenKind(credential.accessToken, credential.metadata) != tokenKind) {
-                throw new ProviderRequestError(401, `Reconnect ${service} with ${tokenKind} authorization before running its actions.`);
+            const credential = await context.getCredential(service);
+            let accessToken;
+            if (credential?.authType === "oauth2") {
+                if (readSlackTokenKind(credential.accessToken, credential.metadata) != tokenKind) {
+                    throw new ProviderRequestError(401, `Reconnect ${service} with ${tokenKind} authorization before running its actions.`);
+                }
+                accessToken = credential.accessToken;
+            }
+            else if (credential?.authType === "api_key") {
+                // A pasted token was authorized by no OAuth flow, so the user/bot flow
+                // gate above has nothing to check for it; Slack enforces its own
+                // per-method token rules. Mirrors github and notion, whose api_key arm
+                // is likewise "use this bearer as-is".
+                accessToken = credential.apiKey;
+            }
+            else {
+                throw new ProviderRequestError(401, `Configure ${service} credentials first.`);
             }
             const providerContext = {
-                accessToken: credential.accessToken,
+                accessToken,
                 fetcher,
                 signal: context.signal,
             };
@@ -27,12 +41,18 @@ export function defineSlackProviderExecutors(service, tokenKind, handlers) {
     });
 }
 export const slackActionHandlers = {
+    get_current_user(_input, context) {
+        return slackGetCurrentUser(context);
+    },
     list_channels(input, context) {
         return slackListChannels(input, context);
     },
     get_channel_messages(input, context) {
         return slackGetChannelMessages(input, context);
     },
+    conversations_members(input, context) {
+        return slackConversationsMembers(input, context);
+    },
     search_messages(input, context) {
         return slackSearchMessages(input, context);
     },
@@ -101,19 +121,20 @@ export const slackActionHandlers = {
     },
 };
 export const slackCredentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const payload = await slackAuthTest({ accessToken: input.apiKey, fetcher, signal });
+        return {
+            profile: slackCredentialProfile(payload),
+            metadata: {
+                currentAccount: payload,
+            },
+        };
+    },
     async oauth2(input, { fetcher, signal }) {
-        const payload = await slackRequestJson({
-            accessToken: input.accessToken,
-            fetcher,
-            signal,
-            method: "auth.test",
-        });
+        const payload = await slackAuthTest({ accessToken: input.accessToken, fetcher, signal });
         const responseScopes = readSlackCredentialScopes(input.accessToken, input.metadata);
         return {
-            profile: {
-                accountId: payload.user_id ?? payload.team_id ?? "slack:oauth2",
-                displayName: payload.team ?? payload.team_id ?? payload.user_id ?? "Slack Workspace",
-            },
+            profile: slackCredentialProfile(payload),
             grantedScopes: responseScopes.length > 0 ? responseScopes : input.profile.grantedScopes,
             metadata: {
                 currentAccount: payload,
@@ -121,6 +142,34 @@ export const slackCredentialValidators = {
         };
     },
 };
+async function slackAuthTest(input) {
+    return slackRequestJson({ ...input, method: "auth.test" });
+}
+/**
+ * Read the identity `auth.test` reports for a token. Slack documents `team_id`
+ * and `user_id` on every successful response and `bot_id` only for bot tokens,
+ * so a response missing either required ID is malformed rather than anonymous:
+ * no fallback identity is manufactured for it, because a connection keyed on a
+ * placeholder cannot be told apart from another token in the same state.
+ */
+function readSlackAuthTestIdentity(payload) {
+    return {
+        teamId: requireSlackId(payload.team_id, "auth.test team_id"),
+        userId: requireSlackId(payload.user_id, "auth.test user_id"),
+        botId: payload.bot_id === undefined ? undefined : requireSlackId(payload.bot_id, "auth.test bot_id"),
+    };
+}
+function slackCredentialProfile(payload) {
+    const identity = readSlackAuthTestIdentity(payload);
+    return {
+        accountId: identity.userId,
+        displayName: optionalString(payload.team) ?? identity.teamId,
+    };
+}
+async function slackGetCurrentUser(context) {
+    const identity = readSlackAuthTestIdentity(await slackAuthTest(context));
+    return { teamId: identity.teamId, userId: identity.userId, isBot: identity.botId !== undefined };
+}
 async function slackListChannels(input, context) {
     const url = slackApiUrl("conversations.list");
     if (input.limit != null) {
@@ -140,14 +189,25 @@ async function slackGetChannelMessages(input, context) {
     if (input.limit != null) {
         url.searchParams.set("limit", String(input.limit));
     }
+    if (input.cursor != null) {
+        url.searchParams.set("cursor", String(input.cursor));
+    }
+    applySlackHistoryWindow(url, input);
+    return readSlackMessagePage(await slackGetJson(url, context), "conversations.history");
+}
+async function slackConversationsMembers(input, context) {
+    const url = slackApiUrl("conversations.members");
+    url.searchParams.set("channel", String(input.channelId));
+    if (input.cursor != null) {
+        url.searchParams.set("cursor", String(input.cursor));
+    }
+    if (input.limit != null) {
+        url.searchParams.set("limit", String(input.limit));
+    }
     const payload = await slackGetJson(url, context);
     return {
-        messages: (payload.messages ?? []).map((message) => ({
-            ts: message.ts,
-            userId: message.user ?? "",
-            text: message.text ?? "",
-        })),
-        hasMore: payload.has_more ?? false,
+        memberIds: requireSlackArray(payload.members, "conversations.members members").map((member) => requireSlackId(member, "conversations.members member")),
+        nextCursor: readSlackNextCursor(payload, "conversations.members"),
     };
 }
 async function slackSearchMessages(input, context) {
@@ -248,15 +308,14 @@ async function slackGetThread(input, context) {
     const url = slackApiUrl("conversations.replies");
     url.searchParams.set("channel", String(input.channelId));
     url.searchParams.set("ts", String(input.threadTs));
-    const payload = await slackGetJson(url, context);
-    return {
-        messages: (payload.messages ?? []).map((message) => ({
-            ts: message.ts,
-            userId: message.user ?? "",
-            text: message.text ?? "",
-        })),
-        hasMore: payload.has_more ?? false,
-    };
+    if (input.limit != null) {
+        url.searchParams.set("limit", String(input.limit));
+    }
+    if (input.cursor != null) {
+        url.searchParams.set("cursor", String(input.cursor));
+    }
+    applySlackHistoryWindow(url, input);
+    return readSlackMessagePage(await slackGetJson(url, context), "conversations.replies");
 }
 async function slackListConversations(input, context) {
     const url = slackApiUrl("conversations.list");
@@ -269,9 +328,11 @@ async function slackListConversations(input, context) {
         url.searchParams.set("exclude_archived", String(input.excludeArchived));
     }
     const payload = await slackGetJson(url, context);
+    // Discovery may prune against this page. Never manufacture an empty list or
+    // terminal cursor from an unreadable enumeration response.
     return {
-        conversations: (payload.channels ?? []).map((channel) => normalizeConversation(channel)),
-        nextCursor: normalizeNextCursor(payload.response_metadata?.next_cursor),
+        conversations: requireSlackArray(payload.channels, "conversations.list channels").map((channel) => normalizeListedConversation(channel)),
+        nextCursor: normalizeNextCursor(readSlackNextCursor(payload, "conversations.list")),
     };
 }
 async function slackGetConversation(input, context) {
@@ -530,11 +591,16 @@ async function slackFormRequestJson(context, method, body) {
     return readSlackResponseJson(response);
 }
 async function readSlackResponseJson(response) {
-    const payload = (await response.json().catch(() => ({})));
+    const payload = (optionalRecord(await response.json().catch(() => undefined)) ?? {});
     if (!response.ok) {
-        throw slackHttpError(response.status, payload);
+        throw slackHttpError(response.status, payload, response.headers.get("retry-after"));
     }
     assertSlackPayload(payload);
+    // Preserve HTTP/Slack failures (including Retry-After) above, but require
+    // affirmative success before any action can normalize an upstream payload.
+    if (payload.ok !== true) {
+        throw slackResponseError("ok");
+    }
     return payload;
 }
 function buildSlackMessagePayload(input, extra = {}) {
@@ -653,6 +719,43 @@ function normalizeScheduledPostAt(value, fallback) {
     }
     return postAt;
 }
+function normalizeListedConversation(value) {
+    const channel = optionalRecord(value);
+    if (!channel) {
+        throw slackResponseError("conversations.list channel");
+    }
+    requireSlackId(channel.id, "conversations.list channel id");
+    for (const field of ["is_im", "is_mpim", "is_private", "is_channel", "is_group"]) {
+        if (channel[field] !== undefined && typeof channel[field] !== "boolean") {
+            throw slackResponseError(`conversations.list ${field}`);
+        }
+    }
+    // Positive IM/MPIM/channel flags establish kind even when unrelated negative
+    // flags are absent. Privacy is required only to distinguish modern channels.
+    if (channel.is_im === true || channel.is_mpim === true) {
+        if ((channel.is_im === true && (channel.is_mpim === true || channel.is_group === true)) ||
+            channel.is_channel === true ||
+            channel.is_private === false) {
+            throw slackResponseError("conversations.list conflicting direct message classification");
+        }
+    }
+    else if (channel.is_channel === true) {
+        if (typeof channel.is_private !== "boolean" || channel.is_group === true) {
+            throw slackResponseError("conversations.list channel classification");
+        }
+    }
+    else if (channel.is_group === true) {
+        // Legacy groups and MPIMs can both set is_group. Only is_mpim:false makes
+        // this unambiguously a private channel; no negative is_im flag is needed.
+        if (channel.is_mpim !== false || channel.is_private === false) {
+            throw slackResponseError("conversations.list ambiguous group classification");
+        }
+    }
+    else {
+        throw slackResponseError("conversations.list channel classification");
+    }
+    return normalizeConversation(channel);
+}
 function normalizeConversationType(conversation) {
     if (conversation.is_im === true) {
         return "im";
@@ -685,6 +788,119 @@ function normalizeConversation(conversation) {
         locale: optionalString(conversation.locale),
     });
 }
+/**
+ * Apply the shared `conversations.history` / `conversations.replies` time
+ * window. Bounds are passed through verbatim: they are Slack `ts` strings,
+ * and reformatting one (rounding, re-serializing as a number) would move the
+ * boundary Slack compares against.
+ */
+function applySlackHistoryWindow(url, input) {
+    if (input.oldest != null) {
+        url.searchParams.set("oldest", String(input.oldest));
+    }
+    if (input.latest != null) {
+        url.searchParams.set("latest", String(input.latest));
+    }
+    if (input.inclusive != null) {
+        url.searchParams.set("inclusive", String(input.inclusive));
+    }
+}
+/**
+ * Read one `conversations.history` / `conversations.replies` page. A page whose
+ * list is missing or whose rows are not objects is rejected rather than
+ * flattened into an empty result, so a broken upstream response cannot pass
+ * for the documented end of a walk.
+ */
+function readSlackMessagePage(payload, method) {
+    if (payload.has_more !== undefined && typeof payload.has_more !== "boolean") {
+        throw slackResponseError(`${method} has_more`);
+    }
+    return {
+        messages: requireSlackArray(payload.messages, `${method} messages`).map((message) => {
+            const record = optionalRecord(message);
+            if (!record) {
+                throw slackResponseError(`${method} message`);
+            }
+            return normalizeSlackMessage(record);
+        }),
+        hasMore: payload.has_more ?? false,
+        nextCursor: readSlackNextCursor(payload, method),
+    };
+}
+/**
+ * Read a page's `response_metadata.next_cursor`. Slack documents an absent,
+ * null or empty cursor as the last page, so those all read as `""`; a present
+ * cursor that is not a plain string is malformed, not evidence the walk ended.
+ */
+function readSlackNextCursor(payload, method) {
+    const metadata = optionalRecord(payload.response_metadata);
+    if (payload.response_metadata !== undefined && !metadata) {
+        throw slackResponseError(`${method} response_metadata`);
+    }
+    const cursor = metadata?.next_cursor;
+    if (cursor == null || cursor === "") {
+        return "";
+    }
+    return requireSlackId(cursor, `${method} next_cursor`);
+}
+function requireSlackArray(value, label) {
+    if (!Array.isArray(value)) {
+        throw slackResponseError(label);
+    }
+    return value;
+}
+/**
+ * Require an upstream identifier exactly as Slack sent it. Whitespace is not
+ * normalized away: a padded or blank ID is a malformed response, and trimming
+ * it would let the wrong key reach a caller.
+ */
+function requireSlackId(value, label) {
+    if (typeof value !== "string" || value === "" || value.trim() !== value) {
+        throw slackResponseError(label);
+    }
+    return value;
+}
+/**
+ * Normalize one `conversations.history` / `conversations.replies` message.
+ *
+ * `ts` and `text` keep their previous always-present shape (an absent text is
+ * `""`, not omitted) because consumers already read them unconditionally;
+ * every field added since is omitted when Slack does not send it, so a
+ * missing value stays distinguishable from an empty one. `userId` is the one
+ * exception kept for compatibility: it stays `""` on a message with no
+ * author, where `botId` / `username` carry the identity instead.
+ */
+function normalizeSlackMessage(message) {
+    const edited = optionalRecord(message.edited) ?? {};
+    const reactions = Array.isArray(message.reactions) ? message.reactions : undefined;
+    return compactObject({
+        ts: requiredString(message.ts, "message ts", () => slackResponseError("conversations message ts")),
+        type: optionalString(message.type),
+        subtype: optionalString(message.subtype),
+        userId: optionalString(message.user) ?? "",
+        botId: optionalString(message.bot_id),
+        appId: optionalString(message.app_id),
+        username: optionalString(message.username),
+        teamId: optionalString(message.team),
+        clientMsgId: optionalString(message.client_msg_id),
+        text: typeof message.text === "string" ? message.text : "",
+        editedTs: optionalString(edited.ts),
+        threadTs: optionalString(message.thread_ts),
+        parentUserId: optionalString(message.parent_user_id),
+        replyCount: optionalInteger(message.reply_count),
+        replyUsersCount: optionalInteger(message.reply_users_count),
+        latestReply: optionalString(message.latest_reply),
+        isLocked: optionalBoolean(message.is_locked),
+        reactions: reactions?.map((reaction) => normalizeSlackReaction(optionalRecord(reaction) ?? {})),
+    });
+}
+function normalizeSlackReaction(reaction) {
+    return compactObject({
+        name: optionalString(reaction.name),
+        count: optionalInteger(reaction.count),
+        userIds: Array.isArray(reaction.users) ? reaction.users.map((user) => String(user)) : undefined,
+    });
+}
 function normalizeSearchMessageMatch(match) {
     const channel = optionalRecord(match.channel) ?? {};
     return compactObject({
@@ -763,8 +979,16 @@ function formatSlackPayloadError(payload) {
     }
     return `${error}: ${details.join("; ")}`;
 }
-function slackHttpError(status, payload) {
+function slackHttpError(status, payload, retryAfter) {
     const message = payload.error ? formatSlackPayloadError(payload) : `slack request failed with ${status}`;
+    if (status === 429 && retryAfter !== null && /^\d+$/.test(retryAfter)) {
+        const retryAfterSeconds = Number(retryAfter);
+        if (Number.isSafeInteger(retryAfterSeconds)) {
+            // The action envelope carries provider details; retain pacing so callers
+            // can resume the same page without guessing when this workspace may retry.
+            return new ProviderRequestError(status, message, { ...payload, retryAfterSeconds });
+        }
+    }
     return new ProviderRequestError(status, message, payload);
 }
 function slackResponseError(message) {

package/src/providers/slackbot/actions.js

@@ -2,7 +2,7 @@ import { defineProviderAction } from "../../core/provider-definition.js";
 import { slackActions } from "../slack/actions.js";
 const service = "slackbot";
 export const slackbotActions = slackActions
-    .filter((action) => action.name != "search_messages" && action.name != "search_context")
+    .filter((action) => action.name != "search_messages" && action.name != "search_context" && action.name != "get_current_user")
     .map((action) => defineProviderAction(service, {
     name: action.name,
     operationType: action.operationType,

package/src/providers/templatedocs/executors.d.ts

@@ -0,0 +1,4 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const executors: ProviderExecutors;
+export declare const proxy: ProviderProxyExecutor;
+export declare const credentialValidators: CredentialValidators;

package/src/providers/templatedocs/executors.js

@@ -0,0 +1,18 @@
+import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { templatedocsActionHandlers, templatedocsApiBaseUrl, validateTemplateDocsCredential } from "./runtime.js";
+const service = "templatedocs";
+export const executors = defineApiKeyProviderExecutors(service, templatedocsActionHandlers);
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: templatedocsApiBaseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        headers.set("accept", "application/json");
+    },
+});
+export const credentialValidators = {
+    apiKey(input, { fetcher, signal }) {
+        return validateTemplateDocsCredential(input.apiKey, fetcher, signal);
+    },
+};

package/src/providers/templatedocs/runtime.d.ts

@@ -0,0 +1,13 @@
+import type { CredentialValidationResult, TransitFileWriter } from "../../core/types.ts";
+import type { ProviderActionHandlers, ProviderFetch } from "../provider-runtime.ts";
+export declare const templatedocsApiBaseUrl = "https://templatedocs.io/api";
+interface TemplateDocsContext {
+    apiKey: string;
+    fetcher: ProviderFetch;
+    transitFiles?: TransitFileWriter;
+    signal?: AbortSignal;
+}
+type TemplateDocsHandler = (input: Record<string, unknown>, context: TemplateDocsContext) => Promise<unknown>;
+export declare const templatedocsActionHandlers: ProviderActionHandlers<"templatedocs", TemplateDocsHandler>;
+export declare function validateTemplateDocsCredential(apiKey: string, fetcher: ProviderFetch, signal?: AbortSignal): Promise<CredentialValidationResult>;
+export {};