@doist/comms-sdk 0.1.0-alpha.1

package/dist/esm/clients/channels-client.js

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+import { ENDPOINT_CHANNELS } from '../consts/endpoints.js';
+import { request } from '../transport/http-client.js';
+import { ChannelSchema, StatusOkSchema } from '../types/entities.js';
+import { resolveCreateId } from '../utils/uuidv7.js';
+import { BaseClient } from './base-client.js';
+export const ChannelListSchema = z.array(ChannelSchema);
+/**
+ * Client for `/api/v1/channels/`. The SDK auto-generates an `id` on
+ * `createChannel` when the caller doesn't supply one — pass your own `id`
+ * to keep an optimistic-UI ID stable through the round-trip.
+ */
+export class ChannelsClient extends BaseClient {
+    /** Lists channels in a workspace. */
+    getChannels(args) {
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_CHANNELS}/get`,
+            apiToken: this.apiToken,
+            payload: args,
+            customFetch: this.customFetch,
+        }).then((response) => ChannelListSchema.parse(response.data));
+    }
+    /** Fetches a single channel by ID. */
+    getChannel(id) {
+        return this.simple('GET', 'getone', { id }, ChannelSchema);
+    }
+    /** Creates a new channel. `id` is auto-generated if not supplied. */
+    createChannel(args) {
+        return this.simple('POST', 'add', { ...args, id: resolveCreateId(args.id) }, ChannelSchema);
+    }
+    /** Partial update of an existing channel. */
+    updateChannel(args) {
+        return this.simple('POST', 'update', { ...args }, ChannelSchema);
+    }
+    /** Updates the channel's view filter (`only_open` / `all` / `only_closed`). */
+    updateFilters(args) {
+        return this.simple('POST', 'update_filters', { ...args }, StatusOkSchema);
+    }
+    /** Permanently deletes a channel. */
+    deleteChannel(id) {
+        return this.simple('POST', 'remove', { id }, StatusOkSchema);
+    }
+    archiveChannel(id) {
+        return this.simple('POST', 'archive', { id }, StatusOkSchema);
+    }
+    unarchiveChannel(id) {
+        return this.simple('POST', 'unarchive', { id }, StatusOkSchema);
+    }
+    favoriteChannel(id) {
+        return this.simple('POST', 'favorite', { id }, StatusOkSchema);
+    }
+    unfavoriteChannel(id) {
+        return this.simple('POST', 'unfavorite', { id }, StatusOkSchema);
+    }
+    addUser(args) {
+        return this.simple('POST', 'add_user', { ...args }, ChannelSchema);
+    }
+    addUsers(args) {
+        return this.simple('POST', 'add_users', { ...args }, ChannelSchema);
+    }
+    removeUser(args) {
+        return this.simple('POST', 'remove_user', { ...args }, ChannelSchema);
+    }
+    removeUsers(args) {
+        return this.simple('POST', 'remove_users', { ...args }, ChannelSchema);
+    }
+    simple(httpMethod, suffix, params, schema) {
+        return request({
+            httpMethod,
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_CHANNELS}/${suffix}`,
+            apiToken: this.apiToken,
+            payload: params,
+            customFetch: this.customFetch,
+        }).then((response) => schema.parse(response.data));
+    }
+}

