@todoist/comms-mcp 0.0.0-stage → 11.0.0

package/dist/index.js

@@ -0,0 +1,55 @@
+import { getMcpServer } from './mcp-server.js';
+import { buildLink } from './tools/build-link.js';
+import { createChannel } from './tools/create-channel.js';
+import { createConversation } from './tools/create-conversation.js';
+import { createThread } from './tools/create-thread.js';
+import { deleteObject } from './tools/delete-object.js';
+import { fetchInbox } from './tools/fetch-inbox.js';
+import { getGroups } from './tools/get-groups.js';
+import { getMentions } from './tools/get-mentions.js';
+import { getUsers } from './tools/get-users.js';
+import { getWorkspaces } from './tools/get-workspaces.js';
+import { listChannels } from './tools/list-channels.js';
+import { listConversations } from './tools/list-conversations.js';
+import { loadConversation } from './tools/load-conversation.js';
+import { loadThread } from './tools/load-thread.js';
+import { markDone } from './tools/mark-done.js';
+import { markRead } from './tools/mark-read.js';
+import { react } from './tools/react.js';
+import { reply } from './tools/reply.js';
+import { searchContent } from './tools/search-content.js';
+import { updateChannel } from './tools/update-channel.js';
+import { updateObject } from './tools/update-object.js';
+import { updateUserInfo } from './tools/update-user-info.js';
+import { userInfo } from './tools/user-info.js';
+import { validateCommsToken } from './utils/validate-comms-token.js';
+const tools = {
+    userInfo,
+    updateUserInfo,
+    fetchInbox,
+    loadThread,
+    loadConversation,
+    searchContent,
+    getMentions,
+    createThread,
+    createConversation,
+    updateObject,
+    deleteObject,
+    reply,
+    react,
+    markDone,
+    markRead,
+    buildLink,
+    listChannels,
+    listConversations,
+    getGroups,
+    getUsers,
+    getWorkspaces,
+    createChannel,
+    updateChannel,
+};
+export { tools, getMcpServer, validateCommsToken };
+// Re-exported so consumers of the exported tools can catch the API's errors without taking a
+// direct @doist/comms-sdk dependency.
+export { CommsRequestError } from '@doist/comms-sdk';
+export { userInfo, updateUserInfo, fetchInbox, loadThread, loadConversation, searchContent, getMentions, createThread, createConversation, updateObject, deleteObject, reply, react, markDone, markRead, buildLink, listChannels, listConversations, getGroups, getUsers, getWorkspaces, createChannel, updateChannel, };

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/main.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/server/stdio';
+import dotenv from 'dotenv';
+import { getMcpServer } from './mcp-server.js';
+function main() {
+    const commsApiKey = process.env.COMMS_API_KEY;
+    if (!commsApiKey) {
+        throw new Error('COMMS_API_KEY is not set');
+    }
+    const server = getMcpServer({ token: commsApiKey });
+    const transport = new StdioServerTransport();
+    server
+        .connect(transport)
+        .then(() => {
+        // We use console.error because standard I/O is being used for the MCP server communication.
+        console.error('Server started');
+    })
+        .catch((error) => {
+        console.error('Error starting the Comms MCP server:', error);
+        process.exit(1);
+    });
+}
+dotenv.config({ quiet: true });
+main();

package/dist/mcp-helpers.d.ts

@@ -0,0 +1,17 @@
+import type { CommsApi } from '@doist/comms-sdk';
+import type { McpServer } from '@modelcontextprotocol/server';
+import type { AnyCommsTool } from './comms-tool.js';
+/**
+ * Registers Comms tools on an MCP server, bound to one Comms API client.
+ *
+ * Schema caching, annotations, result shaping and turning a thrown error into an error result
+ * come from `@todoist/mcp-core`; its default error log names the tool and never its arguments.
+ * Each call runs as its tool (`runAsTool`), so the requests it makes carry the tool's name in
+ * their usage-tracking headers.
+ */
+declare function registerTools({ tools, server, client, }: {
+    tools: readonly AnyCommsTool[];
+    server: McpServer;
+    client: CommsApi;
+}): void;
+export { registerTools };

