@echoes-io/mcp-server 3.0.0 → 4.0.0

package/lib/server.js

@@ -1,305 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { RAGSystem } from '@echoes-io/rag';
-import { Tracker } from '@echoes-io/tracker';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { toJsonSchemaCompat } from '@modelcontextprotocol/sdk/server/zod-json-schema-compat.js';
-import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { getPrompt, listPrompts, validateGitHubRepo } from './prompts/index.js';
-import { bookGenerate, bookGenerateSchema, chapterDelete, chapterDeleteSchema, chapterInfo, chapterInfoSchema, chapterInsert, chapterInsertSchema, chapterRefresh, chapterRefreshSchema, episodeInfo, episodeInfoSchema, episodeUpdate, episodeUpdateSchema, ragCharacters, ragCharactersSchema, ragContext, ragContextSchema, ragIndex, ragIndexSchema, ragSearch, ragSearchSchema, stats, statsSchema, timelineSync, timelineSyncSchema, wordsCount, wordsCountSchema, } from './tools/index.js';
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
-export function createServer(timelines) {
-    const server = new Server({
-        name: pkg.name,
-        version: pkg.version,
-    }, {
-        capabilities: {
-            tools: {},
-            prompts: {},
-        },
-    });
-    server.setRequestHandler(ListToolsRequestSchema, async () => {
-        return {
-            tools: [
-                {
-                    name: 'words-count',
-                    description: 'Count words and text statistics in a markdown file',
-                    inputSchema: toJsonSchemaCompat(wordsCountSchema),
-                },
-                {
-                    name: 'chapter-info',
-                    description: 'Extract chapter metadata, content preview, and statistics',
-                    inputSchema: toJsonSchemaCompat(chapterInfoSchema),
-                },
-                {
-                    name: 'episode-info',
-                    description: 'Get episode information and list of chapters',
-                    inputSchema: toJsonSchemaCompat(episodeInfoSchema),
-                },
-                {
-                    name: 'episode-update',
-                    description: 'Update episode metadata (description, title, slug)',
-                    inputSchema: toJsonSchemaCompat(episodeUpdateSchema),
-                },
-                {
-                    name: 'chapter-refresh',
-                    description: 'Refresh chapter metadata and statistics from file',
-                    inputSchema: toJsonSchemaCompat(chapterRefreshSchema),
-                },
-                {
-                    name: 'chapter-delete',
-                    description: 'Delete chapter from database and optionally from filesystem',
-                    inputSchema: toJsonSchemaCompat(chapterDeleteSchema),
-                },
-                {
-                    name: 'chapter-insert',
-                    description: 'Insert new chapter and automatically renumber subsequent chapters',
-                    inputSchema: toJsonSchemaCompat(chapterInsertSchema),
-                },
-                {
-                    name: 'timeline-sync',
-                    description: 'Synchronize timeline content with database',
-                    inputSchema: toJsonSchemaCompat(timelineSyncSchema),
-                },
-                {
-                    name: 'stats',
-                    description: 'Get statistics for timeline, arc, episode, or POV',
-                    inputSchema: toJsonSchemaCompat(statsSchema),
-                },
-                {
-                    name: 'rag-index',
-                    description: 'Index chapters into RAG vector database for semantic search',
-                    inputSchema: toJsonSchemaCompat(ragIndexSchema),
-                },
-                {
-                    name: 'rag-search',
-                    description: 'Semantic search across timeline content',
-                    inputSchema: toJsonSchemaCompat(ragSearchSchema),
-                },
-                {
-                    name: 'rag-context',
-                    description: 'Retrieve relevant context for AI interactions',
-                    inputSchema: toJsonSchemaCompat(ragContextSchema),
-                },
-                {
-                    name: 'rag-characters',
-                    description: 'Get all characters that appear in chapters with a specific character',
-                    inputSchema: toJsonSchemaCompat(ragCharactersSchema),
-                },
-                {
-                    name: 'book-generate',
-                    description: 'Generate PDF book from timeline content using LaTeX',
-                    inputSchema: toJsonSchemaCompat(bookGenerateSchema),
-                },
-            ],
-        };
-    });
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        const { name, arguments: args } = request.params;
-        // Helper to get timeline context
-        const getContext = (timeline) => {
-            const ctx = timelines.get(timeline);
-            if (!ctx) {
-                throw new Error(`Timeline "${timeline}" not found. Available: ${Array.from(timelines.keys()).join(', ')}`);
-            }
-            return ctx;
-        };
-        switch (name) {
-            case 'words-count':
-                return await wordsCount(wordsCountSchema.parse(args));
-            case 'chapter-info': {
-                const parsed = chapterInfoSchema.parse(args);
-                const { tracker } = getContext(parsed.timeline);
-                return await chapterInfo(parsed, tracker);
-            }
-            case 'chapter-refresh': {
-                const parsed = chapterRefreshSchema.parse(args);
-                const { tracker } = getContext(parsed.timeline);
-                return await chapterRefresh(parsed, tracker);
-            }
-            case 'chapter-delete': {
-                const parsed = chapterDeleteSchema.parse(args);
-                const { tracker } = getContext(parsed.timeline);
-                return await chapterDelete(parsed, tracker);
-            }
-            case 'chapter-insert': {
-                const parsed = chapterInsertSchema.parse(args);
-                const { tracker } = getContext(parsed.timeline);
-                return await chapterInsert(parsed, tracker);
-            }
-            case 'episode-info': {
-                const parsed = episodeInfoSchema.parse(args);
-                const { tracker } = getContext(parsed.timeline);
-                return await episodeInfo(parsed, tracker);
-            }
-            case 'episode-update': {
-                const parsed = episodeUpdateSchema.parse(args);
-                const { tracker } = getContext(parsed.timeline);
-                return await episodeUpdate(parsed, tracker);
-            }
-            case 'timeline-sync': {
-                const parsed = timelineSyncSchema.parse(args);
-                const { tracker, contentPath } = getContext(parsed.timeline);
-                return await timelineSync({ ...parsed, contentPath }, tracker);
-            }
-            case 'stats': {
-                const parsed = statsSchema.parse(args);
-                const { tracker } = getContext(parsed.timeline);
-                return await stats(parsed, tracker);
-            }
-            case 'rag-index': {
-                const parsed = ragIndexSchema.parse(args);
-                const { tracker, rag, contentPath } = getContext(parsed.timeline);
-                return await ragIndex({ ...parsed, contentPath }, tracker, rag);
-            }
-            case 'rag-search': {
-                const parsed = ragSearchSchema.parse(args);
-                const { rag } = getContext(parsed.timeline);
-                return await ragSearch(parsed, rag);
-            }
-            case 'rag-context': {
-                const parsed = ragContextSchema.parse(args);
-                const { rag } = getContext(parsed.timeline);
-                return await ragContext(parsed, rag);
-            }
-            case 'rag-characters': {
-                const parsed = ragCharactersSchema.parse(args);
-                const { rag } = getContext(parsed.timeline);
-                return await ragCharacters(parsed, rag);
-            }
-            case 'book-generate': {
-                const parsed = bookGenerateSchema.parse(args);
-                const { contentPath } = getContext(parsed.timeline);
-                return await bookGenerate({ ...parsed, contentPath });
-            }
-            default:
-                throw new Error(`Unknown tool: ${name}`);
-        }
-    });
-    server.setRequestHandler(ListPromptsRequestSchema, async () => {
-        return listPrompts();
-    });
-    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-        const { name, arguments: args } = request.params;
-        // Get timeline from first available timeline (single-timeline mode)
-        // or require timeline in args for multi-timeline mode
-        const timelineNames = Array.from(timelines.keys());
-        if (timelineNames.length === 0) {
-            throw new Error('No timelines available');
-        }
-        // For single-timeline mode, use the only timeline
-        // For multi-timeline mode, this would need timeline in args
-        const timeline = timelineNames[0];
-        const { tracker } = timelines.get(timeline);
-        return await getPrompt(name, args || {}, timeline, tracker);
-    });
-    return server;
-}
-export async function runServer() {
-    const { readdirSync, existsSync } = await import('node:fs');
-    const { join, basename } = await import('node:path');
-    const cwd = process.cwd();
-    const cwdName = basename(cwd);
-    const timelines = new Map();
-    const isTest = process.env.NODE_ENV === 'test' || process.env.VITEST === 'true';
-    const log = (...args) => {
-        if (!isTest)
-            console.error(...args);
-    };
-    log(`[DEBUG] Starting from: ${cwd}`);
-    if (process.env.NODE_ENV === 'test') {
-        // Test mode: in-memory databases
-        const tracker = new Tracker(':memory:');
-        await tracker.init();
-        const rag = new RAGSystem({
-            provider: 'qwen3',
-            dbPath: ':memory:',
-        });
-        timelines.set('test', { tracker, rag, contentPath: './test-content' });
-        log('[DEBUG] Mode: test (in-memory)');
-    }
-    else if (cwdName.startsWith('timeline-')) {
-        // Single timeline mode: running from timeline directory
-        const timelineName = cwdName.replace('timeline-', '');
-        const contentPath = join(cwd, 'content');
-        if (!existsSync(contentPath)) {
-            throw new Error(`No content directory found in ${cwd}`);
-        }
-        const trackerPath = join(cwd, 'tracker.db');
-        const ragPath = join(cwd, 'lancedb');
-        const tracker = new Tracker(trackerPath);
-        await tracker.init();
-        const provider = (process.env.ECHOES_RAG_PROVIDER || 'qwen3');
-        const rag = new RAGSystem({
-            provider,
-            dbPath: ragPath,
-            geminiApiKey: process.env.ECHOES_GEMINI_API_KEY,
-        });
-        timelines.set(timelineName, { tracker, rag, contentPath });
-        log(`[DEBUG] Mode: single-timeline "${timelineName}"`);
-        log(`[DEBUG] Content: ${contentPath}`);
-        log(`[DEBUG] Tracker: ${trackerPath}`);
-        log(`[DEBUG] RAG: ${ragPath}`);
-    }
-    else if (cwdName === 'mcp-server') {
-        // Test mode from mcp-server directory: in-memory
-        const tracker = new Tracker(':memory:');
-        await tracker.init();
-        const rag = new RAGSystem({
-            provider: 'qwen3',
-            dbPath: ':memory:',
-        });
-        timelines.set('test', { tracker, rag, contentPath: './test-content' });
-        log('[DEBUG] Mode: test from mcp-server (in-memory)');
-    }
-    else {
-        // Multi-timeline mode: discover from parent directory (backward compat for .github)
-        const parentDir = join(cwd, '..');
-        const entries = readdirSync(parentDir, { withFileTypes: true });
-        log(`[DEBUG] Mode: multi-timeline (scanning ${parentDir})`);
-        for (const entry of entries) {
-            if (entry.isDirectory() && entry.name.startsWith('timeline-')) {
-                const timelineName = entry.name.replace('timeline-', '');
-                const timelinePath = join(parentDir, entry.name);
-                const contentPath = join(timelinePath, 'content');
-                if (!existsSync(contentPath)) {
-                    log(`[DEBUG] Skipping ${entry.name}: no content directory`);
-                    continue;
-                }
-                const trackerPath = join(timelinePath, 'tracker.db');
-                const ragPath = join(timelinePath, 'lancedb');
-                const tracker = new Tracker(trackerPath);
-                await tracker.init();
-                const provider = (process.env.ECHOES_RAG_PROVIDER || 'qwen3');
-                const rag = new RAGSystem({
-                    provider,
-                    dbPath: ragPath,
-                    geminiApiKey: process.env.ECHOES_GEMINI_API_KEY,
-                });
-                timelines.set(timelineName, { tracker, rag, contentPath });
-                log(`[DEBUG] Timeline "${timelineName}": ${trackerPath}`);
-            }
-        }
-        if (timelines.size === 0) {
-            throw new Error('No timelines found in parent directory');
-        }
-    }
-    const server = createServer(timelines);
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    log(`[DEBUG] Server ready with ${timelines.size} timeline(s)`);
-    // Validate .github repo for prompts
-    const { exists: githubExists } = validateGitHubRepo();
-    if (!githubExists) {
-        log('⚠️  WARNING: .github repository not found');
-        log('   Expected location: ../.github/.kiro/prompts/');
-        log('   MCP prompts will not work until .github repo is cloned as sibling.');
-        log('   Clone: git clone https://github.com/echoes-io/.github ../.github');
-    }
-    else {
-        log('✓ .github repository found');
-    }
-}

