@juspay/neurolink 5.3.0 → 6.0.0

package/dist/lib/providers/ollama.js

@@ -54,7 +54,8 @@ class OllamaLanguageModel {
             .join("\n");
     }
     async doGenerate(options) {
-        const messages = options.messages || [];
+        const messages = options
+            .messages || [];
         const prompt = this.convertMessagesToPrompt(messages);
         const response = await fetch(`${this.baseUrl}/api/generate`, {
             method: "POST",
@@ -80,11 +81,25 @@ class OllamaLanguageModel {
             usage: {
                 promptTokens: this.estimateTokens(prompt),
                 completionTokens: this.estimateTokens(data.response),
+                totalTokens: this.estimateTokens(prompt) + this.estimateTokens(data.response),
+            },
+            finishReason: "stop",
+            rawCall: {
+                rawPrompt: prompt,
+                rawSettings: {
+                    model: this.modelId,
+                    temperature: options.temperature,
+                    num_predict: options.maxTokens,
+                },
+            },
+            rawResponse: {
+                headers: {},
             },
         };
     }
     async doStream(options) {
-        const messages = options.messages || [];
+        const messages = options
+            .messages || [];
         const prompt = this.convertMessagesToPrompt(messages);
         const response = await fetch(`${this.baseUrl}/api/generate`, {
             method: "POST",
@@ -104,8 +119,32 @@ class OllamaLanguageModel {
         if (!response.ok) {
             throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
         }
+        const self = this;
         return {
-            stream: this.parseStreamResponse(response),
+            stream: new ReadableStream({
+                async start(controller) {
+                    try {
+                        for await (const chunk of self.parseStreamResponse(response)) {
+                            controller.enqueue(chunk);
+                        }
+                        controller.close();
+                    }
+                    catch (error) {
+                        controller.error(error);
+                    }
+                },
+            }),
+            rawCall: {
+                rawPrompt: prompt,
+                rawSettings: {
+                    model: this.modelId,
+                    temperature: options.temperature,
+                    num_predict: options.maxTokens,
+                },
+            },
+            rawResponse: {
+                headers: {},
+            },
         };
     }
     async *parseStreamResponse(response) {
@@ -194,6 +233,7 @@ export class OllamaProvider extends BaseProvider {
     }
     /**
      * Returns the Vercel AI SDK model instance for Ollama
+     * The OllamaLanguageModel implements LanguageModelV1 interface properly
      */
     getAISDKModel() {
         return this.ollamaModel;

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

@@ -16,7 +16,7 @@ export declare class OpenAIProvider extends BaseProvider {
      * Returns the Vercel AI SDK model instance for OpenAI
      */
     protected getAISDKModel(): LanguageModelV1;
-    protected handleProviderError(error: any): Error;
+    protected handleProviderError(error: unknown): Error;
     /**
      * executeGenerate method removed - generation is now handled by BaseProvider.
      * For details on the changes and migration steps, refer to the BaseProvider documentation

package/dist/lib/providers/openAI.js

@@ -52,14 +52,18 @@ export class OpenAIProvider extends BaseProvider {
         if (error instanceof TimeoutError) {
             return new Error(`OpenAI request timed out: ${error.message}`);
         }
-        if (error?.message?.includes("API_KEY_INVALID") ||
-            error?.message?.includes("Invalid API key")) {
+        const errorObj = error;
+        const message = errorObj?.message && typeof errorObj.message === "string"
+            ? errorObj.message
+            : "Unknown error";
+        if (message.includes("API_KEY_INVALID") ||
+            message.includes("Invalid API key")) {
             return new Error("Invalid OpenAI API key. Please check your OPENAI_API_KEY environment variable.");
         }
-        if (error?.message?.includes("rate limit")) {
+        if (message.includes("rate limit")) {
             return new Error("OpenAI rate limit exceeded. Please try again later.");
         }
-        return new Error(`OpenAI error: ${error?.message || "Unknown error"}`);
+        return new Error(`OpenAI error: ${message}`);
     }
     /**
      * executeGenerate method removed - generation is now handled by BaseProvider.

package/dist/lib/proxy/proxy-fetch.js

@@ -40,11 +40,12 @@ export function createProxyFetch() {
                     dispatcher: dispatcher,
                 });
                 logger.debug(`[Proxy Fetch] ✅ Request proxied successfully to ${url.hostname}`);
-                return response; // Type assertion to avoid complex type issues
+                return response; // undici.fetch returns compatible Response type
             }
         }
         catch (error) {
-            logger.warn(`[Proxy Fetch] Proxy failed (${error.message}), falling back to direct connection`);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.warn(`[Proxy Fetch] Proxy failed (${errorMessage}), falling back to direct connection`);
         }
         // Fallback to standard fetch
         return fetch(input, init);

package/dist/lib/sdk/tool-extension.d.ts

@@ -16,11 +16,11 @@ export interface CustomTool {
     /**
      * Parameters schema using Zod or JSON Schema
      */
-    parameters?: z.ZodSchema | Record<string, any>;
+    parameters?: z.ZodSchema | Record<string, unknown>;
     /**
      * Tool execution function
      */
-    execute: (args: any, context?: ToolContext) => Promise<any> | any;
+    execute: (args: unknown, context?: ToolContext) => Promise<unknown> | unknown;
     /**
      * Optional metadata
      */
@@ -46,7 +46,7 @@ export interface ToolContext {
     /**
      * Call another tool
      */
-    callTool: (name: string, args: any) => Promise<any>;
+    callTool: (name: string, args: unknown) => Promise<unknown>;
     /**
      * Current session information
      */
@@ -64,7 +64,7 @@ export interface ToolContext {
 /**
  * Tool middleware function
  */
-export type ToolMiddleware = (toolName: string, args: any, next: () => Promise<any>, context: ToolContext) => Promise<any>;
+export type ToolMiddleware = (toolName: string, args: unknown, next: () => Promise<unknown>, context: ToolContext) => Promise<unknown>;
 /**
  * Tool permission configuration
  */
@@ -72,7 +72,7 @@ export interface ToolPermissions {
     allowlist?: string[];
     denylist?: string[];
     requireApproval?: string[];
-    customValidator?: (toolName: string, args: any) => boolean | Promise<boolean>;
+    customValidator?: (toolName: string, args: unknown) => boolean | Promise<boolean>;
 }
 /**
  * Converts a custom tool to Vercel AI SDK format
@@ -129,7 +129,7 @@ export declare class ToolRegistry {
     /**
      * Execute a tool with middleware
      */
-    execute(name: string, args: any, context: ToolContext): Promise<any>;
+    execute(name: string, args: unknown, context: ToolContext): Promise<unknown>;
 }
 /**
  * Create a simple tool helper
@@ -139,7 +139,7 @@ export declare function createTool(config: CustomTool): CustomTool;
  * Create an async tool helper
  */
 export declare function createAsyncTool(config: Omit<CustomTool, "execute"> & {
-    execute: (args: any, context?: ToolContext) => Promise<any>;
+    execute: (args: unknown, context?: ToolContext) => Promise<unknown>;
 }): CustomTool;
 /**
  * Create a batch tool that processes multiple items
@@ -163,16 +163,16 @@ export declare const TestUtils: {
      * Test a tool with mock data
      */
     testTool(tool: CustomTool, testCases: Array<{
-        input: any;
-        expected?: any;
+        input: unknown;
+        expected?: unknown;
     }>): Promise<({
-        input: any;
-        output: any;
+        input: unknown;
+        output: unknown;
         success: boolean;
         matches: boolean | undefined;
         error?: undefined;
     } | {
-        input: any;
+        input: unknown;
         error: string;
         success: boolean;
         output?: undefined;

package/dist/lib/sdk/tool-extension.js

@@ -217,7 +217,8 @@ export function createAsyncTool(config) {
 export function createBatchTool(config) {
     return {
         ...config,
-        execute: async ({ items }, context) => {
+        execute: async (args, context) => {
+            const { items } = args;
             const batchSize = config.batchSize || 10;
             const results = [];
             for (let i = 0; i < items.length; i += batchSize) {

package/dist/lib/sdk/tool-registration.d.ts

@@ -6,18 +6,17 @@ import { z } from "zod";
 import type { Tool } from "ai";
 import { logger } from "../utils/logger.js";
 import type { InMemoryMCPServerConfig, InMemoryToolInfo } from "../types/mcp-types.js";
+import type { ToolArgs, ToolContext as CoreToolContext, ToolResult, SimpleTool as CoreSimpleTool } from "../types/tools.js";
+import type { JsonValue } from "../types/common.js";
 /**
  * Context provided to tools during execution
+ * Extends the core ToolContext with SDK-specific features
  */
-export interface ToolContext {
+export interface ToolContext extends CoreToolContext {
     /**
      * Current session ID
      */
     sessionId: string;
-    /**
-     * User ID if available
-     */
-    userId?: string;
     /**
      * AI provider being used
      */
@@ -29,7 +28,7 @@ export interface ToolContext {
     /**
      * Call another tool
      */
-    callTool?: (name: string, args: any) => Promise<any>;
+    callTool?: (name: string, args: ToolArgs) => Promise<ToolResult>;
     /**
      * Logger instance
      */
@@ -37,8 +36,9 @@ export interface ToolContext {
 }
 /**
  * Simple tool interface for SDK users
+ * Extends the core SimpleTool with specific types
  */
-export interface SimpleTool {
+export interface SimpleTool<TArgs = ToolArgs, TResult = JsonValue> extends Omit<CoreSimpleTool<TArgs, TResult>, "execute"> {
     /**
      * Tool description that helps AI understand when to use it
      */
@@ -50,7 +50,7 @@ export interface SimpleTool {
     /**
      * Tool execution function
      */
-    execute: (args: any, context?: ToolContext) => Promise<any> | any;
+    execute: (args: TArgs, context?: ToolContext) => Promise<TResult> | TResult;
     /**
      * Optional metadata
      */
@@ -58,7 +58,9 @@ export interface SimpleTool {
         category?: string;
         version?: string;
         author?: string;
-        [key: string]: any;
+        tags?: string[];
+        documentation?: string;
+        [key: string]: JsonValue | undefined;
     };
 }
 /**
@@ -76,18 +78,20 @@ export declare function createMCPServerFromTools(serverId: string, tools: Record
     title?: string;
     description?: string;
     category?: string;
-    [key: string]: any;
+    version?: string;
+    author?: string;
+    [key: string]: JsonValue | undefined;
 }): InMemoryMCPServerConfig;
 /**
  * Helper to create a tool with type safety
  */
-export declare function createTool<TParams = any>(config: SimpleTool): SimpleTool;
+export declare function createTool<TParams = ToolArgs>(config: SimpleTool): SimpleTool;
 /**
  * Helper to create a tool with typed parameters
  */
 export declare function createTypedTool<TParams extends z.ZodSchema>(config: Omit<SimpleTool, "execute"> & {
     parameters: TParams;
-    execute: (args: z.infer<TParams>, context?: ToolContext) => Promise<any> | any;
+    execute: (args: z.infer<TParams>, context?: ToolContext) => Promise<JsonValue> | JsonValue;
 }): SimpleTool;
 /**
  * Validate tool configuration with detailed error messages

package/dist/lib/sdk/tool-registration.js

@@ -41,8 +41,9 @@ export function convertToMCPTool(simpleTool) {
     return {
         description: simpleTool.description,
         execute: async (params) => {
+            const typedParams = params;
             try {
-                const result = await simpleTool.execute(params);
+                const result = await simpleTool.execute(typedParams);
                 return {
                     success: true,
                     data: result,
@@ -134,7 +135,7 @@ export function validateTool(name, tool) {
     // Validate execute function with signature guidance
     if (typeof tool.execute !== "function") {
         throw new Error(`Tool '${name}' must have an execute function. ` +
-            `Expected signature: async (params?: any) => Promise<any>. ` +
+            `Expected signature: async (params?: ToolArgs) => Promise<unknown>. ` +
             `Received: ${typeof tool.execute}. ` +
             `Example: { execute: async (params) => { return { success: true, data: result }; } }`);
     }

package/dist/lib/services/types.d.ts

@@ -1,3 +1,4 @@
+import type { UnknownRecord, Unknown } from "../types/common.js";
 export interface StreamingSession {
     id: string;
     connectionId: string;
@@ -57,12 +58,12 @@ export interface StreamingChannel {
     type: "ai-response" | "mcp-tool" | "chat" | "notification";
     status: "open" | "closed" | "error";
     buffer: StreamingBuffer;
-    onData: (data: any) => void;
+    onData: (data: Unknown) => void;
     onError: (error: Error) => void;
     onClose: () => void;
 }
 export interface StreamingBuffer {
-    data: any[];
+    data: Unknown[];
     maxSize: number;
     currentSize: number;
     flushThreshold: number;
@@ -92,7 +93,7 @@ export interface WebSocketMessage {
     connectionId: string;
     roomId?: string;
     timestamp: number;
-    data: any;
+    data: Unknown;
     metadata?: {
         provider?: string;
         model?: string;
@@ -151,5 +152,5 @@ export interface ConnectionInfo {
     lastActivity: number;
     rooms: Set<string>;
     subscriptions: Set<string>;
-    metadata: Record<string, any>;
+    metadata: UnknownRecord;
 }

package/dist/lib/services/websocket/websocket-server.d.ts

@@ -18,7 +18,7 @@ export declare class NeuroLinkWebSocketServer extends EventEmitter {
     broadcastToRoom(roomId: string, message: WebSocketMessage): void;
     createStreamingChannel(connectionId: string, channelId: string): StreamingChannel;
     destroyStreamingChannel(channelId: string): void;
-    private sendMessage;
+    sendMessage(connectionId: string, message: WebSocketMessage): boolean;
     private sendError;
     private updateLastActivity;
     private handleHeartbeat;

package/dist/lib/services/websocket/websocket-server.js

@@ -44,7 +44,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
         }
         const connectionId = randomUUID();
         const userAgent = request.headers["user-agent"];
-        const ipAddress = request.socket.remoteAddress;
+        const ipAddress = request.socket?.remoteAddress;
         // Store connection
         this.connections.set(connectionId, ws);
         this.connectionInfo.set(connectionId, {

package/dist/lib/telemetry/telemetry-service.js

@@ -1,5 +1,5 @@
 import { NodeSDK } from "@opentelemetry/sdk-node";
-import { metrics, trace } from "@opentelemetry/api";
+import { metrics, trace, } from "@opentelemetry/api";
 import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { Resource } from "@opentelemetry/resources";

package/dist/lib/types/cli.d.ts

@@ -0,0 +1,247 @@
+/**
+ * CLI-specific type definitions for NeuroLink
+ * Replaces 'any' types in CLI commands and arguments
+ */
+import type { UnknownRecord, JsonValue } from "./common.js";
+import type { AnalyticsData, EvaluationData, TokenUsage } from "./providers.js";
+import type { ToolCall, ToolResult } from "./tools.js";
+/**
+ * Base command arguments interface
+ */
+export interface BaseCommandArgs {
+    /** Enable debug output */
+    debug?: boolean;
+    /** Output format */
+    format?: "text" | "json" | "table";
+    /** Verbose output */
+    verbose?: boolean;
+    /** Quiet mode */
+    quiet?: boolean;
+}
+/**
+ * Generate command arguments
+ */
+export interface GenerateCommandArgs extends BaseCommandArgs {
+    /** Input text or prompt */
+    input?: string;
+    /** AI provider to use */
+    provider?: string;
+    /** Model name */
+    model?: string;
+    /** System prompt */
+    system?: string;
+    /** Temperature setting */
+    temperature?: number;
+    /** Maximum tokens */
+    maxTokens?: number;
+    /** Enable analytics */
+    analytics?: boolean;
+    /** Enable evaluation */
+    evaluation?: boolean;
+    /** Context data */
+    context?: string;
+    /** Disable tools */
+    disableTools?: boolean;
+    /** Maximum steps for multi-turn */
+    maxSteps?: number;
+    /** Output file */
+    output?: string;
+}
+/**
+ * Stream command arguments
+ */
+export interface StreamCommandArgs extends BaseCommandArgs {
+    /** Input text or prompt */
+    input?: string;
+    /** AI provider to use */
+    provider?: string;
+    /** Model name */
+    model?: string;
+    /** System prompt */
+    system?: string;
+    /** Temperature setting */
+    temperature?: number;
+    /** Maximum tokens */
+    maxTokens?: number;
+    /** Disable tools */
+    disableTools?: boolean;
+}
+/**
+ * MCP command arguments
+ */
+export interface MCPCommandArgs extends BaseCommandArgs {
+    /** MCP server name */
+    server?: string;
+    /** Tool name to execute */
+    tool?: string;
+    /** Tool parameters as JSON string */
+    params?: string;
+    /** List available tools */
+    list?: boolean;
+    /** Discover MCP servers */
+    discover?: boolean;
+    /** Show server information */
+    info?: boolean;
+}
+/**
+ * Ollama command arguments
+ */
+export interface OllamaCommandArgs extends BaseCommandArgs {
+    /** Ollama model name */
+    model?: string;
+    /** List available models */
+    list?: boolean;
+    /** Pull a model */
+    pull?: boolean;
+    /** Remove a model */
+    remove?: boolean;
+    /** Show model information */
+    show?: boolean;
+}
+/**
+ * Provider status command arguments
+ */
+export interface ProviderStatusArgs extends BaseCommandArgs {
+    /** Specific provider to check */
+    provider?: string;
+    /** Check all providers */
+    all?: boolean;
+}
+/**
+ * CLI command result
+ */
+export interface CommandResult {
+    /** Command success status */
+    success: boolean;
+    /** Result data */
+    data?: unknown;
+    /** Error message if failed */
+    error?: string;
+    /** Output content */
+    content?: string;
+    /** Execution metadata */
+    metadata?: {
+        executionTime?: number;
+        timestamp?: number;
+        command?: string;
+    };
+}
+/**
+ * Generate command result
+ */
+export interface GenerateResult extends CommandResult {
+    content: string;
+    provider?: string;
+    model?: string;
+    usage?: TokenUsage;
+    responseTime?: number;
+    toolCalls?: ToolCall[];
+    toolResults?: ToolResult[];
+    analytics?: AnalyticsData;
+    evaluation?: EvaluationData;
+    toolsUsed?: string[];
+    toolExecutions?: Array<{
+        toolName: string;
+        args: UnknownRecord;
+        result: unknown;
+        executionTime: number;
+    }>;
+    enhancedWithTools?: boolean;
+    availableTools?: Array<{
+        name: string;
+        description: string;
+    }>;
+}
+/**
+ * Stream result chunk
+ */
+export interface StreamChunk {
+    content?: string;
+    delta?: string;
+    done?: boolean;
+    metadata?: UnknownRecord;
+}
+/**
+ * CLI output formatting options
+ */
+export interface OutputOptions {
+    format: "text" | "json" | "table";
+    pretty?: boolean;
+    color?: boolean;
+    compact?: boolean;
+}
+/**
+ * Command handler function type
+ */
+export type CommandHandler<TArgs = BaseCommandArgs, TResult = CommandResult> = (args: TArgs) => Promise<TResult>;
+/**
+ * Command definition
+ */
+export interface CommandDefinition<TArgs = BaseCommandArgs> {
+    name: string;
+    description: string;
+    aliases?: string[];
+    args?: {
+        [K in keyof TArgs]: {
+            type: "string" | "number" | "boolean";
+            description: string;
+            required?: boolean;
+            default?: TArgs[K];
+        };
+    };
+    handler: CommandHandler<TArgs>;
+}
+/**
+ * CLI context
+ */
+export interface CLIContext {
+    cwd: string;
+    args: string[];
+    env: NodeJS.ProcessEnv;
+    exitCode?: number;
+}
+/**
+ * Color mapping for CLI output
+ */
+export interface ColorMap {
+    [severity: string]: {
+        color: string;
+        symbol?: string;
+    };
+}
+/**
+ * Display severity colors (for evaluation display)
+ */
+export interface SeverityColors {
+    [key: string]: {
+        color: string;
+        symbol: string;
+    };
+}
+/**
+ * JSON output structure
+ */
+export interface JSONOutput {
+    success: boolean;
+    data?: JsonValue;
+    error?: string;
+    metadata?: {
+        timestamp: number;
+        command: string;
+        version?: string;
+    };
+}
+/**
+ * Console override for quiet mode
+ */
+export interface ConsoleOverride {
+    [method: string]: (() => void) | undefined;
+}
+/**
+ * Type guard for generate result
+ */
+export declare function isGenerateResult(value: unknown): value is GenerateResult;
+/**
+ * Type guard for command result
+ */
+export declare function isCommandResult(value: unknown): value is CommandResult;

package/dist/lib/types/cli.js

@@ -0,0 +1,22 @@
+/**
+ * CLI-specific type definitions for NeuroLink
+ * Replaces 'any' types in CLI commands and arguments
+ */
+/**
+ * Type guard for generate result
+ */
+export function isGenerateResult(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "content" in value &&
+        typeof value.content === "string");
+}
+/**
+ * Type guard for command result
+ */
+export function isCommandResult(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "success" in value &&
+        typeof value.success === "boolean");
+}