Module thinktool 

ThinkTool protocol engine - the core of ReasonKit.

This module provides the structured reasoning protocols that transform ad-hoc LLM prompting into auditable, reproducible reasoning chains.

Key Types

• ProtocolExecutor - Executes protocols with LLM integration
• ProtocolInput - Input data for protocol execution
• ProtocolOutput - Results with confidence scores

Example

use reasonkit::thinktool::{ProtocolExecutor, ProtocolInput};

let executor = ProtocolExecutor::new()?;
let result = executor.execute(
    "gigathink",
    ProtocolInput::query("Analyze market trends")
).await?;

ThinkTool Protocol Engine

Structured reasoning protocols that transform ad-hoc LLM prompting into auditable, reproducible reasoning chains.

Core Concept

A ThinkTool is a structured reasoning protocol that:

1. Defines a reasoning strategy (expansive, deductive, adversarial, etc.)
2. Structures the thought process into auditable steps
3. Produces verifiable output with confidence scores
4. Maintains provenance of the reasoning chain

Available ThinkTools (OSS)

Tool	Code	Purpose
GigaThink	gt	Expansive creative thinking (10+ perspectives)
LaserLogic	ll	Precision deductive reasoning, fallacy detection
BedRock	br	First principles decomposition
ProofGuard	pg	Multi-source verification
BrutalHonesty	bh	Adversarial self-critique

Supported LLM Providers (18+)

Tier	Providers
Major Cloud	Anthropic, OpenAI, Google Gemini, Vertex AI, Azure OpenAI, AWS Bedrock
Specialized	xAI (Grok), Groq, Mistral, DeepSeek, Cohere, Perplexity, Cerebras
Inference	Together AI, Fireworks AI, Alibaba Qwen
Aggregation	OpenRouter (300+ models), Cloudflare AI Gateway

Quick Start - LLM Clients

use reasonkit::thinktool::{UnifiedLlmClient, LlmRequest};

// Use default provider (Anthropic Claude)
let client = UnifiedLlmClient::default_anthropic()?;

// Use Groq for ultra-fast inference
let groq = UnifiedLlmClient::groq("llama-3.3-70b-versatile")?;

// Use xAI Grok
let grok = UnifiedLlmClient::grok("grok-2")?;

// Use OpenRouter for 300+ models
let openrouter = UnifiedLlmClient::openrouter("anthropic/claude-sonnet-4")?;

// Make a request
let response = client.complete(
    LlmRequest::new("Explain quantum computing")
        .with_system("You are a physics teacher")
).await?;

Provider Auto-Discovery

use reasonkit::thinktool::{discover_available_providers, create_available_client};

// Find all providers with API keys configured
let available = discover_available_providers();

// Create client using first available provider
let client = create_available_client()?;

Protocol Execution Example

use reasonkit::thinktool::{ProtocolExecutor, ProtocolInput};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let executor = ProtocolExecutor::new()?;

    let result = executor.execute(
        "gigathink",
        ProtocolInput::query("What are the key factors for startup success?")
    ).await?;

    println!("Confidence: {:.2}", result.confidence);
    for perspective in result.perspectives() {
        println!("- {}", perspective);
    }

    Ok(())
}

Re-exports

pub use benchmark::Answer;

pub use benchmark::BenchmarkProblem;

pub use benchmark::BenchmarkResults;

pub use benchmark::BenchmarkRunner;

pub use benchmark::CalibrationMetrics;

pub use benchmark::ComparisonReport;

pub use benchmark::ConfidenceBin;

pub use benchmark::EvaluationResult;

pub use budget::BudgetConfig;

pub use budget::BudgetParseError;

pub use budget::BudgetStrategy;

pub use budget::BudgetSummary;

pub use budget::BudgetTracker;

pub use calibration::platt_scale;

pub use calibration::temperature_scale;

pub use calibration::CalibrationConfig;

pub use calibration::CalibrationDiagnosis;

pub use calibration::CalibrationReport;

pub use calibration::CalibrationTracker;

pub use calibration::CategoryCalibration;

pub use calibration::ConfidenceAdjuster;

pub use calibration::ConfidenceBin as CalibrationBin;

pub use calibration::Prediction;

pub use consistency::ConsistencyResult;

pub use consistency::ReasoningPath;

pub use consistency::SelfConsistencyConfig;

pub use consistency::SelfConsistencyEngine;

pub use consistency::VotingMethod;

pub use debate::AgentRole;

pub use debate::Argument;

pub use debate::Claim as DebateClaim;

pub use debate::DebateArena;

pub use debate::DebateConfig;