package/lib/tools/book-generate.d.ts

@@ -1,20 +0,0 @@
-import { z } from 'zod';
-export declare const bookGenerateSchema: z.ZodObject<{
-    timeline: z.ZodString;
-    outputPath: z.ZodString;
-    episodes: z.ZodOptional<z.ZodString>;
-    format: z.ZodOptional<z.ZodEnum<{
-        a4: "a4";
-        a5: "a5";
-    }>>;
-}, z.core.$strip>;
-type BookGenerateArgs = z.infer<typeof bookGenerateSchema> & {
-    contentPath: string;
-};
-export declare function bookGenerate(args: BookGenerateArgs): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export {};

package/lib/tools/book-generate.js

@@ -1,36 +0,0 @@
-import { generateBook } from '@echoes-io/books-generator';
-import { z } from 'zod';
-export const bookGenerateSchema = z.object({
-    timeline: z.string().describe('Timeline name'),
-    outputPath: z.string().describe('Output PDF file path'),
-    episodes: z.string().optional().describe('Comma-separated episode numbers (e.g., "1,2,3")'),
-    format: z.enum(['a4', 'a5']).optional().describe('Page format (default: a4)'),
-});
-export async function bookGenerate(args) {
-    try {
-        await generateBook({
-            contentPath: args.contentPath,
-            outputPath: args.outputPath,
-            timeline: args.timeline,
-            episodes: args.episodes,
-            format: args.format || 'a4',
-        });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        timeline: args.timeline,
-                        outputPath: args.outputPath,
-                        episodes: args.episodes || 'all',
-                        format: args.format || 'a4',
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        throw new Error(`Failed to generate book: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}

package/lib/tools/chapter-delete.d.ts

@@ -1,15 +0,0 @@
-import type { Tracker } from '@echoes-io/tracker';
-import { z } from 'zod';
-export declare const chapterDeleteSchema: z.ZodObject<{
-    timeline: z.ZodString;
-    arc: z.ZodString;
-    episode: z.ZodNumber;
-    chapter: z.ZodNumber;
-    file: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare function chapterDelete(args: z.infer<typeof chapterDeleteSchema>, tracker: Tracker): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;

package/lib/tools/chapter-delete.js

@@ -1,48 +0,0 @@
-import { unlinkSync } from 'node:fs';
-import { z } from 'zod';
-export const chapterDeleteSchema = z.object({
-    timeline: z.string().describe('Timeline name'),
-    arc: z.string().describe('Arc name'),
-    episode: z.number().describe('Episode number'),
-    chapter: z.number().describe('Chapter number'),
-    file: z.string().optional().describe('Path to markdown file to delete from filesystem'),
-});
-export async function chapterDelete(args, tracker) {
-    try {
-        const existing = await tracker.getChapter(args.timeline, args.arc, args.episode, args.chapter);
-        if (!existing) {
-            throw new Error(`Chapter not found: ${args.timeline}/${args.arc}/ep${args.episode}/ch${args.chapter}`);
-        }
-        await tracker.deleteChapter(args.timeline, args.arc, args.episode, args.chapter);
-        let fileDeleted = false;
-        if (args.file) {
-            unlinkSync(args.file);
-            fileDeleted = true;
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        timeline: args.timeline,
-                        arc: args.arc,
-                        episode: args.episode,
-                        chapter: args.chapter,
-                        deleted: {
-                            pov: existing.pov,
-                            title: existing.title,
-                            words: existing.words,
-                        },
-                        fileDeleted,
-                        message: fileDeleted
-                            ? 'Chapter deleted from database and filesystem'
-                            : 'Chapter deleted from database only',
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        throw new Error(`Failed to delete chapter: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}

package/lib/tools/chapter-info.d.ts

@@ -1,14 +0,0 @@
-import type { Tracker } from '@echoes-io/tracker';
-import { z } from 'zod';
-export declare const chapterInfoSchema: z.ZodObject<{
-    timeline: z.ZodString;
-    arc: z.ZodString;
-    episode: z.ZodNumber;
-    chapter: z.ZodNumber;
-}, z.core.$strip>;
-export declare function chapterInfo(args: z.infer<typeof chapterInfoSchema>, tracker: Tracker): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;

package/lib/tools/chapter-info.js

@@ -1,47 +0,0 @@
-import { z } from 'zod';
-export const chapterInfoSchema = z.object({
-    timeline: z.string().describe('Timeline name'),
-    arc: z.string().describe('Arc name'),
-    episode: z.number().describe('Episode number'),
-    chapter: z.number().describe('Chapter number'),
-});
-export async function chapterInfo(args, tracker) {
-    try {
-        const chapter = await tracker.getChapter(args.timeline, args.arc, args.episode, args.chapter);
-        if (!chapter) {
-            throw new Error(`Chapter not found: ${args.timeline}/${args.arc}/ep${args.episode}/ch${args.chapter}`);
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        timeline: args.timeline,
-                        arc: args.arc,
-                        episode: args.episode,
-                        chapter: args.chapter,
-                        metadata: {
-                            pov: chapter.pov,
-                            title: chapter.title,
-                            date: chapter.date,
-                            summary: chapter.summary,
-                            location: chapter.location,
-                            outfit: chapter.outfit,
-                            kink: chapter.kink,
-                        },
-                        stats: {
-                            words: chapter.words,
-                            characters: chapter.characters,
-                            charactersNoSpaces: chapter.charactersNoSpaces,
-                            paragraphs: chapter.paragraphs,
-                            sentences: chapter.sentences,
-                        },
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        throw new Error(`Failed to get chapter info: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}

package/lib/tools/chapter-insert.d.ts

@@ -1,21 +0,0 @@
-import type { Tracker } from '@echoes-io/tracker';
-import { z } from 'zod';
-export declare const chapterInsertSchema: z.ZodObject<{
-    timeline: z.ZodString;
-    arc: z.ZodString;
-    episode: z.ZodNumber;
-    after: z.ZodNumber;
-    pov: z.ZodString;
-    title: z.ZodString;
-    summary: z.ZodOptional<z.ZodString>;
-    location: z.ZodOptional<z.ZodString>;
-    outfit: z.ZodOptional<z.ZodString>;
-    kink: z.ZodOptional<z.ZodString>;
-    file: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare function chapterInsert(args: z.infer<typeof chapterInsertSchema>, tracker: Tracker): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;

package/lib/tools/chapter-insert.js

@@ -1,104 +0,0 @@
-import { getTextStats, parseMarkdown } from '@echoes-io/utils';
-import { z } from 'zod';
-export const chapterInsertSchema = z.object({
-    timeline: z.string().describe('Timeline name'),
-    arc: z.string().describe('Arc name'),
-    episode: z.number().describe('Episode number'),
-    after: z.number().describe('Insert after this chapter number'),
-    pov: z.string().describe('Point of view character'),
-    title: z.string().describe('Chapter title'),
-    summary: z.string().optional().describe('Chapter summary'),
-    location: z.string().optional().describe('Chapter location'),
-    outfit: z.string().optional().describe('Character outfit'),
-    kink: z.string().optional().describe('Content tags'),
-    file: z.string().optional().describe('Path to markdown file to read content from'),
-});
-export async function chapterInsert(args, tracker) {
-    try {
-        const episode = await tracker.getEpisode(args.timeline, args.arc, args.episode);
-        if (!episode) {
-            throw new Error(`Episode not found: ${args.timeline}/${args.arc}/ep${args.episode}`);
-        }
-        const existingChapters = await tracker.getChapters(args.timeline, args.arc, args.episode);
-        const newChapterNumber = args.after + 1;
-        const chaptersToRenumber = existingChapters.filter((ch) => ch.number >= newChapterNumber);
-        for (const chapter of chaptersToRenumber) {
-            try {
-                await tracker.updateChapter(args.timeline, args.arc, args.episode, chapter.number, {
-                    number: chapter.number + 1,
-                });
-            }
-            catch (error) {
-                throw new Error(`Failed to renumber chapter ${chapter.number}: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            }
-        }
-        let words = 0;
-        let characters = 0;
-        let charactersNoSpaces = 0;
-        let paragraphs = 0;
-        let sentences = 0;
-        if (args.file) {
-            const { readFileSync } = await import('node:fs');
-            const content = readFileSync(args.file, 'utf-8');
-            const { content: markdownContent } = parseMarkdown(content);
-            const stats = getTextStats(markdownContent);
-            words = stats.words;
-            characters = stats.characters;
-            charactersNoSpaces = stats.charactersNoSpaces;
-            paragraphs = stats.paragraphs;
-            sentences = stats.sentences;
-        }
-        const chapterData = {
-            timelineName: args.timeline,
-            arcName: args.arc,
-            episodeNumber: args.episode,
-            partNumber: 1,
-            number: newChapterNumber,
-            timeline: args.timeline,
-            arc: args.arc,
-            episode: args.episode,
-            part: 1,
-            chapter: newChapterNumber,
-            pov: args.pov,
-            title: args.title,
-            date: new Date().toISOString(),
-            summary: args.summary || '',
-            location: args.location || '',
-            outfit: args.outfit || '',
-            kink: args.kink || '',
-            words,
-            characters,
-            charactersNoSpaces,
-            paragraphs,
-            sentences,
-            readingTimeMinutes: Math.ceil(words / 200),
-        };
-        await tracker.createChapter(chapterData);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        timeline: args.timeline,
-                        arc: args.arc,
-                        episode: args.episode,
-                        inserted: {
-                            chapter: newChapterNumber,
-                            pov: args.pov,
-                            title: args.title,
-                            words,
-                        },
-                        renumbered: chaptersToRenumber.map((ch) => ({
-                            oldNumber: ch.number,
-                            newNumber: ch.number + 1,
-                            title: ch.title,
-                        })),
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        throw new Error(`Failed to insert chapter: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}

package/lib/tools/chapter-refresh.d.ts

@@ -1,12 +0,0 @@
-import type { Tracker } from '@echoes-io/tracker';
-import { z } from 'zod';
-export declare const chapterRefreshSchema: z.ZodObject<{
-    timeline: z.ZodString;
-    file: z.ZodString;
-}, z.core.$strip>;
-export declare function chapterRefresh(args: z.infer<typeof chapterRefreshSchema>, tracker: Tracker): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;