@anyshift/mcp-proxy 0.2.0 → 0.2.1

package/dist/__tests__/helpers/testUtils.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Test utilities and helpers for MCP Proxy tests
+ */
+/**
+ * Create an MCP response with specified character count
+ * @param charCount - Number of characters in the response
+ * @param jsonData - Optional JSON data to include (overrides charCount)
+ * @returns MCP-formatted response
+ */
+export declare function createMCPResponse(charCount: number, jsonData?: object): {
+    content: {
+        type: string;
+        text: string;
+    }[];
+};
+/**
+ * Create an MCP response with specific JSON data
+ */
+export declare function createMCPResponseWithJSON(jsonData: object): {
+    content: {
+        type: string;
+        text: string;
+    }[];
+};
+/**
+ * Create an error response
+ */
+export declare function createErrorResponse(errorMessage: string): {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+};
+/**
+ * Extract file path from file reference response
+ */
+export declare function extractFilePath(result: any): string;
+/**
+ * Extract reported file size from file reference
+ */
+export declare function extractReportedSize(result: any): number;
+/**
+ * Check if response is a file reference
+ */
+export declare function isFileReference(result: any): boolean;
+/**
+ * Check if response is truncated
+ */
+export declare function isTruncated(result: any): boolean;
+/**
+ * Create a mock file system for testing
+ */
+export declare class MockFileSystem {
+    private files;
+    writeFile(path: string, content: string): Promise<void>;
+    readFile(path: string): Promise<string>;
+    existsSync(path: string): boolean;
+    clear(): void;
+    getFiles(): string[];
+}
+/**
+ * Test fixtures for common scenarios
+ */
+export declare const fixtures: {
+    smallResponse: {
+        content: {
+            type: string;
+            text: string;
+        }[];
+    };
+    mediumResponse: {
+        content: {
+            type: string;
+            text: string;
+        }[];
+    };
+    largeResponse: {
+        content: {
+            type: string;
+            text: string;
+        }[];
+    };
+    atThreshold: {
+        content: {
+            type: string;
+            text: string;
+        }[];
+    };
+    justBelowThreshold: {
+        content: {
+            type: string;
+            text: string;
+        }[];
+    };
+    atTruncationLimit: {
+        content: {
+            type: string;
+            text: string;
+        }[];
+    };
+    overTruncationLimit: {
+        content: {
+            type: string;
+            text: string;
+        }[];
+    };
+    errorResponse: {
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError: boolean;
+    };
+    jsonResponse: {
+        content: {
+            type: string;
+            text: string;
+        }[];
+    };
+    withPagination: {
+        content: {
+            type: string;
+            text: string;
+        }[];
+    };
+};

package/dist/__tests__/helpers/testUtils.js

