@todoist/comms-mcp 0.0.1 → 11.0.0

package/dist/tools/mark-read.js

@@ -0,0 +1,214 @@
+import { z } from 'zod';
+import { limitedAll } from '../utils/concurrency.js';
+import { logOperationFailures, SAMPLE_LIMIT } from '../utils/degrade.js';
+import { MarkReadOutputSchema } from '../utils/output-schemas.js';
+import { markConversationFullyRead, markThreadFullyRead } from '../utils/read-position.js';
+import { ToolNames } from '../utils/tool-names.js';
+const ArgsSchema = {
+    workspaceId: z
+        .number()
+        .describe('The workspace the threads and conversations belong to. Its unread lists decide which requested items actually need marking.'),
+    threadIds: z
+        .array(z.string())
+        .optional()
+        .describe('Thread IDs to mark as read. Threads that are not currently unread are reported as alreadyRead and left untouched.'),
+    conversationIds: z
+        .array(z.string())
+        .optional()
+        .describe('Conversation IDs to mark as read. Conversations that are not currently unread are reported as alreadyRead and left untouched.'),
+    all: z
+        .boolean()
+        .optional()
+        .describe('Mark every unread thread and conversation in the workspace as read. Cannot be combined with threadIds or conversationIds.'),
+};
+function dedupe(ids) {
+    return [...new Set(ids ?? [])];
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : 'Unknown error';
+}
+/**
+ * Marks each item read through its latest comment/message, one API pair per
+ * item. Failures are returned per item rather than thrown so one deleted or
+ * inaccessible item never stops the rest of the batch.
+ */
+async function markEach(client, itemType, ids) {
+    const markOne = itemType === 'thread' ? markThreadFullyRead : markConversationFullyRead;
+    const results = await limitedAll(ids, async (id) => {
+        try {
+            await markOne(client, id);
+            return { id };
+        }
+        catch (error) {
+            return { id, error: errorMessage(error) };
+        }
+    });
+    const marked = [];
+    const failed = [];
+    for (const result of results) {
+        if (result.error === undefined) {
+            marked.push(result.id);
+        }
+        else {
+            failed.push({ item: result.id, itemType, error: result.error });
+        }
+    }
+    return { marked, failed };
+}
+/**
+ * Marks every unread thread in the workspace read with a single call. The
+ * IDs come from the unread list fetched beforehand, so the result can still
+ * name what was marked; if the call fails, every one of them is reported.
+ */
+async function markAllThreads(client, workspaceId, unreadThreadIds) {
+    if (unreadThreadIds.length === 0) {
+        return { marked: [], failed: [] };
+    }
+    try {
+        await client.threads.markAllRead({ workspaceId });
+        return { marked: [...unreadThreadIds], failed: [] };
+    }
+    catch (error) {
+        const message = errorMessage(error);
+        return {
+            marked: [],
+            failed: unreadThreadIds.map((item) => ({ item, itemType: 'thread', error: message })),
+        };
+    }
+}
+/**
+ * Lists IDs for the text output. In `all` mode the caller never supplied the
+ * IDs and cannot act on them individually, so a workspace with hundreds of
+ * unread items would only flood the context; the list is capped there while
+ * `structuredContent` keeps every ID.
+ */
+function formatIdList(ids, cap) {
+    if (ids.length === 0) {
+        return 'none';
+    }
+    if (cap === null || ids.length <= cap) {
+        return ids.join(', ');
+    }
+    return `${ids.slice(0, cap).join(', ')} … and ${ids.length - cap} more`;
+}
+function formatItemSection(label, items, mode) {
+    const cap = mode === 'all' ? SAMPLE_LIMIT : null;
+    const lines = [`## ${label}`, ''];
+    lines.push(`**Marked:** ${formatIdList(items.marked, cap)}`);
+    if (mode === 'individual') {
+        lines.push(`**Already read:** ${formatIdList(items.alreadyRead, cap)}`);
+    }
+    lines.push('');
+    return lines;
+}
+const markRead = {
+    name: ToolNames.MARK_READ,
+    description: 'Mark threads and/or conversations as read without archiving them, so they stay in the inbox but no longer count as unread. Pass specific 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 items should also be archived.',
+    parameters: ArgsSchema,
+    outputSchema: MarkReadOutputSchema.shape,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
+    async execute(args, client) {
+        const { workspaceId, all = false } = args;
+        const threadIds = dedupe(args.threadIds);
+        const conversationIds = dedupe(args.conversationIds);
+        if (all && (threadIds.length > 0 || conversationIds.length > 0)) {
+            throw new Error('`all` cannot be combined with threadIds or conversationIds');
+        }
+        if (!all && threadIds.length === 0 && conversationIds.length === 0) {
+            throw new Error('Provide threadIds, conversationIds, or all: true');
+        }
+        const mode = all ? 'all' : 'individual';
+        // The unread lists are the source of truth for what needs marking. With
+        // explicit IDs they let already-read items be skipped (and reported as
+        // such) instead of re-marked; with `all` they are the work list itself.
+        // Each list is only fetched when that item type is in play.
+        const [unreadThreads, unreadConversations] = await Promise.all([
+            all || threadIds.length > 0
+                ? client.threads.getUnread(workspaceId).then((r) => r.data.map((t) => t.threadId))
+                : [],
+            all || conversationIds.length > 0
+                ? client.conversations
+                    .getUnread(workspaceId)
+                    .then((r) => r.data.map((c) => c.conversationId))
+                : [],
+        ]);
+        const threads = { marked: [], alreadyRead: [] };
+        const conversations = { marked: [], alreadyRead: [] };
+        const failed = [];
+        if (all) {
+            // One workspace-level call covers every unread thread. There is no
+            // working equivalent for conversations, so those go one by one,
+            // concurrently with the thread call.
+            const [threadResult, conversationResult] = await Promise.all([
+                markAllThreads(client, workspaceId, unreadThreads),
+                markEach(client, 'conversation', unreadConversations),
+            ]);
+            threads.marked = threadResult.marked;
+            conversations.marked = conversationResult.marked;
+            failed.push(...threadResult.failed, ...conversationResult.failed);
+        }
+        else {
+            const unreadThreadSet = new Set(unreadThreads);
+            const unreadConversationSet = new Set(unreadConversations);
+            threads.alreadyRead = threadIds.filter((id) => !unreadThreadSet.has(id));
+            conversations.alreadyRead = conversationIds.filter((id) => !unreadConversationSet.has(id));
+            const [threadResult, conversationResult] = await Promise.all([
+                markEach(client, 'thread', threadIds.filter((id) => unreadThreadSet.has(id))),
+                markEach(client, 'conversation', conversationIds.filter((id) => unreadConversationSet.has(id))),
+            ]);
+            threads.marked = threadResult.marked;
+            conversations.marked = conversationResult.marked;
+            failed.push(...threadResult.failed, ...conversationResult.failed);
+        }
+        logOperationFailures(ToolNames.MARK_READ, failed);
+        const markedCount = threads.marked.length + conversations.marked.length;
+        const alreadyReadCount = threads.alreadyRead.length + conversations.alreadyRead.length;
+        const lines = ['# Mark Read', ''];
+        lines.push(`**Workspace ID:** ${workspaceId}`);
+        lines.push(`**Mode:** ${mode === 'all' ? 'All unread in workspace' : 'Individual IDs'}`);
+        lines.push(`**Marked:** ${markedCount}`);
+        if (mode === 'individual') {
+            lines.push(`**Already read:** ${alreadyReadCount}`);
+        }
+        lines.push(`**Failed:** ${failed.length}`);
+        lines.push('');
+        if (mode === 'all' || threadIds.length > 0) {
+            lines.push(...formatItemSection('Threads', threads, mode));
+        }
+        if (mode === 'all' || conversationIds.length > 0) {
+            lines.push(...formatItemSection('Conversations', conversations, mode));
+        }
+        if (failed.length > 0) {
+            lines.push('## Failed', '');
+            for (const failure of failed) {
+                lines.push(`- ${failure.itemType} ${failure.item}: ${failure.error}`);
+            }
+            lines.push('');
+        }
+        lines.push('## Next Steps', '');
+        if (failed.length > 0) {
+            lines.push('Review failed items and retry if needed.');
+        }
+        else if (markedCount === 0) {
+            lines.push('Nothing was unread, so no changes were made.');
+        }
+        else {
+            lines.push('Items remain in the inbox. Use `mark-done` to archive them, or `fetch-inbox` with `onlyUnread: true` to see what is still unread.');
+        }
+        const structuredContent = {
+            type: 'mark_read_result',
+            workspaceId,
+            mode,
+            threads,
+            conversations,
+            failed,
+            markedCount,
+            failureCount: failed.length,
+        };
+        return {
+            textContent: lines.join('\n'),
+            structuredContent,
+        };
+    },
+};
+export { markRead };