pub use debate::DebatePrompts;

pub use debate::DebateResult;

pub use debate::DebateStats;

pub use debate::DebateVerdict;

pub use debate::Evidence;

pub use debate::Rebuttal as DebateRebuttal;

pub use debate::VerdictType;

pub use deep_logic::ConstraintEvaluator;

pub use deep_logic::ConstraintType;

pub use deep_logic::ConstraintValidationResult;

pub use deep_logic::ContradictionDetector;

pub use deep_logic::ContradictionInfo;

pub use deep_logic::DeepLogicValidation;

pub use deep_logic::DeepLogicValidator;

pub use deep_logic::InferenceEngine;

pub use deep_logic::InferenceRule;

pub use deep_logic::LogicalConstraint;

pub use deep_logic::LogicalFact;

pub use deep_logic::LogicalOperator;

pub use deep_logic::RuleValidationResult;

pub use deep_logic::ValidationResult;

pub use executor::CliToolConfig;

pub use executor::ExecutorConfig;

pub use executor::ProtocolExecutor;

pub use executor::ProtocolInput;

pub use executor::ProtocolOutput;

pub use fol::Connective;

pub use fol::DetectedFallacy;

pub use fol::FolArgument;

pub use fol::FolConfig;

pub use fol::FolFallacy;

pub use fol::FolPrompts;

pub use fol::FolResult;

pub use fol::Formula;

pub use fol::PremiseAssessment;

pub use fol::Quantifier;

pub use fol::SoundnessStatus;

pub use fol::Term;

pub use fol::ValidityStatus;

pub use llm::create_available_client;

pub use llm::discover_available_providers;

pub use llm::get_provider_info;

pub use llm::FinishReason;

pub use llm::LlmClient;

pub use llm::LlmConfig;

pub use llm::LlmProvider;

pub use llm::LlmRequest;

pub use llm::LlmResponse;

pub use llm::LlmUsage;

pub use llm::ProviderExtra;

pub use llm::ProviderInfo;

pub use llm::UnifiedLlmClient;

pub use llm_cli::ClusterConfig;

pub use llm_cli::ClusterResult;

pub use llm_cli::EmbeddingConfig;

pub use llm_cli::LlmCliClient;

pub use llm_cli::PromptResult;

pub use metrics::AggregateStats;

pub use metrics::ExecutionRecord;

pub use metrics::ExecutionRecordBuilder;

pub use metrics::MetricsReport;

pub use metrics::MetricsTracker;

pub use metrics::StepMetric;

pub use modules::BedRock;

pub use modules::BrutalHonesty;

pub use modules::GigaThink;

pub use modules::LaserLogic;

pub use modules::ProofGuard;

pub use modules::ThinkToolContext;

pub use modules::ThinkToolModule;

pub use modules::ThinkToolModuleConfig;

pub use modules::ThinkToolOutput;

pub use oscillation::ConvergentCriterion;

pub use oscillation::ConvergentPhase;

pub use oscillation::CriterionScore;

pub use oscillation::DivergentDimension;

pub use oscillation::DivergentPhase;

pub use oscillation::Idea;

pub use oscillation::OscillationConfig;

pub use oscillation::OscillationMetrics;

pub use oscillation::OscillationPrompts;

pub use oscillation::OscillationResult;

pub use prm::IssueType;

pub use prm::PrmConfig;

pub use prm::PrmMetrics;

pub use prm::PrmReranker;

pub use prm::PrmResult;

pub use prm::ScoreAggregation;

pub use prm::Severity;

pub use prm::StepIssue;

pub use prm::StepParser;

pub use prm::StepScore;

pub use prm::VerificationPrompts;

pub use prm::VerificationStrategy;

pub use profiles::ProfileRegistry;

pub use profiles::ReasoningProfile;

pub use protocol::Protocol;

pub use protocol::ProtocolStep;

pub use protocol::ReasoningStrategy;

pub use protocol::StepAction;

pub use quality::MetricRecord;

pub use quality::QualityDashboard;

pub use quality::QualityGrade;

pub use quality::QualityMetric;

pub use quality::QualityReport;

pub use quality::QualityScore;

pub use quality::QualityTargets;

pub use quality::TargetViolation;

pub use quality::Trend;

pub use registry::ProtocolRegistry;

pub use self_refine::DimensionFeedback;

pub use self_refine::FeedbackDimension;

pub use self_refine::IterationFeedback;

pub use self_refine::RefineConfig;

pub use self_refine::RefineIteration;

pub use self_refine::RefinePrompts;

pub use self_refine::RefineResult;

pub use self_refine::StopReason;

