@juspay/neurolink 7.37.0 → 7.38.0

package/dist/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "7.37.0",
+  "version": "7.38.0",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 9 major providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
     "name": "Juspay Technologies",
@@ -174,6 +174,7 @@
     "chalk": "^5.3.0",
     "dotenv": "^16.5.0",
     "inquirer": "^9.2.15",
+    "json-schema-to-zod": "^2.6.1",
     "mathjs": "^14.5.3",
     "nanoid": "^5.1.5",
     "ollama-ai-provider": "^1.2.0",
@@ -186,7 +187,7 @@
     "ws": "^8.18.3",
     "yargs": "^17.7.2",
     "zod": "^3.22.0",
-    "zod-to-json-schema": "^3.24.5"
+    "zod-to-json-schema": "^3.24.6"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.1.4",