package/dist/tools/react.d.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import { type ReactionTargetType } from '../utils/target-types.js';
+type ReactStructured = {
+    type: 'reaction_result';
+    success: boolean;
+    operation: 'add' | 'remove';
+    targetType: ReactionTargetType;
+    targetId: string;
+    emoji: string;
+    targetUrl: string;
+};
+declare const react: {
+    name: "react";
+    description: string;
+    parameters: {
+        targetType: z.ZodEnum<{
+            thread: "thread";
+            comment: "comment";
+            message: "message";
+        }>;
+        targetId: z.ZodString;
+        emoji: z.ZodString;
+        operation: z.ZodDefault<z.ZodEnum<{
+            add: "add";
+            remove: "remove";
+        }>>;
+    };
+    outputSchema: {
+        type: z.ZodLiteral<"reaction_result">;
+        success: z.ZodBoolean;
+        operation: z.ZodEnum<{
+            add: "add";
+            remove: "remove";
+        }>;
+        targetType: z.ZodEnum<{
+            thread: "thread";
+            comment: "comment";
+            message: "message";
+        }>;
+        targetId: z.ZodString;
+        emoji: z.ZodString;
+        targetUrl: z.ZodString;
+    };
+    annotations: {
+        readOnlyHint: false;
+        destructiveHint: true;
+        idempotentHint: false;
+    };
+    execute(args: {
+        targetType: "thread" | "comment" | "message";
+        targetId: string;
+        emoji: string;
+        operation: "add" | "remove";
+    }, client: import("@doist/comms-sdk").CommsApi): Promise<{
+        textContent: string;
+        structuredContent: ReactStructured;
+    }>;
+};
+export { react, type ReactStructured };