pub use crate::evaluation::Profile;

pub use socratic::AnswerType;

pub use socratic::Aporia;

pub use socratic::QuestionCategory;

pub use socratic::SocraticConfig;

pub use socratic::SocraticPrompts;

pub use socratic::SocraticQuestion;

pub use socratic::SocraticResult;

pub use step::OutputFormat;

pub use step::StepResult;

pub use thinktool_executor::ThinkToolExecutor;

pub use tot::parse_thoughts;

pub use tot::SearchStrategy;

pub use tot::ThoughtNode;

pub use tot::ThoughtPrompts;

pub use tot::ThoughtState;

pub use tot::ToTConfig;

pub use tot::ToTResult;

pub use tot::ToTStats;

pub use tot::TreeOfThoughts;

pub use toulmin::ArgumentBuilder;

pub use toulmin::ArgumentError;

pub use toulmin::ArgumentEvaluation;

pub use toulmin::ArgumentIssue;

pub use toulmin::Backing;

pub use toulmin::BackingType;

pub use toulmin::Claim;

pub use toulmin::ClaimType;

pub use toulmin::EvidenceType;

pub use toulmin::Ground;

pub use toulmin::IssueSeverity as ToulminIssueSeverity;

pub use toulmin::Qualifier;

pub use toulmin::Rebuttal;

pub use toulmin::RebuttalSeverity;

pub use toulmin::Scope;

pub use toulmin::ToulminArgument;

pub use toulmin::ToulminComponent;

pub use toulmin::ToulminPrompts;

pub use toulmin::Warrant;

pub use toulmin::WarrantType;

pub use trace::ExecutionStatus;

pub use trace::ExecutionTrace;

pub use trace::StepStatus;

pub use trace::StepTrace;

pub use triangulation::Source;

pub use triangulation::SourceTier;

pub use triangulation::SourceType;

pub use triangulation::Stance;

pub use triangulation::TriangulationConfig;

pub use triangulation::TriangulationIssue;

pub use triangulation::TriangulationIssueType;

pub use triangulation::TriangulationPrompts;

pub use triangulation::TriangulationResult;

pub use triangulation::Triangulator;

pub use triangulation::VerificationConfidence;

pub use triangulation::VerificationRecommendation;

pub use validation::ComplianceResult;

pub use validation::ComplianceStatus;

pub use validation::ComplianceViolation;

pub use validation::DeepSeekValidationConfig;

pub use validation::DeepSeekValidationEngine;

pub use validation::DeepSeekValidationResult;

pub use validation::DetectedBias;

pub use validation::MethodologyStatus;

pub use validation::RegulatoryStatus;

pub use validation::StatisticalResult;

pub use validation::ValidationCategory;

pub use validation::ValidationFinding;

pub use validation::ValidationPerformance;

pub use validation::ValidationVerdict;

pub use validation_executor::ValidatingProtocolExecutor;

pub use validation_executor::ValidationExecutorConfig;

pub use validation_executor::ValidationLevel;

Modules

bedrock_tot

BedRock + Tree-of-Thoughts Integration

benchmark

Benchmark Harness for ThinkTools Evaluation

budget

Budget Configuration for Adaptive Compute Time

calibration

Metacognitive Calibration System

consistency

Self-Consistency Module

debate

Multi-Agent Debate Architecture

deep_logic

Deep Logic Module - Neuro-Symbolic Reasoning Framework

deepseek_benchmark

DeepSeek Validation Engine Benchmark Framework

executor

Protocol Executor

fol

First-Order Logic Verification

llm

LLM Provider abstraction for ThinkTool Protocol Engine

llm_cli

LLM CLI Ecosystem Integration

metrics

ThinkTools Metrics Tracking System

modules

ThinkTool Module Type Definitions

oscillation

Divergent-Convergent Oscillation

prm

Process Reward Model (PRM) for Step-by-Step Verification

profiles

Reasoning Profiles - Compositions of ThinkTool protocols

protocol

Protocol definition types

quality

Quality Metrics Collection System

registry

Protocol Registry

self_refine

Self-Refine Module

socratic

Socratic Questioning Engine

step

Step execution types and result handling

thinktool_executor

toml_loader

TOML Protocol Loader

tot

Tree-of-Thoughts (ToT) Parallel Exploration

toulmin

Toulmin Argumentation Model

trace

Execution trace types for auditability

triangulation

Epistemic Triangulation Protocol

validation

DeepSeek Protocol Validation Engine

validation_executor

DeepSeek Protocol Validation Engine - Protocol Integration

yaml_loader

YAML Protocol Loader