@anyshift/mcp-proxy 0.3.1 → 0.3.3

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,204 @@
+import { describe, it, expect } from '@jest/globals';
+import { parseDynatraceDqlResponse, isDynatraceDqlTool, } from '../../fileWriter/dynatrace.js';
+// Type guards for test assertions
+function isDqlSuccess(result) {
+    return (typeof result === 'object' &&
+        result !== null &&
+        'isDynatraceDql' in result &&
+        result.isDynatraceDql === true &&
+        'isError' in result &&
+        result.isError === false);
+}
+function isDqlError(result) {
+    return (typeof result === 'object' &&
+        result !== null &&
+        'isDynatraceDql' in result &&
+        result.isDynatraceDql === true &&
+        'isError' in result &&
+        result.isError === true);
+}
+describe('Dynatrace DQL Parser', () => {
+    describe('isDynatraceDqlTool', () => {
+        it('should return true for execute_dql tool', () => {
+            expect(isDynatraceDqlTool('execute_dql')).toBe(true);
+        });
+        it('should return false for other tools', () => {
+            expect(isDynatraceDqlTool('execute_jq_query')).toBe(false);
+            expect(isDynatraceDqlTool('get_metrics')).toBe(false);
+            expect(isDynatraceDqlTool('list_entities')).toBe(false);
+        });
+    });
+    describe('parseDynatraceDqlResponse - Success Responses', () => {
+        const successResponse = `📊 **DQL Query Results**
+
+- **Scanned Records:** 3,988,787
+- **Scanned Bytes:** 10.00 GB (Session total: 10.00 GB / 100 GB budget, 10.0% used)
+    💡 **Moderate Data Usage:** This query scanned 10.00 GB of data.
+- **⚠️ Sampling Used:** Yes (results may be approximate)
+
+📋 **Query Results**: (50 records):
+
+\`\`\`json
+[
+  {
+    "faas.name": "compassdigital-order-v1-root",
+    "logCount": "861021"
+  },
+  {
+    "faas.name": "cdl-shoppingcart-v1-root",
+    "logCount": "421993"
+  }
+]
+\`\`\``;
+        it('should parse a success response correctly', () => {
+            const result = parseDynatraceDqlResponse(successResponse);
+            expect(result.isDynatraceDql).toBe(true);
+            expect(isDqlSuccess(result)).toBe(true);
+            if (isDqlSuccess(result)) {
+                expect(result.metadata.scannedRecords).toBe(3988787);
+                expect(result.metadata.scannedBytes).toBe('10.00 GB');
+                expect(result.metadata.sessionTotal).toBe('10.00 GB');
+                expect(result.metadata.sessionBudget).toBe('100 GB');
+                expect(result.metadata.budgetUsedPercent).toBe('10.0%');
+                expect(result.metadata.samplingUsed).toBe(true);
+                expect(result.metadata.recordCount).toBe(50);
+                // dataUsageNote is optional, may or may not be present depending on formatting
+                expect(result.data).toBeInstanceOf(Array);
+                expect(result.data.length).toBe(2);
+                expect(result.data[0]['faas.name']).toBe('compassdigital-order-v1-root');
+            }
+        });
+        it('should parse response without sampling info', () => {
+            const responseNoSampling = `📊 **DQL Query Results**
+
+- **Scanned Records:** 1,000
+- **Scanned Bytes:** 100 MB (Session total: 100 MB / 100 GB budget, 0.1% used)
+
+📋 **Query Results**: (10 records):
+
+\`\`\`json
+[{"id": 1}]
+\`\`\``;
+            const result = parseDynatraceDqlResponse(responseNoSampling);
+            expect(result.isDynatraceDql).toBe(true);
+            if (isDqlSuccess(result)) {
+                expect(result.metadata.samplingUsed).toBeUndefined();
+                expect(result.metadata.recordCount).toBe(10);
+            }
+        });
+        it('should handle single record count', () => {
+            const responseSingleRecord = `📊 **DQL Query Results**
+
+- **Scanned Records:** 100
+- **Scanned Bytes:** 1 MB
+
+📋 **Query Results**: (1 record):
+
+\`\`\`json
+{"id": 1}
+\`\`\``;
+            const result = parseDynatraceDqlResponse(responseSingleRecord);
+            expect(result.isDynatraceDql).toBe(true);
+            if (isDqlSuccess(result)) {
+                expect(result.metadata.recordCount).toBe(1);
+            }
+        });
+    });
+    describe('parseDynatraceDqlResponse - Error Responses', () => {
+        const errorResponse = `Client Request Error: PARAMETER_MUST_NOT_BE_AN_AGGREGATION. exceptionType: "DQL-SYNTAX-ERROR". syntaxErrorPosition: {"start":{"column":113,"index":112,"line":1},"end":{"column":119,"index":118,"line":1}}. errorType: "PARAMETER_MUST_NOT_BE_AN_AGGREGATION". errorMessage: "Aggregations aren't allowed here, but \`count()\` is an aggregation function.". arguments: ["count()"]. queryString: "fetch logs, scanLimitGBytes: 10, samplingRatio: 100, from: now()-7d | summarize count(), by: {faas.name} | sort count() desc | limit 50". errorMessageFormatSpecifierTypes: ["INPUT_QUERY_PART"]. errorMessageFormat: "Aggregations aren't allowed here, but \`%1$s\` is an aggregation function.". queryId: "9be6a579-545c-4157-957f-5d8d39129a78" with HTTP status: 400.  (body: {"error":{"message":"PARAMETER_MUST_NOT_BE_AN_AGGREGATION","details":{"exceptionType":"DQL-SYNTAX-ERROR"}}})`;
+        it('should parse an error response correctly', () => {
+            const result = parseDynatraceDqlResponse(errorResponse);
+            expect(result.isDynatraceDql).toBe(true);
+            expect(isDqlError(result)).toBe(true);
+            if (isDqlError(result)) {
+                expect(result.errorMessage).toContain("Aggregations aren't allowed here");
+                expect(result.errorMessage).toContain('count()');
+                expect(result.errorMessage).toContain('Query:');
+                expect(result.errorMessage).toContain('HTTP 400');
+            }
+        });
+        it('should extract error type when no errorMessage field', () => {
+            const simpleError = `Client Request Error: INVALID_QUERY. exceptionType: "DQL-ERROR". with HTTP status: 400.`;
+            const result = parseDynatraceDqlResponse(simpleError);
+            expect(result.isDynatraceDql).toBe(true);
+            expect(isDqlError(result)).toBe(true);
+            if (isDqlError(result)) {
+                expect(result.errorMessage).toContain('INVALID_QUERY');
+                expect(result.errorMessage).toContain('HTTP 400');
+            }
+        });
+    });
+    describe('parseDynatraceDqlResponse - Non-Dynatrace Responses', () => {
+        it('should return isDynatraceDql: false for regular JSON', () => {
+            const regularJson = '{"status": "success", "data": [1, 2, 3]}';
+            const result = parseDynatraceDqlResponse(regularJson);
+            expect(result.isDynatraceDql).toBe(false);
+        });
+        it('should return isDynatraceDql: false for plain text', () => {
+            const plainText = 'This is just some plain text response';
+            const result = parseDynatraceDqlResponse(plainText);
+            expect(result.isDynatraceDql).toBe(false);
+        });
+        it('should return isDynatraceDql: false for other MCP tool outputs', () => {
+            const otherToolOutput = `Listed metrics:
+- metric.cpu.usage
+- metric.memory.used`;
+            const result = parseDynatraceDqlResponse(otherToolOutput);
+            expect(result.isDynatraceDql).toBe(false);
+        });
+    });
+    describe('Edge Cases', () => {
+        it('should handle malformed JSON in success response', () => {
+            const malformedJson = `📊 **DQL Query Results**
+
+- **Scanned Records:** 100
+
+📋 **Query Results**: (1 record):
+
+\`\`\`json
+{this is not valid json}
+\`\`\``;
+            const result = parseDynatraceDqlResponse(malformedJson);
+            expect(result.isDynatraceDql).toBe(true);
+            if (isDqlSuccess(result)) {
+                // Should still parse metadata
+                expect(result.metadata.scannedRecords).toBe(100);
+                // Data should be the raw text from code block since JSON parsing failed
+                expect(result.data).toBe('{this is not valid json}');
+            }
+        });
+        it('should handle empty JSON array', () => {
+            const emptyResults = `📊 **DQL Query Results**
+
+- **Scanned Records:** 0
+
+📋 **Query Results**: (0 records):
+
+\`\`\`json
+[]
+\`\`\``;
+            const result = parseDynatraceDqlResponse(emptyResults);
+            expect(result.isDynatraceDql).toBe(true);
+            if (isDqlSuccess(result)) {
+                expect(result.metadata.scannedRecords).toBe(0);
+                expect(result.metadata.recordCount).toBe(0);
+                expect(result.data).toEqual([]);
+            }
+        });
+        it('should handle response with no code block', () => {
+            const noCodeBlock = `📊 **DQL Query Results**
+
+- **Scanned Records:** 100
+
+📋 **Query Results**: (0 records):
+
+No data found.`;
+            const result = parseDynatraceDqlResponse(noCodeBlock);
+            expect(result.isDynatraceDql).toBe(true);
+            if (isDqlSuccess(result)) {
+                expect(result.metadata.scannedRecords).toBe(100);
+                expect(result.data).toBeNull();
+            }
+        });
+    });
+});

