client_claude.py

# client_claude.py - pracovna verzie pre uz skratene odpovede z tools + rozhodovanie o pouziti tools

from __future__ import annotations

from langchain_openai import ChatOpenAI
from langchain_core.messages import SystemMessage, HumanMessage

import asyncio
import os
import traceback
import tiktoken
import json
import time
from typing import Union, Optional, List, Dict, Any, Type
from dotenv import load_dotenv
from langchain_anthropic import ChatAnthropic
from langchain.callbacks.base import BaseCallbackHandler
from langchain.schema import LLMResult
from mcp_use import MCPAgent, MCPClient

# Načítanie environment variables
load_dotenv()



class McpFunctionRouter:
    """OpenAI Function Calling Router for decision-making"""

    def __init__(self, openai_api_key: str):
        self.decision_llm = ChatOpenAI(
            model="gpt-4o-mini",
            temperature=0,
            api_key=openai_api_key
        )
        self.last_mcp_intent = None  # Track the last intent

    async def should_use_mcp(self, message: str) -> bool:
        """Decides using simple OpenAI completion whether to use MCP, with context awareness"""
        try:
            # Get configurable keywords from environment variables
            ecommerce_keywords = os.getenv("ECOMMERCE_KEYWORDS", "product,discount,category,search,create,update,delete,set,order,top,price,available,sale,ship,shipping,delivery,europe,country,international").split(',')
            general_keywords = os.getenv("GENERAL_KEYWORDS", "how,what is,explain,why,hello,math,weather,time").split(',')
            
            decision_prompt = f"""You are a routing assistant for e-commerce MCP tools. Analyze the user's message and decide if e-commerce tools are needed.

Respond with exactly "YES" if the user wants to:
- Search for products, prices, availability, sizes, colors, discounts
- Questions like "Do you have...?", "What products...?", "Show me..."
- E-commerce related queries about the store
- Follow-up responses like "yes", "no", "more details", "tell me more" when previous context exists
- Key words: {', '.join(ecommerce_keywords)}

Respond with exactly "NO" for:
- General questions, greetings, mathematical operations
- Theoretical discussions or explanations
- Questions not related to shopping or products (when no shopping context exists)
- Key words: {', '.join(general_keywords)}

IMPORTANT: If the previous context was shopping-related ('{self.last_mcp_intent}'), then short responses like "yes", "no", "more", "details" should be treated as follow-ups to that shopping conversation.

User message: "{message}"

Response (YES or NO):"""

            response = await self.decision_llm.ainvoke([
                SystemMessage(content=decision_prompt),
                HumanMessage(content=message)
            ])

            # Extract the decision from the response
            decision_text = response.content.strip().upper()
            used_mcp = decision_text.startswith("YES")

            # Update last intent if MCP tools are used
            if used_mcp:
                self.last_mcp_intent = message if not self.last_mcp_intent else f"{self.last_mcp_intent}, {message}"
            elif self.last_mcp_intent and any(
                    keyword in message.lower() for keyword in ['under', 'price', 'euro', 'cost', 'top', 'yes', 'no', 'more', 'details', 'tell me', 'show me']):
                # Treat follow-up responses as MCP if context exists
                used_mcp = True
                print(f"🔄 Context-aware decision: '{message}' treated as follow-up to '{self.last_mcp_intent}'")

            # Fallback keyword check (English only)
            if not used_mcp:
                message_lower = message.lower()
                
                if any(keyword.strip() in message_lower for keyword in ecommerce_keywords):
                    used_mcp = True
                elif any(keyword.strip() in message_lower for keyword in general_keywords):
                    used_mcp = False

            print(f"🧠 Decision: Use MCP tools = {used_mcp}")
            return used_mcp

        except Exception as e:
            print(f"⚠️ Decision error: {e}")
            traceback.print_exc()
            # Fallback decision with configurable keywords
            message_lower = message.lower()
            ecommerce_keywords = os.getenv("ECOMMERCE_KEYWORDS", "product,discount,category,search,create,update,delete,set,order,top,price,available,sale,ship,shipping,delivery,europe,country,international").split(',')
            used_mcp = any(keyword.strip() in message_lower for keyword in ecommerce_keywords)
            print(f"🧠 Fallback decision: Use MCP tools = {used_mcp}")
            return used_mcp