package/dist/mcp-helpers.js

@@ -0,0 +1,40 @@
+import { createToolRegistrar } from '@todoist/mcp-core';
+import { runAsTool } from './usage-tracking.js';
+/**
+ * Whether to return the structured content directly, vs. in the `content` part of the output.
+ *
+ * The `structuredContent` part of the output is relatively new in the spec, and it's not yet
+ * supported by all clients. This flag controls whether we return the structured content using this
+ * new feature of the MCP protocol or not.
+ *
+ * If `false`, the `structuredContent` is also returned as stringified JSON in one of the `content`
+ * parts, ahead of the summary.
+ *
+ * Eventually we should be able to remove this, and change the code to always work with the
+ * structured content returned directly, once most or all MCP clients support it.
+ */
+const USE_STRUCTURED_CONTENT = process.env.USE_STRUCTURED_CONTENT === 'true' || process.env.NODE_ENV === 'test';
+function formatError(error) {
+    return error instanceof Error ? error.message : 'An unknown error occurred';
+}
+/**
+ * Registers Comms tools on an MCP server, bound to one Comms API client.
+ *
+ * Schema caching, annotations, result shaping and turning a thrown error into an error result
+ * come from `@todoist/mcp-core`; its default error log names the tool and never its arguments.
+ * Each call runs as its tool (`runAsTool`), so the requests it makes carry the tool's name in
+ * their usage-tracking headers.
+ */
+function registerTools({ tools, server, client, }) {
+    const register = createToolRegistrar({
+        titlePrefix: 'Comms',
+        createContext: () => client,
+        wrapExecute: (tool, run) => runAsTool(tool.name, run),
+        formatError,
+        structuredContentAsText: !USE_STRUCTURED_CONTENT,
+    });
+    for (const tool of tools) {
+        register(server, tool);
+    }
+}
+export { registerTools };

package/dist/mcp-server.d.ts

@@ -0,0 +1,10 @@
+import { McpServer } from '@modelcontextprotocol/server';
+import type { McpServerOptions } from '@todoist/mcp-core/host';
+/**
+ * Create the MCP server.
+ * @param token - The user's Comms API token.
+ * @param baseUrl - Optional base URL for the Comms API.
+ * @returns the MCP server.
+ */
+declare function getMcpServer({ token, baseUrl }: McpServerOptions): McpServer;
+export { getMcpServer };

package/dist/mcp-server.js

