feat: Add thinking parameters to Analysis mode and update models list in README

README.md

@@ -64,15 +64,15 @@ python_version: "3.11"
 ## 🎯 Підтримка AI провайдерів
 
 ### Для генерації:
-- **OpenAI**: GPT-5.2 (NEW! з reasoning), GPT-4.1, GPT-4o, custom fine-tuned models
-- **Anthropic**: Claude 4.5 Sonnet (з підтримкою Extended Thinking)
-- **Google**: Gemini 3.0 Flash, 3.5 Flash (з підтримкою Thinking Mode)
+- **OpenAI**: GPT-5.4, GPT-5.3 Chat Latest, GPT-5.2 (NEW! з reasoning), GPT-4o Mini Fine-Tuned (кастомні моделі)
+- **Anthropic**: Claude Opus 4.6, Claude Sonnet 4.6 (з підтримкою Extended Thinking), Claude Haiku 4.5
+- **Google**: Gemini 3 Flash, Gemini 3 Pro (з підтримкою Thinking Mode)
 - **DeepSeek**: DeepSeek Chat
 
 ### Для аналізу:
-- **OpenAI**: GPT-5.2 (NEW! з reasoning), GPT-4.1, GPT-4o
-- **Anthropic**: Claude 4.5 Sonnet
-- **Google**: Gemini 3.0 Flash, 3.5 Flash
+- **OpenAI**: GPT-5.4, GPT-5.3 Chat Latest, GPT-5.2 (NEW! з reasoning)
+- **Anthropic**: Claude Opus 4.6, Claude Sonnet 4.6 (з підтримкою Extended Thinking), Claude Haiku 4.5
+- **Google**: Gemini 3 Flash, Gemini 3 Pro (з підтримкою Thinking Mode)
 - **DeepSeek**: DeepSeek Chat
 
 ### 🆕 GPT-5.2 - Нова модель з reasoning!

interface.py

@@ -800,7 +800,7 @@ def create_gradio_interface() -> gr.Blocks:
                         label="Модель аналізу",
                         scale=1
                     )
-                with gr.Accordion("⚙️ Налаштування аналізу", open=False):
+                with gr.Accordion("⚙️ Налаштування аналізу", open=False) as analysis_thinking_accordion:
                     with gr.Row():
                         analysis_temp_slider = gr.Slider(
                             minimum=0.0,
@@ -816,6 +816,38 @@ def create_gradio_interface() -> gr.Blocks:
                             step=512,
                             label="Max Tokens (ліміт відповіді)"
                         )
+                    analysis_thinking_enabled_checkbox = gr.Checkbox(
+                        label="Увімкнути режим Thinking (глибокий аналіз)",
+                        value=False,
+                        info="Активує розширений ланцюг міркувань (Gemini 3+, Claude 4.5/4.6)"
+                    )
+                    with gr.Row():
+                        analysis_thinking_type_dropdown = gr.Dropdown(
+                            choices=["Adaptive", "Enabled"],
+                            value="Adaptive",
+                            label="Тип Thinking (Claude)",
+                            interactive=False
+                        )
+                        analysis_thinking_level_dropdown = gr.Dropdown(
+                            choices=["none", "low", "medium", "high", "xhigh"],
+                            value="medium",
+                            label="Рівень Thinking (OpenAI/Gemini)",
+                            interactive=False
+                        )
+                        analysis_openai_verbosity_dropdown = gr.Dropdown(
+                            choices=["low", "medium", "high"],
+                            value="medium",
+                            label="Verbosity (OpenAI GPT-5)",
+                            interactive=True
+                        )
+                        analysis_thinking_budget_slider = gr.Slider(
+                            minimum=1024,
+                            maximum=32000,
+                            value=10000,
+                            step=1024,
+                            label="Бюджет токенів (Claude 4.5)",
+                            interactive=False
+                        )
 
                 question_input = gr.Textbox(
                     label="Уточнююче питання для аналізу",
@@ -1099,6 +1131,19 @@ def create_gradio_interface() -> gr.Blocks:
             outputs=[batch_thinking_type_dropdown, batch_thinking_level_dropdown, batch_thinking_budget_slider]
         )
 
