@probelabs/probe 0.6.0-rc76 → 0.6.0-rc77

package/build/agent/ProbeAgent.js

@@ -54,6 +54,7 @@ export class ProbeAgent {
    * @param {string} [options.provider] - Force specific AI provider
    * @param {string} [options.model] - Override model name
    * @param {boolean} [options.debug] - Enable debug mode
+   * @param {boolean} [options.outline] - Enable outline-xml format for search results
    */
   constructor(options = {}) {
     // Basic configuration
@@ -64,6 +65,7 @@ export class ProbeAgent {
     this.debug = options.debug || process.env.DEBUG === '1';
     this.cancelled = false;
     this.tracer = options.tracer || null;
+    this.outline = !!options.outline;
 
     // Search configuration
     this.allowedFolders = options.path ? [options.path] : [process.cwd()];
@@ -103,7 +105,8 @@ export class ProbeAgent {
       sessionId: this.sessionId,
       debug: this.debug,
       defaultPath: this.allowedFolders.length > 0 ? this.allowedFolders[0] : process.cwd(),
-      allowedFolders: this.allowedFolders
+      allowedFolders: this.allowedFolders,
+      outline: this.outline
     };
 
     // Create base tools
@@ -1010,15 +1013,115 @@ Convert your previous response content into actual JSON data that follows this s
             console.log(`[DEBUG] Mermaid validation: attempt_completion result validation completed (no fixes needed)`);
           }
           
-          // Validate JSON if schema expects JSON
+          // Validate and potentially correct JSON for attempt_completion results
           if (isJsonSchema(options.schema)) {
             if (this.debug) {
-              console.log(`[DEBUG] JSON validation: Validating attempt_completion result`);
+              console.log(`[DEBUG] JSON validation: Starting validation process for attempt_completion result`);
+              console.log(`[DEBUG] JSON validation: Response length: ${finalResult.length} chars`);
+            }
+            
+            // Record JSON validation start in telemetry
+            if (this.tracer) {
+              this.tracer.recordJsonValidationEvent('attempt_completion_started', {
+                'json_validation.response_length': finalResult.length,
+                'json_validation.schema_type': 'JSON',
+                'json_validation.context': 'attempt_completion'
+              });
             }
-            const validation = validateJsonResponse(finalResult, { debug: this.debug });
+            
+            let validation = validateJsonResponse(finalResult, { debug: this.debug });
+            let retryCount = 0;
+            const maxRetries = 3;
+            
+            // First check if the response is valid JSON but is actually a schema definition
+            if (validation.isValid && isJsonSchemaDefinition(finalResult, { debug: this.debug })) {
+              if (this.debug) {
+                console.log(`[DEBUG] JSON validation: attempt_completion response is a JSON schema definition instead of data, correcting...`);
+              }
+              
+              // Use specialized correction prompt for schema definition confusion
+              const schemaDefinitionPrompt = createSchemaDefinitionCorrectionPrompt(
+                finalResult,
+                options.schema,
+                0
+              );
+              
+              finalResult = await this.answer(schemaDefinitionPrompt, [], { 
+                ...options, 
+                _schemaFormatted: true 
+              });
+              finalResult = cleanSchemaResponse(finalResult);
+              validation = validateJsonResponse(finalResult);
+              retryCount = 1; // Start at 1 since we already did one correction
+            }
+            
+            while (!validation.isValid && retryCount < maxRetries) {
+              if (this.debug) {
+                console.log(`[DEBUG] JSON validation: attempt_completion validation failed (attempt ${retryCount + 1}/${maxRetries}):`, validation.error);
+                console.log(`[DEBUG] JSON validation: Invalid response sample: ${finalResult.substring(0, 300)}${finalResult.length > 300 ? '...' : ''}`);
+              }
+              
+              // Check if the invalid response is actually a schema definition
+              let correctionPrompt;
+              try {
+                if (isJsonSchemaDefinition(finalResult, { debug: this.debug })) {
+                  if (this.debug) {
+                    console.log(`[DEBUG] JSON validation: attempt_completion response is still a schema definition, using specialized correction`);
+                  }
+                  correctionPrompt = createSchemaDefinitionCorrectionPrompt(
+                    finalResult,
+                    options.schema,
+                    retryCount
+                  );
+                } else {
+                  correctionPrompt = createJsonCorrectionPrompt(
+                    finalResult, 
+                    options.schema, 
+                    validation.error,
+                    retryCount
+                  );
+                }
+              } catch (error) {
+                // If we can't parse to check if it's a schema definition, use regular correction
+                correctionPrompt = createJsonCorrectionPrompt(
+                  finalResult, 
+                  options.schema, 
+                  validation.error,
+                  retryCount
+                );
+              }
+              
+              finalResult = await this.answer(correctionPrompt, [], { 
+                ...options, 
+                _schemaFormatted: true 
+              });
+              finalResult = cleanSchemaResponse(finalResult);
+              
+              // Validate the corrected response
+              validation = validateJsonResponse(finalResult, { debug: this.debug });
+              retryCount++;
+              
+              if (this.debug) {
+                if (validation.isValid) {
+                  console.log(`[DEBUG] JSON validation: attempt_completion correction successful on attempt ${retryCount}`);
+                } else {
+                  console.log(`[DEBUG] JSON validation: attempt_completion correction failed on attempt ${retryCount}: ${validation.error}`);
+                }
+              }
+            }
+            
+            // Record final validation result
+            if (this.tracer) {
+              this.tracer.recordJsonValidationEvent('attempt_completion_completed', {
+                'json_validation.success': validation.isValid,
+                'json_validation.retry_count': retryCount,
+                'json_validation.final_response_length': finalResult.length
+              });
+            }
+            
             if (!validation.isValid && this.debug) {
-              console.log(`[DEBUG] JSON validation: attempt_completion result validation failed: ${validation.error}`);
-              console.log(`[DEBUG] JSON validation: attempt_completion response: ${finalResult.substring(0, 500)}${finalResult.length > 500 ? '...' : ''}`);
+              console.log(`[DEBUG] JSON validation: attempt_completion result validation failed after ${maxRetries} attempts: ${validation.error}`);
+              console.log(`[DEBUG] JSON validation: Final attempt_completion response: ${finalResult.substring(0, 500)}${finalResult.length > 500 ? '...' : ''}`);
             } else if (validation.isValid && this.debug) {
               console.log(`[DEBUG] JSON validation: attempt_completion result validation successful`);
             }

package/build/agent/index.js

@@ -1103,8 +1103,12 @@ async function search(options) {
   }
   const binaryPath = await getBinaryPath(options.binaryOptions || {});
   const cliArgs = buildCliArgs(options, SEARCH_FLAG_MAP);
-  if (options.json) {
+  if (options.json && !options.format) {
     cliArgs.push("--format", "json");
+  } else if (options.format) {
+    if (options.format === "json") {
+      options.json = true;
+    }
   }
   if (!options.maxTokens) {
     options.maxTokens = 1e4;
@@ -1229,7 +1233,8 @@ var init_search = __esm({
       mergeThreshold: "--merge-threshold",
       session: "--session",
       timeout: "--timeout",
-      language: "--language"
+      language: "--language",
+      format: "--format"
     };
   }
 });
@@ -1876,7 +1881,7 @@ var init_vercel = __esm({
     init_delegate();
     init_common();
     searchTool = (options = {}) => {
-      const { sessionId, maxTokens = 1e4, debug = false } = options;
+      const { sessionId, maxTokens = 1e4, debug = false, outline = false } = options;
       return tool({
         name: "search",
         description: searchDescription,
@@ -1894,10 +1899,10 @@ var init_vercel = __esm({
             if (debug) {
               console.error(`Executing search with query: "${searchQuery}", path: "${searchPath}", exact: ${exact ? "true" : "false"}, language: ${language || "all"}, session: ${sessionId || "none"}`);
             }
-            const results = await search({
+            const searchOptions = {
               query: searchQuery,
               path: searchPath,
-              allow_tests,
+              allowTests: allow_tests,
               exact,
               json: false,
               maxTokens: effectiveMaxTokens,
@@ -1905,7 +1910,11 @@ var init_vercel = __esm({
               // Pass session ID if provided
               language
               // Pass language parameter if provided
-            });
+            };
+            if (outline) {
+              searchOptions.format = "outline-xml";
+            }
+            const results = await search(searchOptions);
             return results;
           } catch (error) {
             console.error("Error executing search command:", error);
@@ -1948,7 +1957,7 @@ var init_vercel = __esm({
       });
     };
     extractTool = (options = {}) => {
-      const { debug = false } = options;
+      const { debug = false, outline = false } = options;
       return tool({
         name: "extract",
         description: extractDescription,
@@ -1981,19 +1990,27 @@ var init_vercel = __esm({
               if (debug) {
                 console.error(`Created temporary file for input content: ${tempFilePath}`);
               }
+              let effectiveFormat = format;
+              if (outline && format === "outline-xml") {
+                effectiveFormat = "xml";
+              }
               extractOptions = {
                 inputFile: tempFilePath,
                 allowTests: allow_tests,
                 contextLines: context_lines,
-                format
+                format: effectiveFormat
               };
             } else if (file_path) {
               const files = [file_path];
+              let effectiveFormat = format;
+              if (outline && format === "outline-xml") {
+                effectiveFormat = "xml";
+              }
               extractOptions = {
                 files,
                 allowTests: allow_tests,
                 contextLines: context_lines,
-                format
+                format: effectiveFormat
               };
             } else {
               throw new Error("Either file_path or input_content must be provided");
@@ -3709,6 +3726,7 @@ var init_ProbeAgent = __esm({
        * @param {string} [options.provider] - Force specific AI provider
        * @param {string} [options.model] - Override model name
        * @param {boolean} [options.debug] - Enable debug mode
+       * @param {boolean} [options.outline] - Enable outline-xml format for search results
        */
       constructor(options = {}) {
         this.sessionId = options.sessionId || randomUUID4();
@@ -3718,6 +3736,7 @@ var init_ProbeAgent = __esm({
         this.debug = options.debug || process.env.DEBUG === "1";
         this.cancelled = false;
         this.tracer = options.tracer || null;
+        this.outline = !!options.outline;
         this.allowedFolders = options.path ? [options.path] : [process.cwd()];
         this.clientApiProvider = options.provider || null;
         this.clientApiKey = null;
@@ -3741,7 +3760,8 @@ var init_ProbeAgent = __esm({
           sessionId: this.sessionId,
           debug: this.debug,
           defaultPath: this.allowedFolders.length > 0 ? this.allowedFolders[0] : process.cwd(),
-          allowedFolders: this.allowedFolders
+          allowedFolders: this.allowedFolders,
+          outline: this.outline
         };
         const baseTools = createTools(configOptions);
         const wrappedTools = createWrappedTools(baseTools);
@@ -4510,12 +4530,93 @@ Convert your previous response content into actual JSON data that follows this s
               }
               if (isJsonSchema(options.schema)) {
                 if (this.debug) {
-                  console.log(`[DEBUG] JSON validation: Validating attempt_completion result`);
+                  console.log(`[DEBUG] JSON validation: Starting validation process for attempt_completion result`);
+                  console.log(`[DEBUG] JSON validation: Response length: ${finalResult.length} chars`);
+                }
+                if (this.tracer) {
+                  this.tracer.recordJsonValidationEvent("attempt_completion_started", {
+                    "json_validation.response_length": finalResult.length,
+                    "json_validation.schema_type": "JSON",
+                    "json_validation.context": "attempt_completion"
+                  });
+                }
+                let validation = validateJsonResponse(finalResult, { debug: this.debug });
+                let retryCount = 0;
+                const maxRetries = 3;
+                if (validation.isValid && isJsonSchemaDefinition(finalResult, { debug: this.debug })) {
+                  if (this.debug) {
+                    console.log(`[DEBUG] JSON validation: attempt_completion response is a JSON schema definition instead of data, correcting...`);
+                  }
+                  const schemaDefinitionPrompt = createSchemaDefinitionCorrectionPrompt(
+                    finalResult,
+                    options.schema,
+                    0
+                  );
+                  finalResult = await this.answer(schemaDefinitionPrompt, [], {
+                    ...options,
+                    _schemaFormatted: true
+                  });
+                  finalResult = cleanSchemaResponse(finalResult);
+                  validation = validateJsonResponse(finalResult);
+                  retryCount = 1;
+                }
+                while (!validation.isValid && retryCount < maxRetries) {
+                  if (this.debug) {
+                    console.log(`[DEBUG] JSON validation: attempt_completion validation failed (attempt ${retryCount + 1}/${maxRetries}):`, validation.error);
+                    console.log(`[DEBUG] JSON validation: Invalid response sample: ${finalResult.substring(0, 300)}${finalResult.length > 300 ? "..." : ""}`);
+                  }
+                  let correctionPrompt;
+                  try {
+                    if (isJsonSchemaDefinition(finalResult, { debug: this.debug })) {
+                      if (this.debug) {
+                        console.log(`[DEBUG] JSON validation: attempt_completion response is still a schema definition, using specialized correction`);
+                      }
+                      correctionPrompt = createSchemaDefinitionCorrectionPrompt(
+                        finalResult,
+                        options.schema,
+                        retryCount
+                      );
+                    } else {
+                      correctionPrompt = createJsonCorrectionPrompt(
+                        finalResult,
+                        options.schema,
+                        validation.error,
+                        retryCount
+                      );
+                    }
+                  } catch (error) {
+                    correctionPrompt = createJsonCorrectionPrompt(
+                      finalResult,
+                      options.schema,
+                      validation.error,
+                      retryCount
+                    );
+                  }
+                  finalResult = await this.answer(correctionPrompt, [], {
+                    ...options,
+                    _schemaFormatted: true
+                  });
+                  finalResult = cleanSchemaResponse(finalResult);
+                  validation = validateJsonResponse(finalResult, { debug: this.debug });
+                  retryCount++;
+                  if (this.debug) {
+                    if (validation.isValid) {
+                      console.log(`[DEBUG] JSON validation: attempt_completion correction successful on attempt ${retryCount}`);
+                    } else {
+                      console.log(`[DEBUG] JSON validation: attempt_completion correction failed on attempt ${retryCount}: ${validation.error}`);
+                    }
+                  }
+                }
+                if (this.tracer) {
+                  this.tracer.recordJsonValidationEvent("attempt_completion_completed", {
+                    "json_validation.success": validation.isValid,
+                    "json_validation.retry_count": retryCount,
+                    "json_validation.final_response_length": finalResult.length
+                  });
                 }
-                const validation = validateJsonResponse(finalResult, { debug: this.debug });
                 if (!validation.isValid && this.debug) {
-                  console.log(`[DEBUG] JSON validation: attempt_completion result validation failed: ${validation.error}`);
-                  console.log(`[DEBUG] JSON validation: attempt_completion response: ${finalResult.substring(0, 500)}${finalResult.length > 500 ? "..." : ""}`);
+                  console.log(`[DEBUG] JSON validation: attempt_completion result validation failed after ${maxRetries} attempts: ${validation.error}`);
+                  console.log(`[DEBUG] JSON validation: Final attempt_completion response: ${finalResult.substring(0, 500)}${finalResult.length > 500 ? "..." : ""}`);
                 } else if (validation.isValid && this.debug) {
                   console.log(`[DEBUG] JSON validation: attempt_completion result validation successful`);
                 }
@@ -5316,8 +5417,10 @@ function parseArgs() {
     traceFile: void 0,
     traceRemote: void 0,
     traceConsole: false,
-    useStdin: false
+    useStdin: false,
     // New flag to indicate stdin should be used
+    outline: false
+    // New flag to enable outline format
   };
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -5351,6 +5454,8 @@ function parseArgs() {
       config.traceRemote = args[++i];
     } else if (arg === "--trace-console") {
       config.traceConsole = true;
+    } else if (arg === "--outline") {
+      config.outline = true;
     } else if (!arg.startsWith("--") && !config.question) {
       config.question = arg;
     }
@@ -5380,6 +5485,7 @@ Options:
   --model <name>                   Override model name
   --allow-edit                     Enable code modification capabilities
   --verbose                        Enable verbose output
+  --outline                        Use outline-xml format for code search results
   --mcp                           Run as MCP server
   --acp                           Run as ACP server (Agent Client Protocol)
   --max-iterations <number>        Max tool iterations (default: 30)
@@ -5719,7 +5825,8 @@ async function main() {
       customPrompt: systemPrompt,
       allowEdit: config.allowEdit,
       debug: config.verbose,
-      tracer: appTracer
+      tracer: appTracer,
+      outline: config.outline
     };
     const agent = new ProbeAgent(agentConfig);
     let result;

package/build/mcp/index.js

@@ -25,6 +25,11 @@ function parseArgs() {
             }
             i++; // Skip the next argument
         }
+        else if (args[i] === '--format' && i + 1 < args.length) {
+            config.format = args[i + 1];
+            console.error(`Format set to ${config.format}`);
+            i++; // Skip the next argument
+        }
         else if (args[i] === '--help' || args[i] === '-h') {
             console.log(`
 Probe MCP Server
@@ -34,6 +39,7 @@ Usage:
 
 Options:
   --timeout, -t <seconds>  Set timeout for search operations (default: 30)
+  --format <format>       Set output format (json, outline-xml, etc.)
   --help, -h              Show this help message
 `);
             process.exit(0);
@@ -87,8 +93,9 @@ if (packageVersion === '0.0.0') {
 const binDir = path.resolve(__dirname, '..', 'bin');
 console.log(`Bin directory: ${binDir}`);
 class ProbeServer {
-    constructor(timeout = 30) {
+    constructor(timeout = 30, format) {
         this.defaultTimeout = timeout;
+        this.defaultFormat = format;
         this.server = new Server({
             name: '@probelabs/probe',
             version: packageVersion,
@@ -358,6 +365,14 @@ class ProbeServer {
             else if (this.defaultTimeout !== undefined) {
                 options.timeout = this.defaultTimeout;
             }
+            // Handle format options
+            if (this.defaultFormat === 'outline-xml') {
+                // For outline-xml format, we pass it as a format flag to the search command
+                options.format = 'outline-xml';
+            }
+            else if (this.defaultFormat === 'json') {
+                options.json = true;
+            }
             console.error("Executing search with options:", JSON.stringify(options, null, 2));
             // Double-check that path is still in the options object
             if (!options.path) {
@@ -495,5 +510,5 @@ class ProbeServer {
         console.error('Probe MCP server running on stdio');
     }
 }
-const server = new ProbeServer(cliConfig.timeout);
+const server = new ProbeServer(cliConfig.timeout, cliConfig.format);
 server.run().catch(console.error);

package/build/mcp/index.ts

@@ -17,10 +17,10 @@ import { fileURLToPath } from 'url';
 import { search, query, extract, getBinaryPath, setBinaryPath } from '../index.js';
 
 // Parse command-line arguments
-function parseArgs(): { timeout?: number } {
+function parseArgs(): { timeout?: number; format?: string } {
   const args = process.argv.slice(2);
-  const config: { timeout?: number } = {};
-  
+  const config: { timeout?: number; format?: string } = {};
+
   for (let i = 0; i < args.length; i++) {
     if ((args[i] === '--timeout' || args[i] === '-t') && i + 1 < args.length) {
       const timeout = parseInt(args[i + 1], 10);
@@ -31,6 +31,10 @@ function parseArgs(): { timeout?: number } {
         console.error(`Invalid timeout value: ${args[i + 1]}. Using default.`);
       }
       i++; // Skip the next argument
+    } else if (args[i] === '--format' && i + 1 < args.length) {
+      config.format = args[i + 1];
+      console.error(`Format set to ${config.format}`);
+      i++; // Skip the next argument
     } else if (args[i] === '--help' || args[i] === '-h') {
       console.log(`
 Probe MCP Server
@@ -40,12 +44,13 @@ Usage:
 
 Options:
   --timeout, -t <seconds>  Set timeout for search operations (default: 30)
+  --format <format>       Set output format (json, outline-xml, etc.)
   --help, -h              Show this help message
 `);
       process.exit(0);
     }
   }
-  
+
   return config;
 }
 
@@ -144,9 +149,11 @@ interface ExtractCodeArgs {
 class ProbeServer {
   private server: Server;
   private defaultTimeout: number;
+  private defaultFormat?: string;
 
-  constructor(timeout: number = 30) {
+  constructor(timeout: number = 30, format?: string) {
     this.defaultTimeout = timeout;
+    this.defaultFormat = format;
     this.server = new Server(
       {
         name: '@probelabs/probe',
@@ -426,6 +433,14 @@ class ProbeServer {
       } else if (this.defaultTimeout !== undefined) {
         options.timeout = this.defaultTimeout;
       }
+
+      // Handle format options
+      if (this.defaultFormat === 'outline-xml') {
+        // For outline-xml format, we pass it as a format flag to the search command
+        options.format = 'outline-xml';
+      } else if (this.defaultFormat === 'json') {
+        options.json = true;
+      }
       
       console.error("Executing search with options:", JSON.stringify(options, null, 2));
       
@@ -589,5 +604,5 @@ class ProbeServer {
   }
 }
 
-const server = new ProbeServer(cliConfig.timeout);
+const server = new ProbeServer(cliConfig.timeout, cliConfig.format);
 server.run().catch(console.error);

package/build/search.js

@@ -28,7 +28,8 @@ const SEARCH_FLAG_MAP = {
 	mergeThreshold: '--merge-threshold',
 	session: '--session',
 	timeout: '--timeout',
-	language: '--language'
+	language: '--language',
+	format: '--format'
 };
 
 /**
@@ -52,6 +53,7 @@ const SEARCH_FLAG_MAP = {
  * @param {string} [options.session] - Session ID for caching results
  * @param {number} [options.timeout] - Timeout in seconds (default: 30)
  * @param {string} [options.language] - Limit search to files of a specific programming language
+ * @param {string} [options.format] - Output format ('json', 'outline-xml', etc.)
  * @param {Object} [options.binaryOptions] - Options for getting the binary
  * @param {boolean} [options.binaryOptions.forceDownload] - Force download even if binary exists
  * @param {string} [options.binaryOptions.version] - Specific version to download
@@ -74,9 +76,15 @@ export async function search(options) {
 	// Build CLI arguments from options
 	const cliArgs = buildCliArgs(options, SEARCH_FLAG_MAP);
 
-	// Add JSON format if requested
-	if (options.json) {
+	// Add format if specified, with json option taking precedence for backwards compatibility
+	if (options.json && !options.format) {
 		cliArgs.push('--format', 'json');
+	} else if (options.format) {
+		// Format is already handled by buildCliArgs through SEARCH_FLAG_MAP
+		// but we need to ensure json parsing for json format
+		if (options.format === 'json') {
+			options.json = true;
+		}
 	}
 
 	// Set default maxTokens if not provided

package/build/tools/vercel.js

@@ -20,7 +20,7 @@ import { searchSchema, querySchema, extractSchema, delegateSchema, searchDescrip
  * @returns {Object} Configured search tool
  */
 export const searchTool = (options = {}) => {
-	const { sessionId, maxTokens = 10000, debug = false } = options;
+	const { sessionId, maxTokens = 10000, debug = false, outline = false } = options;
 
 	return tool({
 		name: 'search',
@@ -46,16 +46,23 @@ export const searchTool = (options = {}) => {
 					console.error(`Executing search with query: "${searchQuery}", path: "${searchPath}", exact: ${exact ? 'true' : 'false'}, language: ${language || 'all'}, session: ${sessionId || 'none'}`);
 				}
 
-				const results = await search({
+				const searchOptions = {
 					query: searchQuery,
 					path: searchPath,
-					allow_tests,
+					allowTests: allow_tests,
 					exact,
 					json: false,
 					maxTokens: effectiveMaxTokens,
 					session: sessionId, // Pass session ID if provided
 					language // Pass language parameter if provided
-				});
+				};
+
+				// Add outline format if enabled
+				if (outline) {
+					searchOptions.format = 'outline-xml';
+				}
+
+				const results = await search(searchOptions);
 
 				return results;
 			} catch (error) {
@@ -122,7 +129,7 @@ export const queryTool = (options = {}) => {
  * @returns {Object} Configured extract tool
  */
 export const extractTool = (options = {}) => {
-	const { debug = false } = options;
+	const { debug = false, outline = false } = options;
 
 	return tool({
 		name: 'extract',
@@ -168,23 +175,35 @@ export const extractTool = (options = {}) => {
 						console.error(`Created temporary file for input content: ${tempFilePath}`);
 					}
 
+					// Apply format mapping for outline-xml to xml
+					let effectiveFormat = format;
+					if (outline && format === 'outline-xml') {
+						effectiveFormat = 'xml';
+					}
+
 					// Set up extract options with input file
 					extractOptions = {
 						inputFile: tempFilePath,
 						allowTests: allow_tests,
 						contextLines: context_lines,
-						format
+						format: effectiveFormat
 					};
 				} else if (file_path) {
 					// Parse file_path to handle line numbers and symbol names
 					const files = [file_path];
 
+					// Apply format mapping for outline-xml to xml
+					let effectiveFormat = format;
+					if (outline && format === 'outline-xml') {
+						effectiveFormat = 'xml';
+					}
+
 					// Set up extract options with files
 					extractOptions = {
 						files,
 						allowTests: allow_tests,
 						contextLines: context_lines,
-						format
+						format: effectiveFormat
 					};
 				} else {
 					throw new Error('Either file_path or input_content must be provided');