@@ -0,0 +1,78 @@
+import { McpServer } from '@modelcontextprotocol/server';
+import { registerTools } from './mcp-helpers.js';
+import { registeredTools } from './tool-registry.js';
+import { COMMS_MCP_VERSION, createCommsClient } from './usage-tracking.js';
+const instructions = `
+## Comms Communication Tools
+
+You have access to comprehensive Comms management tools for team communication and collaboration. Use these tools to help users manage threads, messages, channels, and team interactions effectively.
+
+### Core Capabilities:
+- Create and manage conversations and threads
+- Send and update messages
+- Organize channels and workspaces
+- Handle team communication workflows
+
+### Tool Usage Guidelines:
+
+- **fetch-inbox**: Use to fetch inbox threads for a workspace, along with unread conversations and counts. Supports archiveFilter values of active, archived, or all; use all when the user needs both open and done threads. Optionally set onlyUnread to focus on unread items.
+- **list-channels**: Use to discover channels in a workspace. Requires a workspace ID. Optionally set includeArchived to true to also list archived channels. Returns channel names, IDs, descriptions, visibility, archive status, and URLs.
+- **list-conversations**: Use to discover conversations (direct messages and group chats) in a workspace. Requires a workspace ID. Without searchText, returns the first page of conversations. Set searchText to find a group chat by title: it matches whole words in the titles of titled group chats only, so direct messages, untitled group chats, and participant names do not match. Its results are paged with limit and cursor, and a page can have fewer results than limit, so follow hasMore. Optionally set includeArchived to true to also list archived conversations. Returns conversation IDs, titles, a partial list of participant user IDs and names, archive status, last-active timestamps, snippets, and URLs.
+- **get-groups**: Use to discover group IDs in a workspace before notifying groups from tools that support group notifications. Requires a workspace ID. Optionally filter by group IDs or search text. Returns group IDs, names, and member counts (descriptions are never returned). Set includeMembers to true to also get each member's user ID, name, and email — use that to answer "who is in this group?" or to expand a group into individual recipients; leave it off when you only need IDs, since member lists make the response much longer.
+- **create-channel**: Use to create a channel in a workspace. Pass workspaceId, name, and optional description or public; omitting public creates a private channel. Pass numeric userIds to add initial members.
+- **update-channel**: Use to rename a channel or update its description/visibility. Pass channelId and at least one of name, description, or public. Pass description: null to clear the description.
+- **create-thread**: Use to create a new channel thread. Optionally pass recipients for user IDs and groups for group IDs; call get-users or get-groups first when resolving names. To notify everyone in the channel, pass notifyAudience: "channel" (tags the thread with "Everyone in channel") instead of listing every member as recipients; "thread" has no effect at thread creation. Pass displayInInbox: true to unarchive the thread after creation so it appears in the author's own Inbox (defaults to false).
+- **create-conversation**: Use to start a direct or group conversation with one or more users and post an initial message. Pass workspaceId, recipients (user IDs, excluding yourself), and content; call get-users first when resolving names. Reuses an existing conversation when one already exists for the same set of users rather than creating a duplicate.
+- **reply**: Use to reply to a thread or conversation. Thread replies notify everyone who has interacted with the thread by default. Optionally pass recipients for user IDs or groups for group IDs to override that default, and/or notifyAudience ("channel" | "thread") to add a broader audience on top of recipients/groups. Passing groups or notifyAudience to a conversation reply is rejected.
+- **mark-read**: Use to clear unread markers on threads and/or conversations while leaving them in the inbox. Pass workspaceId plus threadIds and/or conversationIds, or all: true to mark everything unread in the workspace. Items that are not currently unread are skipped and reported as alreadyRead. Use mark-done instead when the user wants items archived (done) rather than just read.
+- **get-mentions**: Use to fetch threads, comments, and messages that mention the current user. Prefer this over search-content when no keyword query is needed (search-content requires a non-empty query). Supports filtering by channel, author, and date range, and exposes a cursor for pagination.
+- **update-object**: Use to edit something you previously sent. Pass targetType ("thread", "comment", or "message"), targetId, and the new content. For threads you may also pass title (and may pass title without content). title is only valid for threads.
+- **delete-object**: Use to permanently delete a thread, comment, or conversation message. Pass targetType ("thread", "comment", or "message") and targetId. Deletion is irreversible — confirm with the user before invoking. Deleting a thread also removes all of its comments. Only the object's creator or a workspace admin can delete; the Comms API will reject the call otherwise.
+- **update-user-info**: A status given replaces the whole status, so call user-info first when the user only wants to change part of it. Pass status: null to remove it.
+
+### Writing Content (threads, comments, and messages):
+
+Content is markdown. Mentions and references are markdown links using \`comms-\` URL schemes — anything else renders as literal text:
+
+- User mention: \`[Afzal](comms-mention://29367677)\` — the ID must be numeric
+- Group mention: \`[Design](comms-group-mention://<groupId>)\`
+- Channel reference: \`[#general](comms-channel://<channelId>)\`
+- Thread reference: \`[Q3 planning](comms-thread://<threadId>)\`
+
+Rules:
+
+1. Never write \`@Name\`, \`[[Name|id]]\`, or any other mention format. Only the link syntax above is parsed; everything else is posted as plain text.
+2. Never put \`@\` inside the label — the client adds it when rendering. \`[Afzal](comms-mention://29367677)\` renders as \`@Afzal\`.
+3. The label is a display fallback only. The client resolves the current name from the ID, so the ID must be correct; a wrong ID mentions the wrong person no matter what the label says.
+4. Resolve IDs with get-users, get-groups, or list-channels before writing content. Never guess an ID.
+5. Mentions control rendering, not delivery, and notification support varies by tool. create-thread and thread replies take \`recipients\`, \`groups\`, and \`notifyAudience\` — pass a mentioned user's numeric ID (or group ID) there to actually notify them. Conversation messages (create-conversation, conversation replies) notify all participants automatically and take no notification parameters — a mentioned person must be a participant to be notified. update-object has no notification parameters; adding a mention while editing does not notify anyone.
+
+### Best Practices:
+
+1. **Communication**: Write clear, professional messages. Consider context and audience.
+
+2. **Organization**: Use appropriate channels and threads for different topics.
+
+3. **Collaboration**: Respect team communication patterns and workflows.
+
+Always provide clear context and maintain professional communication standards.
+`;
+/**
+ * Create the MCP server.
+ * @param token - The user's Comms API token.
+ * @param baseUrl - Optional base URL for the Comms API.
+ * @returns the MCP server.
+ */
+function getMcpServer({ token, baseUrl }) {
+    const server = new McpServer({ name: 'comms-mcp-server', version: COMMS_MCP_VERSION }, {
+        capabilities: {
+            tools: { listChanged: true },
+        },
+        instructions,
+    });
+    // Every request it makes carries the usage-tracking headers, named for the tool that made it.
+    const comms = createCommsClient({ token, baseUrl });
+    registerTools({ tools: registeredTools, server, client: comms });
+    return server;
+}
+export { getMcpServer };