@@ -0,0 +1,122 @@
+/**
+ * Test utilities and helpers for MCP Proxy tests
+ */
+/**
+ * Create an MCP response with specified character count
+ * @param charCount - Number of characters in the response
+ * @param jsonData - Optional JSON data to include (overrides charCount)
+ * @returns MCP-formatted response
+ */
+export function createMCPResponse(charCount, jsonData) {
+    const content = jsonData
+        ? JSON.stringify(jsonData)
+        : 'x'.repeat(Math.max(0, charCount - 50)) + JSON.stringify({ padding: true });
+    return {
+        content: [{ type: 'text', text: content }]
+    };
+}
+/**
+ * Create an MCP response with specific JSON data
+ */
+export function createMCPResponseWithJSON(jsonData) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(jsonData) }]
+    };
+}
+/**
+ * Create an error response
+ */
+export function createErrorResponse(errorMessage) {
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({ status: 'error', message: errorMessage })
+            }],
+        isError: true
+    };
+}
+/**
+ * Extract file path from file reference response
+ */
+export function extractFilePath(result) {
+    const text = result.content[0].text;
+    const match = text.match(/📄 File: (.+)/);
+    if (!match) {
+        throw new Error('No file path found in response');
+    }
+    return match[1].split('\n')[0].trim();
+}
+/**
+ * Extract reported file size from file reference
+ */
+export function extractReportedSize(result) {
+    const text = result.content[0].text;
+    const match = text.match(/Size: (\d+) characters/);
+    if (!match) {
+        throw new Error('No size information found in response');
+    }
+    return parseInt(match[1], 10);
+}
+/**
+ * Check if response is a file reference
+ */
+export function isFileReference(result) {
+    return result.content &&
+        result.content[0] &&
+        result.content[0].text &&
+        result.content[0].text.includes('📄 File:');
+}
+/**
+ * Check if response is truncated
+ */
+export function isTruncated(result) {
+    return result.content &&
+        result.content[0] &&
+        result.content[0].text &&
+        result.content[0].text.includes('=== RESPONSE TRUNCATED ===');
+}
+/**
+ * Create a mock file system for testing
+ */
+export class MockFileSystem {
+    files = new Map();
+    async writeFile(path, content) {
+        this.files.set(path, content);
+    }
+    async readFile(path) {
+        const content = this.files.get(path);
+        if (content === undefined) {
+            throw new Error(`File not found: ${path}`);
+        }
+        return content;
+    }
+    existsSync(path) {
+        return this.files.has(path);
+    }
+    clear() {
+        this.files.clear();
+    }
+    getFiles() {
+        return Array.from(this.files.keys());
+    }
+}
+/**
+ * Test fixtures for common scenarios
+ */
+export const fixtures = {
+    smallResponse: createMCPResponse(500),
+    mediumResponse: createMCPResponse(5000),
+    largeResponse: createMCPResponse(100000),
+    atThreshold: createMCPResponse(1000),
+    justBelowThreshold: createMCPResponse(999),
+    atTruncationLimit: createMCPResponse(40000),
+    overTruncationLimit: createMCPResponse(50000),
+    errorResponse: createErrorResponse('Test error'),
+    jsonResponse: createMCPResponseWithJSON({ data: { nested: 'value' } }),
+    withPagination: createMCPResponseWithJSON({
+        data: [{ item: 1 }, { item: 2 }],
+        pagination: { page: 1, total: 10 },
+        has_more: true,
+        next_page: '/api/page/2'
+    })
+};

package/dist/__tests__/unit/truncation.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for truncation module
+ * Tests token estimation and truncation logic
+ */
+export {};

package/dist/__tests__/unit/truncation.test.js

