@todoist/comms-mcp 0.0.0-stage → 11.0.0

package/dist/utils/read-position.js

@@ -0,0 +1,37 @@
+/**
+ * Returns the objIndex of the last comment in a thread, which is the read
+ * position that clears its unread marker.
+ *
+ * Comment objIndexes start at 0 for the thread post, so the last one is
+ * `commentCount - 1`. `lastObjIndex` carries that value directly; the
+ * count-based fallback covers records where the API omits it.
+ */
+function getThreadLastObjIndex(thread) {
+    return thread.lastObjIndex ?? Math.max(thread.commentCount - 1, 0);
+}
+/**
+ * Marks a thread as read through its latest comment.
+ *
+ * `threads.markRead` takes the objIndex the caller has read up to; the unread
+ * marker moves to the comment after it. Passing 0 only covers the thread post,
+ * so any thread with comments stays unread and keeps its badge. The read
+ * position is resolved from the thread record rather than guessed: overshooting
+ * (e.g. `commentCount`) also clears the badge, but pushes the marker past the
+ * next comment so it would arrive already read.
+ */
+export async function markThreadFullyRead(client, id) {
+    const thread = await client.threads.getThread(id);
+    await client.threads.markRead({ id, objIndex: getThreadLastObjIndex(thread) });
+}
+/**
+ * Marks a conversation as read through its latest message.
+ *
+ * The API rejects `conversations.markRead` without a position (`Either
+ * obj_index or message_id should be provided`), and `objIndex: 0` only covers
+ * the first message, so the conversation record is fetched for its
+ * `lastObjIndex`.
+ */
+export async function markConversationFullyRead(client, id) {
+    const conversation = await client.conversations.getConversation(id);
+    await client.conversations.markRead({ id, objIndex: conversation.lastObjIndex });
+}

package/dist/utils/search-results.d.ts

@@ -0,0 +1,36 @@
+import { type SearchResult } from '@doist/comms-sdk';
+import type { SearchResultItem } from './output-schemas.js';
+export type RawSearchResult = {
+    id: string;
+    content: string;
+    creatorId: number;
+    created: string;
+} & ({
+    type: 'thread';
+    threadId: string;
+    commentId?: string;
+    channelId?: string;
+} | {
+    type: 'conversation';
+    conversationId: string;
+    messageId: string;
+});
+/**
+ * Normalizes SDK search results into the discriminated shape shared by
+ * search-content and get-mentions. The search API only emits 'thread' and
+ * 'conversation' results, each with its container id set; a comment match is a
+ * 'thread' result with commentId set, a message match a 'conversation' result
+ * with messageId set. Results missing a required id are dropped with a logged
+ * warning.
+ */
+export declare function toRawSearchResults(items: SearchResult[], toolName: string): RawSearchResult[];
+/**
+ * Enriches raw search results with creator/channel names and permalinks.
+ * Comment deep-links require a channel (see build-link); without one the URL
+ * falls back to the plain thread link.
+ */
+export declare function toSearchResultItems(results: RawSearchResult[], { workspaceId, userLookup, channelLookup, }: {
+    workspaceId: number;
+    userLookup: Record<number, string>;
+    channelLookup: Record<string, string>;
+}): SearchResultItem[];

package/dist/utils/search-results.js

