@j0hanz/superfetch 1.2.1 → 1.2.3

package/dist/services/transform-worker-pool.js

@@ -0,0 +1,167 @@
+import os from 'node:os';
+import { isMainThread, Worker } from 'node:worker_threads';
+import { config } from '../config/index.js';
+import { getErrorMessage } from '../utils/error-utils.js';
+import { logWarn } from './logger.js';
+const MAX_POOL_SIZE = 4;
+function resolvePoolSize() {
+    const available = os.availableParallelism();
+    return Math.max(1, Math.min(available - 1, MAX_POOL_SIZE));
+}
+let pool = null;
+let poolDisabled = false;
+function shouldUseWorkers() {
+    return isMainThread && config.runtime.httpMode && !poolDisabled;
+}
+function getWorkerUrl() {
+    return new URL('../workers/transform-worker.js', import.meta.url);
+}
+export async function runTransformInWorker(job) {
+    if (!shouldUseWorkers())
+        return null;
+    if (!pool) {
+        try {
+            pool = new TransformWorkerPool(getWorkerUrl(), resolvePoolSize());
+        }
+        catch (error) {
+            poolDisabled = true;
+            logWarn('Failed to initialize transform worker pool', {
+                error: getErrorMessage(error),
+            });
+            return null;
+        }
+    }
+    try {
+        return await pool.run(job);
+    }
+    catch (error) {
+        poolDisabled = true;
+        pool.destroy();
+        pool = null;
+        logWarn('Transform worker failed; falling back to main thread', {
+            error: getErrorMessage(error),
+        });
+        return null;
+    }
+}
+export function destroyTransformWorkers() {
+    pool?.destroy();
+    pool = null;
+}
+class TransformWorkerPool {
+    workerUrl;
+    size;
+    workers = [];
+    queue = [];
+    pending = new Map();
+    nextId = 1;
+    destroyed = false;
+    constructor(workerUrl, size) {
+        this.workerUrl = workerUrl;
+        this.size = size;
+        for (let i = 0; i < size; i += 1) {
+            this.workers.push(this.createWorker());
+        }
+    }
+    run(job) {
+        if (this.destroyed) {
+            return Promise.reject(new Error('Transform worker pool is closed'));
+        }
+        const id = this.nextId++;
+        const queuedJob = { ...job, id };
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.queue.push(queuedJob);
+            this.schedule();
+        });
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        for (const workerState of this.workers) {
+            void workerState.worker.terminate();
+        }
+        for (const [id, pending] of this.pending.entries()) {
+            pending.reject(new Error('Transform worker pool shut down'));
+            this.pending.delete(id);
+        }
+        this.queue.length = 0;
+    }
+    createWorker() {
+        const worker = new Worker(this.workerUrl);
+        worker.unref();
+        const state = { worker, busy: false, currentJobId: undefined };
+        worker.on('message', (message) => {
+            this.handleMessage(state, message);
+        });
+        worker.on('error', (error) => {
+            this.handleWorkerError(state, error);
+        });
+        worker.on('exit', (code) => {
+            this.handleWorkerExit(state, code);
+        });
+        return state;
+    }
+    handleMessage(state, message) {
+        const pending = this.pending.get(message.id);
+        if (pending) {
+            this.pending.delete(message.id);
+            if (message.ok) {
+                pending.resolve(message.result);
+            }
+            else {
+                pending.reject(new Error(message.error));
+            }
+        }
+        state.busy = false;
+        state.currentJobId = undefined;
+        this.schedule();
+    }
+    handleWorkerError(state, error) {
+        this.failCurrentJob(state, error);
+        this.replaceWorker(state);
+    }
+    handleWorkerExit(state, code) {
+        if (code !== 0) {
+            this.failCurrentJob(state, new Error(`Transform worker exited with code ${code}`));
+        }
+        this.replaceWorker(state);
+    }
+    failCurrentJob(state, error) {
+        if (!state.currentJobId)
+            return;
+        const pending = this.pending.get(state.currentJobId);
+        if (pending) {
+            pending.reject(error);
+            this.pending.delete(state.currentJobId);
+        }
+        state.currentJobId = undefined;
+        state.busy = false;
+    }
+    replaceWorker(state) {
+        if (this.destroyed)
+            return;
+        const index = this.workers.indexOf(state);
+        if (index === -1)
+            return;
+        this.workers[index] = this.createWorker();
+        this.schedule();
+    }
+    schedule() {
+        if (this.destroyed)
+            return;
+        for (const workerState of this.workers) {
+            if (this.queue.length === 0)
+                return;
+            if (workerState.busy)
+                continue;
+            const job = this.queue.shift();
+            if (!job)
+                return;
+            workerState.busy = true;
+            workerState.currentJobId = job.id;
+            workerState.worker.postMessage(job);
+        }
+    }
+}

