@juspay/neurolink 6.1.0 → 6.2.1

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

@@ -1,284 +0,0 @@
-/**
- * NeuroLink SDK Tool Extension System
- * Allows developers to register custom tools that integrate with AI providers
- */
-import { z } from "zod";
-import { tool as createAISDKTool } from "ai";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { logger } from "../utils/logger.js";
-/**
- * Converts a custom tool to Vercel AI SDK format
- */
-export function convertToAISDKTool(name, customTool) {
-    // Convert parameters to JSON schema if needed
-    let parametersSchema = {};
-    let zodSchema;
-    if (customTool.parameters) {
-        if ("parse" in customTool.parameters && "_def" in customTool.parameters) {
-            // It's a Zod schema
-            zodSchema = customTool.parameters;
-            parametersSchema = zodToJsonSchema(zodSchema);
-        }
-        else {
-            // It's already a JSON schema - convert to Zod
-            parametersSchema = customTool.parameters;
-            zodSchema = z.object({}).passthrough(); // Allow any properties
-        }
-    }
-    else {
-        zodSchema = z.object({});
-    }
-    return createAISDKTool({
-        description: customTool.description,
-        parameters: zodSchema,
-        execute: async (args) => {
-            try {
-                // Apply timeout if configured
-                if (customTool.config?.timeout) {
-                    return await Promise.race([
-                        customTool.execute(args),
-                        new Promise((_, reject) => setTimeout(() => reject(new Error(`Tool ${name} timed out`)), customTool.config.timeout)),
-                    ]);
-                }
-                return await customTool.execute(args);
-            }
-            catch (error) {
-                logger.error(`Tool ${name} execution failed:`, error);
-                throw error;
-            }
-        },
-    });
-}
-/**
- * Tool registry for managing custom tools
- */
-export class ToolRegistry {
-    tools = new Map();
-    middleware = [];
-    permissions = {};
-    rateLimits = new Map();
-    /**
-     * Simple rate limiting check with automatic cleanup
-     */
-    checkRateLimit(name, rateLimit) {
-        const now = Date.now();
-        // Clean up expired entries to prevent memory leaks
-        for (const [key, limit] of this.rateLimits.entries()) {
-            if (limit.resetTime <= now) {
-                this.rateLimits.delete(key);
-            }
-        }
-        const limit = this.rateLimits.get(name);
-        if (limit && limit.resetTime > now) {
-            if (limit.count >= rateLimit.requests) {
-                throw new Error(`Tool ${name} rate limit exceeded`);
-            }
-            limit.count++;
-        }
-        else {
-            this.rateLimits.set(name, {
-                count: 1,
-                resetTime: now + rateLimit.window,
-            });
-        }
-    }
-    /**
-     * Register a custom tool
-     */
-    register(name, tool) {
-        if (this.tools.has(name)) {
-            logger.warn(`Tool ${name} already registered, overwriting`);
-        }
-        this.tools.set(name, tool);
-        logger.info(`Registered custom tool: ${name}`);
-    }
-    /**
-     * Register multiple tools at once
-     */
-    registerMany(tools) {
-        Object.entries(tools).forEach(([name, tool]) => {
-            this.register(name, tool);
-        });
-    }
-    /**
-     * Unregister a tool
-     */
-    unregister(name) {
-        const result = this.tools.delete(name);
-        if (result) {
-            logger.info(`Unregistered tool: ${name}`);
-        }
-        return result;
-    }
-    /**
-     * Get a tool by name
-     */
-    get(name) {
-        return this.tools.get(name);
-    }
-    /**
-     * Get all registered tools
-     */
-    getAll() {
-        return new Map(this.tools);
-    }
-    /**
-     * Convert all tools to AI SDK format
-     */
-    toAISDKTools() {
-        const aiTools = {};
-        for (const [name, tool] of this.tools) {
-            if (this.isToolAllowed(name)) {
-                aiTools[name] = convertToAISDKTool(name, tool);
-            }
-        }
-        return aiTools;
-    }
-    /**
-     * Add middleware
-     */
-    use(middleware) {
-        this.middleware.push(middleware);
-    }
-    /**
-     * Set permissions
-     */
-    setPermissions(permissions) {
-        this.permissions = permissions;
-    }
-    /**
-     * Check if a tool is allowed
-     */
-    isToolAllowed(name) {
-        // Check denylist first
-        if (this.permissions.denylist?.includes(name)) {
-            return false;
-        }
-        // Check allowlist if specified
-        if (this.permissions.allowlist &&
-            !this.permissions.allowlist.includes(name)) {
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Execute a tool with middleware
-     */
-    async execute(name, args, context) {
-        const tool = this.tools.get(name);
-        if (!tool) {
-            throw new Error(`Tool ${name} not found`);
-        }
-        // Check permissions
-        if (!this.isToolAllowed(name)) {
-            throw new Error(`Tool ${name} is not allowed`);
-        }
-        // Check custom validator
-        if (this.permissions.customValidator) {
-            const allowed = await this.permissions.customValidator(name, args);
-            if (!allowed) {
-                throw new Error(`Tool ${name} execution denied by custom validator`);
-            }
-        }
-        // Check rate limit
-        if (tool.config?.rateLimit) {
-            this.checkRateLimit(name, tool.config.rateLimit);
-        }
-        // Build middleware chain
-        let index = 0;
-        const next = async () => {
-            if (index < this.middleware.length) {
-                const middleware = this.middleware[index++];
-                return middleware(name, args, next, context);
-            }
-            else {
-                // Execute the actual tool
-                return tool.execute(args, context);
-            }
-        };
-        return next();
-    }
-}
-/**
- * Create a simple tool helper
- */
-export function createTool(config) {
-    return config;
-}
-/**
- * Create an async tool helper
- */
-export function createAsyncTool(config) {
-    return config;
-}
-/**
- * Create a batch tool that processes multiple items
- */
-export function createBatchTool(config) {
-    return {
-        ...config,
-        execute: async (args, context) => {
-            const { items } = args;
-            const batchSize = config.batchSize || 10;
-            const results = [];
-            for (let i = 0; i < items.length; i += batchSize) {
-                const batch = items.slice(i, i + batchSize);
-                const batchResults = await Promise.all(batch.map((item) => config.processItem(item, context)));
-                results.push(...batchResults);
-            }
-            return results;
-        },
-    };
-}
-/**
- * Tool testing utilities
- */
-export const TestUtils = {
-    /**
-     * Create a mock tool context
-     */
-    mockContext(overrides) {
-        return {
-            callTool: async (name, args) => {
-                logger.debug(`Mock tool call: ${name}`, args);
-                return {};
-            },
-            session: {
-                id: "test-session",
-                userId: "test-user",
-                provider: "test-provider",
-                model: "test-model",
-            },
-            logger,
-            ...overrides,
-        };
-    },
-    /**
-     * Test a tool with mock data
-     */
-    async testTool(tool, testCases) {
-        const context = TestUtils.mockContext();
-        const results = [];
-        for (const testCase of testCases) {
-            try {
-                const result = await tool.execute(testCase.input, context);
-                results.push({
-                    input: testCase.input,
-                    output: result,
-                    success: true,
-                    matches: testCase.expected
-                        ? JSON.stringify(result) === JSON.stringify(testCase.expected)
-                        : undefined,
-                });
-            }
-            catch (error) {
-                results.push({
-                    input: testCase.input,
-                    error: error instanceof Error ? error.message : String(error),
-                    success: false,
-                });
-            }
-        }
-        return results;
-    },
-};

package/dist/lib/services/streaming/streaming-manager.d.ts

@@ -1,29 +0,0 @@
-import { EventEmitter } from "events";
-import type { StreamingSession, StreamingConfig, StreamingPoolConfig, StreamingMetrics, StreamingHealthStatus, BufferConfig } from "../types.js";
-export declare class StreamingManager extends EventEmitter {
-    private activeSessions;
-    private streamingPools;
-    private metrics;
-    private healthCheckInterval?;
-    private startTime;
-    constructor();
-    createStreamingSession(config: StreamingConfig): Promise<StreamingSession>;
-    terminateStreamingSession(sessionId: string): Promise<void>;
-    pauseStreamingSession(sessionId: string): Promise<void>;
-    resumeStreamingSession(sessionId: string): Promise<void>;
-    optimizeStreamingLatency(sessionId: string): Promise<void>;
-    enableStreamingCompression(sessionId: string): Promise<void>;
-    configureStreamingBuffering(sessionId: string, bufferConfig: BufferConfig): Promise<void>;
-    createStreamingPool(poolId: string, config: StreamingPoolConfig): Promise<void>;
-    balanceStreamingLoad(poolId: string): Promise<void>;
-    scaleStreamingCapacity(poolId: string, scale: number): Promise<void>;
-    getStreamingMetrics(sessionId?: string): StreamingMetrics;
-    getStreamingHealthStatus(): StreamingHealthStatus;
-    private updateGlobalMetrics;
-    private startHealthMonitoring;
-    private roundRobinBalance;
-    private leastConnectionsBalance;
-    private weightedBalance;
-    private adaptiveBalance;
-    destroy(): void;
-}

package/dist/lib/services/streaming/streaming-manager.js

@@ -1,245 +0,0 @@
-import { EventEmitter } from "events";
-import { randomUUID } from "crypto";
-import { logger } from "../../utils/logger.js";
-export class StreamingManager extends EventEmitter {
-    activeSessions = new Map();
-    streamingPools = new Map();
-    metrics;
-    healthCheckInterval;
-    startTime;
-    constructor() {
-        super();
-        this.startTime = Date.now();
-        this.metrics = {
-            activeSessions: 0,
-            totalBytesTransferred: 0,
-            averageLatency: 0,
-            throughputBps: 0,
-            errorRate: 0,
-            connectionCount: 0,
-            uptime: 0,
-        };
-        this.startHealthMonitoring();
-    }
-    // Stream Lifecycle Management
-    async createStreamingSession(config) {
-        const sessionId = randomUUID();
-        const session = {
-            id: sessionId,
-            connectionId: config.provider, // Temporary, should be actual connection ID
-            provider: config.provider,
-            status: "active",
-            startTime: Date.now(),
-            lastActivity: Date.now(),
-            config,
-            metrics: {
-                bytesTransferred: 0,
-                messagesCount: 0,
-                averageLatency: 0,
-                errorCount: 0,
-            },
-        };
-        this.activeSessions.set(sessionId, session);
-        this.updateGlobalMetrics();
-        logger.debug(`[Streaming Manager] Created session ${sessionId} for provider ${config.provider}`);
-        this.emit("session-created", session);
-        return session;
-    }
-    async terminateStreamingSession(sessionId) {
-        const session = this.activeSessions.get(sessionId);
-        if (!session) {
-            throw new Error(`Session ${sessionId} not found`);
-        }
-        session.status = "terminated";
-        this.activeSessions.delete(sessionId);
-        this.updateGlobalMetrics();
-        logger.debug(`[Streaming Manager] Terminated session ${sessionId}`);
-        this.emit("session-terminated", session);
-    }
-    async pauseStreamingSession(sessionId) {
-        const session = this.activeSessions.get(sessionId);
-        if (!session) {
-            throw new Error(`Session ${sessionId} not found`);
-        }
-        if (session.status === "active") {
-            session.status = "paused";
-            logger.debug(`[Streaming Manager] Paused session ${sessionId}`);
-            this.emit("session-paused", session);
-        }
-    }
-    async resumeStreamingSession(sessionId) {
-        const session = this.activeSessions.get(sessionId);
-        if (!session) {
-            throw new Error(`Session ${sessionId} not found`);
-        }
-        if (session.status === "paused") {
-            session.status = "active";
-            session.lastActivity = Date.now();
-            logger.debug(`[Streaming Manager] Resumed session ${sessionId}`);
-            this.emit("session-resumed", session);
-        }
-    }
-    // Stream Optimization
-    async optimizeStreamingLatency(sessionId) {
-        const session = this.activeSessions.get(sessionId);
-        if (!session) {
-            return;
-        }
-        // Adaptive optimization based on current metrics
-        const currentLatency = session.metrics.averageLatency;
-        const targetLatency = session.config.latencyTarget;
-        if (currentLatency > targetLatency * 1.2) {
-            // Increase buffer size for better throughput
-            session.config.bufferSize = Math.min(session.config.bufferSize * 1.5, 16384);
-            session.config.streamingMode = "buffered";
-        }
-        else if (currentLatency < targetLatency * 0.8) {
-            // Decrease buffer size for better latency
-            session.config.bufferSize = Math.max(session.config.bufferSize * 0.8, 1024);
-            session.config.streamingMode = "real-time";
-        }
-        logger.debug(`[Streaming Manager] Optimized session ${sessionId}: latency=${currentLatency}ms, mode=${session.config.streamingMode}`);
-    }
-    async enableStreamingCompression(sessionId) {
-        const session = this.activeSessions.get(sessionId);
-        if (!session) {
-            return;
-        }
-        session.config.compressionEnabled = true;
-        logger.debug(`[Streaming Manager] Enabled compression for session ${sessionId}`);
-    }
-    async configureStreamingBuffering(sessionId, bufferConfig) {
-        const session = this.activeSessions.get(sessionId);
-        if (!session) {
-            return;
-        }
-        session.config.bufferSize = bufferConfig.maxSize;
-        session.config.maxChunkSize = Math.min(session.config.maxChunkSize, bufferConfig.flushThreshold);
-        logger.debug(`[Streaming Manager] Updated buffer config for session ${sessionId}:`, bufferConfig);
-    }
-    // Multi-Stream Coordination
-    async createStreamingPool(poolId, config) {
-        const pool = {
-            id: poolId,
-            maxSessions: config.maxConcurrentSessions,
-            activeSessions: new Set(),
-            config,
-            loadBalancer: config.loadBalancing,
-        };
-        this.streamingPools.set(poolId, pool);
-        logger.debug(`[Streaming Manager] Created pool ${poolId} with max ${config.maxConcurrentSessions} sessions`);
-    }
-    async balanceStreamingLoad(poolId) {
-        const pool = this.streamingPools.get(poolId);
-        if (!pool) {
-            return;
-        }
-        const activeSessions = Array.from(pool.activeSessions)
-            .map((sessionId) => this.activeSessions.get(sessionId))
-            .filter((session) => session && session.status === "active");
-        // Implement load balancing strategies
-        switch (pool.loadBalancer) {
-            case "round-robin":
-                this.roundRobinBalance(activeSessions);
-                break;
-            case "least-connections":
-                this.leastConnectionsBalance(activeSessions);
-                break;
-            case "weighted":
-                this.weightedBalance(activeSessions);
-                break;
-            case "adaptive":
-                this.adaptiveBalance(activeSessions);
-                break;
-        }
-    }
-    async scaleStreamingCapacity(poolId, scale) {
-        const pool = this.streamingPools.get(poolId);
-        if (!pool) {
-            return;
-        }
-        const newMaxSessions = Math.max(1, Math.floor(pool.maxSessions * scale));
-        pool.maxSessions = newMaxSessions;
-        pool.config.maxConcurrentSessions = newMaxSessions;
-        logger.debug(`[Streaming Manager] Scaled pool ${poolId} to ${newMaxSessions} max sessions (${scale}x)`);
-    }
-    // Performance Monitoring
-    getStreamingMetrics(sessionId) {
-        if (sessionId) {
-            const session = this.activeSessions.get(sessionId);
-            if (session) {
-                return {
-                    sessionId,
-                    activeSessions: 1,
-                    totalBytesTransferred: session.metrics.bytesTransferred,
-                    averageLatency: session.metrics.averageLatency,
-                    throughputBps: session.metrics.bytesTransferred /
-                        ((Date.now() - session.startTime) / 1000),
-                    errorRate: session.metrics.errorCount /
-                        Math.max(session.metrics.messagesCount, 1),
-                    connectionCount: 1,
-                    uptime: Date.now() - session.startTime,
-                };
-            }
-        }
-        return { ...this.metrics, uptime: Date.now() - this.startTime };
-    }
-    getStreamingHealthStatus() {
-        const metrics = this.getStreamingMetrics();
-        const issues = [];
-        let status = "healthy";
-        if (metrics.errorRate > 0.1) {
-            issues.push(`High error rate: ${(metrics.errorRate * 100).toFixed(1)}%`);
-            status = "degraded";
-        }
-        if (metrics.averageLatency > 1000) {
-            issues.push(`High latency: ${metrics.averageLatency}ms`);
-            status = status === "healthy" ? "degraded" : "unhealthy";
-        }
-        if (metrics.activeSessions === 0 && this.activeSessions.size > 0) {
-            issues.push("Session count mismatch");
-            status = "unhealthy";
-        }
-        return {
-            status,
-            activeSessions: metrics.activeSessions,
-            errorRate: metrics.errorRate,
-            averageLatency: metrics.averageLatency,
-            lastHealthCheck: Date.now(),
-            issues,
-        };
-    }
-    // Private helper methods
-    updateGlobalMetrics() {
-        this.metrics.activeSessions = this.activeSessions.size;
-        this.metrics.connectionCount = this.activeSessions.size;
-    }
-    startHealthMonitoring() {
-        this.healthCheckInterval = setInterval(() => {
-            const health = this.getStreamingHealthStatus();
-            if (health.status !== "healthy") {
-                logger.debug("[Streaming Manager] Health check:", health);
-                this.emit("health-warning", health);
-            }
-        }, 30000); // Check every 30 seconds
-    }
-    roundRobinBalance(sessions) {
-        // Round-robin implementation
-    }
-    leastConnectionsBalance(sessions) {
-        // Least connections implementation
-    }
-    weightedBalance(sessions) {
-        // Weighted load balancing implementation
-    }
-    adaptiveBalance(sessions) {
-        // Adaptive load balancing implementation
-    }
-    destroy() {
-        if (this.healthCheckInterval) {
-            clearInterval(this.healthCheckInterval);
-        }
-        this.activeSessions.clear();
-        this.streamingPools.clear();
-    }
-}