package/dist/tools/react.js

@@ -0,0 +1,97 @@
+import { getFullCommsURL } from '@doist/comms-sdk';
+import { z } from 'zod';
+import { ReactOutputSchema } from '../utils/output-schemas.js';
+import { ReactionTargetTypeSchema } from '../utils/target-types.js';
+import { ToolNames } from '../utils/tool-names.js';
+const ArgsSchema = {
+    targetType: ReactionTargetTypeSchema.describe('The type of object to react to: thread, comment, or message.'),
+    targetId: z.string().describe('The ID of the thread, comment, or message to react to.'),
+    emoji: z.string().min(1).describe('The emoji to react with (e.g., "👍", "❤️", "🎉").'),
+    operation: z
+        .enum(['add', 'remove'])
+        .default('add')
+        .describe('Whether to add or remove the reaction.'),
+};
+const react = {
+    name: ToolNames.REACT,
+    description: 'Add or remove an emoji reaction on a thread, comment, or conversation message. Use targetType to specify the type of object (thread, comment, or message) and targetId for the ID.',
+    parameters: ArgsSchema,
+    outputSchema: ReactOutputSchema.shape,
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false },
+    async execute(args, client) {
+        const { targetType, targetId, emoji, operation } = args;
+        let targetUrl;
+        // Fetch target metadata to get URL
+        if (targetType === 'thread') {
+            const thread = await client.threads.getThread(targetId);
+            targetUrl =
+                thread.url ??
+                    getFullCommsURL({
+                        workspaceId: thread.workspaceId,
+                        channelId: thread.channelId,
+                        threadId: thread.id,
+                    });
+        }
+        else if (targetType === 'comment') {
+            const comment = await client.comments.getComment(targetId);
+            targetUrl =
+                comment.url ??
+                    getFullCommsURL({
+                        workspaceId: comment.workspaceId,
+                        channelId: comment.channelId,
+                        threadId: comment.threadId,
+                        commentId: comment.id,
+                    });
+        }
+        else {
+            // message
+            const message = await client.conversationMessages.getMessage(targetId);
+            targetUrl =
+                message.url ??
+                    getFullCommsURL({
+                        workspaceId: message.workspaceId,
+                        conversationId: message.conversationId,
+                        messageId: message.id,
+                    });
+        }
+        // Map targetType to the appropriate API parameter
+        const apiParams = { reaction: emoji };
+        if (targetType === 'thread') {
+            apiParams.threadId = targetId;
+        }
+        else if (targetType === 'comment') {
+            apiParams.commentId = targetId;
+        }
+        else {
+            apiParams.messageId = targetId;
+        }
+        // Perform the reaction operation
+        if (operation === 'add') {
+            await client.reactions.add({ ...apiParams, reaction: emoji });
+        }
+        else {
+            await client.reactions.remove({ ...apiParams, reaction: emoji });
+        }
+        const lines = [
+            `# Reaction ${operation === 'add' ? 'Added' : 'Removed'}`,
+            '',
+            `**Target:** ${targetType} ${targetId}`,
+            `**Emoji:** ${emoji}`,
+            `**Operation:** ${operation}`,
+        ];
+        const structuredContent = {
+            type: 'reaction_result',
+            success: true,
+            operation,
+            targetType,
+            targetId,
+            emoji,
+            targetUrl,
+        };
+        return {
+            textContent: lines.join('\n'),
+            structuredContent,
+        };
+    },
+};
+export { react };