package/dist/tool-registry.d.ts

@@ -0,0 +1,3 @@
+import type { AnyCommsTool } from './comms-tool.js';
+/** Every tool the MCP server registers, in registration order. */
+export declare const registeredTools: readonly AnyCommsTool[];

package/dist/tool-registry.js

@@ -0,0 +1,49 @@
+import { buildLink } from './tools/build-link.js';
+import { createChannel } from './tools/create-channel.js';
+import { createConversation } from './tools/create-conversation.js';
+import { createThread } from './tools/create-thread.js';
+import { deleteObject } from './tools/delete-object.js';
+import { fetchInbox } from './tools/fetch-inbox.js';
+import { getGroups } from './tools/get-groups.js';
+import { getMentions } from './tools/get-mentions.js';
+import { getUsers } from './tools/get-users.js';
+import { getWorkspaces } from './tools/get-workspaces.js';
+import { listChannels } from './tools/list-channels.js';
+import { listConversations } from './tools/list-conversations.js';
+import { loadConversation } from './tools/load-conversation.js';
+import { loadThread } from './tools/load-thread.js';
+import { markDone } from './tools/mark-done.js';
+import { markRead } from './tools/mark-read.js';
+import { react } from './tools/react.js';
+import { reply } from './tools/reply.js';
+import { searchContent } from './tools/search-content.js';
+import { updateChannel } from './tools/update-channel.js';
+import { updateObject } from './tools/update-object.js';
+import { updateUserInfo } from './tools/update-user-info.js';
+import { userInfo } from './tools/user-info.js';
+/** Every tool the MCP server registers, in registration order. */
+export const registeredTools = [
+    userInfo,
+    updateUserInfo,
+    getWorkspaces,
+    getUsers,
+    getGroups,
+    fetchInbox,
+    loadThread,
+    loadConversation,
+    searchContent,
+    getMentions,
+    buildLink,
+    createChannel,
+    updateChannel,
+    createThread,
+    createConversation,
+    updateObject,
+    deleteObject,
+    reply,
+    react,
+    markDone,
+    markRead,
+    listChannels,
+    listConversations,
+];

