@juspay/neurolink 7.14.1 → 7.14.3

package/dist/sdk/toolRegistration.d.ts

@@ -5,7 +5,7 @@
 import { z } from "zod";
 import { logger } from "../utils/logger.js";
 import type { MCPServerInfo, MCPServerCategory } from "../types/mcpTypes.js";
-import type { ToolArgs, ToolContext as CoreToolContext, ToolResult, SimpleTool as CoreSimpleTool } from "../types/tools.js";
+import type { ToolArgs, ToolContext as CoreToolContext, ToolResult, SimpleTool as CoreSimpleTool, ZodUnknownSchema } from "../types/tools.js";
 import type { JsonValue } from "../types/common.js";
 /**
  * Enhanced validation configuration
@@ -39,7 +39,7 @@ export interface ToolContext extends CoreToolContext {
     /**
      * Call another tool
      */
-    callTool?: (name: string, args: ToolArgs) => Promise<ToolResult>;
+    callTool?: (name: string, params: ToolArgs) => Promise<ToolResult>;
     /**
      * Logger instance
      */
@@ -57,11 +57,11 @@ export interface SimpleTool<TArgs = ToolArgs, TResult = JsonValue> extends Omit<
     /**
      * Parameters schema using Zod (optional)
      */
-    parameters?: z.ZodSchema;
+    parameters?: ZodUnknownSchema;
     /**
      * Tool execution function
      */
-    execute: (args: TArgs, context?: ToolContext) => Promise<TResult> | TResult;
+    execute: (params: TArgs, context?: ToolContext) => Promise<TResult>;
     /**
      * Optional metadata
      */