package/dist/tools/reply.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { type ReplyOutput } from '../utils/output-schemas.js';
+declare const reply: {
+    name: "reply";
+    description: string;
+    parameters: {
+        targetType: z.ZodEnum<{
+            thread: "thread";
+            conversation: "conversation";
+        }>;
+        targetId: z.ZodString;
+        content: z.ZodString;
+        recipients: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        groups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        notifyAudience: z.ZodOptional<z.ZodEnum<{
+            thread: "thread";
+            channel: "channel";
+        }>>;
+    };
+    outputSchema: {
+        type: z.ZodLiteral<"reply_result">;
+        success: z.ZodBoolean;
+        targetType: z.ZodEnum<{
+            thread: "thread";
+            conversation: "conversation";
+        }>;
+        targetId: z.ZodString;
+        replyId: z.ZodString;
+        content: z.ZodString;
+        created: z.ZodString;
+        replyUrl: z.ZodString;
+        recipients: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        notifyAudience: z.ZodOptional<z.ZodEnum<{
+            thread: "thread";
+            channel: "channel";
+        }>>;
+        groups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    };
+    annotations: {
+        readOnlyHint: false;
+        destructiveHint: false;
+        idempotentHint: false;
+    };
+    execute(args: {
+        targetType: "thread" | "conversation";
+        targetId: string;
+        content: string;
+        recipients?: number[] | undefined;
+        groups?: string[] | undefined;
+        notifyAudience?: "thread" | "channel" | undefined;
+    }, client: import("@doist/comms-sdk").CommsApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            type: "reply_result";
+            success: boolean;
+            targetType: "thread" | "conversation";
+            targetId: string;
+            replyId: string;
+            content: string;
+            created: string;
+            replyUrl: string;
+            recipients?: number[] | undefined;
+            notifyAudience?: "thread" | "channel" | undefined;
+            groups?: string[] | undefined;
+        };
+    }>;
+};
+type ReplyStructured = ReplyOutput;
+export { reply, type ReplyStructured };

package/dist/tools/reply.js

