@juspay/neurolink 7.36.0 → 7.37.1

package/dist/lib/utils/schemaConversion.js

@@ -0,0 +1,140 @@
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { jsonSchemaToZod } from "json-schema-to-zod";
+import { z } from "zod";
+import { logger } from "./logger.js";
+/**
+ * Convert Zod schema to JSON Schema format for Claude AI
+ */
+export function convertZodToJsonSchema(zodSchema) {
+    try {
+        // Use a type assertion that bypasses the infinite recursion check
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const jsonSchema = zodToJsonSchema(zodSchema, {
+            name: "ToolParameters",
+            target: "jsonSchema7",
+            errorMessages: true,
+        });
+        // CRITICAL FIX: Ensure schema always has a proper type field for Google Vertex AI
+        if (!jsonSchema.type) {
+            // Default to "object" type if not specified, as most tool schemas are objects
+            jsonSchema.type = "object";
+            // If no properties, ensure it's at least an empty object schema
+            if (!jsonSchema.properties) {
+                jsonSchema.properties = {};
+            }
+            logger.info(`[SCHEMA-TYPE-FIX] Added missing type field to JSON Schema`, {
+                originalType: undefined,
+                fixedType: jsonSchema.type,
+                hasProperties: !!jsonSchema.properties,
+                addedEmptyProperties: !jsonSchema.properties,
+            });
+        }
+        logger.debug("Converted Zod schema to JSON Schema", {
+            hasProperties: !!jsonSchema.properties,
+            propertiesCount: Object.keys(jsonSchema.properties || {}).length,
+            schemaType: jsonSchema.type,
+            hasTypeField: !!jsonSchema.type,
+        });
+        return jsonSchema;
+    }
+    catch (error) {
+        logger.warn("Failed to convert Zod schema to JSON Schema", {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        // Return a valid empty object schema instead of empty object
+        return {
+            type: "object",
+            properties: {},
+        };
+    }
+}
+/**
+ * Check if a value is a Zod schema
+ */
+export function isZodSchema(value) {
+    return !!(value &&
+        typeof value === "object" &&
+        "_def" in value &&
+        typeof value.parse === "function");
+}
+/**
+ * Convert JSON Schema to Zod schema format using official json-schema-to-zod library
+ * This ensures complete preservation of all schema structure and validation rules
+ */
+export function convertJsonSchemaToZod(jsonSchema) {
+    const startTime = Date.now();
+    try {
+        // Handle empty or invalid schemas
+        if (!jsonSchema || typeof jsonSchema !== "object") {
+            logger.debug("🔍 [SCHEMA-CONVERSION] Invalid or empty JSON schema, using fallback");
+            return z.object({}).passthrough();
+        }
+        // Log detailed input schema for debugging
+        logger.debug("🔍 [SCHEMA-CONVERSION] ===== STARTING OFFICIAL LIBRARY CONVERSION =====");
+        logger.debug("🔍 [SCHEMA-CONVERSION] Input JSON Schema:", {
+            type: jsonSchema.type,
+            hasProperties: !!jsonSchema.properties,
+            propertiesCount: jsonSchema.properties
+                ? Object.keys(jsonSchema.properties).length
+                : 0,
+            requiredCount: Array.isArray(jsonSchema.required)
+                ? jsonSchema.required.length
+                : 0,
+            required: jsonSchema.required,
+            sampleProperties: jsonSchema.properties
+                ? Object.keys(jsonSchema.properties).slice(0, 5)
+                : [],
+        });
+        // Use official library to convert JSON Schema to Zod code
+        const zodCodeResult = jsonSchemaToZod(jsonSchema, {
+            module: "esm",
+            name: "schema",
+        });
+        logger.debug("🔍 [SCHEMA-CONVERSION] Generated Zod code:", {
+            codeLength: zodCodeResult.length,
+            codePreview: zodCodeResult.substring(0, 200) + "...",
+        });
+        // Extract the actual Zod schema expression from the generated code
+        // Generated code looks like: "import { z } from "zod"\n\nexport const schema = z.object({...})\n"
+        const schemaMatch = zodCodeResult.match(/export const schema = (z\..+?)(?:\n|$)/s);
+        if (!schemaMatch) {
+            throw new Error("Could not extract Zod schema from generated code");
+        }
+        const schemaExpression = schemaMatch[1].trim();
+        logger.debug("🔍 [SCHEMA-CONVERSION] Extracted schema expression:", {
+            expression: schemaExpression.substring(0, 300) + "...",
+        });
+        // Use Function constructor instead of eval for better scope control
+        const createZodSchema = new Function("z", `return ${schemaExpression}`);
+        const zodSchema = createZodSchema(z);
+        const conversionTime = Date.now() - startTime;
+        logger.debug("🔍 [SCHEMA-CONVERSION] ===== CONVERSION SUCCESSFUL =====", {
+            inputType: jsonSchema.type,
+            propertiesCount: jsonSchema.properties
+                ? Object.keys(jsonSchema.properties).length
+                : 0,
+            requiredCount: Array.isArray(jsonSchema.required)
+                ? jsonSchema.required.length
+                : 0,
+            conversionSuccess: true,
+            conversionTimeMs: conversionTime,
+            libraryUsed: "json-schema-to-zod-official",
+            zodSchemaType: zodSchema?.constructor?.name || "unknown",
+        });
+        return zodSchema;
+    }
+    catch (error) {
+        const conversionTime = Date.now() - startTime;
+        logger.warn("🚨 [SCHEMA-CONVERSION] Official library conversion failed, using passthrough fallback", {
+            error: error instanceof Error ? error.message : String(error),
+            errorType: error instanceof Error ? error.constructor.name : typeof error,
+            inputSchemaType: jsonSchema?.type,
+            inputSchemaKeys: jsonSchema && typeof jsonSchema === "object"
+                ? Object.keys(jsonSchema)
+                : [],
+            conversionTimeMs: conversionTime,
+            libraryUsed: "json-schema-to-zod-official-FAILED",
+        });
+        return z.object({}).passthrough();
+    }
+}

package/dist/lib/utils/taskClassificationUtils.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Task Classification Utility Functions
+ * Helper functions for analyzing prompts and calculating scores
+ */
+import type { ClassificationScores } from "../types/taskClassificationTypes.js";
+/**
+ * Analyze prompt length and apply scoring bonuses
+ */
+export declare function analyzeLengthFactors(prompt: string, reasons: string[]): {
+    fastScore: number;
+    reasoningScore: number;
+};
+/**
+ * Check prompt against fast task patterns
+ */
+export declare function checkFastPatterns(normalizedPrompt: string, reasons: string[]): number;
+/**
+ * Check prompt against reasoning task patterns
+ */
+export declare function checkReasoningPatterns(normalizedPrompt: string, reasons: string[]): number;
+/**
+ * Analyze keyword matches in the prompt
+ */
+export declare function analyzeKeywords(normalizedPrompt: string, reasons: string[]): {
+    fastScore: number;
+    reasoningScore: number;
+};
+/**
+ * Analyze question complexity
+ */
+export declare function analyzeQuestionComplexity(prompt: string, reasons: string[]): number;
+/**
+ * Analyze prompt structure and punctuation
+ */
+export declare function analyzePromptStructure(prompt: string, reasons: string[]): number;
+/**
+ * Analyze domain-specific indicators
+ */
+export declare function analyzeDomainIndicators(normalizedPrompt: string, prompt: string, reasons: string[]): {
+    fastScore: number;
+    reasoningScore: number;
+};
+/**
+ * Calculate final confidence score
+ */
+export declare function calculateConfidence(fastScore: number, reasoningScore: number): number;
+/**
+ * Determine task type based on scores
+ */
+export declare function determineTaskType(fastScore: number, reasoningScore: number): "fast" | "reasoning";
+/**
+ * Comprehensive prompt analysis
+ * Runs all analysis functions and returns combined scores
+ */
+export declare function analyzePrompt(prompt: string): ClassificationScores;

package/dist/lib/utils/taskClassificationUtils.js

@@ -0,0 +1,149 @@
+/**
+ * Task Classification Utility Functions
+ * Helper functions for analyzing prompts and calculating scores
+ */
+import { FAST_PATTERNS, REASONING_PATTERNS, FAST_KEYWORDS, REASONING_KEYWORDS, SCORING_WEIGHTS, CLASSIFICATION_THRESHOLDS, DOMAIN_PATTERNS, } from "../config/taskClassificationConfig.js";
+/**
+ * Analyze prompt length and apply scoring bonuses
+ */
+export function analyzeLengthFactors(prompt, reasons) {
+    let fastScore = 0;
+    let reasoningScore = 0;
+    if (prompt.length < CLASSIFICATION_THRESHOLDS.SHORT_PROMPT_LENGTH) {
+        fastScore += SCORING_WEIGHTS.SHORT_PROMPT_BONUS;
+        reasons.push("short prompt");
+    }
+    else if (prompt.length > CLASSIFICATION_THRESHOLDS.LONG_PROMPT_LENGTH) {
+        reasoningScore += SCORING_WEIGHTS.LONG_PROMPT_BONUS;
+        reasons.push("detailed prompt");
+    }
+    return { fastScore, reasoningScore };
+}
+/**
+ * Check prompt against fast task patterns
+ */
+export function checkFastPatterns(normalizedPrompt, reasons) {
+    for (const pattern of FAST_PATTERNS) {
+        if (pattern.test(normalizedPrompt)) {
+            reasons.push("fast pattern match");
+            return SCORING_WEIGHTS.PATTERN_MATCH_SCORE;
+        }
+    }
+    return 0;
+}
+/**
+ * Check prompt against reasoning task patterns
+ */
+export function checkReasoningPatterns(normalizedPrompt, reasons) {
+    for (const pattern of REASONING_PATTERNS) {
+        if (pattern.test(normalizedPrompt)) {
+            reasons.push("reasoning pattern match");
+            return SCORING_WEIGHTS.PATTERN_MATCH_SCORE;
+        }
+    }
+    return 0;
+}
+/**
+ * Analyze keyword matches in the prompt
+ */
+export function analyzeKeywords(normalizedPrompt, reasons) {
+    const fastKeywordMatches = FAST_KEYWORDS.filter((keyword) => normalizedPrompt.includes(keyword)).length;
+    const reasoningKeywordMatches = REASONING_KEYWORDS.filter((keyword) => normalizedPrompt.includes(keyword)).length;
+    const fastScore = fastKeywordMatches * SCORING_WEIGHTS.KEYWORD_MATCH_SCORE;
+    const reasoningScore = reasoningKeywordMatches * SCORING_WEIGHTS.KEYWORD_MATCH_SCORE;
+    if (fastKeywordMatches > 0) {
+        reasons.push(`${fastKeywordMatches} fast keywords`);
+    }
+    if (reasoningKeywordMatches > 0) {
+        reasons.push(`${reasoningKeywordMatches} reasoning keywords`);
+    }
+    return { fastScore, reasoningScore };
+}
+/**
+ * Analyze question complexity
+ */
+export function analyzeQuestionComplexity(prompt, reasons) {
+    const questionMarks = (prompt.match(/\?/g) || []).length;
+    if (questionMarks > 1) {
+        reasons.push("multiple questions");
+        return SCORING_WEIGHTS.MULTIPLE_QUESTIONS_BONUS;
+    }
+    return 0;
+}
+/**
+ * Analyze prompt structure and punctuation
+ */
+export function analyzePromptStructure(prompt, reasons) {
+    const sentences = prompt.split(/[.!?]+/).filter((s) => s.trim().length > 0);
+    if (sentences.length > 3) {
+        reasons.push("multi-sentence structure");
+        return SCORING_WEIGHTS.MULTI_SENTENCE_BONUS;
+    }
+    return 0;
+}
+/**
+ * Analyze domain-specific indicators
+ */
+export function analyzeDomainIndicators(normalizedPrompt, prompt, reasons) {
+    let fastScore = 0;
+    let reasoningScore = 0;
+    // Check for technical domain
+    if (DOMAIN_PATTERNS.TECHNICAL.test(normalizedPrompt)) {
+        reasoningScore += SCORING_WEIGHTS.TECHNICAL_DOMAIN_BONUS;
+        reasons.push("technical domain");
+    }
+    // Check for simple definition requests
+    if (DOMAIN_PATTERNS.SIMPLE_DEFINITION.test(normalizedPrompt) &&
+        prompt.length < CLASSIFICATION_THRESHOLDS.SIMPLE_DEFINITION_LENGTH) {
+        fastScore += SCORING_WEIGHTS.SIMPLE_DEFINITION_BONUS;
+        reasons.push("simple definition request");
+    }
+    return { fastScore, reasoningScore };
+}
+/**
+ * Calculate final confidence score
+ */
+export function calculateConfidence(fastScore, reasoningScore) {
+    const totalScore = fastScore + reasoningScore;
+    if (totalScore === 0) {
+        return CLASSIFICATION_THRESHOLDS.DEFAULT_CONFIDENCE;
+    }
+    const rawConfidence = Math.max(fastScore, reasoningScore) / totalScore;
+    return Math.max(CLASSIFICATION_THRESHOLDS.MIN_CONFIDENCE, Math.min(CLASSIFICATION_THRESHOLDS.MAX_CONFIDENCE, rawConfidence));
+}
+/**
+ * Determine task type based on scores
+ */
+export function determineTaskType(fastScore, reasoningScore) {
+    return fastScore >= reasoningScore ? "fast" : "reasoning";
+}
+/**
+ * Comprehensive prompt analysis
+ * Runs all analysis functions and returns combined scores
+ */
+export function analyzePrompt(prompt) {
+    const normalizedPrompt = prompt.toLowerCase().trim();
+    const reasons = [];
+    let fastScore = 0;
+    let reasoningScore = 0;
+    // 1. Length analysis
+    const lengthScores = analyzeLengthFactors(prompt, reasons);
+    fastScore += lengthScores.fastScore;
+    reasoningScore += lengthScores.reasoningScore;
+    // 2. Pattern matching
+    fastScore += checkFastPatterns(normalizedPrompt, reasons);
+    reasoningScore += checkReasoningPatterns(normalizedPrompt, reasons);
+    // 3. Keyword analysis
+    const keywordScores = analyzeKeywords(normalizedPrompt, reasons);
+    fastScore += keywordScores.fastScore;
+    reasoningScore += keywordScores.reasoningScore;
+    // 4. Question complexity
+    reasoningScore += analyzeQuestionComplexity(prompt, reasons);
+    // 5. Structure analysis
+    reasoningScore += analyzePromptStructure(prompt, reasons);
+    // 6. Domain analysis
+    const domainScores = analyzeDomainIndicators(normalizedPrompt, prompt, reasons);
+    fastScore += domainScores.fastScore;
+    reasoningScore += domainScores.reasoningScore;
+    return { fastScore, reasoningScore, reasons };
+}

package/dist/lib/utils/taskClassifier.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Binary Task Classifier for NeuroLink Orchestration
+ * Classifies tasks as either 'fast' (quick responses) or 'reasoning' (complex analysis)
+ */
+import type { TaskType, TaskClassification, ClassificationStats, ClassificationValidation } from "../types/taskClassificationTypes.js";
+/**
+ * Binary Task Classifier
+ * Determines if a task requires fast response or deeper reasoning
+ */
+export declare class BinaryTaskClassifier {
+    /**
+     * Classify a prompt as either fast or reasoning task
+     */
+    static classify(prompt: string): TaskClassification;
+    /**
+     * Get classification statistics for multiple prompts
+     */
+    static getClassificationStats(prompts: string[]): ClassificationStats;
+    /**
+     * Validate classification accuracy (for testing/tuning)
+     */
+    static validateClassification(prompt: string, expectedType: TaskType): ClassificationValidation;
+}

package/dist/lib/utils/taskClassifier.js

@@ -0,0 +1,94 @@
+/**
+ * Binary Task Classifier for NeuroLink Orchestration
+ * Classifies tasks as either 'fast' (quick responses) or 'reasoning' (complex analysis)
+ */
+import { logger } from "./logger.js";
+import { CLASSIFICATION_THRESHOLDS } from "../config/taskClassificationConfig.js";
+import { analyzePrompt, calculateConfidence, determineTaskType, } from "./taskClassificationUtils.js";
+import { redactForClassification } from "./promptRedaction.js";
+/**
+ * Binary Task Classifier
+ * Determines if a task requires fast response or deeper reasoning
+ */
+export class BinaryTaskClassifier {
+    /**
+     * Classify a prompt as either fast or reasoning task
+     */
+    static classify(prompt) {
+        const startTime = Date.now();
+        // Analyze the prompt using utility functions
+        const scores = analyzePrompt(prompt);
+        const { fastScore, reasoningScore, reasons } = scores;
+        // Determine final classification
+        const totalScore = fastScore + reasoningScore;
+        let type;
+        let confidence;
+        if (totalScore === 0) {
+            // Default to fast for ambiguous cases
+            type = "fast";
+            confidence = CLASSIFICATION_THRESHOLDS.DEFAULT_CONFIDENCE;
+            reasons.push("default fallback");
+        }
+        else {
+            type = determineTaskType(fastScore, reasoningScore);
+            confidence = calculateConfidence(fastScore, reasoningScore);
+        }
+        const classification = {
+            type,
+            confidence,
+            reasoning: reasons.join(", "),
+        };
+        const classificationTime = Date.now() - startTime;
+        logger.debug("Task classified", {
+            prompt: redactForClassification(prompt),
+            classification: type,
+            confidence: confidence.toFixed(2),
+            fastScore,
+            reasoningScore,
+            reasons: reasons.join(", "),
+            classificationTime: `${classificationTime}ms`,
+        });
+        return classification;
+    }
+    /**
+     * Get classification statistics for multiple prompts
+     */
+    static getClassificationStats(prompts) {
+        // Guard against empty array to prevent divide-by-zero
+        if (prompts.length === 0) {
+            const stats = {
+                total: 0,
+                fast: 0,
+                reasoning: 0,
+                averageConfidence: 0,
+            };
+            logger.debug("Classification stats", stats);
+            return stats;
+        }
+        const classifications = prompts.map((prompt) => this.classify(prompt));
+        const stats = {
+            total: classifications.length,
+            fast: classifications.filter((c) => c.type === "fast").length,
+            reasoning: classifications.filter((c) => c.type === "reasoning").length,
+            averageConfidence: classifications.reduce((sum, c) => sum + c.confidence, 0) /
+                classifications.length,
+        };
+        logger.debug("Classification stats", stats);
+        return stats;
+    }
+    /**
+     * Validate classification accuracy (for testing/tuning)
+     */
+    static validateClassification(prompt, expectedType) {
+        const classification = this.classify(prompt);
+        const correct = classification.type === expectedType;
+        logger.debug("Classification validation", {
+            prompt: redactForClassification(prompt),
+            expected: expectedType,
+            actual: classification.type,
+            correct,
+            confidence: classification.confidence,
+        });
+        return { correct, classification };
+    }
+}

package/dist/lib/utils/transformationUtils.js

@@ -2,6 +2,7 @@
  * Object Transformation Utilities
  * Centralizes repeated object transformation patterns to improve code reuse and maintainability
  */
+import { logger } from "./logger.js";
 // ============================================================================
 // TOOL EXECUTION TRANSFORMATIONS
 // ============================================================================
@@ -43,22 +44,109 @@ export function transformToolExecutions(toolExecutions) {
         if (!toolName) {
             toolName = `tool_execution_${index}`;
         }
+        // Enhanced tool parameter extraction with structured logging
+        const parameterExtractionData = {
+            executionIndex: index,
+            toolNameExtracted: toolName,
+            primarySources: {
+                hasInput: !!teRecord.input,
+                hasParameters: !!teRecord.parameters,
+                hasArgs: !!teRecord.args,
+                inputType: typeof teRecord.input,
+                parametersType: typeof teRecord.parameters,
+                argsType: typeof teRecord.args,
+            },
+            rawRecordKeys: Object.keys(teRecord),
+        };
+        logger.debug("[TransformationUtils] Tool parameter extraction analysis", parameterExtractionData);
         // Enhanced input extraction
         let input = teRecord.input ||
             teRecord.parameters ||
             teRecord.args ||
             {};
+        const primaryExtractionResult = {
+            keysCount: Object.keys(input).length,
+            keys: Object.keys(input),
+            extractionSuccessful: Object.keys(input).length > 0,
+            extractionSource: teRecord.input
+                ? "input"
+                : teRecord.parameters
+                    ? "parameters"
+                    : teRecord.args
+                        ? "args"
+                        : "empty",
+        };
+        logger.debug("[TransformationUtils] Primary parameter extraction result", primaryExtractionResult);
         // Extract input from nested toolCall if available
         if (Object.keys(input).length === 0 &&
             teRecord.toolCall &&
             typeof teRecord.toolCall === "object") {
             const toolCall = teRecord.toolCall;
+            const nestedExtractionData = {
+                reason: "Primary extraction failed, checking nested toolCall",
+                nestedSources: {
+                    hasInput: !!toolCall.input,
+                    hasParameters: !!toolCall.parameters,
+                    hasArgs: !!toolCall.args,
+                },
+                toolCallKeys: Object.keys(toolCall),
+            };
+            logger.debug("[TransformationUtils] Nested parameter extraction attempt", nestedExtractionData);
             input =
                 toolCall.input ||
                     toolCall.parameters ||
                     toolCall.args ||
                     {};
+            const nestedExtractionResult = {
+                keysCount: Object.keys(input).length,
+                keys: Object.keys(input),
+                extractionSuccessful: Object.keys(input).length > 0,
+                extractionSource: toolCall.input
+                    ? "toolCall.input"
+                    : toolCall.parameters
+                        ? "toolCall.parameters"
+                        : toolCall.args
+                            ? "toolCall.args"
+                            : "empty",
+            };
+            logger.debug("[TransformationUtils] Nested parameter extraction result", nestedExtractionResult);
+        }
+        // Target tool parameter analysis for critical tools
+        if (toolName &&
+            (toolName.includes("SuccessRateSRByTime") ||
+                toolName.includes("juspay-analytics"))) {
+            const targetToolAnalysis = {
+                toolName,
+                inputKeys: Object.keys(input),
+                keysCount: Object.keys(input).length,
+                hasStartTime: "startTime" in input,
+                hasEndTime: "endTime" in input,
+                startTimeValue: input.startTime || "MISSING",
+                endTimeValue: input.endTime || "MISSING",
+                extractionStatus: Object.keys(input).length === 0 ? "FAILED" : "SUCCESS",
+            };
+            logger.debug("[TransformationUtils] Target tool parameter analysis", targetToolAnalysis);
+            if (Object.keys(input).length === 0) {
+                logger.error("[TransformationUtils] Critical: Target tool parameter extraction failed", {
+                    toolName,
+                    reason: "Both primary and nested extraction returned empty parameters",
+                    impact: "AI response did not contain expected parameter structure",
+                });
+            }
         }
+        // Final parameter extraction summary
+        const finalExtractionSummary = {
+            toolName,
+            inputKeysCount: Object.keys(input).length,
+            inputKeys: Object.keys(input),
+            hasParameters: Object.keys(input).length > 0,
+            duration: teRecord.duration ??
+                teRecord.executionTime ??
+                teRecord.responseTime ??
+                0,
+            hasOutput: !!(teRecord.output || teRecord.result || teRecord.response),
+        };
+        logger.debug("[TransformationUtils] Final parameter extraction result", finalExtractionSummary);
         // Enhanced output extraction with success indication
         const output = teRecord.output ||
             teRecord.result ||
@@ -169,14 +257,61 @@ export function transformAvailableTools(availableTools) {
     }
     return availableTools.map((tool) => {
         const toolRecord = tool;
+        let extractedParameters = {};
+        const inputSchema = toolRecord.inputSchema;
+        const directParameters = toolRecord.parameters;
+        const fallbackSchema = toolRecord.schema;
+        if (inputSchema && typeof inputSchema === "object") {
+            if (inputSchema.$ref && inputSchema.definitions) {
+                const definitions = inputSchema.definitions;
+                const refValue = inputSchema.$ref;
+                if (typeof refValue === "string") {
+                    const refKey = refValue.replace("#/definitions/", "");
+                    if (definitions[refKey] && typeof definitions[refKey] === "object") {
+                        const resolvedSchema = definitions[refKey];
+                        extractedParameters = {
+                            type: resolvedSchema.type || "object",
+                            properties: resolvedSchema.properties || {},
+                            required: resolvedSchema.required || [],
+                            ...resolvedSchema, // Include all schema metadata
+                        };
+                    }
+                }
+            }
+            else if (inputSchema.properties) {
+                extractedParameters = {
+                    type: inputSchema.type || "object",
+                    properties: inputSchema.properties,
+                    required: inputSchema.required || [],
+                    ...inputSchema,
+                };
+            }
+            else if (inputSchema.type === "object") {
+                extractedParameters = inputSchema;
+            }
+            else {
+                extractedParameters = inputSchema;
+            }
+        }
+        else if (directParameters && typeof directParameters === "object") {
+            extractedParameters = directParameters;
+        }
+        else if (fallbackSchema && typeof fallbackSchema === "object") {
+            extractedParameters = fallbackSchema;
+        }
+        if (!extractedParameters || typeof extractedParameters !== "object") {
+            extractedParameters = {};
+        }
+        if (extractedParameters &&
+            !extractedParameters.type &&
+            extractedParameters.properties) {
+            extractedParameters.type = "object";
+        }
         return {
             name: tool.name || "",
             description: tool.description || "",
             server: tool.server || "",
-            parameters: toolRecord.inputSchema ||
-                toolRecord.parameters ||
-                toolRecord.schema ||
-                {},
+            parameters: extractedParameters,
         };
     });
 }
@@ -246,7 +381,10 @@ export function transformSchemaToParameterDescription(schema) {
         .map(([key, value]) => {
         const typedValue = value;
         const required = requiredParams.has(key) ? " (required)" : "";
-        return `  - ${key}: ${typedValue.type || "unknown"}${required}`;
+        const description = typedValue.description
+            ? ` - ${typedValue.description}`
+            : "";
+        return `  - ${key}: ${typedValue.type || "unknown"}${required}${description}`;
     })
         .join("\n");
 }

package/dist/mcp/externalServerManager.js

@@ -89,9 +89,9 @@ export class ExternalServerManager extends EventEmitter {
             enablePerformanceMonitoring: config.enablePerformanceMonitoring ?? true,
             logLevel: config.logLevel ?? "info",
         };
-        // Enable main tool registry integration by default
+        // Disable main tool registry integration by default to prevent automatic tool execution
         this.enableMainRegistryIntegration =
-            options.enableMainRegistryIntegration ?? true;
+            options.enableMainRegistryIntegration ?? false;
         // Initialize tool discovery service
         this.toolDiscovery = new ToolDiscoveryService();
         // Forward tool discovery events