+        # thinking mode settings — Analysis tab
+        analysis_provider_dropdown.change(
+            fn=update_thinking_visibility,
+            inputs=[analysis_provider_dropdown],
+            outputs=[analysis_thinking_accordion]
+        )
+
+        analysis_thinking_enabled_checkbox.change(
+            fn=update_thinking_level_interactive,
+            inputs=[analysis_thinking_enabled_checkbox],
+            outputs=[analysis_thinking_type_dropdown, analysis_thinking_level_dropdown, analysis_thinking_budget_slider]
+        )
+
         # generation and analysis
         generate_position_button.click(
             fn=lambda: (
@@ -1154,6 +1199,13 @@ def create_gradio_interface() -> gr.Blocks:
         )
 
         analyze_button.click(
+            fn=lambda: (
+                gr.update(value="⏳ **Аналіз правових позицій...**\n\nЗапит відправлено до AI. Зачекайте, це може зайняти кілька хвилин."),
+                gr.update(interactive=False)
+            ),
+            inputs=None,
+            outputs=[analysis_output, analyze_button]
+        ).then(
             fn=analyze_action,
             inputs=[
                 state_lp_json,
@@ -1162,9 +1214,18 @@ def create_gradio_interface() -> gr.Blocks:
                 analysis_provider_dropdown,
                 analysis_model_dropdown,
                 analysis_temp_slider,
-                analysis_max_tokens_slider
+                analysis_max_tokens_slider,
+                analysis_thinking_enabled_checkbox,
+                analysis_thinking_type_dropdown,
+                analysis_thinking_level_dropdown,
+                analysis_openai_verbosity_dropdown,
+                analysis_thinking_budget_slider
             ],
             outputs=analysis_output
+        ).then(
+            fn=lambda: gr.update(interactive=True),
+            inputs=None,
+            outputs=[analyze_button]
         )
 
         # Settings tab event handlers

main.py

@@ -337,7 +337,8 @@ class LLMAnalyzer:
 
     def __init__(self, provider: Any, model_name: Any, temperature: float = GENERATION_TEMPERATURE,
                  max_tokens: Optional[int] = None, thinking_enabled: bool = False,
-                 thinking_level: str = "medium", openai_verbosity: str = "medium"):
+                 thinking_level: str = "medium", openai_verbosity: str = "medium",
+                 thinking_type: str = "Adaptive", thinking_budget: int = 10000):
         self.provider = provider
         self.model_name = model_name
         self.temperature = temperature
@@ -345,6 +346,8 @@ class LLMAnalyzer:
         self.thinking_enabled = thinking_enabled
         self.thinking_level = thinking_level
         self.openai_verbosity = openai_verbosity
+        self.thinking_type = thinking_type
+        self.thinking_budget = thinking_budget
 
         if provider == ModelProvider.OPENAI:
             if not OPENAI_API_KEY:
@@ -513,14 +516,46 @@ class LLMAnalyzer:
         """Analyze text using Anthropic."""
         try:
             _log_prompt("anthropic-analyzer", str(self.model_name), SYSTEM_PROMPT, prompt)