@@ -0,0 +1,122 @@
+import { getFullCommsURL, NOTIFY_AUDIENCES } from '@doist/comms-sdk';
+import { z } from 'zod';
+import { ReplyOutputSchema } from '../utils/output-schemas.js';
+import { ReplyTargetTypeSchema } from '../utils/target-types.js';
+import { ToolNames } from '../utils/tool-names.js';
+const ArgsSchema = {
+    targetType: ReplyTargetTypeSchema.describe('The type of object to reply to: thread (posts a comment) or conversation (posts a message).'),
+    targetId: z.string().describe('The ID of the thread or conversation to reply to.'),
+    content: z
+        .string()
+        .min(1)
+        .describe('The content of the reply. Markdown. Mention people with the link syntax [Name](comms-mention://USER_ID) — e.g. [Afzal](comms-mention://29367677) — never @Name or [[Name|id]], which post as literal text. Do not put "@" in the label; the client adds it. Groups use [Name](comms-group-mention://GROUP_ID), channels [#name](comms-channel://CHANNEL_ID), threads [Title](comms-thread://THREAD_ID). Resolve IDs with get-users/get-groups/list-channels first. Mentioning inline does not notify anyone. For thread replies, also pass mentioned user IDs in recipients and group IDs in groups; conversation replies notify all participants automatically and take no notification parameters.'),
+    recipients: z
+        .array(z.number())
+        .optional()
+        .describe('Optional array of user IDs to notify (thread replies only; ignored for conversation replies, which notify all participants automatically). If omitted with no groups and no notifyAudience, thread replies default to notifying everyone who has interacted with the thread.'),
+    groups: z
+        .array(z.string())
+        .optional()
+        .describe('Optional array of group IDs to notify (only for thread replies). Use get-groups to discover group IDs before passing them here.'),
+    notifyAudience: z
+        .enum(NOTIFY_AUDIENCES)
+        .optional()
+        .describe("Optional broader audience to notify in addition to recipients and groups (only for thread replies). 'channel' notifies everyone in the channel; 'thread' notifies everyone who has interacted with the thread."),
+};
+const reply = {
+    name: ToolNames.REPLY,
+    description: 'Post a reply to a thread (as a comment) or conversation (as a message). Thread replies notify everyone who has interacted with the thread by default unless specific user recipients, groups, or a notifyAudience are provided.',
+    parameters: ArgsSchema,
+    outputSchema: ReplyOutputSchema.shape,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
+    async execute(args, client) {
+        const { targetType, targetId, content, recipients, groups, notifyAudience } = args;
+        if (targetType === 'conversation' && groups !== undefined) {
+            throw new Error('groups can only be used when replying to a thread.');
+        }
+        if (targetType === 'conversation' && notifyAudience !== undefined) {
+            throw new Error('notifyAudience can only be used when replying to a thread.');
+        }
+        const groupsToNotify = targetType === 'thread' && groups && groups.length > 0 ? groups : undefined;
+        const appliedAudience = targetType === 'thread'
+            ? (notifyAudience ??
+                (recipients === undefined && !groupsToNotify ? 'thread' : undefined))
+            : undefined;
+        let replyId;
+        let created;
+        let replyUrl;
+        if (targetType === 'thread') {
+            const comment = await client.comments.createComment({
+                threadId: targetId,
+                content,
+                recipients,
+                groups: groupsToNotify,
+                notifyAudience: appliedAudience,
+            });
+            replyId = comment.id;
+            replyUrl =
+                comment.url ??
+                    getFullCommsURL({
+                        workspaceId: comment.workspaceId,
+                        channelId: comment.channelId,
+                        threadId: comment.threadId,
+                        commentId: comment.id,
+                    });
+            const postedValue = comment.posted;
+            created = postedValue
+                ? typeof postedValue === 'string'
+                    ? new Date(postedValue)
+                    : postedValue
+                : new Date();
+        }
+        else {
+            const message = await client.conversationMessages.createMessage({
+                conversationId: targetId,
+                content,
+            });
+            replyId = message.id;
+            replyUrl =
+                message.url ??
+                    getFullCommsURL({
+                        workspaceId: message.workspaceId,
+                        conversationId: message.conversationId,
+                        messageId: message.id,
+                    });
+            const postedValue = message.posted;
+            created = postedValue
+                ? typeof postedValue === 'string'
+                    ? new Date(postedValue)
+                    : postedValue
+                : new Date();
+        }
+        const lines = [
+            `# Reply Posted`,
+            '',
+            `**Target:** ${targetType === 'thread' ? `Thread ${targetId}` : `Conversation ${targetId}`}`,
+            `**Reply ID:** ${replyId}`,
+            `**Created:** ${created.toISOString()}`,
+            '',
+            '## Content',
+            '',
+            content,
+        ];
+        const structuredContent = {
+            type: 'reply_result',
+            success: true,
+            targetType,
+            targetId,
+            replyId,
+            content,
+            created: created.toISOString(),
+            replyUrl,
+            ...(targetType === 'thread' && recipients ? { recipients } : {}),
+            ...(groupsToNotify ? { groups: groupsToNotify } : {}),
+            ...(appliedAudience ? { notifyAudience: appliedAudience } : {}),
+        };
+        return {
+            textContent: lines.join('\n'),
+            structuredContent,
+        };
+    },
+};
+export { reply };

