@juspay/neurolink 7.37.0 → 7.37.1

package/dist/utils/schemaConversion.d.ts

@@ -0,0 +1,14 @@
+import type { ZodUnknownSchema } from "../types/tools.js";
+/**
+ * Convert Zod schema to JSON Schema format for Claude AI
+ */
+export declare function convertZodToJsonSchema(zodSchema: ZodUnknownSchema): object;
+/**
+ * Check if a value is a Zod schema
+ */
+export declare function isZodSchema(value: unknown): boolean;
+/**
+ * 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 declare function convertJsonSchemaToZod(jsonSchema: Record<string, unknown>): ZodUnknownSchema;

package/dist/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/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.37.1",
   "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",