@juspay/neurolink/dist/lib/types/contextTypes.js

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

/**
 * Context Types for NeuroLink - Factory Pattern Implementation
 * Provides type-safe context integration for AI generation
 */
/**
 * Factory for context processing
 */
export class ContextFactory {
    /**
     * Default context configuration
     */
    static DEFAULT_CONFIG = {
        mode: "metadata_only",
        includeInPrompt: false,
        includeInAnalytics: true,
        includeInEvaluation: true,
        maxLength: 1000,
    };
    /**
     * Validate and normalize context data
     */
    static validateContext(context) {
        if (!context || typeof context !== "object") {
            return null;
        }
        try {
            // Ensure it's JSON serializable
            const serialized = JSON.stringify(context);
            const parsed = JSON.parse(serialized);
            // Basic validation
            if (typeof parsed !== "object" || Array.isArray(parsed)) {
                return null;
            }
            return parsed;
        }
        catch {
            return null;
        }
    }
    /**
     * Process context for AI generation based on configuration
     */
    static processContext(context, config = {}) {
        const startTime = Date.now();
        const finalConfig = { ...this.DEFAULT_CONFIG, ...config };
        let processedContext = null;
        const template = "default";
        let truncated = false;
        if (finalConfig.includeInPrompt && finalConfig.mode !== "metadata_only") {
            processedContext = this.formatContextForPrompt(context, finalConfig);
            // Truncate if necessary
            if (finalConfig.maxLength &&
                processedContext.length > finalConfig.maxLength) {
                processedContext =
                    processedContext.substring(0, finalConfig.maxLength) + "...";
                truncated = true;
            }
        }
        const processingTime = Date.now() - startTime;
        return {
            originalContext: context,
            processedContext,
            config: finalConfig,
            metadata: {
                truncated,
                processingTime,
                template,
                mode: finalConfig.mode,
            },
        };
    }
    /**
     * Format context for prompt integration
     */
    static formatContextForPrompt(context, config) {
        switch (config.mode) {
            case "prompt_prefix":
                return this.formatAsPrefix(context);
            case "prompt_suffix":
                return this.formatAsSuffix(context);
            case "system_prompt":
                return this.formatForSystemPrompt(context);
            case "structured_prompt":
                return this.formatStructured(context);
            case "metadata_only":
            case "none":
            default:
                return "";
        }
    }
    /**
     * Format context as prompt prefix
     */
    static formatAsPrefix(context) {
        const parts = [];
        if (context.userId) {
            parts.push(`User: ${context.userId}`);
        }
        if (context.userRole) {
            parts.push(`Role: ${context.userRole}`);
        }
        if (context.sessionId) {
            parts.push(`Session: ${context.sessionId}`);
        }
        if (parts.length === 0) {
            return "";
        }
        return `Context: ${parts.join(", ")}\n\n`;
    }
    /**
     * Format context as prompt suffix
     */
    static formatAsSuffix(context) {
        const relevantKeys = Object.keys(context).filter((key) => !["userId", "sessionId", "requestId"].includes(key));
        if (relevantKeys.length === 0) {
            return "";
        }
        const contextData = relevantKeys.reduce((acc, key) => {
            acc[key] = context[key];
            return acc;
        }, {});
        return `\n\nAdditional Context: ${JSON.stringify(contextData, null, 2)}`;
    }
    /**
     * Format context for system prompt
     */
    static formatForSystemPrompt(context) {
        const parts = [];
        if (context.userRole) {
            parts.push(`You are assisting a user with the role: ${context.userRole}`);
        }
        if (context.organizationId) {
            parts.push(`Organization context: ${context.organizationId}`);
        }
        if (context.userPreferences) {
            parts.push(`User preferences: ${JSON.stringify(context.userPreferences)}`);
        }
        return parts.join(". ");
    }
    /**
     * Format context in structured format
     */
    static formatStructured(context) {
        return `[CONTEXT]\n${JSON.stringify(context, null, 2)}\n[/CONTEXT]\n\n`;
    }
    /**
     * Extract analytics data from context
     */
    static extractAnalyticsContext(context) {
        return {
            hasUserId: !!context.userId,
            hasSessionId: !!context.sessionId,
            hasUserRole: !!context.userRole,
            hasOrgContext: !!context.organizationId,
            contextKeys: Object.keys(context),
            contextSize: JSON.stringify(context).length,
        };
    }
    /**
     * Extract evaluation context
     */
    static extractEvaluationContext(context) {
        return {
            userRole: context.userRole || "unknown",
            applicationContext: context.applicationContext?.name || "unknown",
            organizationContext: context.organizationId || "unknown",
            hasPreferences: !!context.userPreferences,
        };
    }
}
/**
 * Type guard to check if value is valid context
 */
export function isValidContext(value) {
    return ContextFactory.validateContext(value) !== null;
}