@echoes-io/mcp-server 1.5.0 → 1.7.0

package/README.md

@@ -8,9 +8,27 @@ The server is distributed as an npm package and can be used without cloning the
 
 ### Using with MCP Clients
 
-**Important:** The server must be run from the `.github` directory of your Echoes project.
+The server can run in three modes depending on the working directory:
 
-Add to your MCP client configuration (e.g., `~/.config/q/mcp.json` for Amazon Q):
+1. **Single Timeline Mode**: Run from a `timeline-*` directory to work with that specific timeline
+2. **Multi-Timeline Mode**: Run from `.github` directory to access all timelines
+3. **Test Mode**: Run from `mcp-server` directory for development
+
+#### Single Timeline Configuration (Recommended for Kiro CLI)
+
+```json
+{
+  "mcpServers": {
+    "echoes": {
+      "command": "npx",
+      "args": ["-y", "@echoes-io/mcp-server"],
+      "cwd": "/path/to/timeline-pulse"
+    }
+  }
+}
+```
+
+#### Multi-Timeline Configuration (Legacy/CAO)
 
 ```json
 {
@@ -37,7 +55,7 @@ Then configure:
   "mcpServers": {
     "echoes": {
       "command": "echoes-mcp-server",
-      "cwd": "/path/to/echoes-io/.github",
+      "cwd": "/path/to/timeline-pulse",
       "env": {
         "ECHOES_RAG_PROVIDER": "e5-small"
       }
@@ -50,13 +68,49 @@ Then configure:
 - `ECHOES_RAG_PROVIDER`: Embedding provider (`e5-small`, `e5-large`, or `gemini`). Default: `e5-small`
 - `ECHOES_GEMINI_API_KEY`: Required if using `gemini` provider
 
-## Multi-Timeline Architecture
+## Execution Modes
+
+### Single Timeline Mode (Recommended)
+Run from a timeline directory to work with that specific timeline:
+```bash
+cd timeline-pulse
+npx @echoes-io/mcp-server
+# [DEBUG] Mode: single-timeline "pulse"
+```
+
+**Benefits:**
+- Simpler configuration for single-timeline workflows
+- Direct access to timeline databases
+- Perfect for Kiro CLI integration
+
+### Multi-Timeline Mode (Legacy)
+Run from `.github` directory to access all timelines:
+```bash
+cd .github
+npx @echoes-io/mcp-server
+# [DEBUG] Mode: multi-timeline (scanning /path/to/echoes-io)
+```
+
+**Benefits:**
+- Manage multiple timelines simultaneously
+- Backward compatible with CAO agents
+- Timeline repositories can be private
+
+### Test Mode
+Run from `mcp-server` directory for development:
+```bash
+cd mcp-server
+npm run dev
+# [DEBUG] Mode: test from mcp-server (in-memory)
+```
+
+## Timeline Architecture
 
-The server automatically discovers and manages multiple timelines:
+Each timeline has isolated databases in its own repository:
 
 ```
 echoes-io/
-  .github/              # Server runs from here
+  .github/              # Multi-timeline mode runs from here
   timeline-eros/        # Private timeline repo
     tracker.db          # Timeline-specific database
     rag.db              # Timeline-specific RAG index

package/lib/server.d.ts