@@ -0,0 +1,82 @@
+import { getFullCommsURL } from '@doist/comms-sdk';
+/**
+ * Normalizes SDK search results into the discriminated shape shared by
+ * search-content and get-mentions. The search API only emits 'thread' and
+ * 'conversation' results, each with its container id set; a comment match is a
+ * 'thread' result with commentId set, a message match a 'conversation' result
+ * with messageId set. Results missing a required id are dropped with a logged
+ * warning.
+ */
+export function toRawSearchResults(items, toolName) {
+    const results = items.flatMap((r) => {
+        const common = {
+            id: r.id,
+            content: r.snippet,
+            creatorId: r.snippetCreatorId,
+            created: r.snippetLastUpdated.toISOString(),
+        };
+        if (r.type === 'thread' && r.threadId != null) {
+            return [
+                {
+                    ...common,
+                    type: 'thread',
+                    threadId: r.threadId,
+                    commentId: r.commentId ?? undefined,
+                    channelId: r.channelId ?? undefined,
+                },
+            ];
+        }
+        if (r.type === 'conversation' && r.conversationId != null && r.messageId != null) {
+            return [
+                {
+                    ...common,
+                    type: 'conversation',
+                    conversationId: r.conversationId,
+                    messageId: r.messageId,
+                },
+            ];
+        }
+        return [];
+    });
+    if (results.length < items.length) {
+        console.error(`${toolName}: dropped search result(s) missing a required id`, {
+            dropped: items.length - results.length,
+        });
+    }
+    return results;
+}
+/**
+ * Enriches raw search results with creator/channel names and permalinks.
+ * Comment deep-links require a channel (see build-link); without one the URL
+ * falls back to the plain thread link.
+ */
+export function toSearchResultItems(results, { workspaceId, userLookup, channelLookup, }) {
+    return results.map((r) => {
+        const common = {
+            creatorName: userLookup[r.creatorId],
+            workspaceId,
+        };
+        if (r.type === 'thread') {
+            return {
+                ...r,
+                ...common,
+                channelName: r.channelId ? channelLookup[r.channelId] : undefined,
+                url: getFullCommsURL({
+                    workspaceId,
+                    threadId: r.threadId,
+                    channelId: r.channelId,
+                    commentId: r.channelId ? r.commentId : undefined,
+                }),
+            };
+        }
+        return {
+            ...r,
+            ...common,
+            url: getFullCommsURL({
+                workspaceId,
+                conversationId: r.conversationId,
+                messageId: r.messageId,
+            }),
+        };
+    });
+}

package/dist/utils/target-types.d.ts

@@ -0,0 +1,114 @@
+import { z } from 'zod';
+/**
+ * Target types for reactions
+ */
+export declare const ReactionTargetType: {
+    readonly values: readonly ["thread", "comment", "message"];
+    readonly schema: z.ZodEnum<{
+        thread: "thread";
+        comment: "comment";
+        message: "message";
+    }>;
+};
+export declare const ReactionTargetTypeSchema: z.ZodEnum<{
+    thread: "thread";
+    comment: "comment";
+    message: "message";
+}>;
+export type ReactionTargetType = z.infer<typeof ReactionTargetTypeSchema>;
+/**
+ * Target types for update-object
+ */
+export declare const UpdateTargetType: {
+    readonly values: readonly ["thread", "comment", "message"];
+    readonly schema: z.ZodEnum<{
+        thread: "thread";
+        comment: "comment";
+        message: "message";
+    }>;
+};
+export declare const UpdateTargetTypeSchema: z.ZodEnum<{
+    thread: "thread";
+    comment: "comment";
+    message: "message";
+}>;
+export type UpdateTargetType = z.infer<typeof UpdateTargetTypeSchema>;
+/**
+ * Target types for delete-object
+ */
+export declare const DeleteTargetType: {
+    readonly values: readonly ["thread", "comment", "message"];
+    readonly schema: z.ZodEnum<{
+        thread: "thread";
+        comment: "comment";
+        message: "message";
+    }>;
+};
+export declare const DeleteTargetTypeSchema: z.ZodEnum<{
+    thread: "thread";
+    comment: "comment";
+    message: "message";
+}>;
+export type DeleteTargetType = z.infer<typeof DeleteTargetTypeSchema>;
+/**
+ * Target types for replies
+ */
+export declare const ReplyTargetType: {
+    readonly values: readonly ["thread", "conversation"];
+    readonly schema: z.ZodEnum<{
+        thread: "thread";
+        conversation: "conversation";
+    }>;
+};
+export declare const ReplyTargetTypeSchema: z.ZodEnum<{
+    thread: "thread";
+    conversation: "conversation";
+}>;
+export type ReplyTargetType = z.infer<typeof ReplyTargetTypeSchema>;
+/**
+ * Search scope types
+ */
+export declare const SearchScope: {
+    readonly values: readonly ["workspace", "thread", "conversation"];
+    readonly schema: z.ZodEnum<{
+        thread: "thread";
+        conversation: "conversation";
+        workspace: "workspace";
+    }>;
+};
+export declare const SearchScopeSchema: z.ZodEnum<{
+    thread: "thread";
+    conversation: "conversation";
+    workspace: "workspace";
+}>;
+export type SearchScope = z.infer<typeof SearchScopeSchema>;
+/**
+ * Mark done types
+ */
+export declare const MarkDoneType: {
+    readonly values: readonly ["thread", "conversation"];
+    readonly schema: z.ZodEnum<{
+        thread: "thread";
+        conversation: "conversation";
+    }>;
+};
+export declare const MarkDoneTypeSchema: z.ZodEnum<{
+    thread: "thread";
+    conversation: "conversation";
+}>;
+export type MarkDoneType = z.infer<typeof MarkDoneTypeSchema>;
+/**
+ * Mark read item types
+ */
+export declare const MarkReadItemType: {
+    readonly values: readonly ["thread", "conversation"];
+    readonly schema: z.ZodEnum<{
+        thread: "thread";
+        conversation: "conversation";
+    }>;
+};
+export declare const MarkReadItemTypeSchema: z.ZodEnum<{
+    thread: "thread";
+    conversation: "conversation";
+}>;
+export type MarkReadItemType = z.infer<typeof MarkReadItemTypeSchema>;

