@cyqlelabs/mcp-dual-cycle-reasoner/build/types.d.ts

MCP server implementing dual-cycle metacognitive reasoning framework for autonomous agents

import { z } from 'zod';
export declare const SentinelConfigSchema: z.ZodObject<{
    progress_indicators: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    min_actions_for_detection: z.ZodDefault<z.ZodNumber>;
    alternating_threshold: z.ZodDefault<z.ZodNumber>;
    repetition_threshold: z.ZodDefault<z.ZodNumber>;
    progress_threshold_adjustment: z.ZodDefault<z.ZodNumber>;
    statistical_analysis: z.ZodOptional<z.ZodObject<{
        entropy_threshold: z.ZodDefault<z.ZodNumber>;
        variance_threshold: z.ZodDefault<z.ZodNumber>;
        trend_threshold: z.ZodDefault<z.ZodNumber>;
        cyclicity_threshold: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        entropy_threshold: number;
        variance_threshold: number;
        trend_threshold: number;
        cyclicity_threshold: number;
    }, {
        entropy_threshold?: number | undefined;
        variance_threshold?: number | undefined;
        trend_threshold?: number | undefined;
        cyclicity_threshold?: number | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    progress_indicators: string[];
    min_actions_for_detection: number;
    alternating_threshold: number;
    repetition_threshold: number;
    progress_threshold_adjustment: number;
    statistical_analysis?: {
        entropy_threshold: number;
        variance_threshold: number;
        trend_threshold: number;
        cyclicity_threshold: number;
    } | undefined;
}, {
    progress_indicators?: string[] | undefined;
    min_actions_for_detection?: number | undefined;
    alternating_threshold?: number | undefined;
    repetition_threshold?: number | undefined;
    progress_threshold_adjustment?: number | undefined;
    statistical_analysis?: {
        entropy_threshold?: number | undefined;
        variance_threshold?: number | undefined;
        trend_threshold?: number | undefined;
        cyclicity_threshold?: number | undefined;
    } | undefined;
}>;
export declare const AgentActionSchema: z.ZodObject<{
    type: z.ZodString;
    timestamp: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    result: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    type: string;
    timestamp: number;
    result?: string | undefined;
}, {
    type: string;
    timestamp?: number | undefined;
    result?: string | undefined;
}>;
export declare const EnvironmentStateSchema: z.ZodObject<{
    context: z.ZodOptional<z.ZodString>;
    timestamp: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
}, "strip", z.ZodTypeAny, {
    timestamp: number;
    context?: string | undefined;
}, {
    timestamp?: number | undefined;
    context?: string | undefined;
}>;
export declare const CognitiveTraceSchema: z.ZodObject<{
    recent_actions: z.ZodArray<z.ZodString, "many">;
    current_context: z.ZodOptional<z.ZodString>;
    goal: z.ZodString;
    step_count: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    recent_actions: string[];
    goal: string;
    step_count: number;
    current_context?: string | undefined;
}, {
    recent_actions: string[];
    goal: string;
    current_context?: string | undefined;
    step_count?: number | undefined;
}>;
export declare const LoopTypeSchema: z.ZodEnum<["action_repetition", "state_invariance", "progress_stagnation"]>;
export declare const LoopDetectionResultSchema: z.ZodObject<{
    detected: z.ZodBoolean;
    type: z.ZodOptional<z.ZodEnum<["action_repetition", "state_invariance", "progress_stagnation"]>>;
    confidence: z.ZodNumber;
    details: z.ZodString;
    actions_involved: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    statistical_metrics: z.ZodOptional<z.ZodObject<{
        entropy_score: z.ZodOptional<z.ZodNumber>;
        variance_score: z.ZodOptional<z.ZodNumber>;
        trend_score: z.ZodOptional<z.ZodNumber>;
        cyclicity_score: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        entropy_score?: number | undefined;
        variance_score?: number | undefined;
        trend_score?: number | undefined;
        cyclicity_score?: number | undefined;
    }, {
        entropy_score?: number | undefined;
        variance_score?: number | undefined;
        trend_score?: number | undefined;
        cyclicity_score?: number | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    detected: boolean;
    confidence: number;
    details: string;
    type?: "action_repetition" | "state_invariance" | "progress_stagnation" | undefined;
    actions_involved?: string[] | undefined;
    statistical_metrics?: {
        entropy_score?: number | undefined;
        variance_score?: number | undefined;
        trend_score?: number | undefined;
        cyclicity_score?: number | undefined;
    } | undefined;
}, {
    detected: boolean;
    confidence: number;
    details: string;
    type?: "action_repetition" | "state_invariance" | "progress_stagnation" | undefined;
    actions_involved?: string[] | undefined;
    statistical_metrics?: {
        entropy_score?: number | undefined;
        variance_score?: number | undefined;
        trend_score?: number | undefined;
        cyclicity_score?: number | undefined;
    } | undefined;
}>;
export declare const FailureHypothesisSchema: z.ZodEnum<["element_state_error", "page_state_error", "selector_error", "task_model_error", "network_error", "unknown"]>;
export declare const DiagnosisResultSchema: z.ZodObject<{
    primary_hypothesis: z.ZodEnum<["element_state_error", "page_state_error", "selector_error", "task_model_error", "network_error", "unknown"]>;
    confidence: z.ZodNumber;
    evidence: z.ZodArray<z.ZodString, "many">;
    suggested_actions: z.ZodArray<z.ZodString, "many">;
    semantic_analysis: z.ZodOptional<z.ZodObject<{
        sentiment_score: z.ZodOptional<z.ZodNumber>;
        confidence_factors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        evidence_quality: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        sentiment_score?: number | undefined;
        confidence_factors?: string[] | undefined;
        evidence_quality?: number | undefined;
    }, {
        sentiment_score?: number | undefined;
        confidence_factors?: string[] | undefined;
        evidence_quality?: number | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    confidence: number;
    primary_hypothesis: "unknown" | "element_state_error" | "page_state_error" | "selector_error" | "task_model_error" | "network_error";
    evidence: string[];
    suggested_actions: string[];
    semantic_analysis?: {
        sentiment_score?: number | undefined;
        confidence_factors?: string[] | undefined;
        evidence_quality?: number | undefined;
    } | undefined;
}, {
    confidence: number;
    primary_hypothesis: "unknown" | "element_state_error" | "page_state_error" | "selector_error" | "task_model_error" | "network_error";
    evidence: string[];
    suggested_actions: string[];
    semantic_analysis?: {
        sentiment_score?: number | undefined;
        confidence_factors?: string[] | undefined;
        evidence_quality?: number | undefined;
    } | undefined;
}>;
export declare const RecoveryPatternSchema: z.ZodEnum<["strategic_retreat", "context_refresh", "modality_switching", "information_foraging", "human_escalation"]>;
export declare const RecoveryPlanSchema: z.ZodObject<{
    pattern: z.ZodEnum<["strategic_retreat", "context_refresh", "modality_switching", "information_foraging", "human_escalation"]>;
    actions: z.ZodArray<z.ZodString, "many">;
    rationale: z.ZodString;
    expected_outcome: z.ZodString;
}, "strip", z.ZodTypeAny, {
    pattern: "strategic_retreat" | "context_refresh" | "modality_switching" | "information_foraging" | "human_escalation";
    actions: string[];
    rationale: string;
    expected_outcome: string;
}, {
    pattern: "strategic_retreat" | "context_refresh" | "modality_switching" | "information_foraging" | "human_escalation";
    actions: string[];
    rationale: string;
    expected_outcome: string;
}>;
export declare const CaseSchema: z.ZodObject<{
    id: z.ZodDefault<z.ZodOptional<z.ZodString>>;
    problem_description: z.ZodString;
    solution: z.ZodString;
    outcome: z.ZodBoolean;
    timestamp: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    similarity_metrics: z.ZodOptional<z.ZodObject<{
        semantic_similarity: z.ZodOptional<z.ZodNumber>;
        jaccard_similarity: z.ZodOptional<z.ZodNumber>;
        cosine_similarity: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        semantic_similarity?: number | undefined;
        jaccard_similarity?: number | undefined;
        cosine_similarity?: number | undefined;
    }, {
        semantic_similarity?: number | undefined;
        jaccard_similarity?: number | undefined;
        cosine_similarity?: number | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    timestamp: number;
    id: string;
    problem_description: string;
    solution: string;
    outcome: boolean;
    similarity_metrics?: {
        semantic_similarity?: number | undefined;
        jaccard_similarity?: number | undefined;
        cosine_similarity?: number | undefined;
    } | undefined;
}, {
    problem_description: string;
    solution: string;
    outcome: boolean;
    timestamp?: number | undefined;
    id?: string | undefined;
    similarity_metrics?: {
        semantic_similarity?: number | undefined;
        jaccard_similarity?: number | undefined;
        cosine_similarity?: number | undefined;
    } | undefined;
}>;
export declare const BeliefRevisionResultSchema: z.ZodObject<{
    revised_beliefs: z.ZodArray<z.ZodString, "many">;
    removed_beliefs: z.ZodArray<z.ZodString, "many">;
    rationale: z.ZodString;
    semantic_analysis: z.ZodOptional<z.ZodObject<{
        contradiction_score: z.ZodOptional<z.ZodNumber>;
        sentiment_shift: z.ZodOptional<z.ZodNumber>;
        confidence_level: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        contradiction_score?: number | undefined;
        sentiment_shift?: number | undefined;
        confidence_level?: number | undefined;
    }, {
        contradiction_score?: number | undefined;
        sentiment_shift?: number | undefined;
        confidence_level?: number | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    rationale: string;
    revised_beliefs: string[];
    removed_beliefs: string[];
    semantic_analysis?: {
        contradiction_score?: number | undefined;
        sentiment_shift?: number | undefined;
        confidence_level?: number | undefined;
    } | undefined;
}, {
    rationale: string;
    revised_beliefs: string[];
    removed_beliefs: string[];
    semantic_analysis?: {
        contradiction_score?: number | undefined;
        sentiment_shift?: number | undefined;
        confidence_level?: number | undefined;
    } | undefined;
}>;
export declare const MonitorCognitiveTraceInputSchema: z.ZodObject<{
    trace: z.ZodObject<{
        recent_actions: z.ZodArray<z.ZodString, "many">;
        current_context: z.ZodOptional<z.ZodString>;
        goal: z.ZodString;
        step_count: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        recent_actions: string[];
        goal: string;
        step_count: number;
        current_context?: string | undefined;
    }, {
        recent_actions: string[];
        goal: string;
        current_context?: string | undefined;
        step_count?: number | undefined;
    }>;
    window_size: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    trace: {
        recent_actions: string[];
        goal: string;
        step_count: number;
        current_context?: string | undefined;
    };
    window_size: number;
}, {
    trace: {
        recent_actions: string[];
        goal: string;
        current_context?: string | undefined;
        step_count?: number | undefined;
    };
    window_size?: number | undefined;
}>;
export declare const DetectLoopInputSchema: z.ZodObject<{
    trace: z.ZodObject<{
        recent_actions: z.ZodArray<z.ZodString, "many">;
        current_context: z.ZodOptional<z.ZodString>;
        goal: z.ZodString;
        step_count: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        recent_actions: string[];
        goal: string;
        step_count: number;
        current_context?: string | undefined;
    }, {
        recent_actions: string[];
        goal: string;
        current_context?: string | undefined;
        step_count?: number | undefined;
    }>;
    detection_method: z.ZodDefault<z.ZodEnum<["statistical", "pattern", "hybrid"]>>;
}, "strip", z.ZodTypeAny, {
    trace: {
        recent_actions: string[];
        goal: string;
        step_count: number;
        current_context?: string | undefined;
    };
    detection_method: "pattern" | "statistical" | "hybrid";
}, {
    trace: {
        recent_actions: string[];
        goal: string;
        current_context?: string | undefined;
        step_count?: number | undefined;
    };
    detection_method?: "pattern" | "statistical" | "hybrid" | undefined;
}>;
export declare const DiagnoseFailureInputSchema: z.ZodObject<{
    loop_result: z.ZodObject<{
        detected: z.ZodBoolean;
        type: z.ZodOptional<z.ZodEnum<["action_repetition", "state_invariance", "progress_stagnation"]>>;
        confidence: z.ZodNumber;
        details: z.ZodString;
        actions_involved: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        statistical_metrics: z.ZodOptional<z.ZodObject<{
            entropy_score: z.ZodOptional<z.ZodNumber>;
            variance_score: z.ZodOptional<z.ZodNumber>;
            trend_score: z.ZodOptional<z.ZodNumber>;
            cyclicity_score: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            entropy_score?: number | undefined;
            variance_score?: number | undefined;
            trend_score?: number | undefined;
            cyclicity_score?: number | undefined;
        }, {
            entropy_score?: number | undefined;
            variance_score?: number | undefined;
            trend_score?: number | undefined;
            cyclicity_score?: number | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        detected: boolean;
        confidence: number;
        details: string;
        type?: "action_repetition" | "state_invariance" | "progress_stagnation" | undefined;
        actions_involved?: string[] | undefined;
        statistical_metrics?: {
            entropy_score?: number | undefined;
            variance_score?: number | undefined;
            trend_score?: number | undefined;
            cyclicity_score?: number | undefined;
        } | undefined;
    }, {
        detected: boolean;
        confidence: number;
        details: string;
        type?: "action_repetition" | "state_invariance" | "progress_stagnation" | undefined;
        actions_involved?: string[] | undefined;
        statistical_metrics?: {
            entropy_score?: number | undefined;
            variance_score?: number | undefined;
            trend_score?: number | undefined;
            cyclicity_score?: number | undefined;
        } | undefined;
    }>;
    trace: z.ZodObject<{
        recent_actions: z.ZodArray<z.ZodString, "many">;
        current_context: z.ZodOptional<z.ZodString>;
        goal: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        recent_actions: string[];
        goal: string;
        current_context?: string | undefined;
    }, {
        recent_actions: string[];
        goal: string;
        current_context?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    trace: {
        recent_actions: string[];
        goal: string;
        current_context?: string | undefined;
    };
    loop_result: {
        detected: boolean;
        confidence: number;
        details: string;
        type?: "action_repetition" | "state_invariance" | "progress_stagnation" | undefined;
        actions_involved?: string[] | undefined;
        statistical_metrics?: {
            entropy_score?: number | undefined;
            variance_score?: number | undefined;
            trend_score?: number | undefined;
            cyclicity_score?: number | undefined;
        } | undefined;
    };
}, {
    trace: {
        recent_actions: string[];
        goal: string;
        current_context?: string | undefined;
    };
    loop_result: {
        detected: boolean;
        confidence: number;
        details: string;
        type?: "action_repetition" | "state_invariance" | "progress_stagnation" | undefined;
        actions_involved?: string[] | undefined;
        statistical_metrics?: {
            entropy_score?: number | undefined;
            variance_score?: number | undefined;
            trend_score?: number | undefined;
            cyclicity_score?: number | undefined;
        } | undefined;
    };
}>;
export declare const ReviseBelifsInputSchema: z.ZodObject<{
    current_beliefs: z.ZodArray<z.ZodString, "many">;
    contradicting_evidence: z.ZodString;
    trace: z.ZodObject<{
        recent_actions: z.ZodArray<z.ZodString, "many">;
        goal: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        recent_actions: string[];
        goal: string;
    }, {
        recent_actions: string[];
        goal: string;
    }>;
}, "strip", z.ZodTypeAny, {
    trace: {
        recent_actions: string[];
        goal: string;
    };
    current_beliefs: string[];
    contradicting_evidence: string;
}, {
    trace: {
        recent_actions: string[];
        goal: string;
    };
    current_beliefs: string[];
    contradicting_evidence: string;
}>;
export declare const GenerateRecoveryPlanInputSchema: z.ZodObject<{
    diagnosis: z.ZodObject<{
        primary_hypothesis: z.ZodEnum<["element_state_error", "page_state_error", "selector_error", "task_model_error", "network_error", "unknown"]>;
        confidence: z.ZodNumber;
        evidence: z.ZodArray<z.ZodString, "many">;
        suggested_actions: z.ZodArray<z.ZodString, "many">;
        semantic_analysis: z.ZodOptional<z.ZodObject<{
            sentiment_score: z.ZodOptional<z.ZodNumber>;
            confidence_factors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
            evidence_quality: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            sentiment_score?: number | undefined;
            confidence_factors?: string[] | undefined;
            evidence_quality?: number | undefined;
        }, {
            sentiment_score?: number | undefined;
            confidence_factors?: string[] | undefined;
            evidence_quality?: number | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        confidence: number;
        primary_hypothesis: "unknown" | "element_state_error" | "page_state_error" | "selector_error" | "task_model_error" | "network_error";
        evidence: string[];
        suggested_actions: string[];
        semantic_analysis?: {
            sentiment_score?: number | undefined;
            confidence_factors?: string[] | undefined;
            evidence_quality?: number | undefined;
        } | undefined;
    }, {
        confidence: number;
        primary_hypothesis: "unknown" | "element_state_error" | "page_state_error" | "selector_error" | "task_model_error" | "network_error";
        evidence: string[];
        suggested_actions: string[];
        semantic_analysis?: {
            sentiment_score?: number | undefined;
            confidence_factors?: string[] | undefined;
            evidence_quality?: number | undefined;
        } | undefined;
    }>;
    trace: z.ZodObject<{
        recent_actions: z.ZodArray<z.ZodString, "many">;
        current_context: z.ZodOptional<z.ZodString>;
        goal: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        recent_actions: string[];
        goal: string;
        current_context?: string | undefined;
    }, {
        recent_actions: string[];
        goal: string;
        current_context?: string | undefined;
    }>;
    available_patterns: z.ZodOptional<z.ZodArray<z.ZodEnum<["strategic_retreat", "context_refresh", "modality_switching", "information_foraging", "human_escalation"]>, "many">>;
}, "strip", z.ZodTypeAny, {
    trace: {
        recent_actions: string[];
        goal: string;
        current_context?: string | undefined;
    };
    diagnosis: {
        confidence: number;
        primary_hypothesis: "unknown" | "element_state_error" | "page_state_error" | "selector_error" | "task_model_error" | "network_error";
        evidence: string[];
        suggested_actions: string[];
        semantic_analysis?: {
            sentiment_score?: number | undefined;
            confidence_factors?: string[] | undefined;
            evidence_quality?: number | undefined;
        } | undefined;
    };
    available_patterns?: ("strategic_retreat" | "context_refresh" | "modality_switching" | "information_foraging" | "human_escalation")[] | undefined;
}, {
    trace: {
        recent_actions: string[];
        goal: string;
        current_context?: string | undefined;
    };
    diagnosis: {
        confidence: number;
        primary_hypothesis: "unknown" | "element_state_error" | "page_state_error" | "selector_error" | "task_model_error" | "network_error";
        evidence: string[];
        suggested_actions: string[];
        semantic_analysis?: {
            sentiment_score?: number | undefined;
            confidence_factors?: string[] | undefined;
            evidence_quality?: number | undefined;
        } | undefined;
    };
    available_patterns?: ("strategic_retreat" | "context_refresh" | "modality_switching" | "information_foraging" | "human_escalation")[] | undefined;
}>;
export declare const StoreExperienceInputSchema: z.ZodObject<{
    case: z.ZodObject<{
        problem_description: z.ZodString;
        solution: z.ZodString;
        outcome: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        problem_description: string;
        solution: string;
        outcome: boolean;
    }, {
        problem_description: string;
        solution: string;
        outcome: boolean;
    }>;
}, "strip", z.ZodTypeAny, {
    case: {
        problem_description: string;
        solution: string;
        outcome: boolean;
    };
}, {
    case: {
        problem_description: string;
        solution: string;
        outcome: boolean;
    };
}>;
export declare const RetrieveSimilarCasesInputSchema: z.ZodObject<{
    problem_description: z.ZodString;
    max_results: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    problem_description: string;
    max_results: number;
}, {
    problem_description: string;
    max_results?: number | undefined;
}>;
export type AgentAction = z.infer<typeof AgentActionSchema>;
export type EnvironmentState = z.infer<typeof EnvironmentStateSchema>;
export type CognitiveTrace = z.infer<typeof CognitiveTraceSchema>;
export type LoopType = z.infer<typeof LoopTypeSchema>;
export type LoopDetectionResult = z.infer<typeof LoopDetectionResultSchema>;
export type FailureHypothesis = z.infer<typeof FailureHypothesisSchema>;
export type DiagnosisResult = z.infer<typeof DiagnosisResultSchema>;
export type RecoveryPattern = z.infer<typeof RecoveryPatternSchema>;
export type RecoveryPlan = z.infer<typeof RecoveryPlanSchema>;
export type Case = z.infer<typeof CaseSchema>;
export type BeliefRevisionResult = z.infer<typeof BeliefRevisionResultSchema>;
export type SentinelConfig = z.infer<typeof SentinelConfigSchema>;