package/dist/fileWriter/dynatrace.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Dynatrace DQL Response Parser
+ *
+ * Parses Dynatrace DQL query responses to extract:
+ * - Metadata (scanned records, bytes, sampling info)
+ * - Data (the actual query results)
+ * - Errors (if the query failed)
+ */
+export interface DynatraceDqlMetadata {
+    scannedRecords?: number;
+    scannedBytes?: string;
+    sessionTotal?: string;
+    sessionBudget?: string;
+    budgetUsedPercent?: string;
+    dataUsageNote?: string;
+    samplingUsed?: boolean;
+    recordCount?: number;
+}
+export interface DynatraceDqlParsedResponse {
+    isDynatraceDql: true;
+    isError: false;
+    metadata: DynatraceDqlMetadata;
+    data: unknown;
+}
+export interface DynatraceDqlErrorResponse {
+    isDynatraceDql: true;
+    isError: true;
+    errorMessage: string;
+}
+export interface NotDynatraceDqlResponse {
+    isDynatraceDql: false;
+}
+export type DynatraceParseResult = DynatraceDqlParsedResponse | DynatraceDqlErrorResponse | NotDynatraceDqlResponse;
+/**
+ * Parse a Dynatrace DQL response
+ * @param text - The raw text response from Dynatrace
+ * @returns Parsed response with metadata/data or error, or indication that it's not a Dynatrace response
+ */
+export declare function parseDynatraceDqlResponse(text: string): DynatraceParseResult;
+/**
+ * Check if a tool name is a Dynatrace DQL tool
+ */
+export declare function isDynatraceDqlTool(toolName: string): boolean;