package/dist/utils/target-types.js

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+/**
+ * Helper to create an enum schema with types.
+ * Requires at least 2 values (Zod enum requirement).
+ * Only allows valid Comms object types.
+ */
+function createEnumSchema(values) {
+    return {
+        values,
+        schema: z.enum(values),
+    };
+}
+/**
+ * Target types for reactions
+ */
+export const ReactionTargetType = createEnumSchema(['thread', 'comment', 'message']);
+export const ReactionTargetTypeSchema = ReactionTargetType.schema;
+/**
+ * Targets that can be both updated and deleted (mutating-object tools).
+ * Kept as a shared const so update-object and delete-object stay in lockstep
+ * if/when the supported surface changes.
+ */
+const objectTargets = ['thread', 'comment', 'message'];
+/**
+ * Target types for update-object
+ */
+export const UpdateTargetType = createEnumSchema(objectTargets);
+export const UpdateTargetTypeSchema = UpdateTargetType.schema;
+/**
+ * Target types for delete-object
+ */
+export const DeleteTargetType = createEnumSchema(objectTargets);
+export const DeleteTargetTypeSchema = DeleteTargetType.schema;
+/**
+ * Items that carry an unread marker and accept replies. Shared so the tools
+ * that act on "a thread or a conversation" stay in lockstep.
+ */
+const threadOrConversation = ['thread', 'conversation'];
+/**
+ * Target types for replies
+ */
+export const ReplyTargetType = createEnumSchema(threadOrConversation);
+export const ReplyTargetTypeSchema = ReplyTargetType.schema;
+/**
+ * Search scope types
+ */
+export const SearchScope = createEnumSchema(['workspace', 'thread', 'conversation']);
+export const SearchScopeSchema = SearchScope.schema;
+/**
+ * Mark done types
+ */
+export const MarkDoneType = createEnumSchema(threadOrConversation);
+export const MarkDoneTypeSchema = MarkDoneType.schema;
+/**
+ * Mark read item types
+ */
+export const MarkReadItemType = createEnumSchema(threadOrConversation);
+export const MarkReadItemTypeSchema = MarkReadItemType.schema;

package/dist/utils/test-helpers.d.ts