package/dist/tools/build-link.d.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+type BuildLinkStructured = {
+    type: 'link_data';
+    url: string;
+    linkType: 'conversation' | 'message' | 'thread' | 'comment';
+    params: {
+        workspaceId: number;
+        conversationId?: string;
+        messageId?: string;
+        channelId?: string;
+        threadId?: string;
+        commentId?: string;
+    };
+};
+declare const buildLink: {
+    name: "build-link";
+    description: string;
+    parameters: {
+        workspaceId: z.ZodNumber;
+        conversationId: z.ZodOptional<z.ZodString>;
+        messageId: z.ZodOptional<z.ZodString>;
+        channelId: z.ZodOptional<z.ZodString>;
+        threadId: z.ZodOptional<z.ZodString>;
+        commentId: z.ZodOptional<z.ZodString>;
+        fullUrl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    };
+    outputSchema: {
+        type: z.ZodLiteral<"link_data">;
+        url: z.ZodString;
+        linkType: z.ZodEnum<{
+            thread: "thread";
+            comment: "comment";
+            message: "message";
+            conversation: "conversation";
+        }>;
+        params: z.ZodObject<{
+            workspaceId: z.ZodNumber;
+            conversationId: z.ZodOptional<z.ZodString>;
+            messageId: z.ZodOptional<z.ZodString>;
+            channelId: z.ZodOptional<z.ZodString>;
+            threadId: z.ZodOptional<z.ZodString>;
+            commentId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    annotations: {
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        workspaceId: number;
+        fullUrl: boolean;
+        conversationId?: string | undefined;
+        messageId?: string | undefined;
+        channelId?: string | undefined;
+        threadId?: string | undefined;
+        commentId?: string | undefined;
+    }, _client: import("@doist/comms-sdk").CommsApi): Promise<{
+        textContent: string;
+        structuredContent: BuildLinkStructured;
+    }>;
+};
+export { buildLink, type BuildLinkStructured };

package/dist/tools/build-link.js

@@ -0,0 +1,93 @@
+import { getCommentURL, getCommsURL, getFullCommsURL, getMessageURL } from '@doist/comms-sdk';
+import { z } from 'zod';
+import { BuildLinkOutputSchema } from '../utils/output-schemas.js';
+import { ToolNames } from '../utils/tool-names.js';
+const ArgsSchema = {
+    workspaceId: z.number().describe('The workspace ID.'),
+    conversationId: z
+        .string()
+        .optional()
+        .describe('The conversation ID (for direct message links).'),
+    messageId: z
+        .string()
+        .optional()
+        .describe('The message ID (for specific message links within a conversation).'),
+    channelId: z.string().optional().describe('The channel ID (for thread links in channels).'),
+    threadId: z.string().optional().describe('The thread ID (for thread/comment links).'),
+    commentId: z
+        .string()
+        .optional()
+        .describe('The comment ID (for specific comment links within a thread).'),
+    fullUrl: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('Whether to return a full URL (with https://comms.todoist.com) or relative path.'),
+};
+const buildLink = {
+    name: ToolNames.BUILD_LINK,
+    description: 'Build valid Comms URLs for threads, comments, conversations, or messages. Provide workspace_id and either (conversation_id + optional message_id) OR (thread_id + optional channel_id + optional comment_id).',
+    parameters: ArgsSchema,
+    outputSchema: BuildLinkOutputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+    async execute(args, _client) {
+        const { workspaceId, conversationId, messageId, channelId, threadId, commentId, fullUrl } = args;
+        let url;
+        let linkType;
+        // Determine link type and build URL
+        if (conversationId !== undefined) {
+            if (messageId !== undefined) {
+                // Message link
+                linkType = 'message';
+                const params = { workspaceId, conversationId, messageId };
+                url = fullUrl ? getFullCommsURL(params) : getMessageURL(params);
+            }
+            else {
+                // Conversation link
+                linkType = 'conversation';
+                const params = { workspaceId, conversationId };
+                url = fullUrl ? getFullCommsURL(params) : getCommsURL(params);
+            }
+        }
+        else if (threadId !== undefined) {
+            if (commentId !== undefined) {
+                // Comment link
+                linkType = 'comment';
+                if (channelId === undefined) {
+                    throw new Error('channelId is required when building a comment link');
+                }
+                const params = { workspaceId, channelId, threadId, commentId };
+                url = fullUrl ? getFullCommsURL(params) : getCommentURL(params);
+            }
+            else {
+                // Thread link
+                linkType = 'thread';
+                const params = channelId
+                    ? { workspaceId, channelId, threadId }
+                    : { workspaceId, threadId };
+                url = fullUrl ? getFullCommsURL(params) : getCommsURL(params);
+            }
+        }
+        else {
+            throw new Error('Must provide either conversationId OR threadId to build a link');
+        }
+        const structuredContent = {
+            type: 'link_data',
+            url,
+            linkType,
+            params: {
+                workspaceId,
+                conversationId,
+                messageId,
+                channelId,
+                threadId,
+                commentId,
+            },
+        };
+        return {
+            textContent: url,
+            structuredContent,
+        };
+    },
+};
+export { buildLink };

package/dist/tools/channel-output.d.ts

@@ -0,0 +1,19 @@
+import type { Channel } from '@doist/comms-sdk';
+import type { ChannelOutputFields } from '../utils/output-schemas.js';
+type ChannelListData = ChannelOutputFields & {
+    id: string;
+    creatorId: number;
+    creatorName?: string;
+    color?: number;
+};
+type ChannelMutationData = ChannelOutputFields & {
+    channelId: string;
+    workspaceId: number;
+    creator: number;
+    userIds?: number[];
+};
+declare function getChannelOutputFields(channel: Channel): ChannelOutputFields;
+declare function getChannelMutationData(channel: Channel): ChannelMutationData;
+declare function getChannelMutationText(title: string, channel: Channel): string;
+declare function getChannelListData(channel: Channel, creatorName?: string): ChannelListData;
+export { getChannelListData, getChannelMutationData, getChannelMutationText, getChannelOutputFields, type ChannelListData, };

package/dist/tools/channel-output.js

@@ -0,0 +1,47 @@
+import { getChannelUrl } from '../utils/url-helpers.js';
+function getChannelOutputFields(channel) {
+    return {
+        name: channel.name,
+        ...(channel.description != null ? { description: channel.description } : {}),
+        public: channel.public,
+        archived: channel.archived,
+        created: channel.created.toISOString(),
+        channelUrl: channel.url ?? getChannelUrl(channel.workspaceId, channel.id),
+    };
+}
+function getChannelMutationData(channel) {
+    return {
+        channelId: channel.id,
+        workspaceId: channel.workspaceId,
+        creator: channel.creator,
+        ...getChannelOutputFields(channel),
+        ...(channel.userIds != null ? { userIds: channel.userIds } : {}),
+    };
+}
+function getChannelMutationText(title, channel) {
+    const channelData = getChannelMutationData(channel);
+    const lines = [
+        `# ${title}`,
+        '',
+        `**Name:** ${channelData.name}`,
+        `**Channel ID:** ${channelData.channelId}`,
+        `**Workspace ID:** ${channelData.workspaceId}`,
+        `**Public:** ${channelData.public ? 'Yes' : 'No'}`,
+        `**Created:** ${channelData.created}`,
+        `**URL:** ${channelData.channelUrl}`,
+    ];
+    if (channelData.description != null) {
+        lines.push(`**Description:** ${channelData.description}`);
+    }
+    return lines.join('\n');
+}
+function getChannelListData(channel, creatorName) {
+    return {
+        id: channel.id,
+        ...getChannelOutputFields(channel),
+        creatorId: channel.creator,
+        ...(creatorName ? { creatorName } : {}),
+        ...(channel.color != null ? { color: channel.color } : {}),
+    };
+}
+export { getChannelListData, getChannelMutationData, getChannelMutationText, getChannelOutputFields, };

package/dist/tools/create-channel.d.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+declare const createChannel: {
+    name: "create-channel";
+    description: string;
+    parameters: {
+        workspaceId: z.ZodNumber;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        public: z.ZodOptional<z.ZodBoolean>;
+        userIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    };
+    outputSchema: {
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        public: z.ZodBoolean;
+        archived: z.ZodBoolean;
+        created: z.ZodString;
+        channelUrl: z.ZodString;
+        type: z.ZodLiteral<"create_channel_result">;
+        success: z.ZodBoolean;
+        channelId: z.ZodString;
+        workspaceId: z.ZodNumber;
+        creator: z.ZodNumber;
+        userIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    };
+    annotations: {
+        readOnlyHint: false;
+        destructiveHint: false;
+        idempotentHint: false;
+    };
+    execute(args: {
+        workspaceId: number;
+        name: string;
+        description?: string | undefined;
+        public?: boolean | undefined;
+        userIds?: number[] | undefined;
+    }, client: import("@doist/comms-sdk").CommsApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            name: string;
+            public: boolean;
+            archived: boolean;
+            created: string;
+            channelUrl: string;
+            type: "create_channel_result";
+            success: boolean;
+            channelId: string;
+            workspaceId: number;
+            creator: number;
+            description?: string | undefined;
+            userIds?: number[] | undefined;
+        };
+    }>;
+};
+export { createChannel };

