spiracha 2.0.0 → 2.2.0

package/src/lib/conversation-data/cursor-adapter.ts

@@ -11,8 +11,17 @@ import type {
     CursorWorkspaceGroup,
 } from '../cursor-exporter-types';
 import { getCursorGlobalDbPath, resolveCursorUserDir } from '../cursor-exporter-types';
+import { collectCursorThreadsForDeletion, isCursorRunning, pruneCursorThreads } from '../cursor-recovery';
+import { getCursorTextBubblePhase, getFinalCursorAssistantTextBubbleIds } from '../cursor-transcript-phase';
 import { cleanInlineTitle } from '../shared';
-import { createDeepLinks, createTextMessage, finalizeMessages } from './adapter-helpers';
+import { runWithTranscriptLoadLimit } from '../transcript-load-limiter';
+import {
+    createConversationUiPath,
+    createDeepLinks,
+    createTextMessage,
+    finalizeMessages,
+    isWithinUpdatedWindow,
+} from './adapter-helpers';
 import { selectConversationMessages } from './message-selector';
 import { getFirstConversationPathMatch } from './path-match';
 import type {
@@ -20,6 +29,7 @@ import type {
     ConversationDetail,
     ConversationMessage,
     ConversationPathMatch,
+    DeleteConversationOptions,
     GetConversationOptions,
     ListConversationsForPathOptions,
 } from './types';
@@ -29,21 +39,11 @@ const CURSOR_CONVERSATION_HYDRATION_CONCURRENCY = 4;
 const getUserDir = (options: { locations?: { cursorUserDir?: string } }) =>
     options.locations?.cursorUserDir ?? resolveCursorUserDir();
 
-const isWithinUpdatedWindow = (
-    thread: CursorThreadSummary,
-    options: Pick<ListConversationsForPathOptions, 'updatedAfterMs' | 'updatedBeforeMs'>,
-): boolean => {
-    const updatedAtMs = thread.lastUpdatedAtMs ?? 0;
-    if (options.updatedAfterMs !== undefined && updatedAtMs < options.updatedAfterMs) {
-        return false;
-    }
-    if (options.updatedBeforeMs !== undefined && updatedAtMs > options.updatedBeforeMs) {
-        return false;
-    }
-    return true;
-};
-
-const bubbleToMessages = (bubble: CursorBubble, order: number): ConversationMessage[] => {
+const bubbleToMessages = (
+    bubble: CursorBubble,
+    finalAssistantTextBubbleIds: Set<string>,
+    order: number,
+): ConversationMessage[] => {
     const thinking = createTextMessage({
         createdAtMs: bubble.createdAtMs,
         id: `${bubble.bubbleId}:thinking`,
@@ -56,27 +56,41 @@ const bubbleToMessages = (bubble: CursorBubble, order: number): ConversationMess
         createdAtMs: bubble.createdAtMs,
         id: bubble.bubbleId,
         order,
-        phase: bubble.kind === 'assistant' ? 'final_answer' : 'unknown',
+        phase: getCursorTextBubblePhase(bubble, finalAssistantTextBubbleIds) ?? 'unknown',
         role: bubble.kind === 'assistant' ? 'assistant' : bubble.kind === 'user' ? 'user' : 'unknown',
         text: bubble.text,
     });
-    const tool = bubble.toolCall
+    const toolCall = bubble.toolCall
         ? createTextMessage({
               createdAtMs: bubble.createdAtMs,
-              id: `${bubble.bubbleId}:tool`,
+              id: `${bubble.bubbleId}:tool_call`,
               metadata: { callId: bubble.toolCall.callId, status: bubble.toolCall.status },
               order,
-              phase: bubble.toolCall.resultText ? 'tool_output' : 'tool_call',
+              phase: 'tool_call',
               role: 'tool',
-              text: bubble.toolCall.resultText ?? bubble.toolCall.argumentsText ?? bubble.toolCall.name,
+              text: [bubble.toolCall.name, bubble.toolCall.argumentsText].filter(Boolean).join('\n'),
+          })
+        : [];
+    const toolOutput = bubble.toolCall
+        ? createTextMessage({
+              createdAtMs: bubble.createdAtMs,
+              id: `${bubble.bubbleId}:tool_output`,
+              metadata: { callId: bubble.toolCall.callId, status: bubble.toolCall.status },
+              order,
+              phase: 'tool_output',
+              role: 'tool',
+              text: bubble.toolCall.resultText,
           })
         : [];
 
-    return [...thinking, ...text, ...tool];
+    return [...thinking, ...text, ...toolCall, ...toolOutput];
 };
 
 const transcriptToMessages = (transcript: CursorThreadTranscript) => {
-    return finalizeMessages(transcript.bubbles.flatMap((bubble, order) => bubbleToMessages(bubble, order)));
+    const finalAssistantTextBubbleIds = getFinalCursorAssistantTextBubbleIds(transcript.bubbles);
+    return finalizeMessages(
+        transcript.bubbles.flatMap((bubble, order) => bubbleToMessages(bubble, finalAssistantTextBubbleIds, order)),
+    );
 };
 
 const getWorkspacePath = (group: CursorWorkspaceGroup) => {
@@ -90,8 +104,16 @@ const buildConversation = async (
     matches: ConversationPathMatch[],
     options: Pick<ListConversationsForPathOptions, 'includeMessages' | 'messageSelector'>,
 ): Promise<ConversationDetail> => {
+    const globalDbPath = getCursorGlobalDbPath(userDir);
     const transcript = options.includeMessages
-        ? await readCursorThreadTranscriptWithAgentFiles(getCursorGlobalDbPath(userDir), thread.composerId, userDir)
+        ? await runWithTranscriptLoadLimit(
+              () => readCursorThreadTranscriptWithAgentFiles(globalDbPath, thread.composerId, userDir),
+              {
+                  id: thread.composerId,
+                  path: thread.transcriptDirs[0] ?? globalDbPath,
+                  source: 'cursor-api',
+              },
+          )
         : null;
     const allMessages = transcript ? transcriptToMessages(transcript) : [];
     const messages = options.includeMessages
@@ -100,7 +122,11 @@ const buildConversation = async (
 
     return {
         createdAtMs: thread.createdAtMs,
-        deepLinks: createDeepLinks('cursor', thread.composerId, `/cursor-threads/${thread.composerId}`),
+        deepLinks: createDeepLinks(
+            'cursor',
+            thread.composerId,
+            createConversationUiPath('cursor-threads', thread.composerId),
+        ),
         id: thread.composerId,
         matches,
         messageCount: options.includeMessages ? allMessages.length : thread.bubbleCount,
@@ -109,7 +135,6 @@ const buildConversation = async (
             bubbleBytes: thread.bubbleBytes,
             bucketId: thread.bucketId,
             mode: thread.mode,
-            transcriptDirs: thread.transcriptDirs,
         },
         source: 'cursor',
         title: cleanInlineTitle(thread.name),
@@ -121,7 +146,7 @@ const buildConversation = async (
 
 const listCursorConversationsForPath = async (options: ListConversationsForPathOptions) => {
     const userDir = getUserDir(options);
-    const groups = await listCursorWorkspaceGroups(userDir, { updatedAfterMs: options.updatedAfterMs });
+    const groups = await listCursorWorkspaceGroups(userDir);
     const candidates: { group: CursorWorkspaceGroup; match: ConversationPathMatch; thread: CursorThreadSummary }[] = [];
 
     for (const group of groups) {
@@ -131,10 +156,9 @@ const listCursorConversationsForPath = async (options: ListConversationsForPathO
         }
         const threads = await listCursorThreadsForGroup(group, userDir, {
             includeTranscriptDirs: false,
-            updatedAfterMs: options.updatedAfterMs,
         });
         for (const thread of threads) {
-            if (!isWithinUpdatedWindow(thread, options)) {
+            if (!isWithinUpdatedWindow(thread.lastUpdatedAtMs, options)) {
                 continue;
             }
 
@@ -164,7 +188,31 @@ const getCursorConversation = async (options: GetConversationOptions): Promise<C
     return null;
 };
 
+export const deleteCursorConversation = async (
+    options: DeleteConversationOptions,
+    checkCursorRunning: () => Promise<boolean> = isCursorRunning,
+) => {
+    const userDir = getUserDir(options);
+    if (await checkCursorRunning()) {
+        throw new Error(
+            'Quit Cursor before deleting. It rewrites chat history on exit, which can resurrect deleted threads.',
+        );
+    }
+
+    const threads = await collectCursorThreadsForDeletion([options.id], userDir);
+    if (threads.length === 0) {
+        return { deletedFiles: [], deletedIds: [] };
+    }
+    const deletedFiles = threads.flatMap((thread) => thread.transcriptDirs);
+    const result = await pruneCursorThreads(threads, true, userDir);
+    return {
+        deletedFiles,
+        deletedIds: result.composerIds,
+    };
+};
+
 export const cursorConversationAdapter: ConversationAdapter = {
+    deleteConversation: deleteCursorConversation,
     getConversation: getCursorConversation,
     listConversationsForPath: listCursorConversationsForPath,
     source: 'cursor',

package/src/lib/conversation-data/grok-adapter.ts

@@ -0,0 +1,223 @@
+import { mapWithConcurrency } from '../concurrency';
+import {
+    deleteGrokSession,
+    listGrokSessionTranscriptsForGroup,
+    listGrokWorkspaceGroups,
+    readGrokSessionTranscript,
+    resolveGrokSessionsDir,
+} from '../grok-db';
+import type {
+    GrokSessionSummary,
+    GrokSessionTranscript,
+    GrokTranscriptEntry,
+    GrokTranscriptPart,
+} from '../grok-exporter-types';
+import { getFinalGrokAssistantTextPartIds, getGrokTextPartPhase } from '../grok-transcript-phase';
+import { cleanInlineTitle } from '../shared';
+import { runWithTranscriptLoadLimit } from '../transcript-load-limiter';
+import {
+    createConversationUiPath,
+    createDeepLinks,
+    createTextMessage,
+    finalizeMessages,
+    isWithinUpdatedWindow,
+    normalizeAssistantPhase,
+    normalizeRole,
+} from './adapter-helpers';
+import { selectConversationMessages } from './message-selector';
+import { getConversationPathMatch } from './path-match';
+import type {
+    ConversationAdapter,
+    ConversationDetail,
+    ConversationMessage,
+    ConversationPathMatch,
+    DeleteConversationOptions,
+    GetConversationOptions,
+    ListConversationsForPathOptions,
+} from './types';
+
+const GROK_CONVERSATION_HYDRATION_CONCURRENCY = 4;
+
+const getSessionsDir = (options: { locations?: { grokSessionsDir?: string } }) =>
+    options.locations?.grokSessionsDir ?? resolveGrokSessionsDir();
+
+const partToMessages = (
+    entry: GrokTranscriptEntry,
+    part: GrokTranscriptPart,
+    finalTextPartIds: Set<string>,
+    order: number,
+): ConversationMessage[] => {
+    if (part.type === 'text') {
+        return createTextMessage({
+            createdAtMs: entry.createdAtMs,
+            id: part.partId,
+            metadata: { modelFingerprint: entry.modelFingerprint, modelId: entry.modelId },
+            order,
+            phase: normalizeAssistantPhase(getGrokTextPartPhase(entry, part, finalTextPartIds), 'unknown'),
+            role: normalizeRole(entry.role),
+            text: part.text,
+        });
+    }
+
+    if (part.type === 'reasoning') {
+        return createTextMessage({
+            createdAtMs: entry.createdAtMs,
+            id: part.partId,
+            order,
+            phase: 'reasoning',
+            role: 'assistant',
+            text: part.text,
+        });
+    }
+
+    if (part.type === 'tool_call') {
+        return createTextMessage({
+            createdAtMs: entry.createdAtMs,
+            id: part.partId,
+            metadata: { toolCallId: part.toolCallId, toolName: part.toolName },
+            order,
+            phase: 'tool_call',
+            role: 'tool',
+            text: [part.toolName, part.argumentsText].filter(Boolean).join('\n'),
+        });
+    }
+
+    if (part.type === 'tool_result') {
+        return createTextMessage({
+            createdAtMs: entry.createdAtMs,
+            id: part.partId,
+            metadata: { toolCallId: part.toolCallId },
+            order,
+            phase: 'tool_output',
+            role: 'tool',
+            text: part.outputText,
+        });
+    }
+
+    return [];
+};
+
+const transcriptToMessages = (transcript: GrokSessionTranscript): ConversationMessage[] => {
+    const finalTextPartIds = getFinalGrokAssistantTextPartIds(transcript.entries);
+    return finalizeMessages(
+        transcript.entries.flatMap((entry, entryIndex) =>
+            entry.parts.flatMap((part, partIndex) =>
+                partToMessages(entry, part, finalTextPartIds, entryIndex + partIndex),
+            ),
+        ),
+    );
+};
+
+const buildConversation = async (
+    session: GrokSessionSummary,
+    sessionsDir: string,
+    matches: ConversationPathMatch[],
+    options: Pick<ListConversationsForPathOptions, 'includeMessages' | 'messageSelector'>,
+    loadedTranscript: GrokSessionTranscript | null = null,
+): Promise<ConversationDetail> => {
+    const transcript =
+        loadedTranscript ??
+        (options.includeMessages
+            ? await runWithTranscriptLoadLimit(
+                  () => readGrokSessionTranscript(sessionsDir, session.sessionId, { includeRawPayloads: false }),
+                  {
+                      id: session.sessionId,
+                      path: sessionsDir,
+                      source: 'grok-api',
+                  },
+              )
+            : null);
+    const allMessages = transcript ? transcriptToMessages(transcript) : [];
+    const messages = options.includeMessages
+        ? selectConversationMessages(allMessages, options.messageSelector ?? 'last_final_answer')
+        : [];
+
+    return {
+        createdAtMs: session.createdAtMs,
+        deepLinks: createDeepLinks(
+            'grok',
+            session.sessionId,
+            createConversationUiPath('grok-sessions', session.sessionId),
+        ),
+        id: session.sessionId,
+        matches,
+        messageCount: options.includeMessages ? allMessages.length : session.messageCount,
+        messages,
+        metadata: {
+            agentName: session.agentName,
+            currentModelId: session.currentModelId,
+            gitBranch: session.gitBranch,
+            headCommit: session.headCommit,
+            modelLabel: session.modelLabel,
+            renderablePartCount: session.renderablePartCount,
+            sandboxProfile: session.sandboxProfile,
+        },
+        source: 'grok',
+        title: cleanInlineTitle(session.title),
+        updatedAtMs: session.lastActiveAtMs,
+        workspaceKey: session.workspaceKey,
+        workspacePath: session.worktree,
+    };
+};
+
+const listGrokConversationsForPath = async (options: ListConversationsForPathOptions) => {
+    const sessionsDir = getSessionsDir(options);
+    const groups = await listGrokWorkspaceGroups(sessionsDir);
+    const conversations: ConversationDetail[] = [];
+
+    for (const group of groups) {
+        const match = await getConversationPathMatch(options.cwd, group.worktree);
+        if (!match) {
+            continue;
+        }
+        const transcripts = (await listGrokSessionTranscriptsForGroup(group.key, sessionsDir)).filter((transcript) =>
+            isWithinUpdatedWindow(transcript.session.lastActiveAtMs, options),
+        );
+        conversations.push(
+            ...(await mapWithConcurrency(transcripts, GROK_CONVERSATION_HYDRATION_CONCURRENCY, (transcript) =>
+                buildConversation(transcript.session, sessionsDir, [match], options, transcript),
+            )),
+        );
+    }
+
+    return conversations;
+};
+
+const getGrokConversation = async (options: GetConversationOptions): Promise<ConversationDetail | null> => {
+    const sessionsDir = getSessionsDir(options);
+    const transcript = await runWithTranscriptLoadLimit(
+        () => readGrokSessionTranscript(sessionsDir, options.id, { includeRawPayloads: false }),
+        {
+            id: options.id,
+            path: sessionsDir,
+            source: 'grok-api',
+        },
+    );
+    return transcript
+        ? buildConversation(
+              transcript.session,
+              sessionsDir,
+              [],
+              {
+                  includeMessages: true,
+                  messageSelector: options.messageSelector ?? 'all',
+              },
+              transcript,
+          )
+        : null;
+};
+
+const deleteGrokConversation = async (options: DeleteConversationOptions) => {
+    const result = await deleteGrokSession(getSessionsDir(options), options.id);
+    return {
+        deletedFiles: result.deletedFiles,
+        deletedIds: result.deletedSessionIds,
+    };
+};
+
+export const grokConversationAdapter: ConversationAdapter = {
+    deleteConversation: deleteGrokConversation,
+    getConversation: getGrokConversation,
+    listConversationsForPath: listGrokConversationsForPath,
+    source: 'grok',
+};

package/src/lib/conversation-data/index.ts

@@ -1,7 +1,9 @@
+import { mapWithConcurrency } from '../concurrency';
 import { antigravityConversationAdapter } from './antigravity-adapter';
 import { claudeCodeConversationAdapter } from './claude-code-adapter';
 import { codexConversationAdapter } from './codex-adapter';
 import { cursorConversationAdapter } from './cursor-adapter';
+import { grokConversationAdapter } from './grok-adapter';
 import { kiroConversationAdapter } from './kiro-adapter';
 import { selectConversationMessages } from './message-selector';
 import { opencodeConversationAdapter } from './opencode-adapter';
@@ -14,6 +16,11 @@ import {
     type ConversationPage,
     type ConversationSource,
     type ConversationSourceInfo,
+    type DeleteConversationItemResult,
+    type DeleteConversationOptions,
+    type DeleteConversationResult,
+    type DeleteConversationsOptions,
+    type DeleteConversationsResult,
     type GetConversationOptions,
     type ListConversationsForPathOptions,
     type ResolvedConversationRef,
@@ -27,6 +34,7 @@ export {
     type ConversationDataLocations,
     type ConversationDeepLinks,
     type ConversationDetail,
+    type ConversationIdSetOptions,
     type ConversationMessage,
     type ConversationMessagePhase,
     type ConversationMessageRole,
@@ -35,6 +43,13 @@ export {
     type ConversationPathMatch,
     type ConversationSource,
     type ConversationSourceInfo,
+    type ConversationZipDownload,
+    type DeleteConversationItemResult,
+    type DeleteConversationOptions,
+    type DeleteConversationResult,
+    type DeleteConversationsOptions,
+    type DeleteConversationsResult,
+    type ExportConversationsZipOptions,
     type GetConversationOptions,
     type ListConversationsForPathOptions,
     type ResolvedConversationRef,
@@ -45,6 +60,7 @@ const SOURCE_LABELS: Record<ConversationSource, string> = {
     'claude-code': 'Claude Code',
     codex: 'Codex',
     cursor: 'Cursor',
+    grok: 'Grok',
     kiro: 'Kiro',
     opencode: 'OpenCode',
     qoder: 'Qoder',
@@ -64,6 +80,7 @@ const ADAPTERS: Partial<Record<ConversationSource, ConversationAdapter>> = {
     'claude-code': claudeCodeConversationAdapter,
     codex: codexConversationAdapter,
     cursor: cursorConversationAdapter,
+    grok: grokConversationAdapter,
     kiro: kiroConversationAdapter,
     opencode: opencodeConversationAdapter,
     qoder: qoderConversationAdapter,
@@ -71,13 +88,23 @@ const ADAPTERS: Partial<Record<ConversationSource, ConversationAdapter>> = {
 
 const MAX_LIMIT = 200;
 const DEFAULT_LIMIT = 100;
+const DELETE_CONCURRENCY_BY_SOURCE: Record<ConversationSource, number> = {
+    antigravity: 1,
+    'claude-code': 4,
+    codex: 1,
+    cursor: 1,
+    grok: 1,
+    kiro: 1,
+    opencode: 2,
+    qoder: 1,
+};
 
 const getEnabledSources = (sources: ListConversationsForPathOptions['sources']): ConversationSource[] => {
     if (!sources || sources === 'all') {
         return SOURCE_INFOS.map((sourceInfo) => sourceInfo.source);
     }
 
-    return sources;
+    return [...new Set(sources)];
 };
 
 const isAllSourcesRequest = (sources: ListConversationsForPathOptions['sources']) => !sources || sources === 'all';
@@ -91,8 +118,16 @@ const decodeCursor = (cursor: string | null | undefined) => {
         return 0;
     }
 
-    const parsed = Number.parseInt(Buffer.from(cursor, 'base64url').toString('utf8'), 10);
-    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+    const decoded = Buffer.from(cursor, 'base64url').toString('utf8');
+    if (!/^\d+$/u.test(decoded)) {
+        throw new Error('Invalid conversation pagination cursor.');
+    }
+
+    const parsed = Number(decoded);
+    if (!Number.isSafeInteger(parsed) || parsed < 0) {
+        throw new Error('Invalid conversation pagination cursor.');
+    }
+    return parsed;
 };
 
 const encodeCursor = (offset: number) => Buffer.from(String(offset), 'utf8').toString('base64url');
@@ -130,7 +165,7 @@ const sortConversations = (conversations: Awaited<ReturnType<ConversationAdapter
     );
 };
 
-export const listConversationSources = async (): Promise<ConversationSourceInfo[]> => SOURCE_INFOS;
+export const listConversationSources = async (): Promise<ConversationSourceInfo[]> => [...SOURCE_INFOS];
 
 const listSourceConversationsForPath = async (
     source: ConversationSource,
@@ -148,6 +183,10 @@ const listSourceConversationsForPath = async (
         if (!ignoreSourceFailures) {
             throw error;
         }
+        console.warn(`[spiracha:conversation-data] skipped ${source} during all-source collection`, {
+            error: error instanceof Error ? error.message : String(error),
+            source,
+        });
         return [];
     }
 };
@@ -181,10 +220,56 @@ export const getConversation = async (options: GetConversationOptions) => {
     return getAdapter(options.source)?.getConversation(options) ?? null;
 };
 
+export const deleteConversation = async (
+    options: DeleteConversationOptions,
+): Promise<DeleteConversationResult | null> => {
+    return (await getAdapter(options.source)?.deleteConversation?.(options)) ?? null;
+};
+
+export const deleteConversations = async (
+    options: DeleteConversationsOptions,
+): Promise<DeleteConversationsResult | null> => {
+    const adapter = getAdapter(options.source);
+    if (!adapter?.deleteConversation) {
+        return null;
+    }
+    const deleteAdapterConversation = adapter.deleteConversation;
+
+    const rawResults = await mapWithConcurrency(
+        options.ids,
+        DELETE_CONCURRENCY_BY_SOURCE[options.source],
+        async (id) => ({
+            id,
+            result: await deleteAdapterConversation({
+                id,
+                locations: options.locations,
+                source: options.source,
+            }),
+        }),
+    );
+    const deletedIdSet = new Set(rawResults.flatMap(({ result }) => result.deletedIds));
+    const results: DeleteConversationItemResult[] = rawResults.map(({ id, result }) => ({
+        deleted: result.deletedIds.length > 0 || deletedIdSet.has(id),
+        deletedFiles: result.deletedFiles,
+        deletedIds: result.deletedIds,
+        id,
+    }));
+
+    return {
+        deletedFiles: [...new Set(results.flatMap((result) => result.deletedFiles))],
+        deletedIds: [...deletedIdSet],
+        missingIds: results.filter((result) => !result.deleted).map((result) => result.id),
+        results,
+    };
+};
+
 const sourceFromSessionRoute = (segment: string): ConversationSource | null => {
     if (segment === 'claude-code-sessions') {
         return 'claude-code';
     }
+    if (segment === 'grok-sessions') {
+        return 'grok';
+    }
     if (segment === 'kiro-sessions') {
         return 'kiro';
     }
@@ -241,14 +326,21 @@ const refFromPathSegmentAt = (segments: string[], index: number): ResolvedConver
 };
 
 const refFromPathSegments = (segments: string[]): ResolvedConversationRef | null => {
-    for (let index = 0; index < segments.length - 1; index += 1) {
-        const ref = refFromPathSegmentAt(segments, index);
-        if (ref) {
-            return ref;
-        }
+    if (
+        segments[0] === 'api' &&
+        segments[1] === 'v1' &&
+        segments[2] === 'conversations' &&
+        (segments.length === 5 || (segments.length === 6 && segments[5] === 'export'))
+    ) {
+        return refFromPathSegmentAt(segments, 2);
     }
 
-    return null;
+    if (segments[0] === 'app') {
+        return refFromPathSegments(segments.slice(1));
+    }
+
+    const expectedLength = segments[0] === 'conversations' ? 3 : 2;
+    return segments.length === expectedLength ? refFromPathSegmentAt(segments, 0) : null;
 };
 
 const parseUrlRef = (ref: string): ResolvedConversationRef | null => {
@@ -287,7 +379,9 @@ export const renderConversationMarkdown = (
         messages: ConversationMessage[];
         title: string | null;
     },
-    options: { messageSelector?: ConversationMessageSelector } = {},
+    options: {
+        messageSelector?: ConversationMessageSelector;
+    } = {},
 ) => {
     const selectedMessages = options.messageSelector
         ? selectConversationMessages(conversation.messages, options.messageSelector)