package/dist/tools/search-content.d.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import { type SearchContentOutput } from '../utils/output-schemas.js';
+type SearchContentStructured = SearchContentOutput;
+declare const searchContent: {
+    name: "search-content";
+    description: string;
+    parameters: {
+        query: z.ZodString;
+        workspaceId: z.ZodNumber;
+        channelIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        authorIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        mentionSelf: z.ZodOptional<z.ZodBoolean>;
+        dateFrom: z.ZodOptional<z.ZodString>;
+        dateTo: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    outputSchema: {
+        type: z.ZodLiteral<"search_results">;
+        query: z.ZodString;
+        workspaceId: z.ZodNumber;
+        results: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"thread">;
+            threadId: z.ZodString;
+            commentId: z.ZodOptional<z.ZodString>;
+            channelId: z.ZodOptional<z.ZodString>;
+            channelName: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            content: z.ZodString;
+            creatorId: z.ZodNumber;
+            creatorName: z.ZodOptional<z.ZodString>;
+            created: z.ZodString;
+            workspaceId: z.ZodNumber;
+            url: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"conversation">;
+            conversationId: z.ZodString;
+            messageId: z.ZodString;
+            id: z.ZodString;
+            content: z.ZodString;
+            creatorId: z.ZodNumber;
+            creatorName: z.ZodOptional<z.ZodString>;
+            created: z.ZodString;
+            workspaceId: z.ZodNumber;
+            url: z.ZodString;
+        }, z.core.$strip>], "type">>;
+        totalResults: z.ZodNumber;
+        hasMore: z.ZodBoolean;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    annotations: {
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        query: string;
+        workspaceId: number;
+        limit: number;
+        channelIds?: string[] | undefined;
+        authorIds?: number[] | undefined;
+        mentionSelf?: boolean | undefined;
+        dateFrom?: string | undefined;
+        dateTo?: string | undefined;
+        cursor?: string | undefined;
+    }, client: import("@doist/comms-sdk").CommsApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            type: "search_results";
+            query: string;
+            workspaceId: number;
+            results: ({
+                type: "thread";
+                threadId: string;
+                id: string;
+                content: string;
+                creatorId: number;
+                created: string;
+                workspaceId: number;
+                url: string;
+                commentId?: string | undefined;
+                channelId?: string | undefined;
+                channelName?: string | undefined;
+                creatorName?: string | undefined;
+            } | {
+                type: "conversation";
+                conversationId: string;
+                messageId: string;
+                id: string;
+                content: string;
+                creatorId: number;
+                created: string;
+                workspaceId: number;
+                url: string;
+                creatorName?: string | undefined;
+            })[];
+            totalResults: number;
+            hasMore: boolean;
+            cursor?: string | undefined;
+        };
+    }>;
+};
+export { searchContent, type SearchContentStructured };