@@ -0,0 +1,95 @@
+import type { Channel, Comment, Conversation, ConversationMessage, Thread, User, Workspace } from '@doist/comms-sdk';
+/**
+ * Creates a mock Channel with all required properties and sensible defaults.
+ * Pass only the properties you want to override for your specific test.
+ */
+export declare function createMockChannel(overrides?: Partial<Channel>): Channel;
+/**
+ * Creates a mock Thread with all required properties and sensible defaults.
+ * Pass only the properties you want to override for your specific test.
+ */
+export declare function createMockThread(overrides?: Partial<Thread>): Thread;
+/**
+ * Creates a mock Comment with all required properties and sensible defaults.
+ * Pass only the properties you want to override for your specific test.
+ */
+export declare function createMockComment(overrides?: Partial<Comment>): Comment;
+/**
+ * Creates a mock Conversation with all required properties and sensible defaults.
+ * Pass only the properties you want to override for your specific test.
+ */
+export declare function createMockConversation(overrides?: Partial<Conversation>): Conversation;
+/**
+ * Creates a mock ConversationMessage with all required properties and sensible defaults.
+ * Pass only the properties you want to override for your specific test.
+ */
+export declare function createMockConversationMessage(overrides?: Partial<ConversationMessage>): ConversationMessage;
+/**
+ * Creates a mock User with all required properties and sensible defaults.
+ * Pass only the properties you want to override for your specific test.
+ */
+export declare function createMockUser(overrides?: Partial<User>): User;
+/**
+ * Creates a mock Workspace with all required properties and sensible defaults.
+ * Pass only the properties you want to override for your specific test.
+ */
+export declare function createMockWorkspace(overrides?: Partial<Workspace>): Workspace;
+/**
+ * Common error messages used across tests.
+ */
+export declare const TEST_ERRORS: {
+    readonly API_RATE_LIMIT: "API Error: Rate limit exceeded";
+    readonly API_UNAUTHORIZED: "API Error: Unauthorized";
+    readonly THREAD_NOT_FOUND: "Thread not found";
+    readonly CONVERSATION_NOT_FOUND: "Conversation not found";
+};
+/**
+ * Extracts the text content from a tool output for snapshot testing.
+ * This allows tests to match against just the text content while tools return structured output.
+ */
+export declare function extractTextContent(toolOutput: unknown): string;
+/**
+ * Extracts the structured content from a tool output for testing: a tool's own result, or the
+ * MCP result registration builds from it, which carries it in `structuredContent`.
+ */
+export declare function extractStructuredContent(output: object): Record<string, unknown>;
+/**
+ * Common mock IDs used across tests for consistency.
+ *
+ * Channel/thread/comment/conversation/message/group IDs are opaque base58
+ * UUIDv7 strings in the Comms API; workspace/user IDs are numeric.
+ * The string IDs below are stable fixtures — not real base58 — and exist
+ * purely so tests have predictable values to assert on.
+ */
+export declare const TEST_IDS: {
+    readonly THREAD_1: "thread-id-1";
+    readonly THREAD_2: "thread-id-2";
+    readonly THREAD_3: "thread-id-3";
+    readonly COMMENT_1: "comment-id-1";
+    readonly COMMENT_2: "comment-id-2";
+    readonly CONVERSATION_1: "conv-id-1";
+    readonly CONVERSATION_2: "conv-id-2";
+    readonly MESSAGE_1: "msg-id-1";
+    readonly MESSAGE_2: "msg-id-2";
+    readonly CHANNEL_1: "channel-id-1";
+    readonly GROUP_1: "group-id-1";
+    readonly GROUP_2: "group-id-2";
+    readonly WORKSPACE_1: 11111;
+    readonly WORKSPACE_2: 11112;
+    readonly USER_1: 22222;
+    readonly USER_2: 44444;
+    readonly USER_3: 55555;
+};
+/**
+ * Fixed date for consistent test snapshots.
+ * Use this instead of new Date() in tests to avoid snapshot drift.
+ */
+export declare const TODAY: "2025-01-01";
+/**
+ * A `getUsersByIds` mock implementation answering from `users`, with `null` for
+ * any other requested id — what the API returns for a user the workspace has no
+ * record of.
+ */
+export declare function usersByIds<T extends {
+    id: number;
+}>(users: readonly T[]): never;

package/dist/utils/test-helpers.js