package/dist/esm/clients/comments-client.js

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+import { ENDPOINT_COMMENTS } from '../consts/endpoints.js';
+import { request } from '../transport/http-client.js';
+import { CommentSchema, StatusOkSchema } from '../types/entities.js';
+import { addCommentRequest } from './add-comment-helper.js';
+import { BaseClient } from './base-client.js';
+export const CommentListSchema = z.array(CommentSchema);
+/**
+ * Client for `/api/v1/comments/`. The SDK auto-generates the comment `id`
+ * on `createComment` when the caller doesn't supply one.
+ */
+export class CommentsClient extends BaseClient {
+    /**
+     * Lists comments in a thread. `newerThan` / `olderThan` (`Date`) are
+     * converted to `newer_than_ts` / `older_than_ts` epoch seconds on the
+     * wire.
+     */
+    getComments(args) {
+        const params = { threadId: args.threadId };
+        const newerThan = args.newerThan ?? args.from;
+        if (newerThan)
+            params.newerThanTs = Math.floor(newerThan.getTime() / 1000);
+        if (args.olderThan)
+            params.olderThanTs = Math.floor(args.olderThan.getTime() / 1000);
+        if (args.limit)
+            params.limit = args.limit;
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_COMMENTS}/get`,
+            apiToken: this.apiToken,
+            payload: params,
+            customFetch: this.customFetch,
+        }).then((response) => CommentListSchema.parse(response.data));
+    }
+    /** Fetches a single comment by ID. The API wraps it in `{comment: ...}`. */
+    getComment(id) {
+        const wrappedSchema = z.object({ comment: CommentSchema }).transform((data) => data.comment);
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_COMMENTS}/getone`,
+            apiToken: this.apiToken,
+            payload: { id },
+            customFetch: this.customFetch,
+        }).then((response) => wrappedSchema.parse(response.data));
+    }
+    /**
+     * Creates a new comment. `id` is auto-generated if not supplied.
+     */
+    createComment(args) {
+        return addCommentRequest({ baseUri: this.getBaseUri(), apiToken: this.apiToken, customFetch: this.customFetch }, args);
+    }
+    /** Updates a comment. */
+    updateComment(args) {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_COMMENTS}/update`,
+            apiToken: this.apiToken,
+            payload: { ...args },
+            customFetch: this.customFetch,
+        }).then((response) => CommentSchema.parse(response.data));
+    }
+    /** Permanently deletes a comment. */
+    deleteComment(id) {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_COMMENTS}/remove`,
+            apiToken: this.apiToken,
+            payload: { id },
+            customFetch: this.customFetch,
+        }).then((response) => StatusOkSchema.parse(response.data));
+    }
+    /**
+     * Marks the user's read position in a thread. Comment IDs are strings.
+     */
+    markPosition(args) {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_COMMENTS}/mark_position`,
+            apiToken: this.apiToken,
+            payload: { threadId: args.threadId, commentId: args.commentId },
+            customFetch: this.customFetch,
+        }).then((response) => StatusOkSchema.parse(response.data));
+    }
+}

package/dist/esm/clients/conversation-messages-client.js

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import { ENDPOINT_CONVERSATION_MESSAGES } from '../consts/endpoints.js';
+import { request } from '../transport/http-client.js';
+import { ConversationMessageSchema, StatusOkSchema, } from '../types/entities.js';
+import { resolveCreateId } from '../utils/uuidv7.js';
+import { BaseClient } from './base-client.js';
+export const ConversationMessageListSchema = z.array(ConversationMessageSchema);
+/**
+ * Client for `/api/v1/conversation_messages/`. The SDK auto-generates the
+ * message `id` on `createMessage` when the caller doesn't supply one.
+ */
+export class ConversationMessagesClient extends BaseClient {
+    /** Lists messages in a conversation. */
+    getMessages(args) {
+        const params = { conversationId: args.conversationId };
+        if (args.newerThan)
+            params.newerThanTs = Math.floor(args.newerThan.getTime() / 1000);
+        if (args.olderThan)
+            params.olderThanTs = Math.floor(args.olderThan.getTime() / 1000);
+        if (args.limit)
+            params.limit = args.limit;
+        if (args.cursor)
+            params.cursor = args.cursor;
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_CONVERSATION_MESSAGES}/get`,
+            apiToken: this.apiToken,
+            payload: params,
+            customFetch: this.customFetch,
+        }).then((response) => ConversationMessageListSchema.parse(response.data));
+    }
+    /** Fetches a single message by ID. */
+    getMessage(id) {
+        return this.simple('GET', 'getone', { id }, ConversationMessageSchema);
+    }
+    /** Creates a new message. `id` is auto-generated if not supplied. */
+    createMessage(args) {
+        const params = {
+            conversationId: args.conversationId,
+            content: args.content,
+            id: resolveCreateId(args.id),
+        };
+        if (args.attachments)
+            params.attachments = args.attachments;
+        if (args.actions)
+            params.actions = args.actions;
+        if (args.directMentions)
+            params.directMentions = args.directMentions;
+        if (args.directGroupMentions)
+            params.directGroupMentions = args.directGroupMentions;
+        if (args.notify !== undefined)
+            params.notify = args.notify;
+        return this.simple('POST', 'add', params, ConversationMessageSchema);
+    }
+    /** Updates a message. */
+    updateMessage(args) {
+        const params = { id: args.id, content: args.content };
+        if (args.attachments)
+            params.attachments = args.attachments;
+        if (args.actions)
+            params.actions = args.actions;
+        if (args.directMentions)
+            params.directMentions = args.directMentions;
+        if (args.directGroupMentions)
+            params.directGroupMentions = args.directGroupMentions;
+        return this.simple('POST', 'update', params, ConversationMessageSchema);
+    }
+    /** Permanently deletes a message. */
+    deleteMessage(id) {
+        return this.simple('POST', 'remove', { id }, StatusOkSchema);
+    }
+    simple(httpMethod, suffix, params, schema) {
+        return request({
+            httpMethod,
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_CONVERSATION_MESSAGES}/${suffix}`,
+            apiToken: this.apiToken,
+            payload: params,
+            customFetch: this.customFetch,
+        }).then((response) => schema.parse(response.data));
+    }
+}

package/dist/esm/clients/conversations-client.js

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+import { ENDPOINT_CONVERSATIONS } from '../consts/endpoints.js';
+import { request } from '../transport/http-client.js';
+import { ConversationSchema, StatusOkSchema, UnreadConversationSchema, } from '../types/entities.js';
+import { resolveCreateId } from '../utils/uuidv7.js';
+import { BaseClient } from './base-client.js';
+export const ConversationListSchema = z.array(ConversationSchema);
+const GetUnreadResponseSchema = z.object({
+    data: z.array(UnreadConversationSchema),
+    version: z.number().int(),
+});
+/**
+ * Client for `/api/v1/conversations/`. `getOrCreate` requires an `id` (the
+ * SDK auto-generates one for new conversations); the backend dedupes on
+ * `userIds`, so an existing conversation will be returned with its own
+ * already-assigned `id` and your generated one is silently dropped.
+ */
+export class ConversationsClient extends BaseClient {
+    /** Lists conversations in a workspace. */
+    getConversations(args) {
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_CONVERSATIONS}/get`,
+            apiToken: this.apiToken,
+            payload: args,
+            customFetch: this.customFetch,
+        }).then((response) => ConversationListSchema.parse(response.data));
+    }
+    /** Fetches a single conversation by ID. */
+    getConversation(id) {
+        return this.simple('GET', 'getone', { id }, ConversationSchema);
+    }
+    /**
+     * Gets an existing 1:1 / group conversation with `userIds`, or creates a
+     * new one. `id` is auto-generated if not supplied — on dedupe, the
+     * backend returns the existing conversation's `id` instead.
+     */
+    getOrCreateConversation(args) {
+        return this.simple('GET', 'get_or_create', { ...args, id: resolveCreateId(args.id) }, ConversationSchema);
+    }
+    /** Updates a conversation's title. */
+    updateConversation(args) {
+        const params = { id: args.id, title: args.title };
+        if (args.archived !== undefined)
+            params.archived = args.archived;
+        return this.simple('POST', 'update', params, ConversationSchema);
+    }
+    archiveConversation(id) {
+        return this.simple('GET', 'archive', { id }, ConversationSchema);
+    }
+    unarchiveConversation(id) {
+        return this.simple('GET', 'unarchive', { id }, ConversationSchema);
+    }
+    addUser(args) {
+        return this.simple('POST', 'add_user', { ...args }, ConversationSchema);
+    }
+    addUsers(args) {
+        return this.simple('POST', 'add_users', { ...args }, ConversationSchema);
+    }
+    removeUser(args) {
+        return this.simple('POST', 'remove_user', { ...args }, ConversationSchema);
+    }
+    removeUsers(args) {
+        return this.simple('POST', 'remove_users', { ...args }, ConversationSchema);
+    }
+    markRead(args) {
+        return this.simple('POST', 'mark_read', { ...args }, StatusOkSchema);
+    }
+    markUnread(args) {
+        return this.simple('POST', 'mark_unread', { ...args }, StatusOkSchema);
+    }
+    /**
+     * Returns unread conversations for a workspace, paired with the unread
+     * version counter.
+     */
+    getUnread(workspaceId) {
+        return this.simple('GET', 'get_unread', { workspaceId }, GetUnreadResponseSchema);
+    }
+    clearUnread(workspaceId) {
+        return this.simple('GET', 'clear_unread', { workspaceId }, StatusOkSchema);
+    }
+    muteConversation(args) {
+        return this.simple('GET', 'mute', { ...args }, ConversationSchema);
+    }
+    unmuteConversation(id) {
+        return this.simple('GET', 'unmute', { id }, ConversationSchema);
+    }
+    simple(httpMethod, suffix, params, schema) {
+        return request({
+            httpMethod,
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_CONVERSATIONS}/${suffix}`,
+            apiToken: this.apiToken,
+            payload: params,
+            customFetch: this.customFetch,
+        }).then((response) => schema.parse(response.data));
+    }
+}

package/dist/esm/clients/groups-client.js

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { ENDPOINT_GROUPS } from '../consts/endpoints.js';
+import { request } from '../transport/http-client.js';
+import { GroupSchema, StatusOkSchema } from '../types/entities.js';
+import { resolveCreateId } from '../utils/uuidv7.js';
+import { BaseClient } from './base-client.js';
+export const GroupListSchema = z.array(GroupSchema);
+/**
+ * Client for `/api/v1/groups/`. The broadcast markers `EVERYONE` /
+ * `EVERYONE_IN_THREAD` are NOT addressable through these endpoints — they
+ * only appear as members of `direct_group_mentions` / `groups` lists on
+ * thread/comment writes.
+ *
+ * `getone` / `update` / `remove` and the member-management ops all require
+ * `workspace_id` alongside the group `id`.
+ */
+export class GroupsClient extends BaseClient {
+    /** Lists groups in a workspace. */
+    getGroups(workspaceId) {
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_GROUPS}/get`,
+            apiToken: this.apiToken,
+            payload: { workspaceId },
+            customFetch: this.customFetch,
+        }).then((response) => GroupListSchema.parse(response.data));
+    }
+    /** Fetches a single group by ID (requires `workspaceId`). */
+    getGroup(args) {
+        return this.simple('GET', 'getone', { ...args }, GroupSchema);
+    }
+    /** Creates a new group. `id` is auto-generated if not supplied. */
+    createGroup(args) {
+        return this.simple('POST', 'add', { ...args, id: resolveCreateId(args.id) }, GroupSchema);
+    }
+    /** Updates a group. Requires `workspaceId`. */
+    updateGroup(args) {
+        return this.simple('POST', 'update', { ...args }, GroupSchema);
+    }
+    /** Permanently deletes a group. Requires `workspaceId`. */
+    deleteGroup(args) {
+        return this.simple('POST', 'remove', { ...args }, StatusOkSchema);
+    }
+    addUser(args) {
+        return this.simple('POST', 'add_user', { ...args }, StatusOkSchema);
+    }
+    addUsers(args) {
+        return this.simple('POST', 'add_users', { ...args }, StatusOkSchema);
+    }
+    removeUser(args) {
+        return this.simple('POST', 'remove_user', { ...args }, StatusOkSchema);
+    }
+    removeUsers(args) {
+        return this.simple('POST', 'remove_users', { ...args }, StatusOkSchema);
+    }
+    simple(httpMethod, suffix, params, schema) {
+        return request({
+            httpMethod,
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_GROUPS}/${suffix}`,
+            apiToken: this.apiToken,
+            payload: params,
+            customFetch: this.customFetch,
+        }).then((response) => schema.parse(response.data));
+    }
+}

package/dist/esm/clients/inbox-client.js

@@ -0,0 +1,94 @@
+import { ENDPOINT_INBOX } from '../consts/endpoints.js';
+import { request } from '../transport/http-client.js';
+import { InboxThreadSchema } from '../types/entities.js';
+import { BaseClient } from './base-client.js';
+/** Client for `/api/v1/inbox/`. */
+export class InboxClient extends BaseClient {
+    /**
+     * Gets inbox items (threads).
+     */
+    getInbox(args) {
+        const params = { workspace_id: args.workspaceId };
+        const newerThan = args.newerThan ?? args.since;
+        if (newerThan)
+            params.newer_than_ts = Math.floor(newerThan.getTime() / 1000);
+        const olderThan = args.olderThan ?? args.until;
+        if (olderThan)
+            params.older_than_ts = Math.floor(olderThan.getTime() / 1000);
+        if (args.limit)
+            params.limit = args.limit;
+        if (args.cursor)
+            params.cursor = args.cursor;
+        if (args.archiveFilter)
+            params.archive_filter = args.archiveFilter;
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_INBOX}/get`,
+            apiToken: this.apiToken,
+            payload: params,
+            customFetch: this.customFetch,
+        }).then((response) => response.data.map((thread) => InboxThreadSchema.parse(thread)));
+    }
+    /** Gets unread count for inbox. */
+    getCount(workspaceId) {
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_INBOX}/get_count`,
+            apiToken: this.apiToken,
+            payload: { workspace_id: workspaceId },
+            customFetch: this.customFetch,
+        }).then((response) => response.data.data);
+    }
+    /** Archives a thread in the inbox. */
+    archiveThread(id) {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_INBOX}/archive`,
+            apiToken: this.apiToken,
+            payload: { id },
+            customFetch: this.customFetch,
+        }).then(() => undefined);
+    }
+    /** Unarchives a thread in the inbox. */
+    unarchiveThread(id) {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_INBOX}/unarchive`,
+            apiToken: this.apiToken,
+            payload: { id },
+            customFetch: this.customFetch,
+        }).then(() => undefined);
+    }
+    /** Marks all inbox items as read in a workspace. */
+    markAllRead(workspaceId) {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_INBOX}/mark_all_read`,
+            apiToken: this.apiToken,
+            payload: { workspace_id: workspaceId },
+            customFetch: this.customFetch,
+        }).then(() => undefined);
+    }
+    /** Archives all inbox items in a workspace. */
+    archiveAll(args) {
+        const params = { workspace_id: args.workspaceId };
+        if (args.channelIds)
+            params.channel_ids = args.channelIds;
+        const olderThan = args.olderThan ?? args.until;
+        if (olderThan)
+            params.older_than_ts = Math.floor(olderThan.getTime() / 1000);
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_INBOX}/archive_all`,
+            apiToken: this.apiToken,
+            payload: params,
+            customFetch: this.customFetch,
+        }).then(() => undefined);
+    }
+}

package/dist/esm/clients/reactions-client.js

@@ -0,0 +1,55 @@
+import { ENDPOINT_REACTIONS } from '../consts/endpoints.js';
+import { request } from '../transport/http-client.js';
+import { BaseClient } from './base-client.js';
+function reactionTarget(args) {
+    if (args.threadId)
+        return { threadId: args.threadId };
+    if (args.commentId)
+        return { commentId: args.commentId };
+    if (args.messageId)
+        return { messageId: args.messageId };
+    throw new Error('Must provide one of: threadId, commentId, or messageId');
+}
+/**
+ * Client for interacting with Comms reaction endpoints.
+ */
+export class ReactionsClient extends BaseClient {
+    /** Adds an emoji reaction to a thread, comment, or conversation message. */
+    add(args) {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_REACTIONS}/add`,
+            apiToken: this.apiToken,
+            payload: { ...reactionTarget(args), reaction: args.reaction },
+            customFetch: this.customFetch,
+        }).then(() => undefined);
+    }
+    /**
+     * Gets reactions for a thread, comment, or conversation message.
+     *
+     * Returns an object with emoji reactions as keys and arrays of user IDs as
+     * values, or null if no reactions.
+     */
+    get(args) {
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_REACTIONS}/get`,
+            apiToken: this.apiToken,
+            payload: reactionTarget(args),
+            customFetch: this.customFetch,
+        }).then((response) => response.data);
+    }
+    /** Removes an emoji reaction from a thread, comment, or conversation message. */
+    remove(args) {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_REACTIONS}/remove`,
+            apiToken: this.apiToken,
+            payload: { ...reactionTarget(args), reaction: args.reaction },
+            customFetch: this.customFetch,
+        }).then(() => undefined);
+    }
+}

