@anyshift/mcp-proxy 0.4.0 → 0.4.2-dev0

package/dist/fileWriter/writer.js

@@ -5,6 +5,18 @@ import { generateQueryAssistSchema, generateJsonlQueryAssistSchema } from './sch
 import { parseDynatraceDqlResponse, isDynatraceDqlTool, } from './dynatrace.js';
 // Default minimum character count to trigger file writing
 const DEFAULT_MIN_CHARS = 1000;
+/**
+ * Generate the message to include when data is written to file, guiding the LLM on how to use the result.
+ * The message conditionally includes the timeseries tool based on configuration.
+ */
+function getFileWrittenMessage(enableTimeseries) {
+    const toolsList = enableTimeseries
+        ? '"execute_jq_query" tool (for JSON/JSONL data extraction and transformation) or "detect_timeseries_anomalies" tool (for time series analysis)'
+        : '"execute_jq_query" tool (for JSON/JSONL data extraction and transformation)';
+    return `To read this file, use the ${toolsList}.
+
+IMPORTANT for supporting facts: This tool_id CANNOT be used as the proxy_tool_id in your output's supporting_facts evidence. You must read the file using one of the tools above and use THAT tool's tool_id as the proxy_tool_id to support facts in your output.`;
+}
 /**
  * Detect whether content is JSON, JSONL, or plain text
  */