package/dist/tools/handlers/fetch-markdown.tool.d.ts

@@ -1,4 +1,12 @@
 import type { FetchMarkdownInput, ToolResponseBase } from '../../config/types/tools.js';
+import { transformHtmlToMarkdownAsync } from '../utils/content-transform-async.js';
+import { performSharedFetch } from './fetch-single.shared.js';
 export declare const FETCH_MARKDOWN_TOOL_NAME = "fetch-markdown";
 export declare const FETCH_MARKDOWN_TOOL_DESCRIPTION = "Fetches a webpage and converts it to clean Markdown format with optional frontmatter and content length limits";
-export declare function fetchMarkdownToolHandler(input: FetchMarkdownInput): Promise<ToolResponseBase>;
+interface FetchMarkdownDeps {
+    readonly performSharedFetch?: typeof performSharedFetch;
+    readonly transformHtmlToMarkdown?: typeof transformHtmlToMarkdownAsync;
+}
+export declare function createFetchMarkdownToolHandler(deps?: FetchMarkdownDeps): (input: FetchMarkdownInput) => Promise<ToolResponseBase>;
+export declare const fetchMarkdownToolHandler: (input: FetchMarkdownInput) => Promise<ToolResponseBase>;
+export {};

package/dist/tools/handlers/fetch-markdown.tool.js

@@ -1,7 +1,7 @@
 import { config } from '../../config/index.js';
 import { logDebug, logError } from '../../services/logger.js';
 import { createToolErrorResponse, handleToolError, } from '../../utils/tool-error-handler.js';
-import { transformHtmlToMarkdown } from '../utils/content-transform.js';
+import { transformHtmlToMarkdownAsync } from '../utils/content-transform-async.js';
 import { applyInlineResultToStructuredContent, buildToolContentBlocks, getFileDownloadInfo, getInlineErrorResponse, performSharedFetch, } from './fetch-single.shared.js';
 export const FETCH_MARKDOWN_TOOL_NAME = 'fetch-markdown';
 export const FETCH_MARKDOWN_TOOL_DESCRIPTION = 'Fetches a webpage and converts it to clean Markdown format with optional frontmatter and content length limits';