@@ -0,0 +1,231 @@
+/**
+ * Creates a mock Channel with all required properties and sensible defaults.
+ * Pass only the properties you want to override for your specific test.
+ */
+export function createMockChannel(overrides = {}) {
+    return {
+        id: TEST_IDS.CHANNEL_1,
+        name: 'General',
+        creator: TEST_IDS.USER_1,
+        public: true,
+        workspaceId: TEST_IDS.WORKSPACE_1,
+        archived: false,
+        created: new Date('2024-01-01T00:00:00Z'),
+        version: 1,
+        url: `https://comms.todoist.com/${TEST_IDS.WORKSPACE_1}/ch/${TEST_IDS.CHANNEL_1}/`,
+        ...overrides,
+    };
+}
+/**
+ * Creates a mock Thread with all required properties and sensible defaults.
+ * Pass only the properties you want to override for your specific test.
+ */
+export function createMockThread(overrides = {}) {
+    return {
+        id: TEST_IDS.THREAD_1,
+        title: 'Test Thread',
+        content: 'Test thread content',
+        channelId: TEST_IDS.CHANNEL_1,
+        workspaceId: TEST_IDS.WORKSPACE_1,
+        creator: TEST_IDS.USER_1,
+        posted: new Date('2024-01-01T00:00:00Z'),
+        lastUpdated: new Date('2024-01-01T00:00:00Z'),
+        pinned: false,
+        snippet: 'Test thread content',
+        snippetCreator: TEST_IDS.USER_1,
+        systemMessage: null,
+        attachments: [],
+        groups: [],
+        reactions: {},
+        recipients: [],
+        commentCount: 0,
+        isArchived: false,
+        inInbox: true,
+        participants: [TEST_IDS.USER_1],
+        url: `https://comms.todoist.com/${TEST_IDS.WORKSPACE_1}/ch/${TEST_IDS.CHANNEL_1}/t/${TEST_IDS.THREAD_1}/`,
+        ...overrides,
+    };
+}
+/**
+ * Creates a mock Comment with all required properties and sensible defaults.
+ * Pass only the properties you want to override for your specific test.
+ */
+export function createMockComment(overrides = {}) {
+    return {
+        id: TEST_IDS.COMMENT_1,
+        content: 'Test comment content',
+        threadId: TEST_IDS.THREAD_1,
+        workspaceId: TEST_IDS.WORKSPACE_1,
+        channelId: TEST_IDS.CHANNEL_1,
+        creator: TEST_IDS.USER_1,
+        posted: new Date('2024-01-01T00:00:00Z'),
+        systemMessage: null,
+        attachments: [],
+        reactions: {},
+        objIndex: 1,
+        url: `https://comms.todoist.com/${TEST_IDS.WORKSPACE_1}/ch/${TEST_IDS.CHANNEL_1}/t/${TEST_IDS.THREAD_1}/c/${TEST_IDS.COMMENT_1}`,
+        ...overrides,
+    };
+}
+/**
+ * Creates a mock Conversation with all required properties and sensible defaults.
+ * Pass only the properties you want to override for your specific test.
+ */
+export function createMockConversation(overrides = {}) {
+    return {
+        id: TEST_IDS.CONVERSATION_1,
+        workspaceId: TEST_IDS.WORKSPACE_1,
+        userIds: [TEST_IDS.USER_1, TEST_IDS.USER_2],
+        messageCount: 0,
+        lastObjIndex: 0,
+        snippet: '',
+        snippetCreators: [],
+        archived: false,
+        creator: TEST_IDS.USER_1,
+        created: new Date('2024-01-01T00:00:00Z'),
+        lastActive: new Date('2024-01-01T00:00:00Z'),
+        url: `https://comms.todoist.com/${TEST_IDS.WORKSPACE_1}/msg/${TEST_IDS.CONVERSATION_1}/`,
+        ...overrides,
+    };
+}
+/**
+ * Creates a mock ConversationMessage with all required properties and sensible defaults.
+ * Pass only the properties you want to override for your specific test.
+ */
+export function createMockConversationMessage(overrides = {}) {
+    return {
+        id: TEST_IDS.MESSAGE_1,
+        content: 'Test message content',
+        creator: TEST_IDS.USER_1,
+        conversationId: TEST_IDS.CONVERSATION_1,
+        workspaceId: TEST_IDS.WORKSPACE_1,
+        posted: new Date('2024-01-01T00:00:00Z'),
+        systemMessage: null,
+        attachments: [],
+        reactions: {},
+        objIndex: 1,
+        lastEdited: null,
+        url: `https://comms.todoist.com/${TEST_IDS.WORKSPACE_1}/msg/${TEST_IDS.CONVERSATION_1}/m/${TEST_IDS.MESSAGE_1}`,
+        ...overrides,
+    };
+}
+/**
+ * Creates a mock User with all required properties and sensible defaults.
+ * Pass only the properties you want to override for your specific test.
+ */
+export function createMockUser(overrides = {}) {
+    return {
+        id: TEST_IDS.USER_1,
+        email: 'test@example.com',
+        fullName: 'Test User',
+        shortName: 'Test',
+        timezone: 'UTC',
+        lang: 'en',
+        removed: false,
+        ...overrides,
+    };
+}
+/**
+ * Creates a mock Workspace with all required properties and sensible defaults.
+ * Pass only the properties you want to override for your specific test.
+ */
+export function createMockWorkspace(overrides = {}) {
+    return {
+        id: TEST_IDS.WORKSPACE_1,
+        name: 'Test Workspace',
+        creator: TEST_IDS.USER_1,
+        created: new Date('2024-01-01T00:00:00Z'),
+        defaultConversation: TEST_IDS.CONVERSATION_1,
+        plan: 'free',
+        ...overrides,
+    };
+}
+/**
+ * Common error messages used across tests.
+ */
+export const TEST_ERRORS = {
+    API_RATE_LIMIT: 'API Error: Rate limit exceeded',
+    API_UNAUTHORIZED: 'API Error: Unauthorized',
+    THREAD_NOT_FOUND: 'Thread not found',
+    CONVERSATION_NOT_FOUND: 'Conversation not found',
+};
+/**
+ * Extracts the text content from a tool output for snapshot testing.
+ * This allows tests to match against just the text content while tools return structured output.
+ */
+export function extractTextContent(toolOutput) {
+    if (typeof toolOutput === 'string') {
+        return toolOutput;
+    }
+    // A tool's own result, as `execute` returns it.
+    if (typeof toolOutput === 'object' &&
+        toolOutput !== null &&
+        'textContent' in toolOutput &&
+        typeof toolOutput.textContent === 'string') {
+        return toolOutput.textContent;
+    }
+    if (typeof toolOutput === 'object' && toolOutput !== null && 'content' in toolOutput) {
+        const output = toolOutput;
+        if (Array.isArray(output.content) &&
+            output.content[0] &&
+            typeof output.content[0] === 'object' &&
+            output.content[0] !== null &&
+            'type' in output.content[0] &&
+            'text' in output.content[0] &&
+            output.content[0].type === 'text') {
+            return output.content[0].text;
+        }
+    }
+    throw new Error('Expected tool output to have text content');
+}
+/**
+ * Extracts the structured content from a tool output for testing: a tool's own result, or the
+ * MCP result registration builds from it, which carries it in `structuredContent`.
+ */
+export function extractStructuredContent(output) {
+    if ('structuredContent' in output && typeof output.structuredContent === 'object') {
+        return output.structuredContent;
+    }
+    throw new Error('Expected tool output to have structured content');
+}
+/**
+ * Common mock IDs used across tests for consistency.
+ *
+ * Channel/thread/comment/conversation/message/group IDs are opaque base58
+ * UUIDv7 strings in the Comms API; workspace/user IDs are numeric.
+ * The string IDs below are stable fixtures — not real base58 — and exist
+ * purely so tests have predictable values to assert on.
+ */
+export const TEST_IDS = {
+    THREAD_1: 'thread-id-1',
+    THREAD_2: 'thread-id-2',
+    THREAD_3: 'thread-id-3',
+    COMMENT_1: 'comment-id-1',
+    COMMENT_2: 'comment-id-2',
+    CONVERSATION_1: 'conv-id-1',
+    CONVERSATION_2: 'conv-id-2',
+    MESSAGE_1: 'msg-id-1',
+    MESSAGE_2: 'msg-id-2',
+    CHANNEL_1: 'channel-id-1',
+    GROUP_1: 'group-id-1',
+    GROUP_2: 'group-id-2',
+    WORKSPACE_1: 11111,
+    WORKSPACE_2: 11112,
+    USER_1: 22222,
+    USER_2: 44444,
+    USER_3: 55555,
+};
+/**
+ * Fixed date for consistent test snapshots.
+ * Use this instead of new Date() in tests to avoid snapshot drift.
+ */
+export const TODAY = '2025-01-01';
+/**
+ * A `getUsersByIds` mock implementation answering from `users`, with `null` for
+ * any other requested id — what the API returns for a user the workspace has no
+ * record of.
+ */
+export function usersByIds(users) {
+    const byId = new Map(users.map((user) => [user.id, user]));
+    return (async ({ userIds }) => Object.fromEntries(userIds.map((id) => [id, byId.get(id) ?? null])));
+}