@@ -251,6 +263,7 @@ async function handleDynatraceDqlResponse(config, tool_id, parsedDql) {
             wroteToFile: true,
             filePath: filepath,
             fileSchema,
+            message: getFileWrittenMessage(config.enableTimeseries ?? false),
         };
     }
     catch (error) {
@@ -388,6 +401,7 @@ export async function handleToolResponse(config, toolName, args, responseData) {
             wroteToFile: true,
             filePath: filepath,
             fileSchema,
+            message: getFileWrittenMessage(config.enableTimeseries ?? false),
         };
     }
     catch (error) {

package/dist/index.js

@@ -324,7 +324,8 @@ async function main() {
         toolAbbreviations: {}, // No service-specific abbreviations (generic proxy)
         schemaMaxDepth: SCHEMA_MAX_DEPTH,
         schemaMaxPaths: SCHEMA_MAX_PATHS,
-        schemaMaxKeys: SCHEMA_MAX_KEYS
+        schemaMaxKeys: SCHEMA_MAX_KEYS,
+        enableTimeseries: ENABLE_TIMESERIES
     };
     const fileWriter = createFileWriter(fileWriterConfig);
     // JQ tool configuration
@@ -452,26 +453,72 @@ async function main() {
             const childReturnedError = !!result.isError;
             // Process result through file writer to get unified response
             if (result.content && Array.isArray(result.content) && result.content.length > 0) {
-                const item = result.content[0];
-                if (item.type === 'text' && typeof item.text === 'string') {
-                    const originalLength = item.text.length;
+                // Extract text content and embedded resources from all content items
+                const textContents = [];
+                const resources = [];
+                for (const item of result.content) {
+                    if (item.type === 'text' && typeof item.text === 'string') {
+                        textContents.push(item.text);
+                    }
+                    else if (item.type === 'resource' && item.resource) {
+                        // Handle EmbeddedResource - extract content from resource field
+                        const resource = item.resource;
+                        const resourceObj = {};
+                        if (resource.uri)
+                            resourceObj.uri = resource.uri;
+                        if (resource.mimeType)
+                            resourceObj.mimeType = resource.mimeType;
+                        // Content can be in 'text' (string) or 'blob' (base64 binary)
+                        if (resource.text) {
+                            resourceObj.content = resource.text;
+                        }
+                        else if (resource.blob) {
+                            // For binary content, keep as base64 or decode based on mimeType
+                            resourceObj.content = typeof resource.blob === 'string'
+                                ? resource.blob
+                                : Buffer.from(resource.blob).toString('base64');
+                        }
+                        resources.push(resourceObj);
+                    }
+                }
+                // Build combined content object
+                let combinedContent;
+                if (resources.length > 0) {
+                    // Has resources - combine text and resources into single object
+                    combinedContent = {
+                        text: textContents.length === 1 ? textContents[0] : textContents,
+                        resources: resources.length === 1 ? resources[0] : resources
+                    };
+                    if (ENABLE_LOGGING) {
+                        console.debug(`[mcp-proxy] Combined ${textContents.length} text items and ${resources.length} resources`);
+                    }
+                }
+                else if (textContents.length > 0) {
+                    // Text only - use first text content (original behavior)
+                    combinedContent = textContents[0];
+                }
+                if (combinedContent !== undefined) {
+                    const contentStr = typeof combinedContent === 'string'
+                        ? combinedContent
+                        : JSON.stringify(combinedContent);
+                    const originalLength = contentStr.length;
                     // If child returned error, pass through directly without file writing
                     if (childReturnedError) {
                         const tool_id = generateToolId(toolName, toolArgs, fileWriterConfig.toolAbbreviations);
                         if (ENABLE_LOGGING) {
-                            console.debug(`[mcp-proxy] Child MCP returned error for ${toolName}: ${item.text.substring(0, 100)}...`);
+                            console.debug(`[mcp-proxy] Child MCP returned error for ${toolName}: ${contentStr.substring(0, 100)}...`);
                         }
                         return {
                             content: [{
                                     type: 'text',
-                                    text: JSON.stringify(createErrorResponse(tool_id, item.text, toolArgs), null, 2)
+                                    text: JSON.stringify(createErrorResponse(tool_id, contentStr, toolArgs), null, 2)
                                 }],
                             isError: true
                         };
                     }
                     // Get unified response from file writer
                     const unifiedResponse = await fileWriter.handleResponse(toolName, toolArgs, {
-                        content: [{ type: 'text', text: item.text }]
+                        content: [{ type: 'text', text: contentStr }]
                     });
                     if (ENABLE_LOGGING) {
                         if (unifiedResponse.wroteToFile) {
@@ -483,13 +530,13 @@ async function main() {
                     }
                     // If not written to file, apply truncation to outputContent
                     if (!unifiedResponse.wroteToFile && unifiedResponse.outputContent) {
-                        const contentStr = typeof unifiedResponse.outputContent === 'string'
+                        const outputStr = typeof unifiedResponse.outputContent === 'string'
                             ? unifiedResponse.outputContent
                             : JSON.stringify(unifiedResponse.outputContent);
-                        const truncated = truncateResponseIfNeeded(truncationConfig, contentStr);
-                        if (truncated.length < contentStr.length) {
+                        const truncated = truncateResponseIfNeeded(truncationConfig, outputStr);
+                        if (truncated.length < outputStr.length) {
                             if (ENABLE_LOGGING) {
-                                console.debug(`[mcp-proxy] Truncated response: ${contentStr.length} → ${truncated.length} chars`);
+                                console.debug(`[mcp-proxy] Truncated response: ${outputStr.length} → ${truncated.length} chars`);
                             }
                             // Re-parse if it was JSON, otherwise keep as string
                             try {

package/dist/types/index.d.ts

@@ -34,6 +34,8 @@ export interface FileWriterConfig {
     schemaMaxPaths?: number;
     /** Maximum keys to analyze per object (default: 50) */
     schemaMaxKeys?: number;
+    /** Whether the timeseries anomaly detection tool is enabled (affects file-written message) */
+    enableTimeseries?: boolean;
 }
 /**
  * Configuration for the JQ tool
@@ -74,4 +76,6 @@ export interface UnifiedToolResponse {
     isRetryAttempt?: boolean;
     /** The original tool_id this call is retrying */
     originalToolId?: string;
+    /** Informational message for the LLM (e.g., guidance on how to use the file) */
+    message?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anyshift/mcp-proxy",
-  "version": "0.4.0",
+  "version": "0.4.2-dev0",
   "description": "Generic MCP proxy that adds truncation, file writing, and JQ capabilities to any MCP server",
   "type": "module",
   "main": "dist/index.js",