package/dist/fileWriter/dynatrace.js

@@ -0,0 +1,173 @@
+/**
+ * Dynatrace DQL Response Parser
+ *
+ * Parses Dynatrace DQL query responses to extract:
+ * - Metadata (scanned records, bytes, sampling info)
+ * - Data (the actual query results)
+ * - Errors (if the query failed)
+ */
+/**
+ * Detect if a text response is a Dynatrace DQL error
+ */
+function isDynatraceError(text) {
+    return text.includes('Client Request Error:') && text.includes('HTTP status:');
+}
+/**
+ * Detect if a text response is a Dynatrace DQL success response
+ */
+function isDynatraceSuccess(text) {
+    return text.includes('📊 **DQL Query Results**');
+}
+/**
+ * Parse a Dynatrace error response - keeps more context for debugging
+ */
+function parseErrorResponse(text) {
+    // The error format is:
+    // Client Request Error: ERROR_TYPE. exceptionType: "...". ... errorMessage: "...". ...
+    const parts = [];
+    // Extract error type
+    const errorTypeMatch = text.match(/Client Request Error:\s*([^.]+)/);
+    if (errorTypeMatch) {
+        parts.push(errorTypeMatch[1].trim());
+    }
+    // Extract the human-readable error message
+    const errorMessageMatch = text.match(/errorMessage:\s*"([^"]+)"/);
+    if (errorMessageMatch) {
+        parts.push(errorMessageMatch[1]);
+    }
+    // Extract the query string for context
+    const queryStringMatch = text.match(/queryString:\s*"([^"]+)"/);
+    if (queryStringMatch) {
+        parts.push(`Query: ${queryStringMatch[1]}`);
+    }
+    // Extract syntax error position if available
+    const positionMatch = text.match(/syntaxErrorPosition:\s*(\{[^}]+\})/);
+    if (positionMatch) {
+        try {
+            const pos = JSON.parse(positionMatch[1]);
+            if (pos.start) {
+                parts.push(`Position: line ${pos.start.line}, column ${pos.start.column}`);
+            }
+        }
+        catch {
+            // Ignore JSON parse errors
+        }
+    }
+    // Extract HTTP status
+    const httpStatusMatch = text.match(/HTTP status:\s*(\d+)/);
+    if (httpStatusMatch) {
+        parts.push(`HTTP ${httpStatusMatch[1]}`);
+    }
+    if (parts.length > 0) {
+        return parts.join('. ');
+    }
+    // Last fallback: return a truncated version of the raw error
+    const firstLine = text.split('\n')[0];
+    if (firstLine.length > 500) {
+        return firstLine.substring(0, 500) + '...';
+    }
+    return firstLine;
+}
+/**
+ * Parse metadata from a Dynatrace DQL success response
+ */
+function parseMetadata(text) {
+    const metadata = {};
+    // Parse scanned records: "- **Scanned Records:** 3,988,787"
+    const scannedRecordsMatch = text.match(/\*\*Scanned Records:\*\*\s*([\d,]+)/);
+    if (scannedRecordsMatch) {
+        metadata.scannedRecords = parseInt(scannedRecordsMatch[1].replace(/,/g, ''), 10);
+    }
+    // Parse scanned bytes: "- **Scanned Bytes:** 10.00 GB (Session total: 10.00 GB / 100 GB budget, 10.0% used)"
+    const scannedBytesMatch = text.match(/\*\*Scanned Bytes:\*\*\s*([^\n(]+)/);
+    if (scannedBytesMatch) {
+        metadata.scannedBytes = scannedBytesMatch[1].trim();
+    }
+    // Parse session total and budget from the parenthetical
+    const sessionMatch = text.match(/Session total:\s*([^/]+)\/\s*([^,]+)\s*budget,\s*([^)%]+)%\s*used/);
+    if (sessionMatch) {
+        metadata.sessionTotal = sessionMatch[1].trim();
+        metadata.sessionBudget = sessionMatch[2].trim();
+        metadata.budgetUsedPercent = sessionMatch[3].trim() + '%';
+    }
+    // Parse data usage note: "    💡 **Moderate Data Usage:** This query scanned 10.00 GB of data."
+    const dataUsageMatch = text.match(/\s*💡\s*\*\*([^*]+)\*\*:\s*([^\n]+)/);
+    if (dataUsageMatch) {
+        metadata.dataUsageNote = `${dataUsageMatch[1]}: ${dataUsageMatch[2].trim()}`;
+    }
+    // Parse sampling info: "- **⚠️ Sampling Used:** Yes"
+    const samplingMatch = text.match(/\*\*⚠️?\s*Sampling Used:\*\*\s*(Yes|No)/i);
+    if (samplingMatch) {
+        metadata.samplingUsed = samplingMatch[1].toLowerCase() === 'yes';
+    }
+    // Parse record count: "📋 **Query Results**: (50 records):"
+    const recordCountMatch = text.match(/\*\*Query Results\*\*[^(]*\((\d+)\s*records?\)/);
+    if (recordCountMatch) {
+        metadata.recordCount = parseInt(recordCountMatch[1], 10);
+    }
+    return metadata;
+}
+/**
+ * Extract JSON data from a Dynatrace DQL success response
+ */
+function extractData(text) {
+    // The JSON is in a code block: ```json\n[...]\n```
+    const jsonBlockMatch = text.match(/```json\s*\n([\s\S]*?)\n```/);
+    if (jsonBlockMatch) {
+        try {
+            return JSON.parse(jsonBlockMatch[1]);
+        }
+        catch {
+            // If JSON parsing fails, return the raw text from the block
+            return jsonBlockMatch[1];
+        }
+    }
+    // Fallback: try to find a JSON array or object anywhere after the header
+    const jsonMatch = text.match(/(\[[\s\S]*\]|\{[\s\S]*\})/);
+    if (jsonMatch) {
+        try {
+            return JSON.parse(jsonMatch[1]);
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Parse a Dynatrace DQL response
+ * @param text - The raw text response from Dynatrace
+ * @returns Parsed response with metadata/data or error, or indication that it's not a Dynatrace response
+ */
+export function parseDynatraceDqlResponse(text) {
+    // Check if it's an error response
+    if (isDynatraceError(text)) {
+        return {
+            isDynatraceDql: true,
+            isError: true,
+            errorMessage: parseErrorResponse(text),
+        };
+    }
+    // Check if it's a success response
+    if (isDynatraceSuccess(text)) {
+        const metadata = parseMetadata(text);
+        const data = extractData(text);
+        return {
+            isDynatraceDql: true,
+            isError: false,
+            metadata,
+            data,
+        };
+    }
+    // Not a Dynatrace DQL response
+    return {
+        isDynatraceDql: false,
+    };
+}
+/**
+ * Check if a tool name is a Dynatrace DQL tool
+ */
+export function isDynatraceDqlTool(toolName) {
+    // The tool that executes DQL queries
+    return toolName === 'execute_dql';
+}

package/dist/fileWriter/schema.d.ts

@@ -32,6 +32,10 @@ export interface QueryAssistOptions {
     maxKeys?: number;
     dataSize?: number;
 }
+export interface JsonlSchemaOptions extends QueryAssistOptions {
+    totalLines: number;
+    sampleSize?: number;
+}
 /**
  * Generate query-assist schema for JSON data
  * Main entry point for schema generation
@@ -40,3 +44,10 @@ export interface QueryAssistOptions {
  * @returns Compact text schema optimized for JQ queries
  */
 export declare function generateQueryAssistSchema(data: unknown, options?: QueryAssistOptions): string;
+/**
+ * Generate schema for JSONL data by sampling multiple records
+ * @param lines - Array of raw JSON lines
+ * @param options - Configuration options including totalLines and sampleSize
+ * @returns Formatted text schema optimized for JQ queries on JSONL files
+ */
+export declare function generateJsonlQueryAssistSchema(lines: string[], options: JsonlSchemaOptions): string;

package/dist/fileWriter/schema.js

@@ -268,3 +268,117 @@ export function generateQueryAssistSchema(data, options = {}) {
     // Format as text
     return formatQueryAssist(selectedPaths, limits, dataSize);
 }
+/**
+ * Select sample indices evenly distributed through the data
+ */
+function selectSampleIndices(totalLines, sampleSize) {
+    if (totalLines <= sampleSize) {
+        return Array.from({ length: totalLines }, (_, i) => i);
+    }
+    const indices = [0]; // Always include first
+    const step = Math.floor(totalLines / (sampleSize - 1));
+    for (let i = 1; i < sampleSize - 1; i++) {
+        indices.push(i * step);
+    }
+    indices.push(totalLines - 1); // Always include last
+    return indices;
+}
+/**
+ * Analyze schema consistency across sampled records
+ */
+function analyzeSchemaConsistency(records) {
+    if (records.length < 2) {
+        return { isConsistent: true, optionalFields: [] };
+    }
+    // Collect all keys from all records
+    const allKeys = new Set();
+    const keyPresenceCount = new Map();
+    for (const record of records) {
+        if (record && typeof record === 'object' && !Array.isArray(record)) {
+            const keys = Object.keys(record);
+            for (const key of keys) {
+                allKeys.add(key);
+                keyPresenceCount.set(key, (keyPresenceCount.get(key) || 0) + 1);
+            }
+        }
+    }
+    // Find optional fields (not present in all records)
+    const optionalFields = [];
+    for (const key of allKeys) {
+        if (keyPresenceCount.get(key) !== records.length) {
+            optionalFields.push(key);
+        }
+    }
+    return {
+        isConsistent: optionalFields.length === 0,
+        optionalFields
+    };
+}
+/**
+ * Generate schema for JSONL data by sampling multiple records
+ * @param lines - Array of raw JSON lines
+ * @param options - Configuration options including totalLines and sampleSize
+ * @returns Formatted text schema optimized for JQ queries on JSONL files
+ */
+export function generateJsonlQueryAssistSchema(lines, options) {
+    const { totalLines, sampleSize = 5 } = options;
+    const parts = [];
+    parts.push('📊 JSONL STRUCTURE GUIDE (for JQ queries)');
+    parts.push('');
+    parts.push(`Format: JSON Lines (${totalLines.toLocaleString()} records)`);
+    if (options.dataSize) {
+        parts.push(`Size: ${options.dataSize.toLocaleString()} characters`);
+    }
+    parts.push('');
+    // JQ usage guide for JSONL
+    parts.push('JQ USAGE (JSONL files):');
+    parts.push('  • Stream records:     jq -c "." file.jsonl');
+    parts.push('  • Filter:             jq -c "select(.field == value)" file.jsonl');
+    parts.push('  • Extract field:      jq -r ".fieldName" file.jsonl');
+    parts.push('  • Count records:      jq -s "length" file.jsonl');
+    parts.push('  • First N records:    jq -s ".[:N]" file.jsonl');
+    parts.push('  • Unique values:      jq -s "[.[].field] | unique" file.jsonl');
+    parts.push('');
+    // Sample records evenly distributed through the file
+    const indicesToSample = selectSampleIndices(totalLines, sampleSize);
+    const sampledRecords = [];
+    for (const idx of indicesToSample) {
+        if (lines[idx]) {
+            try {
+                sampledRecords.push(JSON.parse(lines[idx].trim()));
+            }
+            catch {
+                // Skip unparseable lines
+            }
+        }
+    }
+    if (sampledRecords.length === 0) {
+        parts.push('⚠️ Could not parse any records');
+        return parts.join('\n');
+    }
+    // Analyze schema consistency across samples
+    const schemaAnalysis = analyzeSchemaConsistency(sampledRecords);
+    if (schemaAnalysis.isConsistent) {
+        parts.push(`RECORD STRUCTURE (consistent across ${sampledRecords.length} sampled records):`);
+    }
+    else {
+        parts.push(`RECORD STRUCTURE (⚠️ variations detected in ${sampledRecords.length} samples):`);
+        if (schemaAnalysis.optionalFields.length > 0) {
+            parts.push(`  Optional fields: ${schemaAnalysis.optionalFields.join(', ')}`);
+        }
+    }
+    parts.push('');
+    // Generate schema from first record (representative)
+    const recordSchema = generateQueryAssistSchema(sampledRecords[0], {
+        maxDepth: options.maxDepth,
+        maxPaths: options.maxPaths,
+        maxKeys: options.maxKeys,
+    });
+    // Indent the record schema
+    const indentedSchema = recordSchema
+        .split('\n')
+        .map(l => '  ' + l)
+        .join('\n');
+    parts.push(indentedSchema);
+    return parts.join('\n');
+}

package/dist/fileWriter/writer.js

@@ -1,9 +1,58 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { generateToolId } from '../utils/filename.js';
-import { generateQueryAssistSchema } from './schema.js';
+import { generateQueryAssistSchema, generateJsonlQueryAssistSchema } from './schema.js';
+import { parseDynatraceDqlResponse, isDynatraceDqlTool, } from './dynatrace.js';
 // Default minimum character count to trigger file writing
 const DEFAULT_MIN_CHARS = 1000;
+/**
+ * Detect whether content is JSON, JSONL, or plain text
+ */
+function detectContentFormat(content) {
+    const trimmed = content.trim();
+    // Empty content
+    if (!trimmed)
+        return 'text';
+    // Try parsing as single JSON object/array
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+        try {
+            JSON.parse(trimmed);
+            return 'json';
+        }
+        catch {
+            // Could be JSONL starting with {
+        }
+    }
+    // Check for JSONL (multiple JSON objects, one per line)
+    const lines = trimmed.split('\n').filter(l => l.trim());
+    if (lines.length > 1) {
+        // Sample first few lines to avoid parsing huge files
+        const sampleSize = Math.min(lines.length, 10);
+        const allSampledLinesAreJson = lines.slice(0, sampleSize).every(line => {
+            try {
+                JSON.parse(line.trim());
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (allSampledLinesAreJson) {
+            return 'jsonl';
+        }
+    }
+    return 'text';
+}
+/**
+ * Get file extension based on content format
+ */
+function getFileExtension(format) {
+    switch (format) {
+        case 'jsonl': return '.jsonl';
+        case 'text': return '.txt';
+        default: return '.json';
+    }
+}
 /**
  * Helper function to detect if a response contains an error
  */
@@ -160,6 +209,60 @@ const extractContentForFile = (responseData) => {
     }
     return { contentToWrite, parsedForSchema };
 };
+/**
+ * Handle Dynatrace DQL response - extracts metadata and data, writes structured file
+ * @param config - File writer configuration
+ * @param tool_id - Generated tool ID
+ * @param parsedDql - Parsed DQL response with metadata and data
+ * @returns UnifiedToolResponse or null if should fall through to default handling
+ */
+async function handleDynatraceDqlResponse(config, tool_id, parsedDql) {
+    // Build the structured content to write
+    const structuredContent = {
+        metadata: parsedDql.metadata,
+        data: parsedDql.data,
+    };
+    const contentToWrite = JSON.stringify(structuredContent, null, 2);
+    const contentLength = contentToWrite.length;
+    // If file writing is disabled, return null to fall through to default handling
+    if (!config.enabled || !config.outputPath) {
+        return null;
+    }
+    // Check character count threshold
+    const minChars = config.minCharsForWrite ?? DEFAULT_MIN_CHARS;
+    if (contentLength < minChars) {
+        return null;
+    }
+    // Write structured file
+    try {
+        const filename = `${tool_id}.json`;
+        const filepath = path.join(config.outputPath, filename);
+        await fs.mkdir(config.outputPath, { recursive: true });
+        await fs.writeFile(filepath, contentToWrite);
+        // Generate schema from the full structured content (metadata + data)
+        const fileSchema = generateQueryAssistSchema(structuredContent, {
+            maxDepth: config.schemaMaxDepth ?? 2,
+            maxPaths: config.schemaMaxPaths ?? 20,
+            maxKeys: config.schemaMaxKeys ?? 50,
+            dataSize: contentLength,
+        });
+        return {
+            tool_id,
+            wroteToFile: true,
+            filePath: filepath,
+            fileSchema,
+        };
+    }
+    catch (error) {
+        console.error(`[handleDynatraceDqlResponse] Error writing file:`, error);
+        return {
+            tool_id,
+            wroteToFile: false,
+            outputContent: structuredContent,
+            error: `File write failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
 /**
  * Centralized response handler with file writing capability
  * @param config - File writer configuration
@@ -180,6 +283,38 @@ export async function handleToolResponse(config, toolName, args, responseData) {
             outputContent: parsedForSchema ?? contentToWrite,
         };
     }
+    // Handle Dynatrace DQL responses specially
+    if (isDynatraceDqlTool(toolName)) {
+        const rawText = extractRawText(responseData);
+        if (rawText) {
+            const parsedDql = parseDynatraceDqlResponse(rawText);
+            if (parsedDql.isDynatraceDql) {
+                // If it's an error, return error directly
+                if (parsedDql.isError) {
+                    return {
+                        tool_id,
+                        wroteToFile: false,
+                        error: parsedDql.errorMessage,
+                    };
+                }
+                // Try to handle as structured Dynatrace response
+                const dqlResult = await handleDynatraceDqlResponse(config, tool_id, parsedDql);
+                if (dqlResult) {
+                    return dqlResult;
+                }
+                // If dqlResult is null, fall through to return the structured content directly
+                return {
+                    tool_id,
+                    wroteToFile: false,
+                    outputContent: {
+                        metadata: parsedDql.metadata,
+                        data: parsedDql.data,
+                    },
+                };
+            }
+        }
+        // If not a recognized Dynatrace DQL format, fall through to default handling
+    }
     // If there's an error, return error in unified format
     if (isErrorResponse(responseData)) {
         const errorMessage = extractErrorMessage(responseData);
@@ -212,15 +347,31 @@ export async function handleToolResponse(config, toolName, args, responseData) {
     }
     // Success case: write to file
     try {
-        const filename = `${tool_id}.json`;
+        // Detect content format for appropriate extension and schema
+        const format = detectContentFormat(contentToWrite);
+        const extension = getFileExtension(format);
+        const filename = `${tool_id}${extension}`;
         const filepath = path.join(config.outputPath, filename);
         // Ensure output directory exists
         await fs.mkdir(config.outputPath, { recursive: true });
         // Write the exact content we counted
         await fs.writeFile(filepath, contentToWrite);
-        // Generate query-assist schema if we have valid JSON
+        // Generate query-assist schema based on format
         let fileSchema;
-        if (parsedForSchema) {
+        if (format === 'jsonl') {
+            // JSONL format: sample multiple records for schema
+            const lines = contentToWrite.trim().split('\n').filter(l => l.trim());
+            fileSchema = generateJsonlQueryAssistSchema(lines, {
+                maxDepth: config.schemaMaxDepth ?? 2,
+                maxPaths: config.schemaMaxPaths ?? 20,
+                maxKeys: config.schemaMaxKeys ?? 50,
+                dataSize: contentLength,
+                totalLines: lines.length,
+                sampleSize: 5
+            });
+        }
+        else if (parsedForSchema) {
+            // Standard JSON format: use existing schema generator
             // Use the clean data (without pagination) for schema analysis
             const { pagination, has_more, next_page, previous_page, page, page_size, total_pages, ...cleanData } = parsedForSchema;
             // Generate compact query-assist schema using config values

package/dist/jq/handler.js

@@ -37,9 +37,10 @@ export async function executeJqQuery(config, jqQuery, filePath) {
     if (!existsSync(filePath)) {
         throw new Error(`File not found: ${filePath}`);
     }
-    // Validate file extension
-    if (!filePath.toLowerCase().endsWith('.json')) {
-        throw new Error(`Only JSON files (.json) are supported for jq processing: ${filePath}`);
+    // Validate file extension (support both .json and .jsonl)
+    const lowerPath = filePath.toLowerCase();
+    if (!lowerPath.endsWith('.json') && !lowerPath.endsWith('.jsonl')) {
+        throw new Error(`Only JSON (.json) and JSONL (.jsonl) files are supported for jq processing: ${filePath}`);
     }
     // Validate path is within allowed directories
     validatePathWithinAllowedDirs(filePath, config.allowedPaths);

package/dist/jq/tool.js

@@ -8,7 +8,7 @@ export const ExecuteJqQuerySchema = z.object({
         .describe('The jq query to execute on the JSON file. Query will be sanitized to prevent environment variable access.'),
     file_path: z
         .string()
-        .describe('Absolute path starting with "/" pointing to the JSON file to process. Must be a valid, existing file with .json extension. The file will be validated for existence and readability before processing.'),
+        .describe('Absolute path starting with "/" pointing to the JSON or JSONL file to process. Must be a valid, existing file with .json or .jsonl extension. The file will be validated for existence and readability before processing.'),
     description: z
         .string()
         .optional()
@@ -109,7 +109,7 @@ export const JQ_TOOL_DEFINITION = {
             },
             file_path: {
                 type: 'string',
-                description: 'Absolute path starting with "/" pointing to the JSON file to process. Must be a valid, existing file with .json extension. The file will be validated for existence and readability before processing.',
+                description: 'Absolute path starting with "/" pointing to the JSON or JSONL file to process. Must be a valid, existing file with .json or .jsonl extension. The file will be validated for existence and readability before processing.',
             },
             description: {
                 type: 'string',

package/package.json

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