package/dist/utils/tool-names.d.ts

@@ -0,0 +1,25 @@
+export declare const ToolNames: {
+    readonly USER_INFO: "user-info";
+    readonly UPDATE_USER_INFO: "update-user-info";
+    readonly FETCH_INBOX: "fetch-inbox";
+    readonly LOAD_THREAD: "load-thread";
+    readonly LOAD_CONVERSATION: "load-conversation";
+    readonly SEARCH_CONTENT: "search-content";
+    readonly GET_MENTIONS: "get-mentions";
+    readonly CREATE_CHANNEL: "create-channel";
+    readonly UPDATE_CHANNEL: "update-channel";
+    readonly CREATE_THREAD: "create-thread";
+    readonly CREATE_CONVERSATION: "create-conversation";
+    readonly UPDATE_OBJECT: "update-object";
+    readonly DELETE_OBJECT: "delete-object";
+    readonly REPLY: "reply";
+    readonly REACT: "react";
+    readonly MARK_DONE: "mark-done";
+    readonly MARK_READ: "mark-read";
+    readonly BUILD_LINK: "build-link";
+    readonly GET_WORKSPACES: "get-workspaces";
+    readonly GET_USERS: "get-users";
+    readonly GET_GROUPS: "get-groups";
+    readonly LIST_CHANNELS: "list-channels";
+    readonly LIST_CONVERSATIONS: "list-conversations";
+};