package/dist/tools/create-channel.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { CreateChannelOutputSchema } from '../utils/output-schemas.js';
+import { ToolNames } from '../utils/tool-names.js';
+import { getChannelMutationData, getChannelMutationText } from './channel-output.js';
+const ArgsSchema = {
+    workspaceId: z.number().describe('The workspace ID where the channel should be created.'),
+    name: z.string().min(1).describe('The channel name.'),
+    description: z.string().optional().describe('Optional channel description.'),
+    public: z
+        .boolean()
+        .optional()
+        .describe('Whether the channel is public. Defaults to false (private) when omitted.'),
+    userIds: z
+        .array(z.number())
+        .optional()
+        .describe('Optional numeric user IDs to add to the channel when it is created.'),
+};
+const createChannel = {
+    name: ToolNames.CREATE_CHANNEL,
+    description: 'Create a channel in a workspace. Requires a workspace ID and channel name. Optionally set description, visibility, and initial user IDs.',
+    parameters: ArgsSchema,
+    outputSchema: CreateChannelOutputSchema.shape,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
+    async execute(args, client) {
+        const { workspaceId, name, description, public: isPublic, userIds } = args;
+        const channel = await client.channels.createChannel({
+            workspaceId,
+            name,
+            ...(description !== undefined ? { description } : {}),
+            ...(isPublic !== undefined ? { public: isPublic } : {}),
+            ...(userIds !== undefined ? { userIds } : {}),
+        });
+        const structuredContent = {
+            type: 'create_channel_result',
+            success: true,
+            ...getChannelMutationData(channel),
+        };
+        return {
+            textContent: getChannelMutationText('Channel Created', channel),
+            structuredContent,
+        };
+    },
+};
+export { createChannel };