@@ -0,0 +1,204 @@
+/**
+ * Unit tests for truncation module
+ * Tests token estimation and truncation logic
+ */
+import { describe, test, expect } from '@jest/globals';
+import { estimateTokens, wouldBeTruncated, truncateResponseIfNeeded } from '../../truncation/truncate.js';
+describe('Truncation - Token Estimation', () => {
+    test('estimateTokens with default ratio (4 chars/token)', () => {
+        expect(estimateTokens('x'.repeat(100))).toBe(25); // 100/4 = 25
+        expect(estimateTokens('x'.repeat(1000))).toBe(250); // 1000/4 = 250
+        expect(estimateTokens('x'.repeat(40000))).toBe(10000); // 40000/4 = 10000
+    });
+    test('estimateTokens with custom ratio', () => {
+        expect(estimateTokens('x'.repeat(100), 3)).toBe(34); // 100/3 = 33.33 -> 34 (ceil)
+        expect(estimateTokens('x'.repeat(100), 5)).toBe(20); // 100/5 = 20
+    });
+    test('estimateTokens handles empty string', () => {
+        expect(estimateTokens('')).toBe(0);
+    });
+    test('estimateTokens rounds up (ceiling)', () => {
+        expect(estimateTokens('xxx', 4)).toBe(1); // 3/4 = 0.75 -> 1
+        expect(estimateTokens('xxxxx', 4)).toBe(2); // 5/4 = 1.25 -> 2
+    });
+});
+describe('Truncation - Would Be Truncated Check', () => {
+    test('returns false when content is under limit', () => {
+        const content = 'x'.repeat(30000); // 7500 tokens
+        expect(wouldBeTruncated(content, 10000, 4)).toBe(false);
+    });
+    test('returns true when content exceeds limit', () => {
+        const content = 'x'.repeat(50000); // 12500 tokens
+        expect(wouldBeTruncated(content, 10000, 4)).toBe(true);
+    });
+    test('returns false when exactly at limit', () => {
+        const content = 'x'.repeat(40000); // exactly 10000 tokens
+        expect(wouldBeTruncated(content, 10000, 4)).toBe(false);
+    });
+    test('returns true when 1 char over limit', () => {
+        const content = 'x'.repeat(40001); // 10000.25 -> 10001 tokens
+        expect(wouldBeTruncated(content, 10000, 4)).toBe(true);
+    });
+});
+describe('Truncation - Truncate Response If Needed', () => {
+    let config;
+    beforeEach(() => {
+        config = {
+            maxTokens: 10000,
+            charsPerToken: 4,
+            enableLogging: false,
+            messagePrefix: 'RESPONSE TRUNCATED'
+        };
+    });
+    test('Does not truncate when under limit', () => {
+        const content = 'x'.repeat(30000); // 7500 tokens
+        const result = truncateResponseIfNeeded(config, content);
+        expect(result).toBe(content);
+        expect(result).not.toContain('=== RESPONSE TRUNCATED ===');
+        expect(result.length).toBe(30000);
+    });
+    test('Truncates when over limit', () => {
+        const content = 'x'.repeat(100000); // 25000 tokens
+        const result = truncateResponseIfNeeded(config, content);
+        expect(result).toContain('=== RESPONSE TRUNCATED ===');
+        expect(result).toContain('Estimated tokens: 25000 (limit: 10000)');
+        expect(result).toContain('Please refine your query');
+        expect(result).toContain('=== END TRUNCATION NOTICE ===');
+    });
+    test('Truncated content is under maxChars', () => {
+        const content = 'x'.repeat(100000); // 25000 tokens
+        const result = truncateResponseIfNeeded(config, content);
+        // Result should be truncation notice + 40000 chars of content
+        const maxChars = config.maxTokens * (config.charsPerToken || 4);
+        expect(result.length).toBeLessThan(maxChars + 500); // +500 for notice
+    });
+    test('Exactly at limit: no truncation', () => {
+        const content = 'x'.repeat(40000); // exactly 10000 tokens
+        const result = truncateResponseIfNeeded(config, content);
+        expect(result).toBe(content);
+        expect(result).not.toContain('=== RESPONSE TRUNCATED ===');
+    });
+    test('One char over limit: truncates', () => {
+        const content = 'x'.repeat(40001); // 10000.25 tokens
+        const result = truncateResponseIfNeeded(config, content);
+        expect(result).toContain('=== RESPONSE TRUNCATED ===');
+    });
+    test('Custom message prefix', () => {
+        config.messagePrefix = 'CUSTOM TRUNCATION MESSAGE';
+        const content = 'x'.repeat(100000);
+        const result = truncateResponseIfNeeded(config, content);
+        expect(result).toContain('=== CUSTOM TRUNCATION MESSAGE ===');
+    });
+    test('Custom charsPerToken ratio', () => {
+        config.charsPerToken = 3; // Tighter ratio
+        const content = 'x'.repeat(35000); // 11666 tokens with ratio of 3
+        const result = truncateResponseIfNeeded(config, content);
+        // Should truncate (11666 > 10000)
+        expect(result).toContain('=== RESPONSE TRUNCATED ===');
+        expect(result).toContain('limit: 10000');
+        // Truncated to 30000 chars (10000 * 3)
+        const truncatedContent = result.split('=== END TRUNCATION NOTICE ===')[1];
+        expect(truncatedContent.trim().length).toBeLessThanOrEqual(30000);
+    });
+    test('Truncation preserves original content up to limit', () => {
+        const content = 'ABCD'.repeat(25000); // 100000 chars, 25000 tokens
+        const result = truncateResponseIfNeeded(config, content);
+        // After truncation notice, should have first 40000 chars
+        const truncatedContent = result.split('=== END TRUNCATION NOTICE ===\n\n')[1];
+        expect(truncatedContent).toBe('ABCD'.repeat(10000)); // 40000 chars
+    });
+    test('Small content is not affected', () => {
+        const content = 'Hello, world!';
+        const result = truncateResponseIfNeeded(config, content);
+        expect(result).toBe(content);
+    });
+    test('Empty content is not affected', () => {
+        const content = '';
+        const result = truncateResponseIfNeeded(config, content);
+        expect(result).toBe('');
+    });
+});
+describe('Truncation - Edge Cases', () => {
+    let config;
+    beforeEach(() => {
+        config = {
+            maxTokens: 10000,
+            charsPerToken: 4,
+            enableLogging: false,
+            messagePrefix: 'RESPONSE TRUNCATED'
+        };
+    });
+    test('Handles very large content', () => {
+        const content = 'x'.repeat(1000000); // 1 million chars
+        const result = truncateResponseIfNeeded(config, content);
+        expect(result).toContain('=== RESPONSE TRUNCATED ===');
+        expect(result).toContain('Estimated tokens: 250000');
+        expect(result.length).toBeLessThan(50000); // Truncated + notice
+    });
+    test('Handles special characters', () => {
+        const content = '🚀'.repeat(25000); // Emoji might be 2 chars each in JS
+        const result = truncateResponseIfNeeded(config, content);
+        // Should still apply truncation logic based on string length
+        expect(result).toContain('=== RESPONSE TRUNCATED ===');
+    });
+    test('Handles newlines and whitespace', () => {
+        const content = 'line\n'.repeat(20000); // 100000 chars with newlines
+        const result = truncateResponseIfNeeded(config, content);
+        expect(result).toContain('=== RESPONSE TRUNCATED ===');
+    });
+    test('Truncation notice format is consistent', () => {
+        const content = 'x'.repeat(100000);
+        const result = truncateResponseIfNeeded(config, content);
+        // Verify notice structure
+        expect(result).toMatch(/=== RESPONSE TRUNCATED ===/);
+        expect(result).toMatch(/Estimated tokens: \d+ \(limit: \d+\)/);
+        expect(result).toMatch(/Response truncated to prevent context overflow\./);
+        expect(result).toMatch(/=== END TRUNCATION NOTICE ===/);
+        // Notice should be at the beginning
+        expect(result.indexOf('=== RESPONSE TRUNCATED ===')).toBe(0);
+    });
+});
+describe('Truncation - Different Token Limits', () => {
+    test('5000 token limit', () => {
+        const config = {
+            maxTokens: 5000,
+            charsPerToken: 4,
+            enableLogging: false
+        };
+        const content = 'x'.repeat(30000); // 7500 tokens
+        const result = truncateResponseIfNeeded(config, content);
+        expect(result).toContain('=== RESPONSE TRUNCATED ===');
+        expect(result).toContain('limit: 5000');
+        // Should truncate to 20000 chars (5000 * 4)
+        const truncatedContent = result.split('=== END TRUNCATION NOTICE ===\n\n')[1];
+        expect(truncatedContent.length).toBe(20000);
+    });
+    test('20000 token limit', () => {
+        const config = {
+            maxTokens: 20000,
+            charsPerToken: 4,
+            enableLogging: false
+        };
+        const content = 'x'.repeat(100000); // 25000 tokens
+        const result = truncateResponseIfNeeded(config, content);
+        expect(result).toContain('=== RESPONSE TRUNCATED ===');
+        expect(result).toContain('limit: 20000');
+        // Should truncate to 80000 chars (20000 * 4)
+        const truncatedContent = result.split('=== END TRUNCATION NOTICE ===\n\n')[1];
+        expect(truncatedContent.length).toBe(80000);
+    });
+    test('Very low token limit (100)', () => {
+        const config = {
+            maxTokens: 100,
+            charsPerToken: 4,
+            enableLogging: false
+        };
+        const content = 'x'.repeat(1000); // 250 tokens
+        const result = truncateResponseIfNeeded(config, content);
+        expect(result).toContain('=== RESPONSE TRUNCATED ===');
+        expect(result).toContain('limit: 100');
+        // Should truncate to 400 chars (100 * 4)
+        const truncatedContent = result.split('=== END TRUNCATION NOTICE ===\n\n')[1];
+        expect(truncatedContent.length).toBe(400);
+    });
+});