@@ -10,9 +10,18 @@ export declare function createServer(timelines: Map<string, TimelineContext>): S
     method: string;
     params?: {
         [x: string]: unknown;
+        task?: {
+            [x: string]: unknown;
+            ttl?: number | null | undefined;
+            pollInterval?: number | undefined;
+        } | undefined;
         _meta?: {
             [x: string]: unknown;
             progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                [x: string]: unknown;
+                taskId: string;
+            } | undefined;
         } | undefined;
     } | undefined;
 }, {
@@ -21,12 +30,20 @@ export declare function createServer(timelines: Map<string, TimelineContext>): S
         [x: string]: unknown;
         _meta?: {
             [x: string]: unknown;
+            "io.modelcontextprotocol/related-task"?: {
+                [x: string]: unknown;
+                taskId: string;
+            } | undefined;
         } | undefined;
     } | undefined;
 }, {
     [x: string]: unknown;
     _meta?: {
         [x: string]: unknown;
+        "io.modelcontextprotocol/related-task"?: {
+            [x: string]: unknown;
+            taskId: string;
+        } | undefined;
     } | undefined;
 }>;
 interface TimelineContext {

package/lib/server.js

@@ -5,8 +5,8 @@ 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, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { zodToJsonSchema } from 'zod-to-json-schema';
 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'));
@@ -25,72 +25,72 @@ export function createServer(timelines) {
                 {
                     name: 'words-count',
                     description: 'Count words and text statistics in a markdown file',
-                    inputSchema: zodToJsonSchema(wordsCountSchema),
+                    inputSchema: toJsonSchemaCompat(wordsCountSchema),
                 },
                 {
                     name: 'chapter-info',
                     description: 'Extract chapter metadata, content preview, and statistics',
-                    inputSchema: zodToJsonSchema(chapterInfoSchema),
+                    inputSchema: toJsonSchemaCompat(chapterInfoSchema),
                 },
                 {
                     name: 'episode-info',
                     description: 'Get episode information and list of chapters',
-                    inputSchema: zodToJsonSchema(episodeInfoSchema),
+                    inputSchema: toJsonSchemaCompat(episodeInfoSchema),
                 },
                 {
                     name: 'episode-update',
                     description: 'Update episode metadata (description, title, slug)',
-                    inputSchema: zodToJsonSchema(episodeUpdateSchema),
+                    inputSchema: toJsonSchemaCompat(episodeUpdateSchema),
                 },
                 {
                     name: 'chapter-refresh',
                     description: 'Refresh chapter metadata and statistics from file',
-                    inputSchema: zodToJsonSchema(chapterRefreshSchema),
+                    inputSchema: toJsonSchemaCompat(chapterRefreshSchema),
                 },
                 {
                     name: 'chapter-delete',
                     description: 'Delete chapter from database and optionally from filesystem',
-                    inputSchema: zodToJsonSchema(chapterDeleteSchema),
+                    inputSchema: toJsonSchemaCompat(chapterDeleteSchema),
                 },
                 {
                     name: 'chapter-insert',
                     description: 'Insert new chapter and automatically renumber subsequent chapters',
-                    inputSchema: zodToJsonSchema(chapterInsertSchema),
+                    inputSchema: toJsonSchemaCompat(chapterInsertSchema),
                 },
                 {
                     name: 'timeline-sync',
                     description: 'Synchronize timeline content with database',
-                    inputSchema: zodToJsonSchema(timelineSyncSchema),
+                    inputSchema: toJsonSchemaCompat(timelineSyncSchema),
                 },
                 {
                     name: 'stats',
                     description: 'Get statistics for timeline, arc, episode, or POV',
-                    inputSchema: zodToJsonSchema(statsSchema),
+                    inputSchema: toJsonSchemaCompat(statsSchema),
                 },
                 {
                     name: 'rag-index',
                     description: 'Index chapters into RAG vector database for semantic search',
-                    inputSchema: zodToJsonSchema(ragIndexSchema),
+                    inputSchema: toJsonSchemaCompat(ragIndexSchema),
                 },
                 {
                     name: 'rag-search',
                     description: 'Semantic search across timeline content',
-                    inputSchema: zodToJsonSchema(ragSearchSchema),
+                    inputSchema: toJsonSchemaCompat(ragSearchSchema),
                 },
                 {
                     name: 'rag-context',
                     description: 'Retrieve relevant context for AI interactions',
-                    inputSchema: zodToJsonSchema(ragContextSchema),
+                    inputSchema: toJsonSchemaCompat(ragContextSchema),
                 },
                 {
                     name: 'rag-characters',
                     description: 'Get all characters that appear in chapters with a specific character',
-                    inputSchema: zodToJsonSchema(ragCharactersSchema),
+                    inputSchema: toJsonSchemaCompat(ragCharactersSchema),
                 },
                 {
                     name: 'book-generate',
                     description: 'Generate PDF book from timeline content using LaTeX',
-                    inputSchema: zodToJsonSchema(bookGenerateSchema),
+                    inputSchema: toJsonSchemaCompat(bookGenerateSchema),
                 },
             ],
         };
