1"""
2Core data models for reasoning trace optimization.
3"""
4 
5from dataclasses import dataclass, field
6from datetime import datetime
7from enum import Enum
8from typing import Any
9 
10 
11class PatternType(Enum):
12    """Types of patterns detected in reasoning traces."""
13 
14    CONTEXT_DEGRADATION = "context_degradation"
15    TOOL_CONFUSION = "tool_confusion"
16    INSTRUCTION_DRIFT = "instruction_drift"
17    HALLUCINATION = "hallucination"
18    INCOMPLETE_REASONING = "incomplete_reasoning"
19    TOOL_MISUSE = "tool_misuse"
20    GOAL_ABANDONMENT = "goal_abandonment"
21    CIRCULAR_REASONING = "circular_reasoning"
22    PREMATURE_CONCLUSION = "premature_conclusion"
23    MISSING_VALIDATION = "missing_validation"
24 
25 
26class Severity(Enum):
27    """Severity levels for detected patterns."""
28 
29    LOW = "low"
30    MEDIUM = "medium"
31    HIGH = "high"
32    CRITICAL = "critical"
33 
34 
35@dataclass
36class ThinkingBlock:
37    """A single thinking/reasoning block from the model."""
38 
39    content: str
40    turn_index: int
41    timestamp: datetime = field(default_factory=datetime.now)
42    token_count: int = 0
43    signature: str | None = None  # M2.1 thinking signature
44 
45    # Context at time of thinking
46    preceding_tool_call: str | None = None
47    preceding_tool_result: str | None = None
48    following_action: str | None = None  # tool_use, text, or end_turn
49 
50 
51@dataclass
52class ToolCall:
53    """A tool call made by the agent."""
54 
55    id: str
56    name: str
57    input: dict[str, Any]
58    turn_index: int
59    result: str | None = None
60    success: bool | None = None
61    error: str | None = None
62 
63 
64@dataclass
65class ReasoningTrace:
66    """Complete reasoning trace for an agent session."""
67 
68    session_id: str
69    task: str
70    system_prompt: str
71    thinking_blocks: list[ThinkingBlock] = field(default_factory=list)
72    tool_calls: list[ToolCall] = field(default_factory=list)
73    final_response: str | None = None
74 
75    # Metadata
76    model: str = "MiniMax-M2.1"
77    total_turns: int = 0
78    total_tokens: int = 0
79    success: bool | None = None
80    error: str | None = None
81    started_at: datetime = field(default_factory=datetime.now)
82    completed_at: datetime | None = None
83 
84    def get_thinking_at_turn(self, turn: int) -> ThinkingBlock | None:
85        """Get thinking block at specific turn."""
86        for block in self.thinking_blocks:
87            if block.turn_index == turn:
88                return block
89        return None
90 
91    def get_tool_calls_at_turn(self, turn: int) -> list[ToolCall]:
92        """Get all tool calls at specific turn."""
93        return [tc for tc in self.tool_calls if tc.turn_index == turn]
94 
95 
96@dataclass
97class Pattern:
98    """A detected pattern in reasoning traces."""
99 
100    type: PatternType
101    severity: Severity
102    description: str
103    evidence: list[str]  # Excerpts from thinking blocks
104    turn_indices: list[int]
105    suggestion: str
106    confidence: float  # 0.0 to 1.0
107 
108 
109@dataclass
110class AnalysisResult:
111    """Result of analyzing a reasoning trace."""
112 
113    trace_id: str
114    patterns: list[Pattern] = field(default_factory=list)
115 
116    # Scores (0-100)
117    reasoning_clarity: float = 0.0
118    goal_adherence: float = 0.0
119    tool_usage_quality: float = 0.0
120    error_recovery: float = 0.0
121    overall_score: float = 0.0
122 
123    # Feedback
124    strengths: list[str] = field(default_factory=list)
125    weaknesses: list[str] = field(default_factory=list)
126    recommendations: list[str] = field(default_factory=list)
127 
128    # Analysis metadata
129    analyzer_model: str = "MiniMax-M2.1"
130    analyzer_thinking: str = ""  # The analyzer's own reasoning
131 
132 
133@dataclass
134class PromptDiff:
135    """Difference between original and optimized prompt."""
136 
137    section: str  # e.g., "system_prompt", "tool_description", "instruction"
138    original: str
139    optimized: str
140    reason: str
141 
142 
143@dataclass
144class OptimizationResult:
145    """Result of prompt optimization."""
146 
147    original_prompt: str
148    optimized_prompt: str
149    diffs: list[PromptDiff] = field(default_factory=list)
150 
151    # Improvement predictions
152    predicted_improvement: float = 0.0  # Percentage
153    confidence: float = 0.0
154 
155    # Optimizer reasoning
156    optimizer_thinking: str = ""
157    key_changes: list[str] = field(default_factory=list)
158 
159 
160@dataclass
161class LoopIteration:
162    """Single iteration of the optimization loop."""
163 
164    iteration: int
165    trace: ReasoningTrace
166    analysis: AnalysisResult
167    optimization: OptimizationResult | None
168 
169    # Metrics
170    task_completed: bool = False
171    error_count: int = 0
172    token_usage: int = 0
173 
174 
175@dataclass
176class LoopResult:
177    """Result of running the full optimization loop."""
178 
179    task: str
180    iterations: list[LoopIteration] = field(default_factory=list)
181 
182    # Final state
183    final_prompt: str = ""
184    converged: bool = False
185    total_iterations: int = 0
186 
187    # Improvement metrics
188    initial_score: float = 0.0
189    final_score: float = 0.0
190    improvement_percentage: float = 0.0
191 
192    # Generated artifacts
193    generated_skill_path: str | None = None
194