@gotza02/seq-thinking 1.1.0

package/dist/types/index.d.ts

@@ -0,0 +1,806 @@
+/**
+ * Core Type Definitions for MCP Sequential Thinking System
+ * @module types
+ * @version 1.0.0
+ */
+/**
+ * Enumeration of thought types for classification and routing
+ */
+export declare enum ThoughtType {
+    /** Proposed explanation or theory */
+    HYPOTHESIS = "hypothesis",
+    /** Breaking down complex information */
+    ANALYSIS = "analysis",
+    /** Combining multiple thoughts */
+    SYNTHESIS = "synthesis",
+    /** Final determination */
+    CONCLUSION = "conclusion",
+    /** Thinking about the thinking process */
+    META_REASONING = "meta_reasoning",
+    /** Identifying and fixing errors */
+    SELF_CORRECTION = "self_correction",
+    /** Expressing doubt or unknowns */
+    UNCERTAINTY = "uncertainty",
+    /** Inquiry to explore */
+    QUESTION = "question",
+    /** Supporting information */
+    EVIDENCE = "evidence",
+    /** Opposing viewpoint */
+    COUNTERARGUMENT = "counterargument",
+    /** Base premise */
+    ASSUMPTION = "assumption",
+    /** Where parallel paths diverge */
+    BRANCH_POINT = "branch_point",
+    /** Where paths converge */
+    MERGE_POINT = "merge_point",
+    /** Modified version of prior thought */
+    REVISION = "revision"
+}
+/**
+ * Enumeration of agent types
+ */
+export declare enum AgentType {
+    /** Reasoning agent */
+    REASONER = "reasoner",
+    /** Critic/Evaluation agent */
+    CRITIC = "critic",
+    /** Synthesis agent */
+    SYNTHESIZER = "synthesizer",
+    /** Domain specialist agent */
+    SPECIALIST = "specialist",
+    /** Meta-reasoning agent */
+    META_REASONING = "meta_reasoning",
+    /** Utility agent */
+    UTILITY = "utility"
+}
+/**
+ * Enumeration of reasoning strategies
+ */
+export declare enum ReasoningStrategy {
+    /** Step-by-step reasoning */
+    CHAIN_OF_THOUGHT = "chain_of_thought",
+    /** Explore multiple paths */
+    TREE_OF_THOUGHT = "tree_of_thought",
+    /** Reason by analogy */
+    ANALOGICAL = "analogical",
+    /** Inference to best explanation */
+    ABDUCTIVE = "abductive"
+}
+/**
+ * Enumeration of critic types
+ */
+export declare enum CriticType {
+    /** Check logical consistency */
+    LOGICAL = "logical",
+    /** Verify factual accuracy */
+    FACTUAL = "factual",
+    /** Detect cognitive biases */
+    BIAS = "bias",
+    /** Check safety concerns */
+    SAFETY = "safety"
+}
+/**
+ * Enumeration of synthesizer types
+ */
+export declare enum SynthesizerType {
+    /** Build consensus */
+    CONSENSUS = "consensus",
+    /** Creative combination */
+    CREATIVE = "creative",
+    /** Resolve conflicts */
+    CONFLICT_RESOLUTION = "conflict_resolution"
+}
+/**
+ * Enumeration of message types
+ */
+export declare enum MessageType {
+    /** Task assignment message */
+    TASK_ASSIGNMENT = "task_assignment",
+    /** Task result message */
+    TASK_RESULT = "task_result",
+    /** Broadcast to all agents */
+    BROADCAST = "broadcast",
+    /** Direct message to specific agent */
+    DIRECT = "direct",
+    /** Request for consensus */
+    CONSENSUS_REQUEST = "consensus_request",
+    /** Consensus vote */
+    CONSENSUS_VOTE = "consensus_vote",
+    /** Conflict notification */
+    CONFLICT_NOTIFICATION = "conflict_notification",
+    /** Heartbeat/ping */
+    HEARTBEAT = "heartbeat"
+}
+/**
+ * Enumeration of consensus algorithms
+ */
+export declare enum ConsensusAlgorithm {
+    /** Simple majority vote */
+    MAJORITY_VOTE = "majority_vote",
+    /** Weighted by expertise/confidence */
+    WEIGHTED_VOTE = "weighted_vote",
+    /** Borda count ranking */
+    BORDA_COUNT = "borda_count",
+    /** Condorcet method */
+    CONDORCET = "condorcet",
+    /** Iterative Delphi method */
+    DELPHI_METHOD = "delphi_method",
+    /** Prediction market style */
+    PREDICTION_MARKET = "prediction_market"
+}
+/**
+ * Enumeration of conflict resolution strategies
+ */
+export declare enum ConflictResolutionStrategy {
+    /** Facilitated discussion */
+    MEDIATION = "mediation",
+    /** Third-party decision */
+    ARBITRATION = "arbitration",
+    /** Voting-based resolution */
+    VOTING = "voting",
+    /** Escalate to expert */
+    EXPERT_ESCALATION = "expert_escalation",
+    /** Find middle ground */
+    COMPROMISE = "compromise",
+    /** Evidence-based resolution */
+    EVIDENCE_BASED = "evidence_based"
+}
+/**
+ * Enumeration of task statuses
+ */
+export declare enum TaskStatus {
+    /** Task is pending */
+    PENDING = "pending",
+    /** Task is assigned to agent */
+    ASSIGNED = "assigned",
+    /** Task is in progress */
+    IN_PROGRESS = "in_progress",
+    /** Task is completed */
+    COMPLETED = "completed",
+    /** Task failed */
+    FAILED = "failed",
+    /** Task was cancelled */
+    CANCELLED = "cancelled"
+}
+/**
+ * Enumeration of agent statuses
+ */
+export declare enum AgentStatus {
+    /** Agent is idle */
+    IDLE = "idle",
+    /** Agent is busy */
+    BUSY = "busy",
+    /** Agent is offline */
+    OFFLINE = "offline",
+    /** Agent is error state */
+    ERROR = "error",
+    /** Agent is initializing */
+    INITIALIZING = "initializing"
+}
+/**
+ * Enumeration of branch statuses
+ */
+export declare enum BranchStatus {
+    /** Branch is active */
+    ACTIVE = "active",
+    /** Branch is completed */
+    COMPLETED = "completed",
+    /** Branch is merged */
+    MERGED = "merged",
+    /** Branch is pruned */
+    PRUNED = "pruned",
+    /** Branch is abandoned */
+    ABANDONED = "abandoned"
+}
+/**
+ * Enumeration of session statuses
+ */
+export declare enum SessionStatus {
+    /** Session is initializing */
+    INITIALIZING = "initializing",
+    /** Session is active */
+    ACTIVE = "active",
+    /** Session is paused */
+    PAUSED = "paused",
+    /** Session is converging */
+    CONVERGING = "converging",
+    /** Session is completed */
+    COMPLETED = "completed",
+    /** Session is abandoned */
+    ABANDONED = "abandoned"
+}
+/**
+ * Enumeration of conflict statuses
+ */
+export declare enum ConflictStatus {
+    /** Conflict is detected */
+    DETECTED = "detected",
+    /** Conflict is being analyzed */
+    ANALYZING = "analyzing",
+    /** Conflict is being resolved */
+    RESOLVING = "resolving",
+    /** Conflict is resolved */
+    RESOLVED = "resolved",
+    /** Conflict resolution failed */
+    FAILED = "failed"
+}
+/**
+ * Confidence score with calibration data
+ */
+export interface ConfidenceScore {
+    /** Primary score (0.0 - 1.0) */
+    overall: number;
+    /** Component scores */
+    components: {
+        /** Internal logic check */
+        logicalConsistency: number;
+        /** Factual accuracy */
+        factualAccuracy: number;
+        /** Quality of reasoning */
+        reasoningQuality: number;
+        /** Strength of evidence */
+        evidenceStrength: number;
+    };
+    /** Uncertainty bounds [lower, upper] */
+    uncertaintyBounds: [number, number];
+    /** Calibration history */
+    calibrationHistory: CalibrationPoint[];
+}
+/**
+ * Single calibration data point
+ */
+export interface CalibrationPoint {
+    /** Timestamp of calibration */
+    timestamp: Date;
+    /** Prior confidence value */
+    priorConfidence: number;
+    /** Outcome - was the thought correct? */
+    outcome: boolean;
+    /** Adjusted confidence after outcome */
+    adjustedConfidence: number;
+    /** Reason for adjustment */
+    reason: string;
+    /** Adjustment amount */
+    adjustment?: number;
+}
+/**
+ * Core thought node structure
+ */
+export interface Thought {
+    /** Unique identifier */
+    id: string;
+    /** Session ID */
+    sessionId: string;
+    /** Thought content */
+    content: string;
+    /** Sequential position */
+    stepNumber: number;
+    /** Type of thought */
+    thoughtType: ThoughtType;
+    /** Confidence score */
+    confidence: ConfidenceScore;
+    /** Parent thought ID */
+    parentThoughtId: string | null;
+    /** Child thought IDs */
+    childThoughtIds: string[];
+    /** Branch ID */
+    branchId: string;
+    /** Original thought ID if this is a revision */
+    revisionOf: string | null;
+    /** Revision history */
+    revisionHistory: RevisionRecord[];
+    /** Metadata */
+    metadata: {
+        createdAt: Date;
+        modifiedAt: Date;
+        agentId?: string;
+        processingTimeMs: number;
+        tokensUsed: number;
+    };
+    /** Tags */
+    tags: string[];
+    /** Assumptions */
+    assumptions: string[];
+    /** Dependencies */
+    dependencies: string[];
+}
+/**
+ * Revision record for tracking thought evolution
+ */
+export interface RevisionRecord {
+    /** Previous content */
+    previousContent: string;
+    /** Revision timestamp */
+    revisedAt: Date;
+    /** Reason for revision */
+    revisionReason: string;
+}
+/**
+ * Represents a reasoning branch (parallel hypothesis path)
+ */
+export interface ThoughtBranch {
+    /** Branch identifier */
+    id: string;
+    /** Session ID */
+    sessionId: string;
+    /** Branch name */
+    name: string;
+    /** Branch description */
+    description: string;
+    /** Root thought ID */
+    rootThoughtId: string;
+    /** All thought IDs in branch */
+    thoughtIds: string[];
+    /** Parent branch ID */
+    parentBranchId: string | null;
+    /** Child branch IDs */
+    childBranchIds: string[];
+    /** Branch status */
+    status: BranchStatus;
+    /** Aggregate confidence */
+    confidence: number;
+    /** Metadata */
+    metadata: {
+        createdAt: Date;
+        completedAt?: Date;
+        prunedAt?: Date;
+        pruneReason?: string;
+    };
+}
+/**
+ * Meta-note: a thought about a thought
+ */
+export interface MetaNote {
+    /** Unique identifier */
+    id: string;
+    /** Target thought ID */
+    thoughtId: string;
+    /** Observation content */
+    content: string;
+    /** Type of observation */
+    observationType: 'pattern' | 'concern' | 'insight' | 'suggestion';
+    /** Timestamp */
+    timestamp: Date;
+    /** Actions triggered by this observation */
+    triggeredActions: string[];
+}
+/**
+ * Session context
+ */
+export interface SessionContext {
+    /** Original problem statement */
+    originalProblem: string;
+    /** Constraints */
+    constraints: string[];
+    /** Relevant information */
+    relevantInformation: string[];
+    /** Working memory */
+    workingMemory: Map<string, unknown>;
+    /** Long-term references */
+    longTermReferences: string[];
+}
+/**
+ * Session settings
+ */
+export interface SessionSettings {
+    /** Maximum number of branches */
+    maxBranches: number;
+    /** Maximum depth */
+    maxDepth: number;
+    /** Confidence threshold */
+    confidenceThreshold: number;
+    /** Enable self-correction */
+    enableSelfCorrection: boolean;
+    /** Enable meta-reasoning */
+    enableMetaReasoning: boolean;
+    /** Enable parallel hypotheses */
+    enableParallelHypotheses: boolean;
+    /** Enable adaptive granularity */
+    adaptiveGranularity: boolean;
+    /** Granularity settings */
+    granularitySettings: {
+        minStepDetail: number;
+        maxStepDetail: number;
+        complexityThreshold: number;
+    };
+}
+/**
+ * Top-level session containing all thoughts for a reasoning task
+ */
+export interface ThinkingSession {
+    /** Session identifier */
+    id: string;
+    /** Topic/problem statement */
+    topic: string;
+    /** Session status */
+    status: SessionStatus;
+    /** Current branch ID */
+    currentBranchId: string;
+    /** Branches map */
+    branches: Map<string, ThoughtBranch>;
+    /** Thoughts map */
+    thoughts: Map<string, Thought>;
+    /** Meta notes map */
+    metaNotes: Map<string, MetaNote>;
+    /** Session context */
+    context: SessionContext;
+    /** Session settings */
+    settings: SessionSettings;
+    /** Metadata */
+    metadata: {
+        createdAt: Date;
+        lastActivityAt: Date;
+        completedAt?: Date;
+        totalThoughts: number;
+        totalBranches: number;
+    };
+}
+/**
+ * Agent capability
+ */
+export interface AgentCapability {
+    /** Capability name */
+    name: string;
+    /** Description */
+    description: string;
+    /** Confidence level (0-1) */
+    confidence: number;
+    /** Performance metrics */
+    performanceMetrics: {
+        tasksCompleted: number;
+        averageQuality: number;
+        averageTimeMs: number;
+    };
+}
+/**
+ * Agent configuration
+ */
+export interface AgentConfig {
+    /** Agent ID */
+    id: string;
+    /** Agent name */
+    name: string;
+    /** Agent type */
+    type: AgentType;
+    /** Subtype (e.g., critic type) */
+    subtype?: string;
+    /** Capabilities */
+    capabilities: AgentCapability[];
+    /** Maximum concurrent tasks */
+    maxConcurrentTasks: number;
+    /** Confidence threshold */
+    confidenceThreshold: number;
+    /** Metadata */
+    metadata: {
+        createdAt: Date;
+        version: string;
+        config: Record<string, unknown>;
+    };
+}
+/**
+ * Agent information
+ */
+export interface AgentInfo {
+    /** Agent configuration */
+    config: AgentConfig;
+    /** Current status */
+    status: AgentStatus;
+    /** Current task IDs */
+    currentTasks: string[];
+    /** Performance history */
+    performanceHistory: {
+        taskId: string;
+        quality: number;
+        timeMs: number;
+        timestamp: Date;
+    }[];
+}
+/**
+ * Agent type (alias for AgentInfo)
+ */
+export type Agent = AgentInfo;
+/**
+ * Agent performance metrics
+ */
+export interface AgentMetrics {
+    /** Agent ID */
+    agentId: string;
+    /** Tasks completed */
+    tasksCompleted: number;
+    /** Average latency in ms */
+    averageLatency: number;
+    /** Success rate (0-1) */
+    successRate: number;
+    /** Current load */
+    currentLoad: number;
+}
+/**
+ * Task requirements
+ */
+export interface TaskRequirements {
+    /** Required capabilities */
+    requiredCapabilities: string[];
+    /** Minimum confidence */
+    minConfidence: number;
+    /** Maximum time in ms */
+    maxTimeMs: number;
+}
+/**
+ * Task context
+ */
+export interface TaskContext {
+    /** Task dependencies */
+    dependencies: string[];
+    /** Priority level */
+    priority?: number;
+    /** Deadline */
+    deadline?: Date;
+    /** Associated session ID */
+    sessionId?: string;
+    /** Parent task ID */
+    parentTaskId?: string;
+}
+/**
+ * Task definition
+ */
+export interface Task {
+    /** Unique ID */
+    id: string;
+    /** Task type */
+    type: string;
+    /** Task description */
+    description: string;
+    /** Task input */
+    input: unknown;
+    /** Task context */
+    context: TaskContext;
+    /** Task requirements */
+    requirements: TaskRequirements;
+    /** Required capabilities for this task */
+    requiredCapabilities?: string[];
+    /** Assigned agent ID */
+    assignedAgentId: string | null;
+    /** Task status */
+    status: TaskStatus;
+    /** Task result */
+    result: TaskResult | null;
+    /** Metadata */
+    metadata: {
+        createdAt: Date;
+        assignedAt?: Date;
+        startedAt?: Date;
+        completedAt?: Date;
+    };
+}
+/**
+ * Task result
+ */
+export interface TaskResult {
+    /** Task ID */
+    taskId: string;
+    /** Agent ID */
+    agentId: string;
+    /** Success flag */
+    success: boolean;
+    /** Output data */
+    output: unknown;
+    /** Confidence level */
+    confidence: number;
+    /** Processing time in ms */
+    processingTimeMs: number;
+    /** Metadata */
+    metadata: {
+        tokensUsed: number;
+        reasoningSteps: number;
+        intermediateResults: unknown[];
+        error?: string;
+    };
+}
+/**
+ * Task error
+ */
+export interface TaskError {
+    /** Error code */
+    code: string;
+    /** Error message */
+    message: string;
+    /** Error details */
+    details?: Record<string, unknown>;
+}
+/**
+ * Swarm message
+ */
+export interface SwarmMessage {
+    /** Message ID */
+    id: string;
+    /** Message type */
+    type: MessageType;
+    /** Sender ID */
+    senderId: string;
+    /** Recipient ID (null for broadcast) */
+    recipientId: string | null;
+    /** Message payload */
+    payload: unknown;
+    /** Message context */
+    context: Record<string, unknown>;
+    /** Metadata */
+    metadata: {
+        priority: number;
+        ttl: number;
+        retryCount: number;
+    };
+    /** Timestamp */
+    timestamp: Date;
+}
+/**
+ * Consensus vote
+ */
+export interface ConsensusVote {
+    /** Agent ID */
+    agentId: string;
+    /** Proposal ID */
+    proposalId: string;
+    /** Voted option */
+    vote: unknown;
+    /** Confidence in vote */
+    confidence: number;
+    /** Reasoning */
+    reasoning: string;
+    /** Timestamp */
+    timestamp: Date;
+}
+/**
+ * Consensus result
+ */
+export interface ConsensusResult {
+    /** Proposal ID */
+    proposalId: string;
+    /** Algorithm used */
+    algorithm: ConsensusAlgorithm;
+    /** Winning option */
+    winningOption: unknown;
+    /** Confidence level */
+    confidence: number;
+    /** All votes */
+    votes: ConsensusVote[];
+    /** Agreement ratio */
+    agreementRatio: number;
+    /** Dissenting opinions */
+    dissentingOpinions: {
+        agentId: string;
+        opinion: unknown;
+        reasoning: string;
+    }[];
+    /** Metadata */
+    metadata: {
+        rounds: number;
+        totalVotingTimeMs: number;
+        convergenceRate: number;
+    };
+}
+/**
+ * Conflict position
+ */
+export interface ConflictPosition {
+    /** Agent ID */
+    agentId: string;
+    /** Position */
+    position: unknown;
+    /** Confidence */
+    confidence: number;
+    /** Reasoning */
+    reasoning?: string;
+    /** Supporting evidence */
+    evidence?: string[];
+}
+/**
+ * Assignment strategies for task allocation
+ */
+export type AssignmentStrategy = 'round_robin' | 'capability_based' | 'load_balanced' | 'performance_based' | 'adaptive' | 'cost_based' | 'fastest_first';
+/**
+ * Conflict definition
+ */
+export interface Conflict {
+    /** Conflict ID */
+    id: string;
+    /** Conflict type */
+    type: string;
+    /** Description */
+    description: string;
+    /** Involved agent IDs */
+    involvedAgents: string[];
+    /** Conflicting positions */
+    conflictingPositions: ConflictPosition[];
+    /** Conflict status */
+    status: ConflictStatus;
+    /** Resolution */
+    resolution: ConflictResolution | null;
+    /** Metadata */
+    metadata: {
+        createdAt: Date;
+        resolvedAt?: Date;
+        resolutionStrategy?: ConflictResolutionStrategy;
+        resolverAgentId?: string;
+    };
+}
+/**
+ * Conflict resolution
+ */
+export interface ConflictResolution {
+    /** Resolution strategy */
+    strategy: ConflictResolutionStrategy;
+    /** Resolution result */
+    result: unknown;
+    /** Confidence in resolution */
+    confidence: number;
+    /** Reasoning */
+    reasoning?: string;
+}
+/**
+ * Base error class for sequential thinking errors
+ */
+export declare class SequentialThinkingError extends Error {
+    constructor(message: string);
+}
+/**
+ * Validation error
+ */
+export declare class ValidationError extends SequentialThinkingError {
+    constructor(message: string);
+}
+/**
+ * Not found error
+ */
+export declare class NotFoundError extends SequentialThinkingError {
+    constructor(message: string);
+}
+/**
+ * Timeout error
+ */
+export declare class TimeoutError extends SequentialThinkingError {
+    constructor(message: string);
+}
+/** UUID string type */
+export type UUID = string;
+/** Timestamp type */
+export type Timestamp = number;
+/** JSON value type */
+export type JSONValue = string | number | boolean | null | JSONObject | JSONArray;
+/** JSON object type */
+export interface JSONObject {
+    [key: string]: JSONValue;
+}
+/** JSON array type */
+export interface JSONArray extends Array<JSONValue> {
+}
+/** Nullable type */
+export type Nullable<T> = T | null;
+/** Optional type */
+export type Optional<T> = T | undefined;
+/** Deep partial type */
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+/** Deep readonly type */
+export type DeepReadonly<T> = {
+    readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
+};
+/** Result type */
+export type Result<T, E = Error> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: E;
+};
+/** Async result type */
+export type AsyncResult<T, E = Error> = Promise<Result<T, E>>;
+/** Event handler type */
+export type EventHandler<T = unknown> = (event: T) => void | Promise<void>;
+/** Predicate type */
+export type Predicate<T> = (item: T) => boolean;
+/** Comparator type */
+export type Comparator<T> = (a: T, b: T) => number;
+/** Factory type */
+export type Factory<T, Args extends unknown[] = []> = (...args: Args) => T;
+//# sourceMappingURL=index.d.ts.map