class TokenLimitManager:
    """Správca limitov tokenov"""

    def __init__(self):
        # Načítanie limitov z .env
        self.max_input_tokens_per_call = int(os.getenv("MAX_INPUT_TOKENS_PER_CALL", "12000"))
        self.max_output_tokens_per_call = int(os.getenv("MAX_OUTPUT_TOKENS_PER_CALL", "4000"))
        self.max_total_input_tokens_per_interaction = int(os.getenv("MAX_TOTAL_INPUT_TOKENS_PER_INTERACTION", "40000"))
        self.max_total_output_tokens_per_interaction = int(
            os.getenv("MAX_TOTAL_OUTPUT_TOKENS_PER_INTERACTION", "15000"))
        self.max_llm_calls_per_interaction = int(os.getenv("MAX_LLM_CALLS_PER_INTERACTION", "12"))

        # === NOVÉ: Smart truncation nastavenia ===
        self.tool_response_truncation_threshold = int(os.getenv("TOOL_RESPONSE_TRUNCATION_THRESHOLD", "8000"))
        self.max_products_in_truncated_response = int(os.getenv("MAX_PRODUCTS_IN_TRUNCATED_RESPONSE", "10"))
        self.max_lines_in_truncated_text = int(os.getenv("MAX_LINES_IN_TRUNCATED_TEXT", "50"))
        self.chars_per_token_ratio = float(os.getenv("CHARS_PER_TOKEN_RATIO", "3.5"))

        # Preemptívny cleanup nastavenia
        self.preemptive_cleanup_threshold = int(os.getenv("PREEMPTIVE_CLEANUP_THRESHOLD", "5000"))
        self.nuclear_cleanup_threshold = int(os.getenv("NUCLEAR_CLEANUP_THRESHOLD", "8000"))

        # Memory management nastavenia - agresívnejšie
        self.max_conversation_messages = int(os.getenv("MAX_CONVERSATION_MESSAGES", "4"))
        self.memory_cleanup_threshold = float(os.getenv("MEMORY_CLEANUP_THRESHOLD", "0.5"))  # 50% limitu
        self.aggressive_cleanup_threshold = float(
            os.getenv("AGGRESSIVE_CLEANUP_THRESHOLD", "0.8"))  # 80% pre extra cleanup

        # Počítadlá pre aktuálnu interakciu
        self.current_interaction_input_tokens = 0
        self.current_interaction_output_tokens = 0
        self.current_interaction_llm_calls = 0

        self.encoding = tiktoken.get_encoding("cl100k_base")

        print(f"📋 Token Limits nastavené:")
        print(f"   • Max input tokens/call: {self.max_input_tokens_per_call:,}")
        print(f"   • Max output tokens/call: {self.max_output_tokens_per_call:,}")
        print(f"   • Max total input/interaction: {self.max_total_input_tokens_per_interaction:,}")
        print(f"   • Max total output/interaction: {self.max_total_output_tokens_per_interaction:,}")
        print(f"   • Max LLM calls/interaction: {self.max_llm_calls_per_interaction}")
        print(f"   • Max conversation messages: {self.max_conversation_messages}")
        print(f"   • Memory cleanup threshold: {self.memory_cleanup_threshold * 100:.0f}%")
        print(f"   • Aggressive cleanup threshold: {self.aggressive_cleanup_threshold * 100:.0f}%")
        print(f"   • Preemptive cleanup threshold: {self.preemptive_cleanup_threshold:,} tokenov")
        print(f"   • Nuclear cleanup threshold: {self.nuclear_cleanup_threshold:,} tokenov")

        # === NOVÉ: Vypíš truncation nastavenia ===
        print(f"\n🔧 Smart Tool Response Truncation:")
        print(f"   • Truncation threshold: {self.tool_response_truncation_threshold:,} tokenov")
        print(f"   • Max products po skrátení: {self.max_products_in_truncated_response}")
        print(f"   • Max riadkov po skrátení: {self.max_lines_in_truncated_text}")
        print(f"   • Chars/token ratio: {self.chars_per_token_ratio}")

    def get_dynamic_truncation_threshold(self, current_input_tokens: int) -> int:
        """Dynamicky upraví threshold na základe aktuálneho využitia"""
        usage_percent = current_input_tokens / self.max_total_input_tokens_per_interaction

        if usage_percent > 0.8:  # Ak nad 80%, buď agresívnejší
            dynamic_threshold = int(self.tool_response_truncation_threshold * 0.6)  # 60% z normálu
            print(f"🔥 AGRESÍVNY truncation threshold: {dynamic_threshold:,} (usage: {usage_percent:.1%})")
            return dynamic_threshold
        elif usage_percent > 0.6:  # Ak nad 60%, mierne agresívnejší
            dynamic_threshold = int(self.tool_response_truncation_threshold * 0.8)  # 80% z normálu
            print(f"⚡ ZVÝŠENÝ truncation threshold: {dynamic_threshold:,} (usage: {usage_percent:.1%})")
            return dynamic_threshold
        else:
            print(
                f"✅ NORMÁLNY truncation threshold: {self.tool_response_truncation_threshold:,} (usage: {usage_percent:.1%})")
            return self.tool_response_truncation_threshold

    def smart_truncate_tool_response(self, tool_output: str, current_input_tokens: int = 0) -> str:
        """Inteligentne skráti tool response na najdôležitejšie časti - s dynamickým threshold"""

        # 🆕 NOVÉ: Použiť dynamický threshold
        if current_input_tokens > 0:
            dynamic_threshold = self.get_dynamic_truncation_threshold(current_input_tokens)
        else:
            dynamic_threshold = self.tool_response_truncation_threshold

        current_tokens = len(self.encoding.encode(tool_output))

        if current_tokens <= dynamic_threshold:  # ← Zmena z self.tool_response_truncation_threshold
            return tool_output

        print(f"🔧 Tool response príliš veľký ({current_tokens:,} tokenov), spúšťam smart truncation...")
        print(f"   • Dynamic threshold: {dynamic_threshold:,} tokenov")  # ← Zmena

        try:
            # === POKUS 1: JSON TRUNCATION ===
            data = json.loads(tool_output)

            if 'products' in data and isinstance(data['products'], list):
                products = data['products']
                original_count = len(products)

                print(
                    f"🔍 JSON DEBUG: original_count={original_count}, max_allowed={self.max_products_in_truncated_response}")

                if original_count > self.max_products_in_truncated_response or current_tokens > dynamic_threshold:
                    # Skráť na TOP výsledky
                    data['products'] = products[:self.max_products_in_truncated_response]
                    data['truncated'] = True
                    data['original_count'] = original_count
                    data[
                        'truncated_message'] = f"Zobrazených TOP {self.max_products_in_truncated_response} z {original_count} produktov"

                    truncated_output = json.dumps(data, ensure_ascii=False, separators=(',', ':'))
                    new_tokens = len(self.encoding.encode(truncated_output))

                    print(f"✅ JSON skrátené: {original_count} → {self.max_products_in_truncated_response} produktov")
                    print(f"✅ Tokeny znížené: {current_tokens:,} → {new_tokens:,}")

                    return truncated_output

            # Ak má iné JSON polia ako 'products'
            elif 'results' in data and isinstance(data['results'], list):
                results = data['results']
                original_count = len(results)

                if original_count > self.max_products_in_truncated_response:
                    data['results'] = results[:self.max_products_in_truncated_response]
                    data['truncated'] = True
                    data['original_count'] = original_count
                    data[
                        'truncated_message'] = f"Zobrazených TOP {self.max_products_in_truncated_response} z {original_count} výsledkov"

                    truncated_output = json.dumps(data, ensure_ascii=False, separators=(',', ':'))
                    new_tokens = len(self.encoding.encode(truncated_output))

                    print(f"✅ JSON results skrátené: {original_count} → {self.max_products_in_truncated_response}")
                    print(f"✅ Tokeny znížené: {current_tokens:,} → {new_tokens:,}")

                    return truncated_output

        except json.JSONDecodeError:
            pass  # Pokračuj s textovým truncation

        # === POKUS 2: TEXT TRUNCATION ===
        lines = tool_output.split('\n')
        if len(lines) > self.max_lines_in_truncated_text:
            truncated_lines = lines[:self.max_lines_in_truncated_text]
            truncated_lines.append(f"\n... (skrátené z {len(lines)} na {self.max_lines_in_truncated_text} riadkov)")
            truncated_output = '\n'.join(truncated_lines)

            new_tokens = len(self.encoding.encode(truncated_output))
            print(f"✅ Text skrátený: {len(lines)} → {self.max_lines_in_truncated_text} riadkov")
            print(f"✅ Tokeny znížené: {current_tokens:,} → {new_tokens:,}")

            return truncated_output

        # === POKUS 3: HARD TRUNCATION ===
        target_chars = int(dynamic_threshold * 0.7 * self.chars_per_token_ratio)
        truncated = tool_output[:target_chars]
        truncated += f"\n\n... (hard truncation: skrátené z {current_tokens:,} tokenov na ~{dynamic_threshold * 0.7:,})"

        new_tokens = len(self.encoding.encode(truncated))
        print(f"✅ Hard truncation: {current_tokens:,} → {new_tokens:,} tokenov")

        return truncated

    def reset_interaction(self):
        """Reset počítadiel pre novú interakciu"""
        self.current_interaction_input_tokens = 0
        self.current_interaction_output_tokens = 0
        self.current_interaction_llm_calls = 0

    def can_make_llm_call(self, estimated_input_tokens: int = 0) -> tuple[bool, str]:
        """Kontroluje či môžeme robiť ďalší LLM call"""

        # Kontrola počtu LLM calls
        if self.current_interaction_llm_calls >= self.max_llm_calls_per_interaction:
            return False, f"Dosiahnutý limit LLM calls ({self.max_llm_calls_per_interaction})"

        # Kontrola input tokenov pre call
        if estimated_input_tokens > self.max_input_tokens_per_call:
            return False, f"Input pre call príliš veľký ({estimated_input_tokens:,} > {self.max_input_tokens_per_call:,})"

        # Kontrola celkových input tokenov pre interakciu
        if (
                self.current_interaction_input_tokens + estimated_input_tokens) > self.max_total_input_tokens_per_interaction:
            return False, f"Celkové input tokeny príliš veľké ({self.current_interaction_input_tokens + estimated_input_tokens:,} > {self.max_total_input_tokens_per_interaction:,})"

        return True, "OK"

    def should_cleanup_memory(self, estimated_input_tokens: int = 0) -> tuple[bool, str]:
        """Kontroluje či treba vyčistiť memory - citlivejšie nastavenia"""
        # Základný threshold pre štandardný cleanup
        threshold_tokens = int(self.max_input_tokens_per_call * self.memory_cleanup_threshold)

        # Agresívny threshold pre extra cleanup
        aggressive_threshold = int(self.max_input_tokens_per_call * self.aggressive_cleanup_threshold)

        if estimated_input_tokens > aggressive_threshold:
            return True, "aggressive"
        elif estimated_input_tokens > threshold_tokens:
            return True, "standard"

        return False, "none"

    def cleanup_agent_memory(self, agent, cleanup_type: str = "standard") -> int:
        """Vyčistí memory agenta - agresívnejšie podľa typu"""
        if not hasattr(agent, 'memory') or not hasattr(agent.memory, 'chat_memory'):
            return 0

        messages = agent.memory.chat_memory.messages
        original_count = len(messages)

        if original_count <= 1:
            return 0

        # Spočítaj tokeny pred cleanup
        tokens_before = sum(len(self.encoding.encode(str(msg.content))) for msg in messages)

        if cleanup_type == "aggressive":
            # Extra agresívny cleanup - nechaj len poslednú správu
            agent.memory.chat_memory.messages = messages[-1:]
            print(f"🧹🧹 AGGRESSIVE cleanup: nechané len 1 správa")
        elif cleanup_type == "standard":
            # Štandardný cleanup - nechaj 2-3 posledné správy
            keep_count = min(2, original_count)
            agent.memory.chat_memory.messages = messages[-keep_count:]
            print(f"🧹 Standard cleanup: nechané {len(agent.memory.chat_memory.messages)} správy")

        # Spočítaj tokeny po cleanup
        tokens_after = sum(len(self.encoding.encode(str(msg.content))) for msg in agent.memory.chat_memory.messages)

        # Ak stále príliš veľa tokenov, extra agresívny cleanup
        if tokens_after > self.nuclear_cleanup_threshold:  # ← Zmena z 8000 na .env premennú
            agent.memory.chat_memory.messages = []
            tokens_after = 0
            print(
                f"🧹🧹🧹 FORCE NUCLEAR: vymazané všetko kvôli {tokens_after:,} tokenov (threshold: {self.nuclear_cleanup_threshold:,})")

        removed_messages = original_count - len(agent.memory.chat_memory.messages)
        removed_tokens = tokens_before - tokens_after

        if removed_messages > 0:
            print(
                f"🧹 Memory cleanup ({cleanup_type}): odstránených {removed_messages} správ, ušetrených {removed_tokens:,} tokenov")

        return removed_tokens

    def can_accept_output(self, output_tokens: int) -> tuple[bool, str]:
        """Kontroluje či môžeme prijať output"""

        # Kontrola output tokenov pre call
        if output_tokens > self.max_output_tokens_per_call:
            return False, f"Output pre call príliš veľký ({output_tokens:,} > {self.max_output_tokens_per_call:,})"

        # Kontrola celkových output tokenov pre interakciu
        if (self.current_interaction_output_tokens + output_tokens) > self.max_total_output_tokens_per_interaction:
            return False, f"Celkové output tokeny príliš veľké ({self.current_interaction_output_tokens + output_tokens:,} > {self.max_total_output_tokens_per_interaction:,})"

        return True, "OK"

    def add_llm_call(self, input_tokens: int, output_tokens: int):
        """Pridá LLM call do počítadiel"""
        self.current_interaction_input_tokens += input_tokens
        self.current_interaction_output_tokens += output_tokens
        self.current_interaction_llm_calls += 1


