@gotza02/seq-thinking 1.1.21 → 1.1.23

package/dist/validation/schemas.d.ts

@@ -0,0 +1,793 @@
+/**
+ * Zod validation schemas for MCP Sequential Thinking
+ * @module validation/schemas
+ */
+import { z } from 'zod';
+export declare const ThoughtTypeEnum: z.ZodEnum<{
+    hypothesis: "hypothesis";
+    analysis: "analysis";
+    synthesis: "synthesis";
+    conclusion: "conclusion";
+    meta_reasoning: "meta_reasoning";
+    self_correction: "self_correction";
+    uncertainty: "uncertainty";
+    question: "question";
+    evidence: "evidence";
+    counterargument: "counterargument";
+    assumption: "assumption";
+    branch_point: "branch_point";
+    merge_point: "merge_point";
+    revision: "revision";
+}>;
+export declare const AgentTypeEnum: z.ZodEnum<{
+    meta_reasoning: "meta_reasoning";
+    reasoner: "reasoner";
+    critic: "critic";
+    synthesizer: "synthesizer";
+    specialist: "specialist";
+    utility: "utility";
+}>;
+export declare const ReasoningStrategyEnum: z.ZodEnum<{
+    chain_of_thought: "chain_of_thought";
+    tree_of_thought: "tree_of_thought";
+    analogical: "analogical";
+    abductive: "abductive";
+}>;
+export declare const CriticTypeEnum: z.ZodEnum<{
+    logical: "logical";
+    factual: "factual";
+    bias: "bias";
+    safety: "safety";
+}>;
+export declare const SynthesizerTypeEnum: z.ZodEnum<{
+    consensus: "consensus";
+    creative: "creative";
+    conflict_resolution: "conflict_resolution";
+}>;
+export declare const ConsensusAlgorithmEnum: z.ZodEnum<{
+    majority_vote: "majority_vote";
+    weighted_vote: "weighted_vote";
+    borda_count: "borda_count";
+    condorcet: "condorcet";
+    delphi_method: "delphi_method";
+    prediction_market: "prediction_market";
+}>;
+export declare const ConflictResolutionStrategyEnum: z.ZodEnum<{
+    mediation: "mediation";
+    arbitration: "arbitration";
+    voting: "voting";
+    expert_escalation: "expert_escalation";
+    compromise: "compromise";
+    evidence_based: "evidence_based";
+}>;
+export declare const AssignmentStrategyEnum: z.ZodEnum<{
+    round_robin: "round_robin";
+    capability_based: "capability_based";
+    load_balanced: "load_balanced";
+    performance_based: "performance_based";
+    adaptive: "adaptive";
+    cost_based: "cost_based";
+    fastest_first: "fastest_first";
+}>;
+export declare const MessageTypeEnum: z.ZodEnum<{
+    task_assignment: "task_assignment";
+    task_result: "task_result";
+    broadcast: "broadcast";
+    direct: "direct";
+    consensus_request: "consensus_request";
+    consensus_vote: "consensus_vote";
+    conflict_notification: "conflict_notification";
+    heartbeat: "heartbeat";
+}>;
+export declare const BranchStatusEnum: z.ZodEnum<{
+    completed: "completed";
+    active: "active";
+    merged: "merged";
+    pruned: "pruned";
+    abandoned: "abandoned";
+}>;
+export declare const SessionStatusEnum: z.ZodEnum<{
+    completed: "completed";
+    initializing: "initializing";
+    active: "active";
+    abandoned: "abandoned";
+    paused: "paused";
+    converging: "converging";
+}>;
+export declare const AgentStatusEnum: z.ZodEnum<{
+    idle: "idle";
+    busy: "busy";
+    offline: "offline";
+    error: "error";
+    initializing: "initializing";
+}>;
+export declare const TaskStatusEnum: z.ZodEnum<{
+    pending: "pending";
+    assigned: "assigned";
+    in_progress: "in_progress";
+    completed: "completed";
+    failed: "failed";
+    cancelled: "cancelled";
+}>;
+export declare const ConflictStatusEnum: z.ZodEnum<{
+    failed: "failed";
+    detected: "detected";
+    analyzing: "analyzing";
+    resolving: "resolving";
+    resolved: "resolved";
+}>;
+export declare const IdSchema: z.ZodString;
+export declare const SessionIdSchema: z.ZodString;
+export declare const ThoughtIdSchema: z.ZodString;
+export declare const AgentIdSchema: z.ZodString;
+export declare const BranchIdSchema: z.ZodString;
+export declare const TaskIdSchema: z.ZodString;
+export declare const ConflictIdSchema: z.ZodString;
+export declare const ContentSchema: z.ZodString;
+export declare const ConfidenceSchema: z.ZodOptional<z.ZodNumber>;
+export declare const TagsSchema: z.ZodOptional<z.ZodArray<z.ZodString>>;
+export declare const AssumptionsSchema: z.ZodOptional<z.ZodArray<z.ZodString>>;
+export declare const DependenciesSchema: z.ZodOptional<z.ZodArray<z.ZodString>>;
+export declare const CapabilitiesSchema: z.ZodOptional<z.ZodArray<z.ZodString>>;
+export declare const InitializeSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"initialize">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    topic: z.ZodString;
+    settings: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export declare const AddThoughtSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"add_thought">;
+    sessionId: z.ZodString;
+    content: z.ZodString;
+    thoughtType: z.ZodOptional<z.ZodEnum<{
+        hypothesis: "hypothesis";
+        analysis: "analysis";
+        synthesis: "synthesis";
+        conclusion: "conclusion";
+        meta_reasoning: "meta_reasoning";
+        self_correction: "self_correction";
+        uncertainty: "uncertainty";
+        question: "question";
+        evidence: "evidence";
+        counterargument: "counterargument";
+        assumption: "assumption";
+        branch_point: "branch_point";
+        merge_point: "merge_point";
+        revision: "revision";
+    }>>;
+    parentThoughtId: z.ZodOptional<z.ZodString>;
+    branchId: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    assumptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const ReviseThoughtSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"revise_thought">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    thoughtId: z.ZodString;
+    newContent: z.ZodString;
+    revisionReason: z.ZodString;
+}, z.core.$strip>;
+export declare const BranchThoughtSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"branch_thought">;
+    sessionId: z.ZodString;
+    parentThoughtId: z.ZodString;
+    branchName: z.ZodString;
+    branchDescription: z.ZodOptional<z.ZodString>;
+    initialContent: z.ZodString;
+}, z.core.$strip>;
+export declare const MergeBranchesSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"merge_branches">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    targetBranchId: z.ZodString;
+    sourceBranchId: z.ZodString;
+    mergeContent: z.ZodString;
+}, z.core.$strip>;
+export declare const PruneBranchSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"prune_branch">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    branchId: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export declare const SelfCorrectSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"self_correct">;
+    sessionId: z.ZodString;
+    thoughtId: z.ZodString;
+}, z.core.$strip>;
+export declare const AddMetaThoughtSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"add_meta_thought">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    thoughtId: z.ZodString;
+    content: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const GetThinkingPathSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"get_thinking_path">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    thoughtId: z.ZodString;
+}, z.core.$strip>;
+export declare const GetBranchComparisonSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"get_branch_comparison">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    branchIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const CalibrateConfidenceSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"calibrate_confidence">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    thoughtId: z.ZodString;
+    feedback: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const AdjustGranularitySchema: z.ZodObject<{
+    operation: z.ZodLiteral<"adjust_granularity">;
+    sessionId: z.ZodString;
+}, z.core.$strip>;
+export declare const GetSessionStateSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"get_session_state">;
+    sessionId: z.ZodString;
+}, z.core.$strip>;
+export declare const CompleteSessionSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"complete_session">;
+    sessionId: z.ZodString;
+}, z.core.$strip>;
+export declare const DelegateToSwarmSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"delegate_to_swarm">;
+    sessionId: z.ZodString;
+    thoughtId: z.ZodString;
+    taskType: z.ZodString;
+    requiredCapabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    modelProvider: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const RegisterAgentSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"register_agent">;
+    name: z.ZodString;
+    agentType: z.ZodEnum<{
+        meta_reasoning: "meta_reasoning";
+        reasoner: "reasoner";
+        critic: "critic";
+        synthesizer: "synthesizer";
+        specialist: "specialist";
+        utility: "utility";
+    }>;
+    type: z.ZodOptional<z.ZodEnum<{
+        meta_reasoning: "meta_reasoning";
+        reasoner: "reasoner";
+        critic: "critic";
+        synthesizer: "synthesizer";
+        specialist: "specialist";
+        utility: "utility";
+    }>>;
+    subtype: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodArray<z.ZodAny>]>>;
+    payload: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export declare const UnregisterAgentSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"unregister_agent">;
+    agentId: z.ZodString;
+}, z.core.$strip>;
+export declare const ListAgentsSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"list_agents">;
+}, z.core.$strip>;
+export declare const GetAgentStatusSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"get_agent_status">;
+    agentId: z.ZodString;
+}, z.core.$strip>;
+export declare const AssignTaskSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"assign_task">;
+    taskType: z.ZodString;
+    description: z.ZodString;
+    input: z.ZodUnknown;
+    requiredCapabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    strategy: z.ZodOptional<z.ZodEnum<{
+        round_robin: "round_robin";
+        capability_based: "capability_based";
+        load_balanced: "load_balanced";
+        performance_based: "performance_based";
+        adaptive: "adaptive";
+        cost_based: "cost_based";
+        fastest_first: "fastest_first";
+    }>>;
+}, z.core.$strip>;
+export declare const GetTaskStatusSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"get_task_status">;
+    taskId: z.ZodString;
+}, z.core.$strip>;
+export declare const ReachConsensusSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"reach_consensus">;
+    proposal: z.ZodUnknown;
+    options: z.ZodArray<z.ZodUnknown>;
+    algorithm: z.ZodOptional<z.ZodEnum<{
+        majority_vote: "majority_vote";
+        weighted_vote: "weighted_vote";
+        borda_count: "borda_count";
+        condorcet: "condorcet";
+        delphi_method: "delphi_method";
+        prediction_market: "prediction_market";
+    }>>;
+    participatingAgents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    minAgreementRatio: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    maxRounds: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+export declare const IdentifyConflictSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"identify_conflict">;
+    conflictType: z.ZodString;
+    description: z.ZodString;
+    positions: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        position: z.ZodUnknown;
+        confidence: z.ZodNumber;
+        reasoning: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ResolveConflictSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"resolve_conflict">;
+    conflictId: z.ZodString;
+    resolutionStrategy: z.ZodOptional<z.ZodEnum<{
+        mediation: "mediation";
+        arbitration: "arbitration";
+        voting: "voting";
+        expert_escalation: "expert_escalation";
+        compromise: "compromise";
+        evidence_based: "evidence_based";
+    }>>;
+    resolverAgentId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const BroadcastMessageSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"broadcast_message">;
+    senderId: z.ZodString;
+    payload: z.ZodAny;
+}, z.core.$strip>;
+export declare const SendDirectMessageSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"send_direct_message">;
+    senderId: z.ZodString;
+    recipientId: z.ZodString;
+    payload: z.ZodAny;
+}, z.core.$strip>;
+export declare const GetSwarmStatsSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"get_swarm_stats">;
+}, z.core.$strip>;
+export declare const SequentialThinkingSchema: z.ZodUnion<readonly [z.ZodObject<{
+    operation: z.ZodLiteral<"initialize">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    topic: z.ZodString;
+    settings: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"add_thought">;
+    sessionId: z.ZodString;
+    content: z.ZodString;
+    thoughtType: z.ZodOptional<z.ZodEnum<{
+        hypothesis: "hypothesis";
+        analysis: "analysis";
+        synthesis: "synthesis";
+        conclusion: "conclusion";
+        meta_reasoning: "meta_reasoning";
+        self_correction: "self_correction";
+        uncertainty: "uncertainty";
+        question: "question";
+        evidence: "evidence";
+        counterargument: "counterargument";
+        assumption: "assumption";
+        branch_point: "branch_point";
+        merge_point: "merge_point";
+        revision: "revision";
+    }>>;
+    parentThoughtId: z.ZodOptional<z.ZodString>;
+    branchId: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    assumptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"revise_thought">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    thoughtId: z.ZodString;
+    newContent: z.ZodString;
+    revisionReason: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"branch_thought">;
+    sessionId: z.ZodString;
+    parentThoughtId: z.ZodString;
+    branchName: z.ZodString;
+    branchDescription: z.ZodOptional<z.ZodString>;
+    initialContent: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"merge_branches">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    targetBranchId: z.ZodString;
+    sourceBranchId: z.ZodString;
+    mergeContent: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"prune_branch">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    branchId: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"self_correct">;
+    sessionId: z.ZodString;
+    thoughtId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"add_meta_thought">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    thoughtId: z.ZodString;
+    content: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"get_thinking_path">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    thoughtId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"get_branch_comparison">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    branchIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"calibrate_confidence">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    thoughtId: z.ZodString;
+    feedback: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"adjust_granularity">;
+    sessionId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"get_session_state">;
+    sessionId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"complete_session">;
+    sessionId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"delegate_to_swarm">;
+    sessionId: z.ZodString;
+    thoughtId: z.ZodString;
+    taskType: z.ZodString;
+    requiredCapabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    modelProvider: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+export declare const SwarmCoordinationSchema: z.ZodUnion<readonly [z.ZodObject<{
+    operation: z.ZodLiteral<"register_agent">;
+    name: z.ZodString;
+    agentType: z.ZodEnum<{
+        meta_reasoning: "meta_reasoning";
+        reasoner: "reasoner";
+        critic: "critic";
+        synthesizer: "synthesizer";
+        specialist: "specialist";
+        utility: "utility";
+    }>;
+    type: z.ZodOptional<z.ZodEnum<{
+        meta_reasoning: "meta_reasoning";
+        reasoner: "reasoner";
+        critic: "critic";
+        synthesizer: "synthesizer";
+        specialist: "specialist";
+        utility: "utility";
+    }>>;
+    subtype: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodArray<z.ZodAny>]>>;
+    payload: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"unregister_agent">;
+    agentId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"list_agents">;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"get_agent_status">;
+    agentId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"assign_task">;
+    taskType: z.ZodString;
+    description: z.ZodString;
+    input: z.ZodUnknown;
+    requiredCapabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    strategy: z.ZodOptional<z.ZodEnum<{
+        round_robin: "round_robin";
+        capability_based: "capability_based";
+        load_balanced: "load_balanced";
+        performance_based: "performance_based";
+        adaptive: "adaptive";
+        cost_based: "cost_based";
+        fastest_first: "fastest_first";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"get_task_status">;
+    taskId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"reach_consensus">;
+    proposal: z.ZodUnknown;
+    options: z.ZodArray<z.ZodUnknown>;
+    algorithm: z.ZodOptional<z.ZodEnum<{
+        majority_vote: "majority_vote";
+        weighted_vote: "weighted_vote";
+        borda_count: "borda_count";
+        condorcet: "condorcet";
+        delphi_method: "delphi_method";
+        prediction_market: "prediction_market";
+    }>>;
+    participatingAgents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    minAgreementRatio: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    maxRounds: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"identify_conflict">;
+    conflictType: z.ZodString;
+    description: z.ZodString;
+    positions: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        position: z.ZodUnknown;
+        confidence: z.ZodNumber;
+        reasoning: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"resolve_conflict">;
+    conflictId: z.ZodString;
+    resolutionStrategy: z.ZodOptional<z.ZodEnum<{
+        mediation: "mediation";
+        arbitration: "arbitration";
+        voting: "voting";
+        expert_escalation: "expert_escalation";
+        compromise: "compromise";
+        evidence_based: "evidence_based";
+    }>>;
+    resolverAgentId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"broadcast_message">;
+    senderId: z.ZodString;
+    payload: z.ZodAny;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"send_direct_message">;
+    senderId: z.ZodString;
+    recipientId: z.ZodString;
+    payload: z.ZodAny;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"get_swarm_stats">;
+}, z.core.$strip>]>;
+export declare const MCPOperationSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+    operation: z.ZodLiteral<"initialize">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    topic: z.ZodString;
+    settings: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"add_thought">;
+    sessionId: z.ZodString;
+    content: z.ZodString;
+    thoughtType: z.ZodOptional<z.ZodEnum<{
+        hypothesis: "hypothesis";
+        analysis: "analysis";
+        synthesis: "synthesis";
+        conclusion: "conclusion";
+        meta_reasoning: "meta_reasoning";
+        self_correction: "self_correction";
+        uncertainty: "uncertainty";
+        question: "question";
+        evidence: "evidence";
+        counterargument: "counterargument";
+        assumption: "assumption";
+        branch_point: "branch_point";
+        merge_point: "merge_point";
+        revision: "revision";
+    }>>;
+    parentThoughtId: z.ZodOptional<z.ZodString>;
+    branchId: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    assumptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"revise_thought">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    thoughtId: z.ZodString;
+    newContent: z.ZodString;
+    revisionReason: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"branch_thought">;
+    sessionId: z.ZodString;
+    parentThoughtId: z.ZodString;
+    branchName: z.ZodString;
+    branchDescription: z.ZodOptional<z.ZodString>;
+    initialContent: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"merge_branches">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    targetBranchId: z.ZodString;
+    sourceBranchId: z.ZodString;
+    mergeContent: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"prune_branch">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    branchId: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"self_correct">;
+    sessionId: z.ZodString;
+    thoughtId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"add_meta_thought">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    thoughtId: z.ZodString;
+    content: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"get_thinking_path">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    thoughtId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"get_branch_comparison">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    branchIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"calibrate_confidence">;
+    sessionId: z.ZodOptional<z.ZodUndefined>;
+    thoughtId: z.ZodString;
+    feedback: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"adjust_granularity">;
+    sessionId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"get_session_state">;
+    sessionId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"complete_session">;
+    sessionId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"delegate_to_swarm">;
+    sessionId: z.ZodString;
+    thoughtId: z.ZodString;
+    taskType: z.ZodString;
+    requiredCapabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    modelProvider: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodObject<{
+    operation: z.ZodLiteral<"register_agent">;
+    name: z.ZodString;
+    agentType: z.ZodEnum<{
+        meta_reasoning: "meta_reasoning";
+        reasoner: "reasoner";
+        critic: "critic";
+        synthesizer: "synthesizer";
+        specialist: "specialist";
+        utility: "utility";
+    }>;
+    type: z.ZodOptional<z.ZodEnum<{
+        meta_reasoning: "meta_reasoning";
+        reasoner: "reasoner";
+        critic: "critic";
+        synthesizer: "synthesizer";
+        specialist: "specialist";
+        utility: "utility";
+    }>>;
+    subtype: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodArray<z.ZodAny>]>>;
+    payload: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"unregister_agent">;
+    agentId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"list_agents">;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"get_agent_status">;
+    agentId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"assign_task">;
+    taskType: z.ZodString;
+    description: z.ZodString;
+    input: z.ZodUnknown;
+    requiredCapabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    strategy: z.ZodOptional<z.ZodEnum<{
+        round_robin: "round_robin";
+        capability_based: "capability_based";
+        load_balanced: "load_balanced";
+        performance_based: "performance_based";
+        adaptive: "adaptive";
+        cost_based: "cost_based";
+        fastest_first: "fastest_first";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"get_task_status">;
+    taskId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"reach_consensus">;
+    proposal: z.ZodUnknown;
+    options: z.ZodArray<z.ZodUnknown>;
+    algorithm: z.ZodOptional<z.ZodEnum<{
+        majority_vote: "majority_vote";
+        weighted_vote: "weighted_vote";
+        borda_count: "borda_count";
+        condorcet: "condorcet";
+        delphi_method: "delphi_method";
+        prediction_market: "prediction_market";
+    }>>;
+    participatingAgents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    minAgreementRatio: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    maxRounds: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"identify_conflict">;
+    conflictType: z.ZodString;
+    description: z.ZodString;
+    positions: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        position: z.ZodUnknown;
+        confidence: z.ZodNumber;
+        reasoning: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"resolve_conflict">;
+    conflictId: z.ZodString;
+    resolutionStrategy: z.ZodOptional<z.ZodEnum<{
+        mediation: "mediation";
+        arbitration: "arbitration";
+        voting: "voting";
+        expert_escalation: "expert_escalation";
+        compromise: "compromise";
+        evidence_based: "evidence_based";
+    }>>;
+    resolverAgentId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"broadcast_message">;
+    senderId: z.ZodString;
+    payload: z.ZodAny;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"send_direct_message">;
+    senderId: z.ZodString;
+    recipientId: z.ZodString;
+    payload: z.ZodAny;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"get_swarm_stats">;
+}, z.core.$strip>]>]>;
+export type InitializeInput = z.infer<typeof InitializeSchema>;
+export type AddThoughtInput = z.infer<typeof AddThoughtSchema>;
+export type ReviseThoughtInput = z.infer<typeof ReviseThoughtSchema>;
+export type BranchThoughtInput = z.infer<typeof BranchThoughtSchema>;
+export type MergeBranchesInput = z.infer<typeof MergeBranchesSchema>;
+export type PruneBranchInput = z.infer<typeof PruneBranchSchema>;
+export type SelfCorrectInput = z.infer<typeof SelfCorrectSchema>;
+export type AddMetaThoughtInput = z.infer<typeof AddMetaThoughtSchema>;
+export type GetThinkingPathInput = z.infer<typeof GetThinkingPathSchema>;
+export type GetBranchComparisonInput = z.infer<typeof GetBranchComparisonSchema>;
+export type CalibrateConfidenceInput = z.infer<typeof CalibrateConfidenceSchema>;
+export type AdjustGranularityInput = z.infer<typeof AdjustGranularitySchema>;
+export type GetSessionStateInput = z.infer<typeof GetSessionStateSchema>;
+export type CompleteSessionInput = z.infer<typeof CompleteSessionSchema>;
+export type DelegateToSwarmInput = z.infer<typeof DelegateToSwarmSchema>;
+export type RegisterAgentInput = z.infer<typeof RegisterAgentSchema>;
+export type UnregisterAgentInput = z.infer<typeof UnregisterAgentSchema>;
+export type ListAgentsInput = z.infer<typeof ListAgentsSchema>;
+export type GetAgentStatusInput = z.infer<typeof GetAgentStatusSchema>;
+export type AssignTaskInput = z.infer<typeof AssignTaskSchema>;
+export type GetTaskStatusInput = z.infer<typeof GetTaskStatusSchema>;
+export type ReachConsensusInput = z.infer<typeof ReachConsensusSchema>;
+export type IdentifyConflictInput = z.infer<typeof IdentifyConflictSchema>;
+export type ResolveConflictInput = z.infer<typeof ResolveConflictSchema>;
+export type BroadcastMessageInput = z.infer<typeof BroadcastMessageSchema>;
+export type SendDirectMessageInput = z.infer<typeof SendDirectMessageSchema>;
+export type GetSwarmStatsInput = z.infer<typeof GetSwarmStatsSchema>;
+/**
+ * Validate sequential thinking input
+ */
+export declare function validateSequentialThinking(input: unknown): {
+    success: true;
+    data: z.infer<typeof SequentialThinkingSchema>;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Validate swarm coordination input
+ */
+export declare function validateSwarmCoordination(input: unknown): {
+    success: true;
+    data: z.infer<typeof SwarmCoordinationSchema>;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Validate any MCP operation
+ */
+export declare function validateMCPOperation(toolName: string, input: unknown): {
+    success: true;
+    data: unknown;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Safe validation that returns null on error
+ */
+export declare function safeValidate<T>(schema: z.ZodSchema<T>, input: unknown): T | null;
+//# sourceMappingURL=schemas.d.ts.map