package/dist/fileWriter/writer.js

@@ -104,6 +104,53 @@ const extractRawText = (response) => {
     }
     return null;
 };
+/**
+ * Extract the exact content that will be written to file
+ * This is used for both character counting AND file writing to ensure consistency
+ * @returns Object with contentToWrite and parsedForSchema (if applicable)
+ */
+const extractContentForFile = (responseData) => {
+    const rawText = extractRawText(responseData);
+    let contentToWrite;
+    let parsedForSchema = null;
+    if (rawText) {
+        try {
+            // Try to parse the raw text as JSON for prettier formatting
+            let jsonText = rawText;
+            // Extract JSON from common response patterns
+            const jsonMatch = rawText.match(/:\s*(\{.*\}|\[.*\])$/s);
+            if (jsonMatch) {
+                jsonText = jsonMatch[1];
+            }
+            const parsed = JSON.parse(jsonText);
+            parsedForSchema = parsed;
+            // Remove pagination-related fields before writing
+            const { pagination, has_more, next_page, previous_page, page, page_size, total_pages, ...cleanData } = parsed;
+            contentToWrite = JSON.stringify(cleanData, null, 2);
+        }
+        catch {
+            // If parsing fails, write the raw text directly
+            contentToWrite = rawText;
+        }
+    }
+    else {
+        // Fallback: extract from display content or stringify the entire response
+        if (responseData &&
+            typeof responseData === 'object' &&
+            'content' in responseData &&
+            Array.isArray(responseData.content)) {
+            const textContent = responseData.content
+                .filter((item) => item.type === 'text')
+                .map((item) => item.text)
+                .join('\n');
+            contentToWrite = textContent;
+        }
+        else {
+            contentToWrite = JSON.stringify(responseData, null, 2);
+        }
+    }
+    return { contentToWrite, parsedForSchema };
+};
 /**
  * Centralized response handler with file writing capability
  * @param config - File writer configuration
@@ -134,26 +181,11 @@ export async function handleToolResponse(config, toolName, args, responseData) {
     if (!config.enabled || !config.outputPath) {
         return responseData;
     }
+    // Extract the content that will be written to file
+    // This ensures we count the EXACT same content that will be written
+    const { contentToWrite, parsedForSchema } = extractContentForFile(responseData);
     // Check character count threshold - if response is too short, return directly
-    const rawText = extractRawText(responseData);
-    let contentLength = 0;
-    if (rawText) {
-        contentLength = rawText.length;
-    }
-    else if (responseData &&
-        typeof responseData === 'object' &&
-        'content' in responseData &&
-        Array.isArray(responseData.content)) {
-        const textContent = responseData.content
-            .filter((item) => item.type === 'text')
-            .map((item) => item.text)
-            .join('\n');
-        contentLength = textContent.length;
-    }
-    else {
-        contentLength = JSON.stringify(responseData).length;
-    }
-    // If content is shorter than threshold, return response directly instead of writing to file
+    const contentLength = contentToWrite.length;
     const minChars = config.minCharsForWrite ?? DEFAULT_MIN_CHARS;
     if (contentLength < minChars) {
         return responseData;
@@ -165,45 +197,7 @@ export async function handleToolResponse(config, toolName, args, responseData) {
         const filepath = path.join(config.outputPath, filename);
         // Ensure output directory exists
         await fs.mkdir(config.outputPath, { recursive: true });
-        // Extract the actual data from MCP response format
-        let contentToWrite;
-        let parsedForSchema;
-        if (rawText) {
-            try {
-                // Try to parse the raw text as JSON for prettier formatting
-                let jsonText = rawText;
-                // Extract JSON from common response patterns
-                const jsonMatch = rawText.match(/:\s*(\{.*\}|\[.*\])$/s);
-                if (jsonMatch) {
-                    jsonText = jsonMatch[1];
-                }
-                const parsed = JSON.parse(jsonText);
-                parsedForSchema = parsed;
-                // Remove pagination-related fields before writing
-                const { pagination, has_more, next_page, previous_page, page, page_size, total_pages, ...cleanData } = parsed;
-                contentToWrite = JSON.stringify(cleanData, null, 2);
-            }
-            catch {
-                // If parsing fails, write the raw text directly
-                contentToWrite = rawText;
-            }
-        }
-        else {
-            // Fallback: extract from display content or stringify the entire response
-            if (responseData &&
-                typeof responseData === 'object' &&
-                'content' in responseData &&
-                Array.isArray(responseData.content)) {
-                const textContent = responseData.content
-                    .filter((item) => item.type === 'text')
-                    .map((item) => item.text)
-                    .join('\n');
-                contentToWrite = textContent;
-            }
-            else {
-                contentToWrite = JSON.stringify(responseData, null, 2);
-            }
-        }
+        // Write the exact content we counted
         await fs.writeFile(filepath, contentToWrite);
         // Try to generate schema if we have valid JSON
         let schemaInfo = '';

package/dist/index.js

@@ -263,56 +263,71 @@ async function main() {
             console.error(`[mcp-proxy] Tool call: ${toolName}`);
         }
         try {
+            let result;
             // Handle JQ tool locally (if enabled)
             if (toolName === 'execute_jq_query' && jqTool) {
                 if (ENABLE_LOGGING) {
                     console.error('[mcp-proxy] Executing JQ tool locally');
                 }
-                return await jqTool.handler({
+                result = await jqTool.handler({
                     params: { arguments: toolArgs }
                 });
             }
-            // Forward all other tools to child MCP (if child exists)
-            if (!childClient) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `Error: Tool ${toolName} not available in standalone mode (no child MCP)`
-                        }],
-                    isError: true
-                };
-            }
-            if (ENABLE_LOGGING) {
-                console.error(`[mcp-proxy] Forwarding to child MCP: ${toolName}`);
+            else {
+                // Forward all other tools to child MCP (if child exists)
+                if (!childClient) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Error: Tool ${toolName} not available in standalone mode (no child MCP)`
+                            }],
+                        isError: true
+                    };
+                }
+                if (ENABLE_LOGGING) {
+                    console.error(`[mcp-proxy] Forwarding to child MCP: ${toolName}`);
+                }
+                result = await childClient.callTool({
+                    name: toolName,
+                    arguments: toolArgs
+                });
             }
-            const result = await childClient.callTool({
-                name: toolName,
-                arguments: toolArgs
-            });
-            // Apply truncation and file writing to text responses
+            // Apply file writing and truncation to text responses
             if (result.content && Array.isArray(result.content) && result.content.length > 0) {
                 for (let i = 0; i < result.content.length; i++) {
                     const item = result.content[i];
                     if (item.type === 'text' && typeof item.text === 'string') {
+                        const originalText = item.text;
                         const originalLength = item.text.length;
-                        // Step 1: Apply truncation
-                        item.text = truncateResponseIfNeeded(truncationConfig, item.text);
-                        if (item.text.length < originalLength && ENABLE_LOGGING) {
-                            console.error(`[mcp-proxy] Truncated response: ${originalLength} → ${item.text.length} chars`);
-                        }
-                        // Step 2: Apply file writing (if enabled)
+                        let fileWasWritten = false;
+                        // Step 1: Try file writing first (if enabled)
+                        // This writes the FULL original data to file
                         if (fileWriterConfig.enabled) {
                             const fileResult = await fileWriter.handleResponse(toolName, toolArgs, {
                                 content: [{ type: 'text', text: item.text }]
                             });
+                            // Check if file was actually written (file reference returned)
                             if (fileResult && fileResult.content && Array.isArray(fileResult.content) &&
                                 fileResult.content.length > 0 && fileResult.content[0].type === 'text') {
-                                item.text = fileResult.content[0].text;
-                                if (ENABLE_LOGGING) {
-                                    console.error(`[mcp-proxy] File writing applied for ${toolName}`);
+                                const resultText = fileResult.content[0].text;
+                                // File reference contains "📄 File:" - this means file was written
+                                if (resultText.includes('📄 File:')) {
+                                    item.text = resultText;
+                                    fileWasWritten = true;
+                                    if (ENABLE_LOGGING) {
+                                        console.error(`[mcp-proxy] File writing applied for ${toolName} (${originalLength} chars written to file)`);
+                                    }
                                 }
                             }
                         }
+                        // Step 2: Apply truncation only if file was NOT written
+                        // (File references are small and don't need truncation)
+                        if (!fileWasWritten) {
+                            item.text = truncateResponseIfNeeded(truncationConfig, item.text);
+                            if (item.text.length < originalLength && ENABLE_LOGGING) {
+                                console.error(`[mcp-proxy] Truncated response: ${originalLength} → ${item.text.length} chars`);
+                            }
+                        }
                     }
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anyshift/mcp-proxy",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Generic MCP proxy that adds truncation, file writing, and JQ capabilities to any MCP server",
   "type": "module",
   "main": "dist/index.js",
@@ -17,7 +17,11 @@
     "zod": "^3.24.2"
   },
   "devDependencies": {
+    "@jest/globals": "^30.2.0",
+    "@types/jest": "^30.0.0",
     "@types/node": "^22.0.0",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.5",
     "tsx": "^4.7.0",
     "typescript": "^5.3.3"
   },
@@ -27,6 +31,11 @@
   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js",
-    "dev": "tsx src/index.ts"
+    "dev": "tsx src/index.ts",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "test:unit": "node --experimental-vm-modules node_modules/jest/bin/jest.js --testPathPattern=unit",
+    "test:integration": "node --experimental-vm-modules node_modules/jest/bin/jest.js --testPathPattern=integration",
+    "test:watch": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch",
+    "test:coverage": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage"
   }
 }