-            response = self.client.messages.create(
-                model=self.model_name,
-                max_tokens=self.max_tokens or MAX_TOKENS_ANALYSIS,
-                temperature=self.temperature,
-                system=[{"type": "text", "text": SYSTEM_PROMPT, "cache_control": {"type": "ephemeral"}}],
-                messages=[{"role": "user", "content": prompt}]
-            )
-            response_text = response.content[0].text
+            
+            message_params = {
+                "model": self.model_name,
+                "max_tokens": self.max_tokens or MAX_TOKENS_ANALYSIS,
+                "temperature": self.temperature,
+                "system": [{"type": "text", "text": SYSTEM_PROMPT, "cache_control": {"type": "ephemeral"}}],
+                "messages": [{"role": "user", "content": prompt}]
+            }
+
+            if self.thinking_enabled and "claude" in str(self.model_name).lower():
+                if self.thinking_type.lower() == "adaptive" and "-4-6" in str(self.model_name).lower():
+                    message_params["thinking"] = {"type": "adaptive"}
+                    message_params["temperature"] = 1.0
+                    
+                    t_lv = self.thinking_level.lower()
+                    if t_lv == "xhigh":
+                        effort = "max"
+                    elif t_lv in ["low", "medium", "high"]:
+                        effort = t_lv
+                    else:
+                        effort = "medium"
+                    message_params["output_config"] = {"effort": effort}
+                else:
+                    budget = max(1024, int(self.thinking_budget))
+                    if message_params["max_tokens"] <= budget:
+                        message_params["max_tokens"] = budget + 4000
+                    message_params["thinking"] = {
+                        "type": "enabled",
+                        "budget_tokens": budget
+                    }
+                    message_params["temperature"] = 1.0
+
+            response = self.client.messages.create(**message_params)
+            
+            response_text = ""
+            for block in response.content:
+                if hasattr(block, 'type') and block.type == 'text':
+                    response_text += getattr(block, 'text', '')
+                elif hasattr(block, 'text'):
+                    response_text += block.text
             
             # Extract JSON from potential markdown blocks
             json_data = extract_json_from_text(response_text)
@@ -562,13 +597,20 @@ class LLMAnalyzer:
                 ),
             ]
             
-            generate_content_config = types.GenerateContentConfig(
-                temperature=self.temperature,
-                max_output_tokens=self.max_tokens or MAX_TOKENS_ANALYSIS,
-                system_instruction=[
+            config_params = {
+                "temperature": self.temperature,
+                "max_output_tokens": self.max_tokens or MAX_TOKENS_ANALYSIS,
+                "system_instruction": [
                     types.Part.from_text(text=SYSTEM_PROMPT),
                 ],
-            )
+            }
+
+            if self.thinking_enabled and str(self.model_name).startswith("gemini-3"):
+                config_params["thinking_config"] = types.ThinkingConfig(
+                    thinking_level=self.thinking_level.upper()
+                )
+
+            generate_content_config = types.GenerateContentConfig(**config_params)
 
             response = self.client.models.generate_content(
                 model=self.model_name,
@@ -624,13 +666,16 @@ class PrecedentAnalysisWorkflow(Workflow):
                  max_tokens: Optional[int] = None,
                  thinking_enabled: bool = False,
                  thinking_level: str = "medium",
-                 openai_verbosity: str = "medium"):
+                 openai_verbosity: str = "medium",
+                 thinking_type: str = "Adaptive",
+                 thinking_budget: int = 10000):
         super().__init__()
         # Use default analysis model if not specified
         if model_name is None:
             model_name = DEFAULT_ANALYSIS_MODEL or AnalysisModelName.GPT5_2
         self.analyzer = LLMAnalyzer(provider, model_name, temperature, max_tokens,
-                                    thinking_enabled, thinking_level, openai_verbosity)
+                                    thinking_enabled, thinking_level, openai_verbosity,
+                                    thinking_type, thinking_budget)
 
     @step
     async def analyze(self, ctx: Context, ev: StartEvent) -> StopEvent:
@@ -1345,8 +1390,10 @@ async def analyze_action(
         temperature: float = GENERATION_TEMPERATURE,
         max_tokens: Optional[int] = None,
         thinking_enabled: bool = False,
+        thinking_type: str = "Adaptive",
         thinking_level: str = "medium",
-        openai_verbosity: str = "medium"
+        openai_verbosity: str = "medium",
+        thinking_budget: int = 10000
 ) -> str:
     """Analyze search results using AI."""
     try:
@@ -1356,8 +1403,10 @@ async def analyze_action(
             temperature=temperature,
             max_tokens=max_tokens,
             thinking_enabled=thinking_enabled,
+            thinking_type=thinking_type,
             thinking_level=thinking_level,
-            openai_verbosity=openai_verbosity
+            openai_verbosity=openai_verbosity,
+            thinking_budget=thinking_budget
         )
 
         query = (