@@ -99,9 +99,9 @@ export declare function createValidatedTool(name: string, config: SimpleTool, op
 /**
  * Helper to create a tool with typed parameters
  */
-export declare function createTypedTool<TParams extends z.ZodSchema>(config: Omit<SimpleTool, "execute"> & {
+export declare function createTypedTool<TParams extends ZodUnknownSchema>(config: Omit<SimpleTool, "execute"> & {
     parameters: TParams;
-    execute: (args: z.infer<TParams>, context?: ToolContext) => Promise<JsonValue> | JsonValue;
+    execute: (params: z.infer<TParams>, context?: ToolContext) => Promise<JsonValue> | JsonValue;
 }): SimpleTool;
 /**
  * Validate tool configuration with detailed error messages

package/dist/sdk/toolRegistration.js

@@ -4,6 +4,7 @@
  */
 import { logger } from "../utils/logger.js";
 import { createMCPServerInfo } from "../utils/mcpDefaults.js";
+import { validateToolName, validateToolDescription, } from "../utils/parameterValidation.js";
 /**
  * Configuration constants for tool validation
  */
@@ -153,39 +154,15 @@ export function createTypedTool(config) {
     return config;
 }
 /**
- * Enhanced tool name validation
+ * Enhanced tool name validation using centralized utilities
  */
-function validateToolName(name) {
-    // Basic validation
-    if (!name || typeof name !== "string" || name.trim() === "") {
-        throw new Error(`Invalid tool name: must be a non-empty string. Received: ${name}`);
+function validateToolNameLegacy(name) {
+    const error = validateToolName(name);
+    if (error) {
+        throw error;
     }
+    // Additional legacy-specific validations
     const trimmedName = name.trim();
-    // Length validation
-    if (trimmedName.length < VALIDATION_CONFIG.NAME_MIN_LENGTH) {
-        throw new Error(`Tool name too short: '${name}' (${trimmedName.length} chars). ` +
-            `Minimum length: ${VALIDATION_CONFIG.NAME_MIN_LENGTH} characters. ` +
-            `Example: 'get_data', 'send_email'`);
-    }
-    // Only check name length if limit is greater than 0 (0 means unlimited)
-    if (VALIDATION_CONFIG.NAME_MAX_LENGTH > 0 &&
-        trimmedName.length > VALIDATION_CONFIG.NAME_MAX_LENGTH) {
-        throw new Error(`Tool name too long: '${name}' (${trimmedName.length} chars). ` +
-            `Maximum length: ${VALIDATION_CONFIG.NAME_MAX_LENGTH} characters. ` +
-            `Consider shortening: '${trimmedName.substring(0, 20)}...'`);
-    }
-    // Format validation (alphanumeric, hyphens, underscores only)
-    const validNamePattern = /^[a-zA-Z0-9_-]+$/;
-    if (!validNamePattern.test(trimmedName)) {
-        throw new Error(`Invalid tool name format: '${name}'. Tool names must contain only alphanumeric characters, hyphens, and underscores. ` +
-            `Examples: 'calculate-tax', 'get_weather', 'sendEmail123'`);
-    }
-    // Reserved name validation
-    if (VALIDATION_CONFIG.RESERVED_NAMES.has(trimmedName.toLowerCase())) {
-        throw new Error(`Tool name '${name}' is reserved and cannot be used. ` +
-            `Reserved names include: ${Array.from(VALIDATION_CONFIG.RESERVED_NAMES).slice(0, 5).join(", ")}... ` +
-            `Try variations like: '${trimmedName}_tool', 'custom_${trimmedName}', '${trimmedName}_helper'`);
-    }
     // Naming convention suggestions using pre-compiled patterns for performance
     const hasGoodPattern = VALIDATION_CONFIG.COMPILED_PATTERN_REGEXES.some((patternRegex) => {
         return patternRegex.test(trimmedName);
@@ -196,31 +173,15 @@ function validateToolName(name) {
     }
 }
 /**
- * Enhanced description validation
+ * Enhanced description validation using centralized utilities
  */
-function validateToolDescription(name, description) {
-    if (!description ||
-        typeof description !== "string" ||
-        description.trim() === "") {
-        throw new Error(`Tool '${name}' must have a non-empty description string. ` +
-            `Example: { description: "Calculates mathematical expressions", execute: async (params) => {...} }`);
+function validateToolDescriptionLegacy(name, description) {
+    const error = validateToolDescription(description);
+    if (error) {
+        throw new Error(`Tool '${name}': ${error.message}`);
     }
+    // Additional legacy-specific validations
     const trimmedDescription = description.trim();
-    // Length validation
-    if (trimmedDescription.length < VALIDATION_CONFIG.DESCRIPTION_MIN_LENGTH) {
-        throw new Error(`Tool '${name}' description too short: ${trimmedDescription.length} characters. ` +
-            `Minimum length: ${VALIDATION_CONFIG.DESCRIPTION_MIN_LENGTH} characters. ` +
-            `The description should clearly explain what the tool does and when to use it. ` +
-            `Example: "Fetches current weather data for a specified location using coordinates or city name"`);
-    }
-    // Only check description length if limit is greater than 0 (0 means unlimited)
-    if (VALIDATION_CONFIG.DESCRIPTION_MAX_LENGTH > 0 &&
-        trimmedDescription.length > VALIDATION_CONFIG.DESCRIPTION_MAX_LENGTH) {
-        throw new Error(`Tool '${name}' description too long: ${trimmedDescription.length} characters. ` +
-            `Maximum length: ${VALIDATION_CONFIG.DESCRIPTION_MAX_LENGTH} characters. ` +
-            `Current description: "${trimmedDescription.substring(0, 50)}..." ` +
-            `Try to be more concise while keeping the essential information.`);
-    }
     // Quality suggestions
     const hasActionWord = /^(get|fetch|calculate|send|create|update|delete|validate|process|generate|parse|convert)/i.test(trimmedDescription);
     if (!hasActionWord) {
@@ -231,15 +192,15 @@ function validateToolDescription(name, description) {
  * Validate tool configuration with detailed error messages
  */
 export function validateTool(name, tool) {
-    // Enhanced tool name validation
-    validateToolName(name);
+    // Enhanced tool name validation using centralized utilities
+    validateToolNameLegacy(name);
     // Validate tool object
     if (!tool || typeof tool !== "object") {
         throw new Error(`Tool '${name}' must be an object with description and execute properties. Received: ${typeof tool}. ` +
             `Expected format: { description: "Tool description", execute: async (params) => { ... } }`);
     }
-    // Enhanced description validation
-    validateToolDescription(name, tool.description);
+    // Enhanced description validation using centralized utilities
+    validateToolDescriptionLegacy(name, tool.description);
     // Validate execute function with signature guidance
     if (typeof tool.execute !== "function") {
         throw new Error(`Tool '${name}' must have an execute function. ` +

package/dist/types/generateTypes.d.ts

@@ -1,5 +1,5 @@
-import type { ZodType, ZodTypeDef } from "zod";
-import type { Tool, Schema } from "ai";
+import type { Tool } from "ai";
+import type { ValidationSchema, StandardRecord } from "./typeAliases.js";
 import type { AIProviderName, AnalyticsData, EvaluationData } from "../core/types.js";
 /**
  * Generate function options interface - Primary method for content generation
@@ -17,13 +17,13 @@ export interface GenerateOptions {
     temperature?: number;
     maxTokens?: number;
     systemPrompt?: string;
-    schema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>;
+    schema?: ValidationSchema;
     tools?: Record<string, Tool>;
     timeout?: number | string;
     disableTools?: boolean;
     enableEvaluation?: boolean;
     enableAnalytics?: boolean;
-    context?: Record<string, unknown>;
+    context?: StandardRecord;
     evaluationDomain?: string;
     toolUsageContext?: string;
     conversationHistory?: Array<{
@@ -32,7 +32,7 @@ export interface GenerateOptions {
     }>;
     factoryConfig?: {
         domainType?: string;
-        domainConfig?: Record<string, unknown>;
+        domainConfig?: StandardRecord;
         enhancementType?: "domain-configuration" | "streaming-optimization" | "mcp-integration" | "legacy-migration" | "context-conversion";
         preserveLegacyFields?: boolean;
         validateDomainData?: boolean;
@@ -65,20 +65,20 @@ export interface GenerateResult {
     toolCalls?: Array<{
         toolCallId: string;
         toolName: string;
-        args: Record<string, unknown>;
+        args: StandardRecord;
     }>;
     toolResults?: unknown[];
     toolsUsed?: string[];
     toolExecutions?: Array<{
         name: string;
-        input: Record<string, unknown>;
+        input: StandardRecord;
         output: unknown;
     }>;
     enhancedWithTools?: boolean;
     availableTools?: Array<{
         name: string;
         description: string;
-        parameters: Record<string, unknown>;
+        parameters: StandardRecord;
     }>;
     analytics?: AnalyticsData;
     evaluation?: EvaluationData;
@@ -87,7 +87,7 @@ export interface GenerateResult {
         enhancementType?: string;
         domainType?: string;
         processingTime?: number;
-        configurationUsed?: Record<string, unknown>;
+        configurationUsed?: StandardRecord;
         migrationPerformed?: boolean;
         legacyFieldsPreserved?: boolean;
     };

package/dist/types/streamTypes.d.ts

@@ -1,5 +1,5 @@
-import type { ZodType, ZodTypeDef } from "zod";
-import type { Tool, Schema } from "ai";
+import type { Tool } from "ai";
+import type { ValidationSchema, StandardRecord } from "./typeAliases.js";
 import type { AIProviderName, AnalyticsData, EvaluationData } from "../core/types.js";
 import type { UnknownRecord, JsonValue } from "./common.js";
 import type { ChatMessage } from "./conversationTypes.js";
@@ -80,7 +80,7 @@ export interface StreamOptions {
     temperature?: number;
     maxTokens?: number;
     systemPrompt?: string;
-    schema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>;
+    schema?: ValidationSchema;
     tools?: Record<string, Tool>;
     timeout?: number | string;
     disableTools?: boolean;
@@ -96,7 +96,7 @@ export interface StreamOptions {
     }>;
     factoryConfig?: {
         domainType?: string;
-        domainConfig?: Record<string, unknown>;
+        domainConfig?: StandardRecord;
         enhancementType?: "domain-configuration" | "streaming-optimization" | "mcp-integration" | "legacy-migration" | "context-conversion";
         preserveLegacyFields?: boolean;
         validateDomainData?: boolean;

package/dist/types/tools.d.ts

@@ -4,10 +4,18 @@
  */
 import { z } from "zod";
 import type { Result, JsonValue, ErrorInfo } from "./common.js";
+/**
+ * Commonly used Zod schema type aliases for cleaner type declarations
+ */
+import type { ZodUnknownSchema } from "./typeAliases.js";
+export type { ZodUnknownSchema } from "./typeAliases.js";
+export type ZodAnySchema = z.ZodSchema<unknown>;
+export type ZodObjectSchema = z.ZodObject<z.ZodRawShape>;
+export type ZodStringSchema = z.ZodString;
 /**
  * Tool parameter schema types
  */
-export type ToolParameterSchema = z.ZodSchema | Record<string, JsonValue>;
+export type ToolParameterSchema = ZodUnknownSchema | Record<string, JsonValue>;
 /**
  * Standard tool input parameters
  */
@@ -78,16 +86,16 @@ export interface ToolDefinition<TArgs = ToolArgs, TResult = JsonValue> {
     description: string;
     parameters?: ToolParameterSchema;
     metadata?: ToolMetadata;
-    execute: (args: TArgs, context?: ToolContext) => Promise<ToolResult<TResult>> | ToolResult<TResult>;
+    execute: (params: TArgs, context?: ToolContext) => Promise<ToolResult<TResult>> | ToolResult<TResult>;
 }
 /**
  * Simple tool interface (for SDK)
  */
 export interface SimpleTool<TArgs = ToolArgs, TResult = JsonValue> {
     description: string;
-    parameters?: z.ZodSchema;
+    parameters?: ZodUnknownSchema;
     metadata?: ToolMetadata;
-    execute: (args: TArgs, context?: ToolContext) => Promise<TResult> | TResult;
+    execute: (params: TArgs, context?: ToolContext) => Promise<TResult>;
 }
 /**
  * Tool registry entry
@@ -105,7 +113,7 @@ export interface ToolRegistryEntry {
  */
 export interface ToolExecution {
     toolName: string;
-    args: ToolArgs;
+    params: ToolArgs;
     result: ToolResult;
     executionTime: number;
     timestamp: number;
@@ -124,7 +132,7 @@ export interface AvailableTool {
  * Tool validation options
  */
 export interface ToolValidationOptions {
-    customValidator?: (toolName: string, args: ToolArgs) => boolean | Promise<boolean>;
+    customValidator?: (toolName: string, params: ToolArgs) => boolean | Promise<boolean>;
     validateSchema?: boolean;
     allowUnknownProperties?: boolean;
 }
@@ -143,7 +151,7 @@ export interface AiSdkToolCall {
     type: "tool-call";
     toolCallId: string;
     toolName: string;
-    args: ToolArgs;
+    params: ToolArgs;
 }
 /**
  * Tool call result (for AI SDK integration)