package/dist/esm/clients/search-client.js

@@ -0,0 +1,84 @@
+import { ENDPOINT_SEARCH } from '../consts/endpoints.js';
+import { request } from '../transport/http-client.js';
+import { SearchResultSchema, } from '../types/entities.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Client for interacting with Comms search endpoints.
+ */
+export class SearchClient extends BaseClient {
+    /**
+     * Searches across all threads and conversations in a workspace.
+     */
+    search(args) {
+        const params = { workspace_id: args.workspaceId };
+        if (args.query !== undefined)
+            params.query = args.query;
+        if (args.channelIds)
+            params.channel_ids = args.channelIds;
+        if (args.authorIds)
+            params.author_ids = args.authorIds;
+        if (args.mentionSelf !== undefined)
+            params.mention_self = args.mentionSelf;
+        if (args.dateFrom)
+            params.date_from = args.dateFrom;
+        if (args.dateTo)
+            params.date_to = args.dateTo;
+        if (args.limit)
+            params.limit = args.limit;
+        if (args.cursor)
+            params.cursor = args.cursor;
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: ENDPOINT_SEARCH,
+            apiToken: this.apiToken,
+            payload: params,
+            customFetch: this.customFetch,
+        }).then((response) => ({
+            ...response.data,
+            items: response.data.items.map((result) => SearchResultSchema.parse(result)),
+        }));
+    }
+    /**
+     * Searches within comments of a specific thread.
+     */
+    searchThread(args) {
+        const params = {
+            query: args.query,
+            thread_id: args.threadId,
+        };
+        if (args.limit)
+            params.limit = args.limit;
+        if (args.cursor)
+            params.cursor = args.cursor;
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_SEARCH}/thread`,
+            apiToken: this.apiToken,
+            payload: params,
+            customFetch: this.customFetch,
+        }).then((response) => response.data);
+    }
+    /**
+     * Searches within messages of a specific conversation.
+     */
+    searchConversation(args) {
+        const params = {
+            query: args.query,
+            conversation_id: args.conversationId,
+        };
+        if (args.limit)
+            params.limit = args.limit;
+        if (args.cursor)
+            params.cursor = args.cursor;
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_SEARCH}/conversation`,
+            apiToken: this.apiToken,
+            payload: params,
+            customFetch: this.customFetch,
+        }).then((response) => response.data);
+    }
+}