@juspay/neurolink 7.14.1 → 7.14.3

package/dist/lib/providers/openAI.d.ts

@@ -1,5 +1,5 @@
-import type { ZodType, ZodTypeDef } from "zod";
-import { type Schema, type LanguageModelV1 } from "ai";
+import { type LanguageModelV1 } from "ai";
+import type { ValidationSchema } from "../types/typeAliases.js";
 import { AIProviderName } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
@@ -23,6 +23,6 @@ export declare class OpenAIProvider extends BaseProvider {
      * For details on the changes and migration steps, refer to the BaseProvider documentation
      * and the migration guide in the project repository.
      */
-    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected executeStream(options: StreamOptions, analysisSchema?: ValidationSchema): Promise<StreamResult>;
 }
 export default OpenAIProvider;

package/dist/lib/providers/openaiCompatible.d.ts

@@ -1,5 +1,5 @@
-import type { ZodType, ZodTypeDef } from "zod";
 import { type Schema, type LanguageModelV1 } from "ai";
+import type { ZodUnknownSchema } from "../types/typeAliases.js";
 import type { AIProviderName } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
@@ -29,7 +29,7 @@ export declare class OpenAICompatibleProvider extends BaseProvider {
      * Provider-specific streaming implementation
      * Note: This is only used when tools are disabled
      */
-    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected executeStream(options: StreamOptions, analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
     /**
      * Get available models from OpenAI Compatible endpoint
      *

package/dist/lib/providers/sagemaker/client.d.ts

@@ -5,6 +5,7 @@
  * with enhanced error handling, retry logic, and NeuroLink-specific features.
  */
 import type { SageMakerConfig, InvokeEndpointParams, InvokeEndpointResponse } from "./types.js";
+import type { ConnectionResult } from "../../types/typeAliases.js";
 /**
  * Enhanced SageMaker Runtime client with retry logic and error handling
  */
@@ -149,8 +150,4 @@ export declare function createSageMakerRuntimeClient(config: SageMakerConfig): S
  * @param endpointName - Endpoint to test
  * @returns Promise resolving to connectivity test result
  */
-export declare function testSageMakerConnectivity(config: SageMakerConfig, endpointName: string): Promise<{
-    connected: boolean;
-    latency?: number;
-    error?: string;
-}>;
+export declare function testSageMakerConnectivity(config: SageMakerConfig, endpointName: string): Promise<ConnectionResult>;

package/dist/lib/providers/sagemaker/language-model.d.ts

@@ -6,6 +6,7 @@
  */
 import type { LanguageModelV1, LanguageModelV1CallOptions, LanguageModelV1StreamPart } from "ai";
 import type { SageMakerConfig, SageMakerModelConfig } from "./types.js";
+import type { ConnectivityResult } from "../../types/typeAliases.js";
 /**
  * SageMaker Language Model implementing LanguageModelV1 interface
  */
@@ -125,16 +126,13 @@ export declare class SageMakerLanguageModel implements LanguageModelV1 {
         provider: string;
         specificationVersion: string;
         endpointName: string;
-        modelType: "huggingface" | "mistral" | "custom" | "claude" | "llama" | "jumpstart" | undefined;
+        modelType: "mistral" | "huggingface" | "custom" | "claude" | "llama" | "jumpstart" | undefined;
         region: string;
     };
     /**
      * Test basic connectivity to the SageMaker endpoint
      */
-    testConnectivity(): Promise<{
-        success: boolean;
-        error?: string;
-    }>;
+    testConnectivity(): Promise<ConnectivityResult>;
     /**
      * Batch inference support (Phase 4)
      * Process multiple prompts in a single request for efficiency
@@ -175,7 +173,7 @@ export declare class SageMakerLanguageModel implements LanguageModelV1 {
         provider: string;
         specificationVersion: string;
         endpointName: string;
-        modelType: "huggingface" | "mistral" | "custom" | "claude" | "llama" | "jumpstart" | undefined;
+        modelType: "mistral" | "huggingface" | "custom" | "claude" | "llama" | "jumpstart" | undefined;
         region: string;
     };
 }

package/dist/lib/providers/sagemaker/parsers.js

@@ -4,6 +4,7 @@
  * This module provides protocol-specific parsers for different streaming
  * formats used by SageMaker endpoints (HuggingFace, LLaMA, custom models).
  */
+import { isNonNullObject } from "../../utils/typeUtils.js";
 import { createStructuredOutputParser, isStructuredContent, } from "./structured-parser.js";
 import { SageMakerError } from "./errors.js";
 import { logger } from "../../utils/logger.js";
@@ -229,7 +230,7 @@ export class HuggingFaceStreamParser extends BaseStreamingParser {
                 }
                 // Parse JSON data
                 const parsed = this.parseJSON(data);
-                if (parsed && typeof parsed === "object" && parsed !== null) {
+                if (parsed && isNonNullObject(parsed)) {
                     const chunk = this.parseHuggingFaceChunk(parsed);
                     if (chunk) {
                         chunks.push(chunk);
@@ -310,7 +311,7 @@ export class LlamaStreamParser extends BaseStreamingParser {
             }
             // Parse each line as JSON
             const parsed = this.parseJSON(trimmed);
-            if (parsed && typeof parsed === "object" && parsed !== null) {
+            if (parsed && isNonNullObject(parsed)) {
                 const chunk = this.parseLlamaChunk(parsed);
                 if (chunk) {
                     chunks.push(chunk);
@@ -512,7 +513,7 @@ export class CustomStreamParser extends BaseStreamingParser {
                 const line = this.buffer.substring(startIndex, newlineIndex);
                 if (line.trim()) {
                     const parsed = this.parseJSON(line.trim());
-                    if (parsed && typeof parsed === "object" && parsed !== null) {
+                    if (parsed && isNonNullObject(parsed)) {
                         const chunk = this.parseCustomChunk(parsed);
                         if (chunk) {
                             chunks.push(chunk);
@@ -605,7 +606,7 @@ function formatErrorMessage(error) {
  * Handles both string and object error formats consistently
  */
 function extractApiErrorMessage(errorData) {
-    if (typeof errorData === "object" && errorData !== null) {
+    if (isNonNullObject(errorData)) {
         return errorData.message || String(errorData);
     }
     return String(errorData);

package/dist/lib/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/lib/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/lib/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/lib/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/lib/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)