class AgentTokenCounterCallback(BaseCallbackHandler):
    """Callback handler pre počítanie tokenov v agentoch"""

    def __init__(self, token_counter, token_limit_manager):
        self.token_counter = token_counter
        self.token_limit_manager = token_limit_manager
        self.encoding = tiktoken.get_encoding("cl100k_base")
        self.current_step_tokens = {'input': 0, 'output': 0}
        self.should_stop = False
        self.agent_ref = None
        self.cleanup_attempts = 0

    def set_agent_reference(self, agent):
        """Nastaví referenciu na agent pre memory management"""
        self.agent_ref = agent

    def on_llm_start(self, serialized: Dict[str, Any], prompts: List[str], **kwargs) -> None:
        """Zachytí začiatok LLM volania s token counting PRED cleanup"""
        if prompts:
            # === POČÍTANIE TOKENOV PRED CLEANUP ===
            input_text = ' '.join(prompts)
            original_input_tokens = len(self.encoding.encode(input_text))

            print(f"🔍 LLM START: Original input {original_input_tokens:,} tokenov")

            # === OKAMŽITÝ CLEANUP PRED KAŽDÝM LLM CALL ===
            cleanup_performed = False
            if self.agent_ref and hasattr(self.agent_ref, 'memory') and hasattr(self.agent_ref.memory, 'chat_memory'):
                messages = self.agent_ref.memory.chat_memory.messages
                if len(messages) > 0:
                    memory_tokens = sum(len(self.encoding.encode(str(msg.content))) for msg in messages)
                    print(f"🧠 Memory check: {len(messages)} správ, {memory_tokens:,} tokenov")

                    # AGRESÍVNY cleanup - vymaž všetko ak viac ako nuclear threshold
                    if memory_tokens > self.token_limit_manager.nuclear_cleanup_threshold:
                        self.agent_ref.memory.chat_memory.messages = []
                        print(f"🧹🧹🧹 OKAMŽITÝ nuclear cleanup: {memory_tokens:,} tokenov vymazaných!")
                        cleanup_performed = True

                    # Menej agresívny cleanup ak viac ako 2 správy
                    elif len(messages) > 1:
                        self.agent_ref.memory.chat_memory.messages = messages[-1:]
                        print(f"🧹 Standard cleanup: nechané len 1 správa")
                        cleanup_performed = True

            # === PREPOČÍTANIE TOKENOV PO CLEANUP ===
            if cleanup_performed:
                # Prepočítaj input tokeny po cleanup
                new_input_text = ' '.join(prompts)
                final_input_tokens = len(self.encoding.encode(new_input_text))
                print(f"✅ Po cleanup: input znížený na {final_input_tokens:,} tokenov")
            else:
                final_input_tokens = original_input_tokens

            # === ULOŽENIE DO TOKEN COUNTER (POUŽÍVA ORIGINÁLNE TOKENY) ===
            self.current_step_tokens['input'] = original_input_tokens  # ← KĽÚČOVÉ!

            # === PÔVODNÁ LOGIKA PRE LLM LIMITS (POUŽÍVA FINÁLNE TOKENY) ===
            # Kontrola či potrebujeme memory cleanup (backup)
            needs_cleanup, cleanup_type = self.token_limit_manager.should_cleanup_memory(final_input_tokens)

            if needs_cleanup and self.agent_ref:
                print(
                    f"🧹 BACKUP cleanup: Input príliš veľký ({final_input_tokens:,} tokenov), spúšťam {cleanup_type} cleanup...")
                removed_tokens = self.token_limit_manager.cleanup_agent_memory(self.agent_ref, cleanup_type)
                self.cleanup_attempts += 1

                if removed_tokens > 0:
                    estimated_new_tokens = max(final_input_tokens - (removed_tokens // 2),
                                               self.token_limit_manager.nuclear_cleanup_threshold)
                    print(f"✅ Po backup cleanup: odhadovaných {estimated_new_tokens:,} tokenov")
                    final_input_tokens = estimated_new_tokens

            # Kontrola limitov po cleanup
            can_proceed, reason = self.token_limit_manager.can_make_llm_call(final_input_tokens)
            if not can_proceed:
                print(f"\n⚠️  LLM call zastavený: {reason}")

                # Posledný pokus - nuclear cleanup
                if self.cleanup_attempts < 2 and self.agent_ref:
                    print("🧹🧹🧹 Posledný pokus - nuclear cleanup...")
                    self.token_limit_manager.cleanup_agent_memory(self.agent_ref, "aggressive")
                    estimated_minimal = self.token_limit_manager.nuclear_cleanup_threshold
                    can_proceed_final, _ = self.token_limit_manager.can_make_llm_call(estimated_minimal)
                    if can_proceed_final:
                        print(f"✅ Po nuclear cleanup: pokračujem s {estimated_minimal:,} tokenmi")
                        final_input_tokens = estimated_minimal
                    else:
                        self.should_stop = True
                        return
                else:
                    self.should_stop = True
                    return

    def on_llm_end(self, response: LLMResult, **kwargs) -> None:
        """Zachytí ukončenie LLM volania - OPRAVENÉ získavanie real token data"""

        if self.should_stop:
            self.should_stop = False
            self.cleanup_attempts = 0
            return

        # === AGRESÍVNE HĽADANIE REAL TOKEN DATA ===
        real_input = 0
        real_output = 0
        found_real_data = False

        print(f"🔍 HĽADÁM real token data vo všetkých možných miestach:")

        # === NOVÉ: Hľadaj v message objektoch ===
        if response.generations:
            for i, gen_list in enumerate(response.generations):
                for j, gen in enumerate(gen_list):
                    if hasattr(gen, 'message'):
                        message = gen.message

                        # 1. usage_metadata (OPRAVENÉ - je to dict!)
                        if hasattr(message, 'usage_metadata') and message.usage_metadata:
                            usage = message.usage_metadata
                            if 'input_tokens' in usage:  # ← OPRAVENÉ!
                                real_input = usage['input_tokens']
                                real_output = usage['output_tokens']
                                print(f"   ✅ Nájdené v message.usage_metadata: {real_input:,} + {real_output:,}")
                                found_real_data = True
                                break

                        # 2. response_metadata
                        if not found_real_data and hasattr(message, 'response_metadata') and message.response_metadata:
                            metadata = message.response_metadata
                            if 'usage' in metadata:
                                usage = metadata['usage']
                                real_input = usage.get('input_tokens', 0)
                                real_output = usage.get('output_tokens', 0)
                                if real_input > 0 or real_output > 0:
                                    print(
                                        f"   ✅ Nájdené v message.response_metadata.usage: {real_input:,} + {real_output:,}")
                                    found_real_data = True
                                    break

                    if found_real_data:
                        break
                if found_real_data:
                    break

        # === AK MÁME REAL DATA, POUŽIJEME ICH ===
        if found_real_data and (real_input > 0 or real_output > 0):
            print(f"🎯 POUŽÍVAM REAL API tokens: {real_input:,} input + {real_output:,} output")

            self.current_step_tokens['input'] = real_input
            self.current_step_tokens['output'] = real_output

            # Pridaj do limitov a counters
            self.token_limit_manager.add_llm_call(real_input, real_output)
            if hasattr(self.token_counter, 'add_llm_call'):
                self.token_counter.add_llm_call(real_input, real_output)

            # Reset cleanup attempts
            self.cleanup_attempts = 0
            return  # ← KĽÚČOVÉ: Skonči tu ak máš real data!

        # === BACKUP: TIKTOKEN ESTIMATE ===
        print("⚠️  Real token data nenájdené, používam tiktoken estimate")

        if response.generations:
            # Počítanie output tokenov
            output_text = ''
            for generation in response.generations:
                for gen in generation:
                    if hasattr(gen, 'text'):
                        output_text += gen.text

            output_tokens = len(self.encoding.encode(output_text))

            # Kontrola output limitov
            can_accept, reason = self.token_limit_manager.can_accept_output(output_tokens)
            if not can_accept:
                print(f"\n⚠️  Output obmedzený: {reason}")
                return

            self.current_step_tokens['output'] = output_tokens

            # Pridanie do limitov a token counter (používaj pôvodný input z on_llm_start)
            self.token_limit_manager.add_llm_call(
                self.current_step_tokens['input'],
                output_tokens
            )

            if hasattr(self.token_counter, 'add_llm_call'):
                self.token_counter.add_llm_call(
                    self.current_step_tokens['input'],
                    output_tokens
                )

        # Reset cleanup attempts po úspešnom LLM call
        self.cleanup_attempts = 0

    def on_tool_start(self, serialized: Dict[str, Any], input_str: str, **kwargs) -> None:
        """Zachytí začiatok tool volania"""
        tool_name = serialized.get('name', 'unknown_tool')
        if hasattr(self.token_counter, 'add_tool_start'):
            self.token_counter.add_tool_start(tool_name, input_str)

    def on_tool_end(self, output: str, **kwargs) -> None:
        """Zachytí ukončenie tool volania - BEZ duplicitného truncation"""

        # Tool interception sa už robí v SmartMCPAgent._setup_langchain_tool_interception()
        # Takže tu už nemusíme robiť truncation, len počítanie tokenov

        if hasattr(self.token_counter, 'add_tool_end'):
            self.token_counter.add_tool_end(output)

        # Spočítaj veľkosť tool output (už po truncation)
        tool_output_tokens = len(self.encoding.encode(output))

        # === ZAPOČÍTANIE TOOL TOKENOV DO CLAUDE CONTEXT ===
        # Tool responses sa SKUTOČNE rátajú do Claude input tokenov
        claude_context_tokens = int(tool_output_tokens * 1.2)  # 20% overhead
        self.token_limit_manager.current_interaction_input_tokens += claude_context_tokens

        print(f"🔧 Tool response: {tool_output_tokens:,} tokenov")
        print(f"   • Pridané do Claude context: {claude_context_tokens:,} tokenov")
        print(f"   • Celkové input tokeny: {self.token_limit_manager.current_interaction_input_tokens:,}")
        print(f"   • Preemptive threshold: {self.token_limit_manager.preemptive_cleanup_threshold:,}")
        print(f"   • Nuclear threshold: {self.token_limit_manager.nuclear_cleanup_threshold:,}")
        print(f"   • Agent ref exists: {self.agent_ref is not None}")

        # === PREEMPTÍVNY CLEANUP PRE VEĽKÉ TOOL RESPONSES ===
        # Používaj finálne tokeny (po truncation) pre cleanup rozhodnutia
        if tool_output_tokens > self.token_limit_manager.preemptive_cleanup_threshold and self.agent_ref:
            print(f"🧹⚡ Preemptívny cleanup: tool response {tool_output_tokens:,} tokenov")
            removed = self.token_limit_manager.cleanup_agent_memory(self.agent_ref, "standard")
            if removed > 0:
                print(f"✅ Memory vyčistená pred ďalším krokom")

        # === NUCLEAR CLEANUP PRE EXTRA VEĽKÉ TOOL RESPONSES ===
        # Aj po truncation môže byť response stále veľký
        if tool_output_tokens > self.token_limit_manager.nuclear_cleanup_threshold and self.agent_ref:
            print(f"🧹🧹🧹 NUCLEAR cleanup: tool response {tool_output_tokens:,} tokenov!")
            self.token_limit_manager.cleanup_agent_memory(self.agent_ref, "aggressive")
            # Úplne vymaž memory
            if hasattr(self.agent_ref, 'memory') and hasattr(self.agent_ref.memory, 'chat_memory'):
                self.agent_ref.memory.chat_memory.messages = []
                print("✅ Úplné vymazanie conversation history")

        # === EXTRA OCHRANA: Kontrola celkových limitov ===
        input_usage_percent = (self.token_limit_manager.current_interaction_input_tokens /
                               self.token_limit_manager.max_total_input_tokens_per_interaction) * 100

        if input_usage_percent > 90:  # Ak je využitie nad 90%
            print(f"⚠️  VAROVANIE: Input tokeny na {input_usage_percent:.1f}% limitu!")
            print(f"   • Aktuálne: {self.token_limit_manager.current_interaction_input_tokens:,}")
            print(f"   • Limit: {self.token_limit_manager.max_total_input_tokens_per_interaction:,}")

            # Extra agresívny cleanup ak blízko limitu
            if self.agent_ref and hasattr(self.agent_ref, 'memory') and hasattr(self.agent_ref.memory, 'chat_memory'):
                self.agent_ref.memory.chat_memory.messages = []
                print("🧹🧹🧹 EMERGENCY cleanup: vymazaná celá conversation history!")


class AdvancedTokenCounter:
    def __init__(self, token_limit_manager):
        # Claude používa cl100k_base encoding (rovnaký ako GPT-4)
        self.encoding = tiktoken.get_encoding("cl100k_base")
        self.token_limit_manager = token_limit_manager
        self.reset_session()

    def reset_session(self):
        """Reset počítadla pre celú session"""
        self.session_input_tokens = 0
        self.session_output_tokens = 0
        self.conversation_history = []
        self.current_interaction = {}
        self.current_tool_call = {}

    def count_tokens(self, text: str) -> int:
        """Spočíta tokeny v texte"""
        if not text or not isinstance(text, str):
            return 0
        return len(self.encoding.encode(text))

    def extract_text_from_result(self, result) -> str:
        """Extrahuje text z komplexnej štruktúry agenta"""
        if isinstance(result, str):
            return result
        elif isinstance(result, list):
            text_parts = []
            for item in result:
                if isinstance(item, dict):
                    if 'text' in item:
                        text_parts.append(str(item['text']))
                    elif 'content' in item:
                        text_parts.append(str(item['content']))
                elif isinstance(item, str):
                    text_parts.append(item)
            return ' '.join(text_parts)
        elif isinstance(result, dict):
            if 'text' in result:
                return str(result['text'])
            elif 'content' in result:
                return str(result['content'])
            else:
                return str(result)
        else:
            return str(result)

    def start_interaction(self, user_input: str):
        """Začne novú interakciu"""
        # Reset token limit manager
        self.token_limit_manager.reset_interaction()

        self.current_interaction = {
            'user_input': user_input,
            'input_tokens': self.count_tokens(user_input),
            'llm_calls': [],
            'tool_calls': [],
            'final_response': '',
            'total_input_tokens': 0,
            'total_output_tokens': 0,
            'api_calls': 0,
            'duration': 0,
            'start_time': time.time(),
            'limits_hit': [],
            'memory_cleanups': 0
        }

    def add_llm_call(self, input_tokens: int, output_tokens: int):
        """Pridá LLM call do súčasnej interakcie"""
        self.current_interaction['llm_calls'].append({
            'input_tokens': input_tokens,
            'output_tokens': output_tokens
        })
        self.current_interaction['api_calls'] += 1

    def add_tool_start(self, tool_name: str, tool_input: str):
        """Začne tool call"""
        self.current_tool_call = {
            'name': tool_name,
            'input': tool_input,
            'input_tokens': self.count_tokens(f"{tool_name}: {tool_input}"),
            'output': '',
            'output_tokens': 0
        }

    def add_tool_end(self, tool_output: str):
        """Dokončí tool call"""
        self.current_tool_call['output'] = tool_output
        self.current_tool_call['output_tokens'] = self.count_tokens(tool_output)
        self.current_interaction['tool_calls'].append(self.current_tool_call.copy())
        self.current_tool_call = {}

    def finish_interaction(self, final_response):
        """Dokončí interakciu a spočíta celkové tokeny - OPRAVENÉ počítanie"""

        # Extrakcia textu z komplexnej štruktúry
        final_response_text = self.extract_text_from_result(final_response)
        final_response_tokens = self.count_tokens(final_response_text)

        self.current_interaction['final_response'] = final_response_text
        self.current_interaction['duration'] = time.time() - self.current_interaction['start_time']

        # === SPRÁVNE POČÍTANIE INPUT A OUTPUT TOKENOV ===

        # INPUT TOKENY = všetko čo ide DO Claude
        total_input = self.current_interaction['input_tokens']  # User input

        # Pridaj LLM input tokeny
        for llm_call in self.current_interaction['llm_calls']:
            total_input += llm_call['input_tokens']

        # Pridaj tool INPUT tokeny (definície nástrojov)
        for tool_call in self.current_interaction['tool_calls']:
            total_input += tool_call['input_tokens']

        # KĽÚČOVÉ: Tool RESPONSES sa rátajú ako INPUT pre ďalší Claude call
        for tool_call in self.current_interaction['tool_calls']:
            total_input += tool_call['output_tokens']  # Tool output → Claude input!

        # OUTPUT TOKENY = len to čo VYGENEROVAL Claude
        total_output = final_response_tokens  # Final response

        # Pridaj LLM output tokeny (text + tool calls čo Claude vygeneroval)
        for llm_call in self.current_interaction['llm_calls']:
            total_output += llm_call['output_tokens']

        # NIE tool responses - tie sú input pre ďalší call, nie output súčasného!

        # === MANUAL TOOL DETECTION (ak tool_calls je prázdne) ===
        if len(self.current_interaction['tool_calls']) == 0 and len(self.current_interaction['llm_calls']) >= 2:
            # Ak vidíme veľký skok v input tokenoch medzi call-mi
            first_call = self.current_interaction['llm_calls'][0]['input_tokens']
            second_call = self.current_interaction['llm_calls'][1]['input_tokens']
            tool_tokens_estimate = second_call - first_call - 100  # -100 pre malé zmeny

            if tool_tokens_estimate > 1000:  # Ak je rozdiel veľký, tool call sa stal
                # Simuluj tool call
                self.current_interaction['tool_calls'] = [{
                    'name': 'detected_tool_call',
                    'input_tokens': 50,  # Odhad pre tool definíciu
                    'output_tokens': tool_tokens_estimate
                }]

                # Prepočítaj s detected tool call
                total_input += 50 + tool_tokens_estimate  # tool def + tool response

                print(f"🔧 MANUAL tool detection: Odhadovaných {tool_tokens_estimate:,} tool tokenov")

        # Uloženie výsledkov
        self.current_interaction['total_input_tokens'] = total_input
        self.current_interaction['total_output_tokens'] = total_output

        # Pridanie do session počítadla
        self.session_input_tokens += total_input
        self.session_output_tokens += total_output

        # Uloženie do histórie
        self.conversation_history.append(self.current_interaction.copy())

        return total_input, total_output

    def print_interaction_tokens(self, input_tokens: int, output_tokens: int):
        """Vypíše detailné tokeny pre túto interakciu - OPRAVENÉ zobrazenie"""

        duration = self.current_interaction.get('duration', 0)
        api_calls = self.current_interaction.get('api_calls', 0)
        llm_calls = len(self.current_interaction.get('llm_calls', []))
        tool_calls = len(self.current_interaction.get('tool_calls', []))

        print(f"\n📊 Token Usage (táto odpoveď):")
        print(f"   📥 Input tokens:  {input_tokens:,}")
        print(f"     • User input: {self.current_interaction['input_tokens']:,}")

        if self.current_interaction.get('llm_calls'):
            llm_input_total = sum(call['input_tokens'] for call in self.current_interaction['llm_calls'])
            print(f"     • LLM calls input: {llm_input_total:,}")

        if self.current_interaction.get('tool_calls'):
            tool_input_total = sum(tc['input_tokens'] for tc in self.current_interaction['tool_calls'])
            tool_output_total = sum(tc['output_tokens'] for tc in self.current_interaction['tool_calls'])
            print(f"     • Tool definitions: {tool_input_total:,}")
            print(f"     • Tool responses (→ Claude input): {tool_output_total:,}")

        print(f"   📤 Output tokens: {output_tokens:,}")

        if self.current_interaction.get('llm_calls'):
            llm_output_total = sum(call['output_tokens'] for call in self.current_interaction['llm_calls'])
            print(f"     • LLM generated text: {llm_output_total:,}")

        print(f"     • Final response: {self.count_tokens(self.current_interaction['final_response']):,}")

        if self.current_interaction.get('tool_calls'):
            print(f"   🔧 Tools used: {tool_calls}")

            # Detailný breakdown nástrojov
            for tool_call in self.current_interaction['tool_calls']:
                tool_def_tokens = tool_call['input_tokens']
                tool_response_tokens = tool_call['output_tokens']
                print(f"     ◦ {tool_call['name']}: {tool_def_tokens:,} def + {tool_response_tokens:,} response")

        print(f"   📊 Total tokens: {input_tokens + output_tokens:,}")
        print(f"   ⏱️  Duration: {duration:.1f}s")
        print(f"   🌐 LLM calls: {llm_calls} | Tool calls: {tool_calls}")

        # Token limit status
        usage_percent_input = (
                                      self.token_limit_manager.current_interaction_input_tokens / self.token_limit_manager.max_total_input_tokens_per_interaction) * 100
        usage_percent_output = (
                                       self.token_limit_manager.current_interaction_output_tokens / self.token_limit_manager.max_total_output_tokens_per_interaction) * 100

        print(f"   📋 Token Limits Status:")
        print(
            f"     • Input: {self.token_limit_manager.current_interaction_input_tokens:,}/{self.token_limit_manager.max_total_input_tokens_per_interaction:,} ({usage_percent_input:.1f}%)")
        print(
            f"     • Output: {self.token_limit_manager.current_interaction_output_tokens:,}/{self.token_limit_manager.max_total_output_tokens_per_interaction:,} ({usage_percent_output:.1f}%)")
        print(
            f"     • LLM calls: {self.token_limit_manager.current_interaction_llm_calls}/{self.token_limit_manager.max_llm_calls_per_interaction}")

    def print_session_tokens(self):
        """Vypíše celkové tokeny za session"""
        total_tokens = self.session_input_tokens + self.session_output_tokens
        total_interactions = len(self.conversation_history)
        total_tool_calls = sum(len(interaction.get('tool_calls', [])) for interaction in self.conversation_history)
        total_llm_calls = sum(len(interaction.get('llm_calls', [])) for interaction in self.conversation_history)
        total_duration = sum(interaction.get('duration', 0) for interaction in self.conversation_history)
        total_cleanups = sum(interaction.get('memory_cleanups', 0) for interaction in self.conversation_history)

        print(f"\n📊 Session Token Stats:")
        print(f"   📥 Total Input tokens:  {self.session_input_tokens:,}")
        print(f"   📤 Total Output tokens: {self.session_output_tokens:,}")
        print(f"   📊 Total tokens:        {total_tokens:,}")
        print(f"   💬 Interactions:        {total_interactions}")
        print(f"   🔧 Tool calls:          {total_tool_calls}")
        print(f"   🌐 LLM calls:           {total_llm_calls}")
        print(f"   🧹 Memory cleanups:     {total_cleanups}")
        print(f"   ⏱️  Total duration:     {total_duration:.1f}s")
        if total_interactions > 0:
            print(f"   📈 Avg tokens/interaction: {total_tokens // total_interactions:,}")
            print(f"   📈 Avg duration/interaction: {total_duration / total_interactions:.1f}s")


# Globálny rate limiter s adaptívnym delayom
last_api_call = 0
consecutive_429_errors = 0


async def rate_limited_execution(func, *args, **kwargs):
    """Wrapper pre rate limiting akejkoľvek async funkcie s adaptívnym delayom"""
    global last_api_call, consecutive_429_errors

    # Adaptívny delay na základe chýb
    base_delay = float(os.getenv("MIN_DELAY_BETWEEN_CALLS", "1.5"))
    adaptive_delay = base_delay + (consecutive_429_errors * 0.5)  # Pridaj 0.5s za každú 429 chybu
    adaptive_delay = min(adaptive_delay, 5.0)  # Max 5 sekúnd

    current_time = time.time()
    time_since_last = current_time - last_api_call

    if time_since_last < adaptive_delay:
        wait_time = adaptive_delay - time_since_last
        print(f"⏳ Rate limiting: čakám {wait_time:.1f}s (adaptive delay: {adaptive_delay:.1f}s)...")
        await asyncio.sleep(wait_time)

    last_api_call = time.time()

    # Retry logic pre 429 chyby s exponential backoff
    max_retries = 4  # Zvýšený z 3 na 4
    base_wait = 3.0  # Zvýšený z 2.0 na 3.0

    for attempt in range(max_retries):
        try:
            result = await func(*args, **kwargs)
            # Úspech - reset 429 counter
            consecutive_429_errors = max(0, consecutive_429_errors - 1)
            return result

        except Exception as e:
            error_msg = str(e).lower()

            if "429" in error_msg or "too many requests" in error_msg:
                consecutive_429_errors += 1
                wait_time = base_wait * (2 ** attempt) + (consecutive_429_errors * 2)  # Extra delay pre opakované 429
                print(
                    f"⚠️  Rate limit hit (pokus {attempt + 1}/{max_retries}, consecutive 429s: {consecutive_429_errors})")
                print(f"⏳ Čakám {wait_time:.1f}s...")
                await asyncio.sleep(wait_time)
                continue
            else:
                # Iná chyba, prerušiť
                raise e

    # Ak sa všetky pokusy vyčerpali
    consecutive_429_errors += 2  # Penalizácia za úplné zlyhanie
    raise Exception(f"Rate limit exceeded after {max_retries} retries")


class SmartMCPAgent(MCPAgent):
    """MCPAgent with rate limiting and memory management - simplified for Haiku"""

    def __init__(self, *args, token_callback=None, **kwargs):
        super().__init__(*args, **kwargs)
        self.token_callback = token_callback
        self.iteration_count = 0
        self.context_reset = False
        if token_callback:
            token_callback.set_agent_reference(self)

    async def initialize(self):
        """Override initialize to setup tool interception after tools are ready"""
        await super().initialize()
        # Instead of MCP client interception, intercept LangChain tools
        self._setup_langchain_tool_interception()

    def _setup_langchain_tool_interception(self):
        """Sets up intercepting LangChain tool responses for smart truncation"""
        if not hasattr(self, '_tools') or not self._tools:
            print("⚠️  Tools not available for interception")
            return

        print(f"🔧 Intercepting {len(self._tools)} LangChain tools...")

        # Intercept each tool in _tools
        for i, tool in enumerate(self._tools):
            if hasattr(tool, '_run'):
                # Keep original method
                if not hasattr(tool, '_original_run'):
                    tool._original_run = tool._run

                    # Create intercepted version
                    def create_intercepted_run(original_tool, original_run_method):
                        def intercepted_run(*args, **kwargs):
                            print(f"🔧 Tool call intercepted: {original_tool.name}")
                            
                            # Special debug for shipping zone methods
                            if 'shipping_zone' in original_tool.name.lower():
                                print(f"🚢 SHIPPING ZONE DEBUG - {original_tool.name}:")
                                print(f"   • Args: {args}")
                                print(f"   • Kwargs: {kwargs}")

                            try:
                                result = original_run_method(*args, **kwargs)
                                
                                # Check if result indicates an error (MCP client may return error messages instead of raising)
                                if isinstance(result, str):
                                    result_lower = result.lower()
                                    if any(term in result_lower for term in [
                                        "error", "failed", "unable", "timeout", "connection", "invalid"
                                    ]):
                                        print(f"🔄 Tool {original_tool.name} returned error result: {result}")
                                        
                                        # Provide specific responses based on tool type
                                        if 'shipping' in original_tool.name.lower():
                                            return "Shipping information is currently unavailable due to a technical issue. For accurate shipping details and costs, please contact our customer service or check the shipping page on our website."
                                        elif 'product' in original_tool.name.lower():
                                            return "Product information is currently unavailable due to a technical issue. Please visit our website directly to browse our current product catalog."
                                        else:
                                            return f"Tool {original_tool.name} temporarily unavailable due to communication error. Please try again."
                                
                            except Exception as e:
                                error_msg = str(e).lower()
                                is_json_rpc_error = any(term in error_msg for term in [
                                    "json", "rpc", "validation", "pydantic", "field required", 
                                    "parsing json response", "error parsing"
                                ])
                                
                                if is_json_rpc_error:
                                    print(f"🔄 JSON-RPC error in tool {original_tool.name}: {e}")
                                    print("   Returning fallback response...")
                                    
                                    # Provide specific responses based on tool type
                                    if 'shipping' in original_tool.name.lower():
                                        return "Shipping information is currently unavailable due to a technical issue. For accurate shipping details and costs, please contact our customer service or check the shipping page on our website."
                                    elif 'product' in original_tool.name.lower():
                                        return "Product information is currently unavailable due to a technical issue. Please visit our website directly to browse our current product catalog."
                                    else:
                                        return f"Tool {original_tool.name} temporarily unavailable due to communication error. Please try again."
                                else:
                                    print(f"❌ Tool {original_tool.name} error: {e}")
                                    raise e

                            if isinstance(result, str) and self.token_callback:
                                result_tokens = len(self.token_callback.encoding.encode(result))

                                # Dynamic threshold
                                current_input = getattr(self.token_callback.token_limit_manager,
                                                        'current_interaction_input_tokens', 0)
                                dynamic_threshold = self.token_callback.token_limit_manager.get_dynamic_truncation_threshold(
                                    current_input)

                                if result_tokens > dynamic_threshold:
                                    print(f"🔧 LangChain tool truncation: {result_tokens:,} tokens")
                                    truncated_result = self.token_callback.token_limit_manager.smart_truncate_tool_response(
                                        result, current_input)
                                    new_tokens = len(self.token_callback.encoding.encode(truncated_result))
                                    print(f"✅ Tool truncated: {result_tokens:,} → {new_tokens:,}")
                                    return truncated_result

                            return result

                        return intercepted_run

                    # Replace method
                    tool._run = create_intercepted_run(tool, tool._original_run)

            # Similarly for async _arun
            if hasattr(tool, '_arun'):
                if not hasattr(tool, '_original_arun'):
                    tool._original_arun = tool._arun

                    def create_intercepted_arun(original_tool, original_arun_method):
                        async def intercepted_arun(*args, **kwargs):
                            print(f"🔧 Async tool call intercepted: {original_tool.name}")
                            
                            # Special debug for shipping zone methods
                            if 'shipping_zone' in original_tool.name.lower():
                                print(f"🚢 SHIPPING ZONE DEBUG - {original_tool.name}:")
                                print(f"   • Args: {args}")
                                print(f"   • Kwargs: {kwargs}")

                            try:
                                print(f"🔧 About to call original method for {original_tool.name}")
                                result = await original_arun_method(*args, **kwargs)
                                print(f"🔧 Original method returned for {original_tool.name}")
                                
                                # Log the result for debugging
                                print(f"🔍 Tool {original_tool.name} result type: {type(result)}")
                                if isinstance(result, str):
                                    print(f"🔍 Tool {original_tool.name} result preview: {result[:100]}...")
                                    
                                    # Store shipping zones data for dynamic error handling
                                    if original_tool.name == 'wc_get_shipping_zones':
                                        try:
                                            import json
                                            zones_data = json.loads(result)
                                            self.last_shipping_zones_data = zones_data
                                            print(f"🔍 Stored shipping zones data: {len(zones_data)} zones")
                                        except:
                                            pass
                                            
                                elif result is None:
                                    print(f"🔍 Tool {original_tool.name} result is None")
                                else:
                                    print(f"🔍 Tool {original_tool.name} result: {result}")
                                
                                # Check if result indicates an error (MCP client may return error messages instead of raising)
                                if isinstance(result, str):
                                    result_lower = result.lower()
                                    if any(term in result_lower for term in [
                                        "error", "failed", "unable", "timeout", "connection", "invalid"
                                    ]):
                                        print(f"🔄 Tool {original_tool.name} returned error result: {result}")
                                        
                                        # Provide specific responses based on tool type
                                        if 'shipping' in original_tool.name.lower():
                                            return "Shipping information is currently unavailable due to a technical issue. For accurate shipping details and costs, please contact our customer service or check the shipping page on our website."
                                        elif 'product' in original_tool.name.lower():
                                            return "Product information is currently unavailable due to a technical issue. Please visit our website directly to browse our current product catalog."
                                        else:
                                            return f"Tool {original_tool.name} temporarily unavailable due to communication error. Please try again."
                                
                                # Check if result is None or empty (may indicate error)
                                if result is None or (isinstance(result, str) and not result.strip()):
                                    print(f"🔄 Tool {original_tool.name} returned empty result - may indicate error")
                                    
                                    # Provide specific responses based on tool type
                                    if 'shipping' in original_tool.name.lower():
                                        return "Shipping information is currently unavailable due to a technical issue. For accurate shipping details and costs, please contact our customer service or check the shipping page on our website."
                                    elif 'product' in original_tool.name.lower():
                                        return "Product information is currently unavailable due to a technical issue. Please visit our website directly to browse our current product catalog."
                                    else:
                                        return f"Tool {original_tool.name} temporarily unavailable due to communication error. Please try again."
                                
                            except Exception as e:
                                error_msg = str(e).lower()
                                is_json_rpc_error = any(term in error_msg for term in [
                                    "json", "rpc", "validation", "pydantic", "field required", 
                                    "parsing json response", "error parsing", "streamable_http"
                                ])
                                
                                if is_json_rpc_error:
                                    print(f"🔄 JSON-RPC error in async tool {original_tool.name}: {e}")
                                    print("   Returning fallback response...")
                                    print(f"   Current user query: {getattr(self, 'current_user_query', 'Not set')}")
                                    print(f"   Has shipping zones data: {hasattr(self, 'last_shipping_zones_data')}")
                                    
                                    # Provide specific responses based on tool type and user query context
                                    if 'shipping' in original_tool.name.lower():
                                        # Dynamic shipping response based on actual shipping zones
                                        if hasattr(self, 'current_user_query'):
                                            user_query = self.current_user_query.lower()
                                            
                                            # Check if user is asking about shipping to a specific country
                                            shipping_keywords = ['ship to', 'shipping to', 'deliver to', 'send to']
                                            is_country_query = any(keyword in user_query for keyword in shipping_keywords)
                                            
                                            if is_country_query:
                                                # Extract country/location from query (simple pattern matching)
                                                words = user_query.split()
                                                country_idx = -1
                                                for i, word in enumerate(words):
                                                    if word in ['to', 'in']:
                                                        country_idx = i + 1
                                                        break
                                                
                                                country_name = ""
                                                if country_idx > 0 and country_idx < len(words):
                                                    country_name = words[country_idx].strip('?.,!').title()
                                                
                                                # Try to get dynamic shipping zone information
                                                try:
                                                    # Check if we have shipping zones data available
                                                    if hasattr(self, 'last_shipping_zones_data'):
                                                        zones_data = self.last_shipping_zones_data
                                                        
                                                        # Parse zones and build response
                                                        zone_names = []
                                                        for zone in zones_data:
                                                            if zone.get('name') and zone.get('id', -1) != 0:
                                                                zone_names.append(zone['name'])
                                                        
                                                        print(f"   Extracted zone names: {zone_names}")
                                                        country_display = country_name if country_name else "this location"
                                                        zones_text = ", ".join(zone_names) if zone_names else "specific regions"
                                                        print(f"   Country display: {country_display}, Zones text: {zones_text}")
                                                        
                                                        return f"I'm currently unable to access detailed shipping information due to a technical issue. For shipping to {country_display}, this location would fall under our \"Locations not covered by your other zones\" category. Please:\n\n• Check our shipping page on the website for international shipping options\n• Contact our customer service team for specific rates and availability\n• International shipping may be available but rates and delivery times may vary\n• We currently have dedicated shipping zones for: {zones_text}\n\nIs there anything else I can help you with?"
                                                except:
                                                    # Fallback to generic response
                                                    pass
                                                
                                                # Universal fallback response
                                                country_display = country_name if country_name else "this location"
                                                return f"I'm currently unable to access detailed shipping information due to a technical issue. For shipping to {country_display}, this location would fall under our \"Locations not covered by your other zones\" category. Please:\n\n• Check our shipping page on the website for international shipping options\n• Contact our customer service team for specific rates and availability\n• International shipping may be available but rates and delivery times may vary\n\nIs there anything else I can help you with?"
                                        
                                        return "I'm currently unable to access shipping information due to a technical issue. For accurate shipping details and costs, please:\n\n• Check our shipping page on the website\n• Contact our customer service team\n• International shipping options may be available through our default shipping zone\n\nIs there anything else I can help you with?"
                                    elif 'product' in original_tool.name.lower():
                                        return "Product information is currently unavailable due to a technical issue. Please visit our website directly to browse our current product catalog."
                                    else:
                                        return f"I'm experiencing technical difficulties accessing our systems. For the most accurate information, please visit our website directly or contact our customer service team."
                                else:
                                    print(f"❌ Async tool {original_tool.name} error: {e}")
                                    raise e

                            if isinstance(result, str) and self.token_callback:
                                result_tokens = len(self.token_callback.encoding.encode(result))

                                current_input = getattr(self.token_callback.token_limit_manager,
                                                        'current_interaction_input_tokens', 0)
                                dynamic_threshold = self.token_callback.token_limit_manager.get_dynamic_truncation_threshold(
                                    current_input)

                                if result_tokens > dynamic_threshold:
                                    print(f"🔧 Async LangChain tool truncation: {result_tokens:,} tokens")
                                    truncated_result = self.token_callback.token_limit_manager.smart_truncate_tool_response(
                                        result, current_input)
                                    new_tokens = len(self.token_callback.encoding.encode(truncated_result))
                                    print(f"✅ Async tool truncated: {result_tokens:,} → {new_tokens:,}")
                                    return truncated_result

                            return result

                        return intercepted_arun

                    tool._arun = create_intercepted_arun(tool, tool._original_arun)

        print(f"✅ LangChain tool interception set up for {len(self._tools)} tools")

    async def run(self, query: str, max_steps=5, **kwargs):
        """Simplified run with automatic fallback"""
        self.iteration_count = 0
        self.current_user_query = query  # Store current query for error handling
        print(f"🚀 SmartMCPAgent.run() starting (max {max_steps} steps)")

        # === PREVENTIVE CLEANUP AND SESSION RESET ===
        if hasattr(self, 'memory') and hasattr(self.memory, 'chat_memory'):
            messages = self.memory.chat_memory.messages
            message_count = len(messages)

            if message_count > 0:
                encoding = tiktoken.get_encoding("cl100k_base")
                total_memory_tokens = sum(len(encoding.encode(str(msg.content))) for msg in messages)

                print(f"🧠 Pre-run memory check:")
                print(f"   • Messages: {message_count}")
                print(f"   • Memory tokens: {total_memory_tokens:,}")

                # Check if we need to reset MCP client session due to token limits
                session_reset_needed = False
                
                if hasattr(self, 'token_callback') and self.token_callback:
                    current_input = self.token_callback.token_limit_manager.current_interaction_input_tokens
                    input_usage = current_input / self.token_callback.token_limit_manager.max_total_input_tokens_per_interaction
                    
                    if input_usage > 0.75:  # Reset session if over 75% of token limit
                        session_reset_needed = True
                        print(f"🔄 HIGH token usage ({input_usage:.1%}), resetting MCP client session...")
                        try:
                            # COMPLETE session restart to prevent JSON-RPC corruption
                            if hasattr(self, 'client') and hasattr(self.client, 'sessions'):
                                # Close all existing sessions
                                await self.client.close_all_sessions()
                                print("   • Closed all existing MCP sessions")
                                
                                # Create fresh sessions
                                new_sessions = await self.client.create_all_sessions()
                                print(f"   • Created {len(new_sessions)} fresh MCP sessions")
                                
                                # Re-setup tool interception with fresh tools
                                if hasattr(self, '_setup_langchain_tool_interception'):
                                    self._setup_langchain_tool_interception()
                                    print("   • Re-setup tool interception")
                                
                                # Reset token counters
                                if hasattr(self, 'token_callback') and self.token_callback:
                                    self.token_callback.token_limit_manager.reset_interaction()
                                    print("   • Reset token counters")
                                
                            print("✅ Complete MCP session reset successful")
                        except Exception as e:
                            print(f"⚠️  Session reset failed: {e}")

                # SMART SLIDING WINDOW MEMORY MANAGEMENT
                # Keep only the most recent 3 Q&A pairs (6 messages) + system messages
                if message_count > 6:  # If more than 3 Q&A pairs
                    # Separate system messages from conversation messages
                    system_messages = [msg for msg in messages if hasattr(msg, 'type') and msg.type == 'system']
                    conversation_messages = [msg for msg in messages if not (hasattr(msg, 'type') and msg.type == 'system')]
                    
                    # Keep only the most recent 6 conversation messages (3 Q&A pairs)
                    if len(conversation_messages) > 6:
                        recent_conversation = conversation_messages[-6:]  # Last 6 messages = 3 Q&A pairs
                        
                        # Rebuild memory: system messages + recent conversation
                        self.memory.chat_memory.messages = system_messages + recent_conversation
                        
                        removed_pairs = (len(conversation_messages) - 6) // 2
                        print(f"🧹 SLIDING WINDOW cleanup: removed {removed_pairs} oldest Q&A pairs, kept 3 most recent")
                        print(f"   • System messages: {len(system_messages)}")
                        print(f"   • Recent conversation: {len(recent_conversation)} messages (3 Q&A pairs)")
                    
                # Additional cleanup for extreme cases (only if no sliding window was applied)
                elif session_reset_needed and message_count > 4:
                    # Keep only system messages in case of session reset
                    system_messages = [msg for msg in messages if hasattr(msg, 'type') and msg.type == 'system']
                    self.memory.chat_memory.messages = system_messages
                    print(f"🧹 SESSION RESET cleanup: kept {len(system_messages)} system messages, cleared conversation history")

        # System prompt is now set in constructor

        # === EXECUTION WITH RATE LIMITING ===
        try:
            result = await rate_limited_execution(
                self._run_with_limit,
                query,
                max_steps,
                **kwargs
            )
            return result
        except Exception as e:
            print(f"⚠️ Agent run failed after {self.iteration_count} iterations: {e}")
            # Fallback - return generic response
            return self._create_fallback_response(query)

    async def _run_with_limit(self, query: str, max_steps: int, **kwargs):
        """Execution with iteration control"""
        self.iteration_count = 0

        # Set max_steps for MCPAgent
        original_max_steps = self.max_steps
        self.max_steps = max_steps

        try:
            # Run original MCPAgent.run
            result = await super(SmartMCPAgent, self).run(query, **kwargs)

            # Check response quality
            if self._is_response_too_generic(result):
                print("⚠️ Response is too generic, enhancing...")
                return self._enhance_response(result, query)

            return result

        except Exception as e:
            error_msg = str(e).lower()
            
            # Check for various MCP client errors that indicate corruption
            json_rpc_error = any(term in error_msg for term in ["json", "rpc", "validation", "pydantic", "field required", "parsing json response", "streamable_http"])
            connection_error = any(term in error_msg for term in ["connection", "stream", "http", "timeout"])
            mcp_error = any(term in error_msg for term in ["mcp", "streamable", "error parsing"])
            
            if json_rpc_error or connection_error or mcp_error:
                error_type = "JSON-RPC validation" if json_rpc_error else "connection"
                print(f"🔄 MCP {error_type} error detected: {e}")
                print("   Performing complete session reset...")
                
                try:
                    # Complete session restart
                    if hasattr(self, 'client'):
                        print("   • Closing all MCP sessions...")
                        await self.client.close_all_sessions()
                        
                        print("   • Creating fresh MCP sessions...")
                        sessions = await self.client.create_all_sessions()
                        print(f"   • Created {len(sessions)} fresh sessions")
                        
                        # Re-apply tool blacklist
                        await self.initialize()
                        print("   • Re-initialized agent with tool filtering")
                        
                        # Clear memory completely
                        if hasattr(self, 'memory') and hasattr(self.memory, 'chat_memory'):
                            system_messages = [msg for msg in self.memory.chat_memory.messages 
                                             if hasattr(msg, 'type') and msg.type == 'system']
                            self.memory.chat_memory.messages = system_messages
                            print("   • Cleared conversation memory")
                        
                        # Reset token counters
                        if hasattr(self, 'token_callback') and self.token_callback:
                            self.token_callback.token_limit_manager.reset_interaction()
                            print("   • Reset token counters")
                        
                        print("✅ Complete system reset successful")
                        return "I encountered a technical issue and reset the system. The system is now ready - please try your question again."
                    
                except Exception as reset_error:
                    print(f"   ❌ Complete reset failed: {reset_error}")
                    return "I'm experiencing technical difficulties. Please restart the application."
            
            print(f"❌ Error during agent run: {e}")
            return self._create_fallback_response(query)

        finally:
            # Restore original max_steps
            self.max_steps = original_max_steps

    def _is_response_too_generic(self, response: str) -> bool:
        """Check if response is too generic"""
        if not isinstance(response, str):
            return False

        generic_phrases = [
            "don't know", "not sure", "no information",
            "try asking", "contact", "visit the website"
        ]

        response_lower = response.lower()
        return any(phrase in response_lower for phrase in generic_phrases)

    def _enhance_response(self, response: str, query: str) -> str:
        """Enhance generic response"""
        if "product" in query.lower() or "price" in query.lower():
            return f"{response}\n\n💡 For current product information and prices, please visit the shop website directly."
        return response

    def _create_fallback_response(self, query: str) -> str:
        """Create fallback response"""
        if any(keyword in query.lower() for keyword in ['product', 'price', 'search', 'buy']):
            return "Sorry, I can't search for specific products at the moment. Please visit the shop website for current information."
        else:
            return "Sorry, I can't process your question. Please try rephrasing it or ask about something else."


async def main():
    config = {
        "mcpServers": {
            "wordpress_server": {
                "url": os.getenv("MCP_BASE_URL"),
                "headers": {
                    "Authorization": f"Bearer {os.getenv('JWT_TOKEN')}",
                    "Content-Type": "application/json"
                }
            }
        }
    }

    # Vytvorenie MCP klienta
    client = MCPClient.from_dict(config)
    
    # Vytvorenie OpenAI router pre rozhodovanie o použití MCP tools
    print("🔍 Vytváram OpenAI Function Router...")
    try:
        function_router = McpFunctionRouter(os.getenv("OPENAI_API_KEY"))
        print("✅ OpenAI Function Router vytvorený")
    except Exception as e:
        print(f"❌ Chyba pri vytváraní Function Router: {e}")
        print("💡 Uistite sa, že máte nastavený OPENAI_API_KEY v .env súbore")
        return

    # Explicitné vytvorenie sessions s robust error handlingom
    print("🔍 Vytváram MCP sessions...")
    max_retries = 3
    retry_delay = 1.0
    
    for attempt in range(max_retries):
        try:
            sessions = await client.create_all_sessions()
            print(f"✅ Vytvorené sessions: {list(sessions.keys())}")

            # Overenie dostupných nástrojov s error handlingom
            for name, session in sessions.items():
                try:
                    tools = session.connector.tools
                    print(f"🔧 Server '{name}' má {len(tools)} nástrojov")
                except Exception as tool_error:
                    print(f"⚠️  Server '{name}' tool discovery error: {tool_error}")
                    # Continue with other servers
                    continue
            break  # Success, exit retry loop
            
        except Exception as e:
            error_msg = str(e).lower()
            is_json_rpc_error = any(term in error_msg for term in [
                "json", "rpc", "validation", "pydantic", "field required", 
                "parsing json response", "error parsing"
            ])
            
            if is_json_rpc_error:
                print(f"🔄 JSON-RPC error (attempt {attempt + 1}/{max_retries}): {e}")
                if attempt < max_retries - 1:
                    print(f"   Waiting {retry_delay}s before retry...")
                    await asyncio.sleep(retry_delay)
                    retry_delay *= 2  # Exponential backoff
                    continue
                else:
                    print("❌ Max retries exceeded for JSON-RPC errors")
                    print("💡 Server may be returning malformed JSON-RPC responses")
                    print("💡 Try restarting the MCP server or check server logs")
                    return
            else:
                print(f"❌ Chyba pri vytváraní sessions: {e}")
                traceback.print_exc()
                return

    # Vytvorenie token limit manager
    token_limit_manager = TokenLimitManager()

    # Vytvorenie advanced token counter
    token_counter = AdvancedTokenCounter(token_limit_manager)

    # Vytvorenie callback pre token counting
    token_callback = AgentTokenCounterCallback(token_counter, token_limit_manager)

    # Použitie dynamického max_tokens z .env
    max_tokens = token_limit_manager.max_output_tokens_per_call

    # Vytvorenie Claude LLM s callback
    print("🔍 Vytváram Claude LLM...")
    try:
        llm = ChatAnthropic(
            model="claude-3-5-haiku-20241022",
            api_key=os.getenv("ANTHROPIC_API_KEY"),
            temperature=0.1,
            max_tokens=max_tokens,
            max_retries=2,
            callbacks=[token_callback]
        )
        print(f"✅ Claude LLM vytvorený (max_tokens: {max_tokens:,})")
    except Exception as e:
        print(f"❌ Chyba pri vytváraní Claude LLM: {e}")
        print("💡 Uistite sa, že máte nastavený ANTHROPIC_API_KEY v .env súbore")
        return

    # Vytvorenie MCP agenta s smart memory management
    print("🔍 Vytváram Smart MCPAgent...")
    try:
        agent = SmartMCPAgent(
            llm=llm,
            client=client,
            max_steps=5,  # Štandardne 5 krokov
            memory_enabled=True,
            auto_initialize=False,
            token_callback=token_callback,
            system_prompt=os.getenv("SYSTEM_PROMPT", """You are an e-commerce assistant. You have access to tools for product searches and store operations.

CRITICAL: For ALL product-related questions (prices, availability, sizes, colors, discounts, searches), you MUST use the available tools. Do not provide information from memory or make assumptions.

ALWAYS use tools for:
- Product searches and information
- Checking availability, sizes, colors 
- Finding discounts and sales
- Any e-commerce related queries

For SHIPPING questions:
- First use wc_get_shipping_zones to get all shipping zones
- Then use wc_get_shipping_locations with zone_id to check specific locations
- For shipping methods, use wc_get_shipping_methods with zone_id parameter

IMPORTANT: Tools that require parameters (like zone_id, id) MUST be called with proper parameters. If you don't have the required parameter, get it from a previous tool call first.

Only answer without tools for general non-product questions like greetings or explanations.

Use the tools to get accurate, up-to-date information.""")
        )
        print("✅ Smart MCPAgent vytvorený")

        # Manuálna inicializácia s detailným logovaním
        print("🔍 Inicializujem agent...")
        await agent.initialize()
        print("✅ Agent inicializovaný s MCP tool interception")

        # Fix duplicitných nástrojov a problematických tools
        if hasattr(agent, '_tools') and agent._tools:
            print(f"🔧 Pred filtrom: {len(agent._tools)} nástrojov")

            # Blacklist problematických nástrojov
            blacklisted_tools = ['analyze-sales']  # Len skutočne problematický tool
            
            # Filtrovanie duplicít a blacklisted tools
            tool_names = {}
            unique_tools = []
            duplicates_found = []
            blacklisted_found = []

            for tool in agent._tools:
                tool_name = tool.name if hasattr(tool, 'name') else str(tool)
                
                # Skip blacklisted tools
                if tool_name in blacklisted_tools:
                    blacklisted_found.append(tool_name)
                    continue
                    
                if tool_name not in tool_names:
                    tool_names[tool_name] = True
                    unique_tools.append(tool)
                else:
                    duplicates_found.append(tool_name)

            if duplicates_found:
                print(f"❌ Nájdené duplicitné nástroje: {duplicates_found}")
                
            if blacklisted_found:
                print(f"❌ Odstránené problematické nástroje: {blacklisted_found}")
                
            agent._tools = unique_tools
            print(f"✅ Po filtri: {len(agent._tools)} funkčných nástrojov")

        # Overenie či má agent _tools atribút
        if hasattr(agent, '_tools'):
            print(f"✅ Agent má _tools: {len(agent._tools) if agent._tools else 0}")
        else:
            print("❌ Agent nemá _tools atribút!")
            return

    except Exception as e:
        print(f"❌ Chyba pri vytváraní/inicializácii agenta: {e}")
        traceback.print_exc()
        return

    print("\n🚀 E-commerce Claude Chat Bot spustený!")
    print("💬 Napíšte 'exit' pre ukončenie chatu")
    print("🤖 Poháňa Claude Haiku s automatickým tool detection")
    print("📊 Pokročilé počítanie tokenov + Memory management")
    print("🎯 Dodatočné príkazy:")
    print("   - 'tokens' alebo 'stats' - zobrazí celkové tokeny za session")
    print("   - 'limits' - zobrazí aktuálne token limity")
    print("   - 'memory' - zobrazí stav conversation memory")
    print("   - 'clear' alebo 'reset' - vymaže históriu konverzácie")
    print("   - 'debug' - zobrazí debug informácie")
    print("-" * 60)

    try:
        # Hlavný chat loop - zjednodušený
        while True:
            user_input = input("\n👤 Vy: ").strip()

            # Rozšírená validácia vstupu
            if not user_input or user_input.isspace():
                print("⚠️  Zadajte prosím platnú otázku alebo 'exit' pre ukončenie.")
                continue

            if user_input.lower() in ['exit', 'quit', 'bye', 'koniec']:
                token_counter.print_session_tokens()
                print(f"\n⏳ Final rate limiting status:")
                print(f"   • Consecutive 429 errors: {consecutive_429_errors}")
                print(f"   • Current adaptive delay: {1.5 + (consecutive_429_errors * 0.5):.1f}s")
                print("\n👋 Ďakujem za rozhovor! Chat ukončený.")
                break

            if user_input.lower() in ['clear', 'reset', 'vymazat']:
                if hasattr(agent, 'clear_conversation_history'):
                    agent.clear_conversation_history()
                if hasattr(agent, 'memory') and hasattr(agent.memory, 'chat_memory'):
                    agent.memory.chat_memory.clear()
                token_counter.reset_session()
                print("🧹 História konverzácie a tokenov vymazaná.")
                continue

            # Token stats command
            if user_input.lower() in ['tokens', 'stats']:
                token_counter.print_session_tokens()
                continue

            # Memory status command
            if user_input.lower() in ['memory', 'pamat']:
                if hasattr(agent, 'memory') and hasattr(agent.memory, 'chat_memory'):
                    messages = agent.memory.chat_memory.messages
                    total_memory_tokens = 0
                    for msg in messages:
                        total_memory_tokens += len(token_counter.encoding.encode(str(msg.content)))

                    print(f"\n🧠 Conversation Memory Status:")
                    print(f"   • Správy v pamäti: {len(messages)}")
                    print(f"   • Tokeny v pamäti: {total_memory_tokens:,}")
                    print(f"   • Max správy: {token_limit_manager.max_conversation_messages}")
                    print(f"   • Standard cleanup threshold: {token_limit_manager.memory_cleanup_threshold * 100:.0f}%")
                    print(
                        f"   • Aggressive cleanup threshold: {token_limit_manager.aggressive_cleanup_threshold * 100:.0f}%")

                    if total_memory_tokens > token_limit_manager.nuclear_cleanup_threshold:
                        print(f"   ⚠️  VAROVÁNÍ: Memory príliš veľká! Bude vyčistená pri ďalšom call.")
                else:
                    print("❌ Agent nemá prístupnú memory")
                continue

            # Limits command
            if user_input.lower() in ['limits', 'limity']:
                print(f"\n📋 Current Token Limits:")
                print(f"   • Max input tokens/call: {token_limit_manager.max_input_tokens_per_call:,}")
                print(f"   • Max output tokens/call: {token_limit_manager.max_output_tokens_per_call:,}")
                print(
                    f"   • Max total input/interaction: {token_limit_manager.max_total_input_tokens_per_interaction:,}")
                print(
                    f"   • Max total output/interaction: {token_limit_manager.max_total_output_tokens_per_interaction:,}")
                print(f"   • Max LLM calls/interaction: {token_limit_manager.max_llm_calls_per_interaction}")
                print(f"   • Max conversation messages: {token_limit_manager.max_conversation_messages}")
                continue

            # Debug info
            if user_input.lower() == 'debug':
                print(f"🔍 Debug info:")
                print(f"  - Agent má _tools: {hasattr(agent, '_tools')}")
                print(f"  - Počet nástrojov: {len(getattr(agent, '_tools', []))}")
                print(f"  - Client sessions: {len(client.sessions)}")
                print(f"  - Claude model: claude-3-5-haiku-20241022")
                print(f"  - Max tokens: {max_tokens}")
                print(f"  - Max steps: 5")
                print(f"  - Consecutive 429 errors: {consecutive_429_errors}")

                # Memory debug
                if hasattr(agent, 'memory') and hasattr(agent.memory, 'chat_memory'):
                    messages = agent.memory.chat_memory.messages
                    memory_tokens = sum(len(token_counter.encoding.encode(str(msg.content))) for msg in messages)
                    print(f"  - Memory messages: {len(messages)}")
                    print(f"  - Memory tokens: {memory_tokens:,}")

                token_counter.print_session_tokens()
                continue

            # === NOVÝ ZJEDNODUŠENÝ PRÍSTUP S OPENAI ROUTER ===
            print("🤖 Claude: ", end="", flush=True)

            try:
                # Overenie pred spustením
                if not hasattr(agent, '_tools') or agent._tools is None:
                    print("\n❌ Agent nemá inicializované nástroje!")
                    continue

                # Začiatok interakcie
                token_counter.start_interaction(user_input)

                # Rozhodnutie či použiť MCP tools pomocou OpenAI router
                should_use_tools = await function_router.should_use_mcp(user_input)
                
                if not should_use_tools:
                    # Ak sa rozhodlo nepoužiť tools, vráť konfigurovateľnú odpoveď
                    response_text = os.getenv("NON_SHOPPING_RESPONSE", "Your question is not related to our store, so I cannot answer it.")
                    print(response_text)
                    
                    # Počítanie tokenov pre non-tool response
                    input_tokens = token_counter.count_tokens(user_input)
                    output_tokens = token_counter.count_tokens(response_text)
                    token_counter.add_llm_call(input_tokens, output_tokens)
                    input_tokens, output_tokens = token_counter.finish_interaction(response_text)
                    token_counter.print_interaction_tokens(input_tokens, output_tokens)
                    continue

                # Spustenie s max_steps pre kontrolu iterácií (len ak sa rozhodlo použiť tools)
                result = await agent.run(
                    user_input,
                    manage_connector=False,
                    max_steps=5  # Limit na 5 iterácií
                )

                print(result)

                # Dokončenie interakcie
                input_tokens, output_tokens = token_counter.finish_interaction(result)
                token_counter.print_interaction_tokens(input_tokens, output_tokens)

            except Exception as e:
                error_msg = str(e).lower()
                print(f"\n❌ Chyba pri spracovaní: {e}")
                print(f"📝 Typ chyby: {type(e).__name__}")

                # Check for JSON-RPC errors specifically
                is_json_rpc_error = any(term in error_msg for term in [
                    "json", "rpc", "validation", "pydantic", "field required", 
                    "parsing json response", "error parsing", "streamable_http"
                ])

                if is_json_rpc_error:
                    print("🔄 Detected JSON-RPC communication error with MCP server")
                    
                    # Provide specific response based on user question
                    if any(keyword in user_input.lower() for keyword in ['ship', 'shipping', 'delivery']):
                        # Handle specific countries/regions
                        if 'slovakia' in user_input.lower():
                            direct_response = "I apologize, but I'm currently unable to access detailed shipping information due to a technical issue. For shipping to Slovakia specifically:\n\n• Slovakia is typically supported by most international shipping services\n• Check our shipping page on the website for current rates and options\n• Contact our customer service team for specific Slovakia shipping details\n• EU countries like Slovakia usually have good shipping coverage\n\nIs there anything else I can help you with?"
                        elif any(region in user_input.lower() for region in ['europe', 'eu', 'european']):
                            direct_response = "I apologize, but I'm currently unable to access detailed shipping information due to a technical issue. For shipping to Europe:\n\n• Most European countries are typically supported with various shipping options\n• Check our shipping page on the website for current rates and coverage\n• Contact our customer service team for specific European shipping details\n• EU countries usually have good shipping coverage and reasonable rates\n\nIs there anything else I can help you with?"
                        elif any(region in user_input.lower() for region in ['usa', 'us', 'america', 'united states']):
                            direct_response = "I apologize, but I'm currently unable to access detailed shipping information due to a technical issue. For shipping to the USA:\n\n• USA shipping is typically well-supported with multiple options\n• Check our shipping page on the website for current rates and delivery times\n• Contact our customer service team for specific USA shipping details\n• US shipping usually offers various speed and cost options\n\nIs there anything else I can help you with?"
                        else:
                            direct_response = "I apologize, but I'm currently unable to access shipping information due to a technical issue. For accurate shipping details and rates:\n\n• Check our shipping page on the website\n• Contact our customer service team\n• Most major regions are typically supported with various shipping options\n\nIs there anything else I can help you with?"
                    elif any(keyword in user_input.lower() for keyword in ['product', 'price', 'search', 'buy', 'available']):
                        direct_response = "I apologize, but I'm currently unable to access product information due to a technical issue with our systems. For current product details, pricing, and availability, please visit our website directly or contact our customer service team.\n\nIs there anything else I can help you with?"
                    else:
                        direct_response = "I apologize, but I'm experiencing technical difficulties accessing our store systems. For the most accurate and up-to-date information, please visit our website directly or contact our customer service team.\n\nIs there anything else I can help you with?"
                    
                    print(direct_response)
                    
                    # Finish interaction tracking
                    input_tokens, output_tokens = token_counter.finish_interaction(direct_response)
                    token_counter.print_interaction_tokens(input_tokens, output_tokens)
                    continue

                # Fallback: Odpoveď bez tools
                print("\n🔄 Skúšam odpoveď bez nástrojov...")
                try:
                    token_counter.start_interaction(user_input)

                    fallback_response = await llm.ainvoke([
                        SystemMessage(
                            content="Odpovedz na otázku používateľa stručne a priamo, bez použitia nástrojov. Ak sa pýta na produkty, informuj ho, že má navštíviť webstránku priamo."
                        ),
                        HumanMessage(content=user_input)
                    ])

                    response_text = fallback_response.content if hasattr(fallback_response, 'content') else str(
                        fallback_response)
                    print(f"🤖 Claude (fallback): {response_text}")

                    # Počítanie tokenov pre fallback
                    input_tokens = token_counter.count_tokens(user_input)
                    output_tokens = token_counter.count_tokens(response_text)
                    token_counter.add_llm_call(input_tokens, output_tokens)
                    input_tokens, output_tokens = token_counter.finish_interaction(response_text)
                    token_counter.print_interaction_tokens(input_tokens, output_tokens)

                except Exception as fallback_error:
                    print(f"❌ Fallback tiež zlyhal: {fallback_error}")
                    print("💡 Skúste preformulovať otázku alebo reštartovať chat.")

    except KeyboardInterrupt:
        token_counter.print_session_tokens()
        print(f"\n⏳ Rate limiting status pri ukončení:")
        print(f"   • Consecutive 429 errors: {consecutive_429_errors}")
        print(f"   • Final adaptive delay: {1.5 + (consecutive_429_errors * 0.5):.1f}s")
        print("\n⚠️  Chat prerušený používateľom (Ctrl+C)")

    except Exception as e:
        print(f"\n❌ Neočakávaná chyba: {e}")
        traceback.print_exc()

    finally:
        print("\n🧹 Zatváram spojenia...")
        try:
            if client.sessions:
                await client.close_all_sessions()
            print("✅ Spojenia zatvorené.")
        except Exception as e:
            print(f"⚠️  Chyba pri zatváraní: {e}")


if __name__ == "__main__":
    asyncio.run(main())