@oomol-lab/open-connector 1.6.1 → 1.6.3

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,9 +2,10 @@ 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,
     description: action.description,
     requiredScopes: action.requiredScopes,
     inputSchema: action.inputSchema,

package/src/providers/smartsuite/actions.js

@@ -21,6 +21,7 @@ const recordIdentityInputFields = {
 export const smartsuiteActions = [
     defineProviderAction(service, {
         name: "list_solutions",
+        operationType: "read",
         description: "List the Solutions accessible in the connected SmartSuite workspace.",
         requiredScopes: [],
         inputSchema: emptyInputSchema,
@@ -30,6 +31,7 @@ export const smartsuiteActions = [
     }),
     defineProviderAction(service, {
         name: "list_tables",
+        operationType: "read",
         description: "List SmartSuite Tables, optionally limited to one Solution.",
         requiredScopes: [],
         inputSchema: s.object("Filters the SmartSuite Tables to list.", {
@@ -41,6 +43,7 @@ export const smartsuiteActions = [
     }),
     defineProviderAction(service, {
         name: "list_records",
+        operationType: "read",
         description: "List records in a SmartSuite Table with optional pagination, sorting, and filtering.",
         requiredScopes: [],
         inputSchema: s.object("Selects and filters records in a SmartSuite Table.", {
@@ -61,6 +64,7 @@ export const smartsuiteActions = [
     }),
     defineProviderAction(service, {
         name: "get_record",
+        operationType: "read",
         description: "Retrieve one record from a SmartSuite Table.",
         requiredScopes: [],
         inputSchema: s.object("Identifies the SmartSuite record to retrieve.", {
@@ -73,6 +77,7 @@ export const smartsuiteActions = [
     }),
     defineProviderAction(service, {
         name: "create_record",
+        operationType: "write",
         description: "Create a record in a SmartSuite Table using its field slugs.",
         requiredScopes: [],
         inputSchema: s.object("Defines the SmartSuite record to create.", {
@@ -85,6 +90,7 @@ export const smartsuiteActions = [
     }),
     defineProviderAction(service, {
         name: "update_record",
+        operationType: "write",
         description: "Partially update fields on a SmartSuite record without clearing omitted fields.",
         requiredScopes: [],
         inputSchema: s.object("Defines the SmartSuite record fields to update.", {
@@ -97,6 +103,7 @@ export const smartsuiteActions = [
     }),
     defineProviderAction(service, {
         name: "delete_record",
+        operationType: "destructive",
         description: "Delete one record from a SmartSuite Table.",
         requiredScopes: [],
         inputSchema: s.object("Identifies the SmartSuite record to delete.", recordIdentityInputFields),