package/dist/tools/create-conversation.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+declare const createConversation: {
+    name: "create-conversation";
+    description: string;
+    parameters: {
+        workspaceId: z.ZodNumber;
+        recipients: z.ZodArray<z.ZodNumber>;
+        content: z.ZodString;
+    };
+    outputSchema: {
+        type: z.ZodLiteral<"create_conversation_result">;
+        success: z.ZodBoolean;
+        conversationId: z.ZodString;
+        messageId: z.ZodString;
+        workspaceId: z.ZodNumber;
+        content: z.ZodString;
+        recipients: z.ZodArray<z.ZodNumber>;
+        participants: z.ZodArray<z.ZodNumber>;
+        created: z.ZodString;
+        conversationUrl: z.ZodString;
+        messageUrl: z.ZodString;
+    };
+    annotations: {
+        readOnlyHint: false;
+        destructiveHint: false;
+        idempotentHint: false;
+    };
+    execute(args: {
+        workspaceId: number;
+        recipients: number[];
+        content: string;
+    }, client: import("@doist/comms-sdk").CommsApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            type: "create_conversation_result";
+            success: boolean;
+            conversationId: string;
+            messageId: string;
+            workspaceId: number;
+            content: string;
+            recipients: number[];
+            participants: number[];
+            created: string;
+            conversationUrl: string;
+            messageUrl: string;
+        };
+    }>;
+};
+export { createConversation };