@gork-labs/secondbrain-mcp/dist/utils/types.d.ts

Second Brain MCP Server - Agent team orchestration with dynamic tool discovery

import { z } from 'zod';
export interface SessionState {
    sessionId: string;
    totalCalls: number;
    agentTypeCalls: Record<string, number>;
    refinementCount: Record<string, number>;
    isSubAgent: boolean;
    currentDepth: number;
    parentSessionId?: string;
    createdAt: string;
    lastActivity: string;
}
export declare const MemoryOperationSchema: z.ZodObject<{
    operation: z.ZodEnum<["create_entities", "add_observations", "create_relations", "delete_entities", "delete_observations", "delete_relations"]>;
    data: z.ZodRecord<z.ZodString, z.ZodAny>;
}, "strip", z.ZodTypeAny, {
    operation: "create_entities" | "add_observations" | "create_relations" | "delete_entities" | "delete_observations" | "delete_relations";
    data: Record<string, any>;
}, {
    operation: "create_entities" | "add_observations" | "create_relations" | "delete_entities" | "delete_observations" | "delete_relations";
    data: Record<string, any>;
}>;
export declare const DeliverableSchema: z.ZodObject<{
    documents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    analysis: z.ZodOptional<z.ZodString>;
    recommendations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    documents?: string[] | undefined;
    analysis?: string | undefined;
    recommendations?: string[] | undefined;
}, {
    documents?: string[] | undefined;
    analysis?: string | undefined;
    recommendations?: string[] | undefined;
}>;
export declare const SubAgentMetadataSchema: z.ZodObject<{
    subagent: z.ZodString;
    task_completion_status: z.ZodEnum<["complete", "partial", "failed"]>;
    processing_time: z.ZodString;
    confidence_level: z.ZodEnum<["high", "medium", "low"]>;
}, "strip", z.ZodTypeAny, {
    subagent: string;
    task_completion_status: "complete" | "partial" | "failed";
    processing_time: string;
    confidence_level: "high" | "medium" | "low";
}, {
    subagent: string;
    task_completion_status: "complete" | "partial" | "failed";
    processing_time: string;
    confidence_level: "high" | "medium" | "low";
}>;
export declare const SubAgentResponseSchema: z.ZodObject<{
    deliverables: z.ZodObject<{
        documents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        analysis: z.ZodOptional<z.ZodString>;
        recommendations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        documents?: string[] | undefined;
        analysis?: string | undefined;
        recommendations?: string[] | undefined;
    }, {
        documents?: string[] | undefined;
        analysis?: string | undefined;
        recommendations?: string[] | undefined;
    }>;
    memory_operations: z.ZodOptional<z.ZodArray<z.ZodObject<{
        operation: z.ZodEnum<["create_entities", "add_observations", "create_relations", "delete_entities", "delete_observations", "delete_relations"]>;
        data: z.ZodRecord<z.ZodString, z.ZodAny>;
    }, "strip", z.ZodTypeAny, {
        operation: "create_entities" | "add_observations" | "create_relations" | "delete_entities" | "delete_observations" | "delete_relations";
        data: Record<string, any>;
    }, {
        operation: "create_entities" | "add_observations" | "create_relations" | "delete_entities" | "delete_observations" | "delete_relations";
        data: Record<string, any>;
    }>, "many">>;
    metadata: z.ZodObject<{
        subagent: z.ZodString;
        task_completion_status: z.ZodEnum<["complete", "partial", "failed"]>;
        processing_time: z.ZodString;
        confidence_level: z.ZodEnum<["high", "medium", "low"]>;
    }, "strip", z.ZodTypeAny, {
        subagent: string;
        task_completion_status: "complete" | "partial" | "failed";
        processing_time: string;
        confidence_level: "high" | "medium" | "low";
    }, {
        subagent: string;
        task_completion_status: "complete" | "partial" | "failed";
        processing_time: string;
        confidence_level: "high" | "medium" | "low";
    }>;
    tool: z.ZodOptional<z.ZodString>;
    arguments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
}, "strip", z.ZodTypeAny, {
    deliverables: {
        documents?: string[] | undefined;
        analysis?: string | undefined;
        recommendations?: string[] | undefined;
    };
    metadata: {
        subagent: string;
        task_completion_status: "complete" | "partial" | "failed";
        processing_time: string;
        confidence_level: "high" | "medium" | "low";
    };
    memory_operations?: {
        operation: "create_entities" | "add_observations" | "create_relations" | "delete_entities" | "delete_observations" | "delete_relations";
        data: Record<string, any>;
    }[] | undefined;
    tool?: string | undefined;
    arguments?: Record<string, any> | undefined;
}, {
    deliverables: {
        documents?: string[] | undefined;
        analysis?: string | undefined;
        recommendations?: string[] | undefined;
    };
    metadata: {
        subagent: string;
        task_completion_status: "complete" | "partial" | "failed";
        processing_time: string;
        confidence_level: "high" | "medium" | "low";
    };
    memory_operations?: {
        operation: "create_entities" | "add_observations" | "create_relations" | "delete_entities" | "delete_observations" | "delete_relations";
        data: Record<string, any>;
    }[] | undefined;
    tool?: string | undefined;
    arguments?: Record<string, any> | undefined;
}>;
export declare const ParallelAgentSpecSchema: z.ZodObject<{
    agent_id: z.ZodString;
    subagent: z.ZodString;
    task: z.ZodString;
    context: z.ZodString;
    expected_deliverables: z.ZodString;
}, "strip", z.ZodTypeAny, {
    subagent: string;
    agent_id: string;
    task: string;
    context: string;
    expected_deliverables: string;
}, {
    subagent: string;
    agent_id: string;
    task: string;
    context: string;
    expected_deliverables: string;
}>;
export declare const SpawnAgentsParallelArgsSchema: z.ZodObject<{
    agents: z.ZodArray<z.ZodObject<{
        agent_id: z.ZodString;
        subagent: z.ZodString;
        task: z.ZodString;
        context: z.ZodString;
        expected_deliverables: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        subagent: string;
        agent_id: string;
        task: string;
        context: string;
        expected_deliverables: string;
    }, {
        subagent: string;
        agent_id: string;
        task: string;
        context: string;
        expected_deliverables: string;
    }>, "many">;
    coordination_context: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    agents: {
        subagent: string;
        agent_id: string;
        task: string;
        context: string;
        expected_deliverables: string;
    }[];
    coordination_context?: string | undefined;
}, {
    agents: {
        subagent: string;
        agent_id: string;
        task: string;
        context: string;
        expected_deliverables: string;
    }[];
    coordination_context?: string | undefined;
}>;
export interface ParallelAgentResult {
    agent_id: string;
    subagent: string;
    status: 'success' | 'failed';
    execution_time_ms: number;
    session_id: string | null;
    response?: SubAgentResponse;
    error?: string;
}
export type MemoryOperation = z.infer<typeof MemoryOperationSchema>;
export type Deliverable = z.infer<typeof DeliverableSchema>;
export type SubAgentMetadata = z.infer<typeof SubAgentMetadataSchema>;
export type SubAgentResponse = z.infer<typeof SubAgentResponseSchema>;
export declare const SpawnAgentArgsSchema: z.ZodObject<{
    subagent: z.ZodString;
    task: z.ZodString;
    context: z.ZodString;
    expected_deliverables: z.ZodString;
}, "strip", z.ZodTypeAny, {
    subagent: string;
    task: string;
    context: string;
    expected_deliverables: string;
}, {
    subagent: string;
    task: string;
    context: string;
    expected_deliverables: string;
}>;
export declare const ValidateOutputArgsSchema: z.ZodObject<{
    sub_agent_response: z.ZodString;
    requirements: z.ZodString;
    quality_criteria: z.ZodString;
    subagent: z.ZodOptional<z.ZodString>;
    session_id: z.ZodOptional<z.ZodString>;
    enable_refinement: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    sub_agent_response: string;
    requirements: string;
    quality_criteria: string;
    subagent?: string | undefined;
    session_id?: string | undefined;
    enable_refinement?: boolean | undefined;
}, {
    sub_agent_response: string;
    requirements: string;
    quality_criteria: string;
    subagent?: string | undefined;
    session_id?: string | undefined;
    enable_refinement?: boolean | undefined;
}>;
export type SpawnAgentArgs = z.infer<typeof SpawnAgentArgsSchema>;
export type ValidateOutputArgs = z.infer<typeof ValidateOutputArgsSchema>;
export interface ChatmodeDefinition {
    name: string;
    description: string;
    tools: string[];
    content: string;
    filePath: string;
}
export interface QualityAssessment {
    score: number;
    passed: boolean;
    issues: string[];
    recommendations: string[];
    confidence: 'high' | 'medium' | 'low';
}
export interface QualityRuleResult {
    passed: boolean;
    score: number;
    feedback: string;
    severity: 'critical' | 'important' | 'minor';
    category: string;
}
export interface ValidationContext {
    subagent: string;
    requirements: string;
    qualityCriteria: string;
    sessionHistory?: SessionState;
    taskType?: string;
    expectedDeliverables?: string[];
}
export interface QualityRule {
    name: string;
    category: string;
    weight: number;
    applicableToAll: boolean;
    evaluator: (response: SubAgentResponse, context: ValidationContext) => QualityRuleResult;
}
export interface EnhancedQualityAssessment {
    overallScore: number;
    passed: boolean;
    qualityThreshold: number;
    ruleResults: QualityRuleResult[];
    categories: Record<string, number>;
    recommendations: string[];
    criticalIssues: string[];
    confidence: 'high' | 'medium' | 'low';
    processingTime: number;
    canRefine: boolean;
    refinementSuggestions: string[];
}
export interface RefinementState {
    sessionId: string;
    originalTaskId: string;
    attemptNumber: number;
    previousScores: number[];
    improvementAreas: string[];
    lastRefinementTime: string;
    refinementReason: string;
    qualityTrend: 'improving' | 'declining' | 'stable';
}
export interface QualityMetrics {
    totalValidations: number;
    averageScore: number;
    successRate: number;
    refinementRate: number;
    categoryBreakdown: Record<string, number>;
    subagentPerformance: Record<string, number>;
    qualityTrends: Array<{
        timestamp: string;
        averageScore: number;
        validationCount: number;
    }>;
}
export interface SubagentQualityConfig {
    subagent: string;
    qualityThreshold: number;
    maxRefinementAttempts: number;
    specificRules: string[];
    ruleWeights: Record<string, number>;
    requiredCategories: string[];
    refinementPromptTemplate?: string;
}
export declare class SecondBrainError extends Error {
    code: string;
    details?: any | undefined;
    constructor(message: string, code: string, details?: any | undefined);
}
export declare class SessionLimitError extends SecondBrainError {
    constructor(message: string, details?: any);
}
export declare class SubagentNotFoundError extends SecondBrainError {
    constructor(subagent: string);
}
export declare class InvalidResponseError extends SecondBrainError {
    constructor(message: string, details?: any);
}
export interface QualityMetric {
    timestamp: string;
    subagent: string;
    sessionId?: string;
    qualityScore: number;
    passed: boolean;
    processingTime: number;
    refinementAttempts: number;
    ruleBreakdown: Record<string, number>;
    categories: Record<string, number>;
    criticalIssues: string[];
    improvementAreas: string[];
}
export interface PerformanceMetric {
    timestamp: string;
    operation: string;
    duration: number;
    success: boolean;
    errorType?: string;
    resourceUsage?: {
        memory: number;
        cpu?: number;
    };
    requestSize?: number;
    responseSize?: number;
}
export interface UsageMetric {
    timestamp: string;
    subagent: string;
    sessionId: string;
    operation: string;
    success: boolean;
    userContext?: {
        taskType?: string;
        urgency?: string;
        complexity?: 'low' | 'medium' | 'high';
    };
}
export interface AnalyticsData {
    qualityMetrics: Record<string, QualityMetric[]>;
    performanceMetrics: PerformanceMetric[];
    usageMetrics: UsageMetric[];
    lastUpdated: string;
    totalRecords: number;
}
export interface QualityTrend {
    subagent: string;
    timeRange: string;
    scoreAverage: number;
    scoreTrend: 'improving' | 'declining' | 'stable';
    successRate: number;
    refinementRate: number;
    totalValidations: number;
    insights: string[];
    recommendations: string[];
}
export interface SystemHealth {
    status: 'healthy' | 'warning' | 'critical';
    totalRecords: number;
    memoryUsage: number;
    lastCleanup: string;
    storageLocation: string;
    uptime?: number;
    errorRate?: number;
    avgResponseTime?: number;
}
export interface QualityInsight {
    type: 'trend' | 'pattern' | 'anomaly' | 'recommendation';
    subagent?: string;
    severity: 'info' | 'warning' | 'critical';
    title: string;
    description: string;
    metrics: Record<string, number>;
    actionable: boolean;
    recommendation?: string;
    confidence: number;
    timestamp: string;
}
export interface PerformanceInsight {
    operation: string;
    avgDuration: number;
    p95Duration: number;
    successRate: number;
    errorPatterns: string[];
    optimizationSuggestions: string[];
    trend: 'improving' | 'declining' | 'stable';
    timestamp: string;
}
export interface UsagePattern {
    subagent: string;
    peakHours: number[];
    avgSessionDuration: number;
    successRate: number;
    commonTasks: string[];
    userBehaviors: {
        refinementFrequency: number;
        taskComplexity: 'low' | 'medium' | 'high';
        preferredFeatures: string[];
    };
}
export interface AnalyticsConfig {
    retention: {
        qualityMetrics: number;
        performanceMetrics: number;
        usageMetrics: number;
    };
    aggregation: {
        windowSize: number;
        batchSize: number;
    };
    alerts: {
        qualityThreshold: number;
        errorRateThreshold: number;
        performanceThreshold: number;
    };
    intelligence: {
        enablePredictiveScoring: boolean;
        enableAdaptiveThresholds: boolean;
        enableAutoOptimization: boolean;
        learningWindowDays: number;
    };
}
export interface MLPrediction {
    prediction: number;
    confidence: number;
    reasoning: string;
    features: Map<string, number>;
}
export interface MLTrainingData {
    timestamp: number;
    features: Map<string, number>;
    actualScore: number;
    actualPassed: boolean;
    processingTime: number;
    subagent: string;
    prediction?: number;
}
export interface MLModel {
    name: string;
    type: 'regression' | 'classification';
    version: string;
    features: string[];
    weights: Map<string, number>;
    accuracy: number;
    lastTrained: number;
    trainingCount: number;
}
export interface MLInsight {
    type: 'model_performance' | 'learning_pattern' | 'training_data' | 'prediction_accuracy' | 'data_distribution' | 'system_error' | 'anomaly_detection' | 'quality_forecast' | 'cross_chatmode_analysis' | 'proactive_alert';
    severity: 'info' | 'warning' | 'critical';
    title: string;
    description: string;
    actionRequired: boolean;
    recommendation?: string;
    forecastData?: {
        prediction: number;
        confidenceInterval: [number, number];
        timeHorizon: string;
        methodology: string;
    };
    anomalyDetails?: {
        detectionMethod: string;
        severity: number;
        expectedValue: number;
        actualValue: number;
        deviation: number;
    };
}
export interface MLOptimization {
    timestamp: number;
    type: string;
    component: string;
    oldValue: number;
    newValue: number;
    expectedImprovement: number;
    actualImprovement?: number;
    applied: boolean;
}
export interface PredictiveAnalytics {
    qualityForecast: {
        subagent: string;
        currentScore: number;
        predictedScore: number;
        confidenceInterval: [number, number];
        forecastHorizon: string;
        trendDirection: 'improving' | 'declining' | 'stable';
        confidence: number;
    };
    anomalies: {
        subagent: string;
        metric: string;
        severity: 'low' | 'medium' | 'high';
        detectedAt: string;
        description: string;
        expectedValue: number;
        actualValue: number;
        deviationScore: number;
    }[];
    crossSubagentPatterns: {
        pattern: string;
        affectedSubagents: string[];
        correlation: number;
        significance: 'low' | 'medium' | 'high';
        description: string;
        actionable: boolean;
    }[];
    proactiveAlerts: {
        alertType: 'performance_degradation' | 'quality_decline' | 'anomaly_cluster' | 'trend_reversal';
        severity: 'info' | 'warning' | 'critical';
        description: string;
        affectedComponents: string[];
        recommendedActions: string[];
        confidence: number;
        estimatedImpact: string;
    }[];
}
export interface BaseModel {
    id: string;
    name: string;
    type: 'statistical' | 'pattern_recognition' | 'domain_specific' | 'meta_learning';
    version: string;
    accuracy: number;
    lastUpdated: number;
    trainingCount: number;
    specialization?: string;
}
export interface ModelPrediction {
    modelId: string;
    prediction: number;
    confidence: number;
    reasoning: string;
    contributingFactors: Record<string, number>;
    processingTime: number;
}
export interface EnsemblePrediction {
    finalPrediction: number;
    confidence: number;
    modelContributions: ModelPrediction[];
    votingMethod: 'weighted_average' | 'confidence_weighted' | 'majority_vote' | 'expert_selection';
    consensusLevel: number;
    metadata: {
        totalModels: number;
        participatingModels: number;
        conflictResolution?: string;
        qualityAssurance: boolean;
    };
}
export interface ABTestConfig {
    experimentId: string;
    name: string;
    description: string;
    hypothesis: string;
    startDate: string;
    estimatedDuration: number;
    targetSampleSize: number;
    confidenceLevel: number;
    minimumEffectSize: number;
    successMetrics: string[];
    variants: {
        id: string;
        name: string;
        description: string;
        trafficAllocation: number;
        configuration: Record<string, any>;
    }[];
    safetyConstraints: {
        maxAllowedDegradation: number;
        earlyStoppingRules: string[];
        fallbackVariant: string;
    };
}
export interface ABTestResult {
    experimentId: string;
    status: 'running' | 'completed' | 'stopped_early' | 'failed';
    duration: number;
    samplesCollected: number;
    statisticalPower: number;
    pValue: number;
    effectSize: number;
    confidenceInterval: [number, number];
    winningVariant?: string;
    results: {
        variantId: string;
        sampleSize: number;
        successRate: number;
        averageMetric: number;
        confidenceInterval: [number, number];
    }[];
    recommendation: 'deploy_winner' | 'run_longer' | 'redesign_experiment' | 'no_significant_difference';
    insights: string[];
}
export interface AutoOptimizationConfig {
    optimizationId: string;
    name: string;
    description: string;
    objectives: {
        metric: string;
        target: 'maximize' | 'minimize';
        weight: number;
        constraint?: {
            min?: number;
            max?: number;
        };
    }[];
    parameters: {
        name: string;
        type: 'continuous' | 'discrete' | 'categorical';
        range: any;
        currentValue: any;
    }[];
    algorithm: 'bayesian_optimization' | 'genetic_algorithm' | 'random_search' | 'grid_search';
    constraints: {
        maxIterations: number;
        maxDuration: number;
        convergenceThreshold: number;
        safetyChecks: string[];
    };
}
export interface OptimizationResult {
    optimizationId: string;
    status: 'running' | 'converged' | 'max_iterations' | 'failed' | 'safety_stopped';
    iterations: number;
    bestScore: number;
    bestParameters: Record<string, any>;
    improvement: number;
    convergenceHistory: {
        iteration: number;
        score: number;
        parameters: Record<string, any>;
        timestamp: string;
    }[];
    deploymentStatus: 'not_deployed' | 'staged' | 'production' | 'rolled_back';
    safetyMetrics: {
        metric: string;
        baseline: number;
        current: number;
        threshold: number;
        status: 'safe' | 'warning' | 'critical';
    }[];
}
export interface MetaLearningInsight {
    insightType: 'learning_efficiency' | 'transfer_opportunity' | 'curriculum_optimization' | 'feature_importance' | 'model_combination';
    description: string;
    evidenceStrength: number;
    applicableScenarios: string[];
    recommendations: string[];
    transferPotential?: {
        sourceSubagent: string;
        targetSubagent: string;
        similarity: number;
        expectedBenefit: number;
    };
    learningPatterns?: {
        optimalDataAmount: number;
        learningCurveShape: 'linear' | 'logarithmic' | 'exponential' | 'plateau';
        criticalFeatures: string[];
        diminishingReturns: boolean;
    };
}
export interface AdaptiveIntelligence {
    ensemblePredictions: EnsemblePrediction[];
    activeExperiments: ABTestConfig[];
    experimentResults: ABTestResult[];
    optimizationResults: OptimizationResult[];
    metaLearningInsights: MetaLearningInsight[];
    systemAdaptations: {
        timestamp: string;
        adaptationType: 'parameter_tuning' | 'model_reweighting' | 'feature_selection' | 'threshold_adjustment';
        description: string;
        performance_impact: number;
        confidence: number;
    }[];
}