@@ -39,7 +39,15 @@ function resolveMarkdownOptions(input) {
     return {
         extractMainContent: input.extractMainContent ?? config.extraction.extractMainContent,
         includeMetadata: input.includeMetadata ?? config.extraction.includeMetadata,
-        maxContentLength: input.maxContentLength,
+        ...(input.maxContentLength !== undefined && {
+            maxContentLength: input.maxContentLength,
+        }),
+    };
+}
+function buildFetchMarkdownErrorDetails() {
+    return {
+        fetchedAt: new Date().toISOString(),
+        cached: false,
     };
 }
 function buildMarkdownStructuredContent(pipeline, inlineResult, fileDownload) {
@@ -62,25 +70,30 @@ function buildMarkdownStructuredContent(pipeline, inlineResult, fileDownload) {
 function logFetchMarkdownStart(url, options) {
     logDebug('Fetching markdown', { url, ...options });
 }
-function buildMarkdownTransform(options) {
-    return (html, url) => {
-        const markdownResult = transformHtmlToMarkdown(html, url, options);
+function buildMarkdownTransform(options, transform) {
+    return async (html, url) => {
+        const markdownResult = await transform(html, url, options);
         return { ...markdownResult, content: markdownResult.markdown };
     };
 }
-async function fetchMarkdownPipeline(url, input, options, transformOptions) {
-    return performSharedFetch({
+async function fetchMarkdownPipeline(url, input, options, transformOptions, performSharedFetchImpl, transformImpl) {
+    const sharedOptions = {
         url,
         format: 'markdown',
         extractMainContent: options.extractMainContent,
         includeMetadata: options.includeMetadata,
-        maxContentLength: options.maxContentLength,
-        customHeaders: input.customHeaders,
-        retries: input.retries,
-        timeout: input.timeout,
-        transform: buildMarkdownTransform(transformOptions),
+        ...(options.maxContentLength !== undefined && {
+            maxContentLength: options.maxContentLength,
+        }),
+        ...(input.customHeaders !== undefined && {
+            customHeaders: input.customHeaders,
+        }),
+        ...(input.retries !== undefined && { retries: input.retries }),
+        ...(input.timeout !== undefined && { timeout: input.timeout }),
+        transform: buildMarkdownTransform(transformOptions, transformImpl),
         deserialize: deserializeMarkdownPipelineResult,
-    });
+    };
+    return performSharedFetchImpl(sharedOptions);
 }
 function buildMarkdownResponse(pipeline, inlineResult, fileDownload) {
     const structuredContent = buildMarkdownStructuredContent(pipeline, inlineResult, fileDownload);
@@ -89,33 +102,48 @@ function buildMarkdownResponse(pipeline, inlineResult, fileDownload) {
         structuredContent,
     };
 }
-export async function fetchMarkdownToolHandler(input) {
-    try {
-        return await executeFetchMarkdown(input);
-    }
-    catch (error) {
-        logError('fetch-markdown tool error', error instanceof Error ? error : undefined);
-        return handleToolError(error, input.url, 'Failed to fetch markdown');
-    }
+export function createFetchMarkdownToolHandler(deps = {}) {
+    const performSharedFetchImpl = deps.performSharedFetch ?? performSharedFetch;
+    const transformImpl = deps.transformHtmlToMarkdown ?? transformHtmlToMarkdownAsync;
+    return async (input) => {
+        try {
+            return await executeFetchMarkdown(input, performSharedFetchImpl, transformImpl);
+        }
+        catch (error) {
+            logError('fetch-markdown tool error', error instanceof Error ? error : undefined);
+            const errorDetails = buildFetchMarkdownErrorDetails();
+            return handleToolError(error, input.url, 'Failed to fetch markdown', errorDetails);
+        }
+    };
 }
-async function executeFetchMarkdown(input) {
+export const fetchMarkdownToolHandler = createFetchMarkdownToolHandler();
+async function executeFetchMarkdown(input, performSharedFetchImpl, transformImpl) {
     const { url } = input;
     if (!url) {
-        return createToolErrorResponse('URL is required', '', 'VALIDATION_ERROR');
+        return createToolErrorResponse('URL is required', '', 'VALIDATION_ERROR', buildFetchMarkdownErrorDetails());
     }
     const options = resolveMarkdownOptions(input);
     const transformOptions = { ...options };
     logFetchMarkdownStart(url, transformOptions);
-    const { pipeline, inlineResult } = await fetchMarkdownPipeline(url, input, options, transformOptions);
-    const inlineError = getInlineErrorResponse(inlineResult, url);
+    const { pipeline, inlineResult } = await fetchMarkdownPipeline(url, input, options, transformOptions, performSharedFetchImpl, transformImpl);
+    const inlineError = getInlineErrorResponse(inlineResult, url, buildFetchMarkdownErrorDetails());
     if (inlineError)
         return inlineError;
-    const fileDownload = inlineResult.resourceUri
-        ? getFileDownloadInfo({
+    let fileDownload = null;
+    if (inlineResult.resourceUri) {
+        const downloadContext = {
             cacheKey: pipeline.cacheKey ?? null,
             url: pipeline.url,
-            title: pipeline.data.title,
-        })
-        : null;
+        };
+        if (pipeline.data.title !== undefined) {
+            fileDownload = getFileDownloadInfo({
+                ...downloadContext,
+                title: pipeline.data.title,
+            });
+        }
+        else {
+            fileDownload = getFileDownloadInfo(downloadContext);
+        }
+    }
     return buildMarkdownResponse(pipeline, inlineResult, fileDownload);
 }

package/dist/tools/handlers/fetch-single.shared.d.ts

@@ -1,5 +1,6 @@
 import type { PipelineResult, ToolContentBlock } from '../../config/types/runtime.js';
 import type { FileDownloadInfo, ToolResponseBase } from '../../config/types/tools.js';
+import { executeFetchPipeline } from '../utils/fetch-pipeline.js';
 import { applyInlineContentLimit } from '../utils/inline-content.js';
 type SharedFetchFormat = 'jsonl' | 'markdown';
 interface SharedFetchOptions<T extends {
@@ -10,17 +11,21 @@ interface SharedFetchOptions<T extends {
     readonly extractMainContent: boolean;
     readonly includeMetadata: boolean;
     readonly maxContentLength?: number;
+    readonly includeContentBlocks?: boolean;
     readonly cacheVariant?: string;
     readonly customHeaders?: Record<string, string>;
     readonly retries?: number;
     readonly timeout?: number;
-    readonly transform: (html: string, normalizedUrl: string) => T;
+    readonly transform: (html: string, normalizedUrl: string) => T | Promise<T>;
     readonly serialize?: (result: T) => string;
     readonly deserialize?: (cached: string) => T | undefined;
 }
+interface SharedFetchDeps {
+    readonly executeFetchPipeline?: typeof executeFetchPipeline;
+}
 export declare function performSharedFetch<T extends {
     content: string;
-}>(options: SharedFetchOptions<T>): Promise<{
+}>(options: SharedFetchOptions<T>, deps?: SharedFetchDeps): Promise<{
     pipeline: PipelineResult<T>;
     inlineResult: ReturnType<typeof applyInlineContentLimit>;
 }>;
@@ -31,7 +36,7 @@ interface DownloadContext {
     title?: string;
 }
 export declare function getFileDownloadInfo(context: DownloadContext): FileDownloadInfo | null;
-export declare function getInlineErrorResponse(inlineResult: InlineResult, url: string): ToolResponseBase | null;
+export declare function getInlineErrorResponse(inlineResult: InlineResult, url: string, details?: Record<string, unknown>): ToolResponseBase | null;
 export declare function applyInlineResultToStructuredContent(structuredContent: Record<string, unknown>, inlineResult: InlineResult, contentKey: string): void;
 export declare function buildToolContentBlocks(structuredContent: Record<string, unknown>, fromCache: boolean, inlineResult: InlineResult, resourceName: string, cacheKey?: string | null, fullContent?: string, format?: SharedFetchFormat, url?: string, title?: string): ToolContentBlock[];
 export {};

package/dist/tools/handlers/fetch-single.shared.js

@@ -5,7 +5,8 @@ import { createToolErrorResponse } from '../../utils/tool-error-handler.js';
 import { appendHeaderVary } from '../utils/cache-vary.js';
 import { executeFetchPipeline } from '../utils/fetch-pipeline.js';
 import { applyInlineContentLimit } from '../utils/inline-content.js';
-export async function performSharedFetch(options) {
+export async function performSharedFetch(options, deps = {}) {
+    const executePipeline = deps.executeFetchPipeline ?? executeFetchPipeline;
     const cacheNamespace = options.format === 'markdown' ? 'markdown' : 'url';
     const cacheVary = appendHeaderVary({
         format: options.format,
@@ -13,33 +14,54 @@ export async function performSharedFetch(options) {
         includeMetadata: options.includeMetadata,
         maxContentLength: options.maxContentLength,
         ...(options.cacheVariant ? { variant: options.cacheVariant } : {}),
-        ...(options.format === 'markdown' ? {} : { contentBlocks: true }),
+        ...(options.format === 'markdown'
+            ? { includeContentBlocks: options.includeContentBlocks }
+            : { contentBlocks: true }),
     }, options.customHeaders);
-    const pipeline = await executeFetchPipeline({
+    const pipelineOptions = {
         url: options.url,
         cacheNamespace,
-        customHeaders: options.customHeaders,
-        retries: options.retries,
-        timeout: options.timeout,
-        cacheVary,
         transform: options.transform,
-        serialize: options.serialize,
-        deserialize: options.deserialize,
-    });
+    };
+    if (options.customHeaders !== undefined) {
+        pipelineOptions.customHeaders = options.customHeaders;
+    }
+    if (options.retries !== undefined) {
+        pipelineOptions.retries = options.retries;
+    }
+    if (options.timeout !== undefined) {
+        pipelineOptions.timeout = options.timeout;
+    }
+    if (cacheVary !== undefined) {
+        pipelineOptions.cacheVary = cacheVary;
+    }
+    if (options.serialize !== undefined) {
+        pipelineOptions.serialize = options.serialize;
+    }
+    if (options.deserialize !== undefined) {
+        pipelineOptions.deserialize = options.deserialize;
+    }
+    const pipeline = await executePipeline(pipelineOptions);
     const inlineResult = applyInlineContentLimit(pipeline.data.content, pipeline.cacheKey ?? null, options.format);
     return { pipeline, inlineResult };
 }
 export function getFileDownloadInfo(context) {
-    return buildFileDownloadInfo({
+    const infoOptions = {
         cacheKey: context.cacheKey,
         url: context.url,
-        title: context.title,
-    });
+    };
+    if (context.title !== undefined) {
+        return buildFileDownloadInfo({
+            ...infoOptions,
+            title: context.title,
+        });
+    }
+    return buildFileDownloadInfo(infoOptions);
 }
-export function getInlineErrorResponse(inlineResult, url) {
+export function getInlineErrorResponse(inlineResult, url, details) {
     if (!inlineResult.error)
         return null;
-    return createToolErrorResponse(inlineResult.error, url, 'INTERNAL_ERROR');
+    return createToolErrorResponse(inlineResult.error, url, 'INTERNAL_ERROR', details);
 }
 export function applyInlineResultToStructuredContent(structuredContent, inlineResult, contentKey) {
     if (inlineResult.truncated) {
@@ -60,13 +82,16 @@ function buildResourceLink(inlineResult, name) {
     if (!inlineResult.resourceUri) {
         return null;
     }
-    return {
+    const block = {
         type: 'resource_link',
         uri: inlineResult.resourceUri,
         name,
-        mimeType: inlineResult.resourceMimeType,
         description: `Content exceeds inline limit (${config.constants.maxInlineContentChars} chars)`,
     };
+    if (inlineResult.resourceMimeType !== undefined) {
+        block.mimeType = inlineResult.resourceMimeType;
+    }
+    return block;
 }
 function buildEmbeddedResource(content, mimeType, url, title) {
     if (!content) {

package/dist/tools/handlers/fetch-url.tool.js

@@ -1,7 +1,7 @@
 import { config } from '../../config/index.js';
 import { logDebug, logError } from '../../services/logger.js';
 import { createToolErrorResponse, handleToolError, } from '../../utils/tool-error-handler.js';
-import { transformHtmlToJsonl, transformHtmlToMarkdownWithBlocks, } from '../utils/content-transform.js';
+import { transformHtmlToJsonlAsync, transformHtmlToMarkdownWithBlocksAsync, } from '../utils/content-transform-async.js';
 import { applyInlineResultToStructuredContent, buildToolContentBlocks, getInlineErrorResponse, performSharedFetch, } from './fetch-single.shared.js';
 export const FETCH_URL_TOOL_NAME = 'fetch-url';
 export const FETCH_URL_TOOL_DESCRIPTION = 'Fetches a webpage and converts it to AI-readable JSONL format with semantic content blocks. Supports custom headers, retries, and content length limits.';
@@ -37,17 +37,36 @@ function deserializeJsonlTransformResult(cached) {
     }
 }
 function resolveFetchUrlOptions(input) {
+    const format = input.format ?? 'jsonl';
     return {
         extractMainContent: input.extractMainContent ?? config.extraction.extractMainContent,
         includeMetadata: input.includeMetadata ?? config.extraction.includeMetadata,
-        maxContentLength: input.maxContentLength,
-        format: input.format ?? 'jsonl',
+        format,
+        includeContentBlocks: input.includeContentBlocks ?? (format === 'markdown' ? false : true),
+        ...(input.maxContentLength !== undefined && {
+            maxContentLength: input.maxContentLength,
+        }),
+    };
+}
+function buildFetchUrlErrorDetails(format) {
+    return {
+        contentBlocks: 0,
+        fetchedAt: new Date().toISOString(),
+        format,
+        cached: false,
     };
 }
 function buildFetchUrlTransform(options) {
-    return (html, url) => options.format === 'markdown'
-        ? transformHtmlToMarkdownWithBlocks(html, url, options)
-        : transformHtmlToJsonl(html, url, options);
+    return async (html, url) => options.format === 'markdown'
+        ? transformHtmlToMarkdownWithBlocksAsync(html, url, {
+            extractMainContent: options.extractMainContent,
+            includeMetadata: options.includeMetadata,
+            ...(options.maxContentLength !== undefined && {
+                maxContentLength: options.maxContentLength,
+            }),
+            includeContentBlocks: options.includeContentBlocks,
+        })
+        : transformHtmlToJsonlAsync(html, url, options);
 }
 function buildFetchUrlStructuredContent(format, pipeline, inlineResult) {
     const structuredContent = {
@@ -74,22 +93,31 @@ function logFetchUrlStart(url, options) {
         extractMainContent: options.extractMainContent,
         includeMetadata: options.includeMetadata,
         format: options.format,
+        includeContentBlocks: options.includeContentBlocks,
     });
 }
 async function fetchUrlPipeline(url, input, options) {
-    return performSharedFetch({
+    const sharedOptions = {
         url,
         format: options.format,
         extractMainContent: options.extractMainContent,
         includeMetadata: options.includeMetadata,
-        maxContentLength: options.maxContentLength,
-        customHeaders: input.customHeaders,
-        retries: input.retries,
-        timeout: input.timeout,
-        cacheVariant: options.format === 'markdown' ? 'markdown-with-blocks' : undefined,
+        includeContentBlocks: options.includeContentBlocks,
+        ...(options.maxContentLength !== undefined && {
+            maxContentLength: options.maxContentLength,
+        }),
+        ...(input.customHeaders !== undefined && {
+            customHeaders: input.customHeaders,
+        }),
+        ...(input.retries !== undefined && { retries: input.retries }),
+        ...(input.timeout !== undefined && { timeout: input.timeout }),
+        ...(options.format === 'markdown' && {
+            cacheVariant: 'markdown-with-blocks',
+        }),
         transform: buildFetchUrlTransform(options),
         deserialize: deserializeJsonlTransformResult,
-    });
+    };
+    return performSharedFetch(sharedOptions);
 }
 function buildFetchUrlResponse(pipeline, inlineResult, format) {
     const structuredContent = buildFetchUrlStructuredContent(format, pipeline, inlineResult);
@@ -104,18 +132,20 @@ export async function fetchUrlToolHandler(input) {
     }
     catch (error) {
         logError('fetch-url tool error', error instanceof Error ? error : undefined);
-        return handleToolError(error, input.url, 'Failed to fetch URL');
+        const errorDetails = buildFetchUrlErrorDetails(input.format ?? 'jsonl');
+        return handleToolError(error, input.url, 'Failed to fetch URL', errorDetails);
     }
 }
 async function executeFetchUrl(input) {
     const { url } = input;
+    const format = input.format ?? 'jsonl';
     if (!url) {
-        return createToolErrorResponse('URL is required', '', 'VALIDATION_ERROR');
+        return createToolErrorResponse('URL is required', '', 'VALIDATION_ERROR', buildFetchUrlErrorDetails(format));
     }
     const options = resolveFetchUrlOptions(input);
     logFetchUrlStart(url, options);
     const { pipeline, inlineResult } = await fetchUrlPipeline(url, input, options);
-    const inlineError = getInlineErrorResponse(inlineResult, url);
+    const inlineError = getInlineErrorResponse(inlineResult, url, buildFetchUrlErrorDetails(options.format));
     if (inlineError)
         return inlineError;
     return buildFetchUrlResponse(pipeline, inlineResult, options.format);

package/dist/tools/index.js

@@ -9,6 +9,12 @@ const TOOL_DEFINITIONS = [
         inputSchema: fetchUrlInputSchema,
         outputSchema: fetchUrlOutputSchema,
         handler: fetchUrlToolHandler,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
     },
     {
         name: FETCH_MARKDOWN_TOOL_NAME,
@@ -17,6 +23,12 @@ const TOOL_DEFINITIONS = [
         inputSchema: fetchMarkdownInputSchema,
         outputSchema: fetchMarkdownOutputSchema,
         handler: fetchMarkdownToolHandler,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
     },
 ];
 export function registerTools(server) {
@@ -26,6 +38,7 @@ export function registerTools(server) {
             description: tool.description,
             inputSchema: tool.inputSchema,
             outputSchema: tool.outputSchema,
+            annotations: tool.annotations,
         }, tool.handler);
     }
 }