@@ -180,13 +180,48 @@ export function createServer(timelines) {
     return server;
 }
 export async function runServer() {
-    // Validate we're running from .github directory
-    if (process.env.NODE_ENV !== 'test' && !process.cwd().endsWith('/.github')) {
-        throw new Error('Server must be run from .github directory');
-    }
+    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();
+    console.error(`[DEBUG] Starting from: ${cwd}`);
     if (process.env.NODE_ENV === 'test') {
-        // Test mode: single in-memory database
+        // Test mode: in-memory databases
+        const tracker = new Tracker(':memory:');
+        await tracker.init();
+        const rag = new RAGSystem({
+            provider: 'e5-small',
+            dbPath: ':memory:',
+        });
+        timelines.set('test', { tracker, rag, contentPath: './test-content' });
+        console.error('[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, 'rag.db');
+        const tracker = new Tracker(trackerPath);
+        await tracker.init();
+        const provider = (process.env.ECHOES_RAG_PROVIDER || 'e5-small');
+        const rag = new RAGSystem({
+            provider,
+            dbPath: ragPath,
+            geminiApiKey: process.env.ECHOES_GEMINI_API_KEY,
+        });
+        timelines.set(timelineName, { tracker, rag, contentPath });
+        console.error(`[DEBUG] Mode: single-timeline "${timelineName}"`);
+        console.error(`[DEBUG] Content: ${contentPath}`);
+        console.error(`[DEBUG] Tracker: ${trackerPath}`);
+        console.error(`[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({
@@ -194,29 +229,26 @@ export async function runServer() {
             dbPath: ':memory:',
         });
         timelines.set('test', { tracker, rag, contentPath: './test-content' });
-        console.error('Test mode: in-memory databases');
+        console.error('[DEBUG] Mode: test from mcp-server (in-memory)');
     }
     else {
-        // Production: discover timelines and create separate databases
-        const { readdirSync, existsSync, mkdirSync } = await import('node:fs');
-        const { join } = await import('node:path');
-        const parentDir = join(process.cwd(), '..');
+        // Multi-timeline mode: discover from parent directory (backward compat for .github)
+        const parentDir = join(cwd, '..');
         const entries = readdirSync(parentDir, { withFileTypes: true });
+        console.error(`[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)) {
-                    console.error(`Skipping ${entry.name}: no content directory`);
+                    console.error(`[DEBUG] Skipping ${entry.name}: no content directory`);
                     continue;
                 }
-                // Initialize tracker
                 const trackerPath = join(timelinePath, 'tracker.db');
+                const ragPath = join(timelinePath, 'rag.db');
                 const tracker = new Tracker(trackerPath);
                 await tracker.init();
-                // Initialize RAG
-                const ragPath = join(timelinePath, 'rag.db');
                 const provider = (process.env.ECHOES_RAG_PROVIDER || 'e5-small');
                 const rag = new RAGSystem({
                     provider,
@@ -224,7 +256,7 @@ export async function runServer() {
                     geminiApiKey: process.env.ECHOES_GEMINI_API_KEY,
                 });
                 timelines.set(timelineName, { tracker, rag, contentPath });
-                console.error(`Timeline "${timelineName}" initialized: ${trackerPath}`);
+                console.error(`[DEBUG] Timeline "${timelineName}": ${trackerPath}`);
             }
         }
         if (timelines.size === 0) {
@@ -234,5 +266,5 @@ export async function runServer() {
     const server = createServer(timelines);
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error(`Echoes MCP Server running on stdio (${timelines.size} timelines)`);
+    console.error(`[DEBUG] Server ready with ${timelines.size} timeline(s)`);
 }

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

@@ -3,18 +3,11 @@ export declare const bookGenerateSchema: z.ZodObject<{
     timeline: z.ZodString;
     outputPath: z.ZodString;
     episodes: z.ZodOptional<z.ZodString>;
-    format: z.ZodOptional<z.ZodEnum<["a4", "a5"]>>;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    outputPath: string;
-    episodes?: string | undefined;
-    format?: "a4" | "a5" | undefined;
-}, {
-    timeline: string;
-    outputPath: string;
-    episodes?: string | undefined;
-    format?: "a4" | "a5" | undefined;
-}>;
+    format: z.ZodOptional<z.ZodEnum<{
+        a4: "a4";
+        a5: "a5";
+    }>>;
+}, z.core.$strip>;
 type BookGenerateArgs = z.infer<typeof bookGenerateSchema> & {
     contentPath: string;
 };

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

@@ -6,19 +6,7 @@ export declare const chapterDeleteSchema: z.ZodObject<{
     episode: z.ZodNumber;
     chapter: z.ZodNumber;
     file: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    arc: string;
-    episode: number;
-    chapter: number;
-    file?: string | undefined;
-}, {
-    timeline: string;
-    arc: string;
-    episode: number;
-    chapter: number;
-    file?: string | undefined;
-}>;
+}, z.core.$strip>;
 export declare function chapterDelete(args: z.infer<typeof chapterDeleteSchema>, tracker: Tracker): Promise<{
     content: {
         type: "text";

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

@@ -5,17 +5,7 @@ export declare const chapterInfoSchema: z.ZodObject<{
     arc: z.ZodString;
     episode: z.ZodNumber;
     chapter: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    arc: string;
-    episode: number;
-    chapter: number;
-}, {
-    timeline: string;
-    arc: string;
-    episode: number;
-    chapter: number;
-}>;
+}, z.core.$strip>;
 export declare function chapterInfo(args: z.infer<typeof chapterInfoSchema>, tracker: Tracker): Promise<{
     content: {
         type: "text";

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

@@ -12,31 +12,7 @@ export declare const chapterInsertSchema: z.ZodObject<{
     outfit: z.ZodOptional<z.ZodString>;
     kink: z.ZodOptional<z.ZodString>;
     file: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    arc: string;
-    episode: number;
-    after: number;
-    pov: string;
-    title: string;
-    file?: string | undefined;
-    summary?: string | undefined;
-    location?: string | undefined;
-    outfit?: string | undefined;
-    kink?: string | undefined;
-}, {
-    timeline: string;
-    arc: string;
-    episode: number;
-    after: number;
-    pov: string;
-    title: string;
-    file?: string | undefined;
-    summary?: string | undefined;
-    location?: string | undefined;
-    outfit?: string | undefined;
-    kink?: string | undefined;
-}>;
+}, z.core.$strip>;
 export declare function chapterInsert(args: z.infer<typeof chapterInsertSchema>, tracker: Tracker): Promise<{
     content: {
         type: "text";

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

@@ -3,13 +3,7 @@ import { z } from 'zod';
 export declare const chapterRefreshSchema: z.ZodObject<{
     timeline: z.ZodString;
     file: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    file: string;
-}, {
-    timeline: string;
-    file: string;
-}>;
+}, z.core.$strip>;
 export declare function chapterRefresh(args: z.infer<typeof chapterRefreshSchema>, tracker: Tracker): Promise<{
     content: {
         type: "text";

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

@@ -4,15 +4,7 @@ export declare const episodeInfoSchema: z.ZodObject<{
     timeline: z.ZodString;
     arc: z.ZodString;
     episode: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    arc: string;
-    episode: number;
-}, {
-    timeline: string;
-    arc: string;
-    episode: number;
-}>;
+}, z.core.$strip>;
 export declare function episodeInfo(args: z.infer<typeof episodeInfoSchema>, tracker: Tracker): Promise<{
     content: {
         type: "text";

package/lib/tools/episode-update.d.ts

@@ -7,21 +7,7 @@ export declare const episodeUpdateSchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     title: z.ZodOptional<z.ZodString>;
     slug: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    arc: string;
-    episode: number;
-    title?: string | undefined;
-    description?: string | undefined;
-    slug?: string | undefined;
-}, {
-    timeline: string;
-    arc: string;
-    episode: number;
-    title?: string | undefined;
-    description?: string | undefined;
-    slug?: string | undefined;
-}>;
+}, z.core.$strip>;
 export declare function episodeUpdate(args: z.infer<typeof episodeUpdateSchema>, tracker: Tracker): Promise<{
     content: {
         type: "text";

package/lib/tools/rag-characters.d.ts

@@ -3,13 +3,7 @@ import { z } from 'zod';
 export declare const ragCharactersSchema: z.ZodObject<{
     timeline: z.ZodString;
     character: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    character: string;
-}, {
-    timeline: string;
-    character: string;
-}>;
+}, z.core.$strip>;
 export declare function ragCharacters(args: z.infer<typeof ragCharactersSchema>, rag: RAGSystem): Promise<{
     content: {
         type: "text";

package/lib/tools/rag-context.d.ts

@@ -6,22 +6,8 @@ export declare const ragContextSchema: z.ZodObject<{
     arc: z.ZodOptional<z.ZodString>;
     pov: z.ZodOptional<z.ZodString>;
     maxChapters: z.ZodOptional<z.ZodNumber>;
-    characters: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    query: string;
-    arc?: string | undefined;
-    pov?: string | undefined;
-    characters?: string[] | undefined;
-    maxChapters?: number | undefined;
-}, {
-    timeline: string;
-    query: string;
-    arc?: string | undefined;
-    pov?: string | undefined;
-    characters?: string[] | undefined;
-    maxChapters?: number | undefined;
-}>;
+    characters: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
 export declare function ragContext(args: z.infer<typeof ragContextSchema>, rag: RAGSystem): Promise<{
     content: {
         type: "text";

package/lib/tools/rag-index.d.ts

@@ -5,15 +5,7 @@ export declare const ragIndexSchema: z.ZodObject<{
     timeline: z.ZodString;
     arc: z.ZodOptional<z.ZodString>;
     episode: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    arc?: string | undefined;
-    episode?: number | undefined;
-}, {
-    timeline: string;
-    arc?: string | undefined;
-    episode?: number | undefined;
-}>;
+}, z.core.$strip>;
 type RagIndexArgs = z.infer<typeof ragIndexSchema> & {
     contentPath: string;
 };

package/lib/tools/rag-search.d.ts

@@ -6,25 +6,9 @@ export declare const ragSearchSchema: z.ZodObject<{
     arc: z.ZodOptional<z.ZodString>;
     pov: z.ZodOptional<z.ZodString>;
     maxResults: z.ZodOptional<z.ZodNumber>;
-    characters: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    characters: z.ZodOptional<z.ZodArray<z.ZodString>>;
     allCharacters: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    query: string;
-    arc?: string | undefined;
-    pov?: string | undefined;
-    characters?: string[] | undefined;
-    maxResults?: number | undefined;
-    allCharacters?: boolean | undefined;
-}, {
-    timeline: string;
-    query: string;
-    arc?: string | undefined;
-    pov?: string | undefined;
-    characters?: string[] | undefined;
-    maxResults?: number | undefined;
-    allCharacters?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export declare function ragSearch(args: z.infer<typeof ragSearchSchema>, rag: RAGSystem): Promise<{
     content: {
         type: "text";

package/lib/tools/stats.d.ts

@@ -5,17 +5,7 @@ export declare const statsSchema: z.ZodObject<{
     arc: z.ZodOptional<z.ZodString>;
     episode: z.ZodOptional<z.ZodNumber>;
     pov: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    arc?: string | undefined;
-    episode?: number | undefined;
-    pov?: string | undefined;
-}, {
-    timeline: string;
-    arc?: string | undefined;
-    episode?: number | undefined;
-    pov?: string | undefined;
-}>;
+}, z.core.$strip>;
 export declare function stats(args: z.infer<typeof statsSchema>, tracker: Tracker): Promise<{
     content: {
         type: "text";

package/lib/tools/timeline-sync.d.ts

@@ -2,11 +2,7 @@ import type { Tracker } from '@echoes-io/tracker';
 import { z } from 'zod';
 export declare const timelineSyncSchema: z.ZodObject<{
     timeline: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-}, {
-    timeline: string;
-}>;
+}, z.core.$strip>;
 type TimelineSyncArgs = z.infer<typeof timelineSyncSchema> & {
     contentPath: string;
 };

package/lib/tools/words-count.d.ts

@@ -1,11 +1,7 @@
 import { z } from 'zod';
 export declare const wordsCountSchema: z.ZodObject<{
     file: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    file: string;
-}, {
-    file: string;
-}>;
+}, z.core.$strip>;
 export declare function wordsCount(args: z.infer<typeof wordsCountSchema>): Promise<{
     content: {
         type: "text";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@echoes-io/mcp-server",
   "type": "module",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "description": "Model Context Protocol server for AI integration with Echoes storytelling platform",
   "scripts": {
     "dev": "tsx cli/index.ts",
@@ -63,30 +63,30 @@
     ]
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.3",
+    "@biomejs/biome": "^2.3.8",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
-    "@tsconfig/node22": "^22.0.2",
-    "@types/node": "^24.10.0",
-    "@vitest/coverage-v8": "^4.0.6",
+    "@tsconfig/node22": "^22.0.5",
+    "@types/node": "^24.10.1",
+    "@vitest/coverage-v8": "^4.0.15",
     "concurrently": "^9.2.1",
     "husky": "^9.1.7",
-    "lint-staged": "^16.2.5",
+    "lint-staged": "^16.2.7",
     "lockfile-lint": "^4.14.1",
     "ls-engines": "^0.9.3",
     "publint": "^0.3.15",
-    "rimraf": "^6.1.0",
-    "semantic-release": "^25.0.1",
-    "tsx": "^4.19.2",
+    "rimraf": "^6.1.2",
+    "semantic-release": "^25.0.2",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.6"
+    "vitest": "^4.0.15"
   },
   "dependencies": {
-    "@echoes-io/books-generator": "^1.0.1",
-    "@echoes-io/models": "^1.0.3",
+    "@echoes-io/books-generator": "^1.1.0",
+    "@echoes-io/models": "^1.1.0",
     "@echoes-io/rag": "^1.2.0",
-    "@echoes-io/tracker": "^1.0.1",
-    "@echoes-io/utils": "^1.2.0",
-    "@modelcontextprotocol/sdk": "^1.0.2"
+    "@echoes-io/tracker": "^1.1.0",
+    "@echoes-io/utils": "^1.3.0",
+    "@modelcontextprotocol/sdk": "^1.24.2"
   }
 }