Merge branch 'main' into 38-news-problem

src/app/agents/__init__.py

@@ -1,4 +1,4 @@
-from app.agents.predictor import PredictorInput, PredictorOutput
-from app.agents.pipeline import Pipeline, PipelineInputs, PipelineEvent
+from app.agents.pipeline import Pipeline, PipelineEvent
+from app.agents.core import PipelineInputs, QueryOutputs
 
-__all__ = ["PredictorInput", "PredictorOutput", "Pipeline", "PipelineInputs", "PipelineEvent"]
+__all__ = ["Pipeline", "PipelineInputs", "PipelineEvent", "QueryOutputs"]

src/app/agents/core.py

@@ -0,0 +1,198 @@
+from pydantic import BaseModel
+from agno.agent import Agent
+from agno.team import Team
+from agno.tools.reasoning import ReasoningTools
+from app.agents.plan_memory_tool import PlanMemoryTool
+from app.api.tools import *
+from app.configs import AppConfig
+from app.agents.prompts import *
+
+
+
+class QueryInputs(BaseModel):
+    user_query: str
+    strategy: str
+
+class QueryOutputs(BaseModel):
+    response: str
+    is_crypto: bool
+
+class PipelineInputs:
+    """
+    Classe necessaria per passare gli input alla Pipeline.
+    Serve per raggruppare i parametri e semplificare l'inizializzazione.
+    """
+
+    def __init__(self, configs: AppConfig | None = None) -> None:
+        """
+        Inputs per la Pipeline di agenti.
+        Setta i valori di default se non specificati.
+        """
+        self.configs = configs if configs else AppConfig()
+
+        agents = self.configs.agents
+        self.team_model = self.configs.get_model_by_name(agents.team_model)
+        self.team_leader_model = self.configs.get_model_by_name(agents.team_leader_model)
+        self.query_analyzer_model = self.configs.get_model_by_name(agents.query_analyzer_model)
+        self.report_generation_model = self.configs.get_model_by_name(agents.report_generation_model)
+        self.strategy = self.configs.get_strategy_by_name(agents.strategy)
+        self.user_query = ""
+
+    # ======================
+    # Dropdown handlers
+    # ======================
+    def choose_query_checker(self, index: int):
+        """
+        Sceglie il modello LLM da usare per l'analizzatore di query.
+        """
+        assert index >= 0 and index < len(self.configs.models.all_models), "Index out of range for models list."
+        self.query_analyzer_model = self.configs.models.all_models[index]
+
+    def choose_team_leader(self, index: int):
+        """
+        Sceglie il modello LLM da usare per il Team Leader.
+        """
+        assert index >= 0 and index < len(self.configs.models.all_models), "Index out of range for models list."
+        self.team_leader_model = self.configs.models.all_models[index]
+
+    def choose_team(self, index: int):
+        """
+        Sceglie il modello LLM da usare per il Team.
+        """
+        assert index >= 0 and index < len(self.configs.models.all_models), "Index out of range for models list."
+        self.team_model = self.configs.models.all_models[index]
+
+    def choose_report_generator(self, index: int):
+        """
+        Sceglie il modello LLM da usare per il generatore di report.
+        """
+        assert index >= 0 and index < len(self.configs.models.all_models), "Index out of range for models list."
+        self.report_generation_model = self.configs.models.all_models[index]
+
+    def choose_strategy(self, index: int):
+        """
+        Sceglie la strategia da usare per il Team.
+        """
+        self.strategy = self.configs.strategies[index]
+
+    # ======================
+    # Helpers
+    # ======================
+    def list_models_names(self) -> list[str]:
+        """
+        Restituisce la lista dei nomi dei modelli disponibili.
+        """
+        return [model.label for model in self.configs.models.all_models]
+
+    def list_strategies_names(self) -> list[str]:
+        """
+        Restituisce la lista delle strategie disponibili.
+        """
+        return [strat.label for strat in self.configs.strategies]
+
+    def get_query_inputs(self) -> QueryInputs:
+        """
+        Restituisce gli input per l'agente di verifica della query.
+        """
+        return QueryInputs(
+            user_query=self.user_query,
+            strategy=self.strategy.label,
+        )
+
+    # ======================
+    # Agent getters
+    # ======================
+    def get_agent_team(self) -> Team:
+        market_agent = self.team_model.get_agent(MARKET_INSTRUCTIONS, "Market Agent", tools=[MarketAPIsTool()])
+        news_agent = self.team_model.get_agent(NEWS_INSTRUCTIONS, "News Agent", tools=[NewsAPIsTool()])
+        social_agent = self.team_model.get_agent(SOCIAL_INSTRUCTIONS, "Socials Agent", tools=[SocialAPIsTool()])
+        return Team(
+            model=self.team_leader_model.get_model(TEAM_LEADER_INSTRUCTIONS),
+            name="CryptoAnalysisTeam",
+            tools=[ReasoningTools(), PlanMemoryTool(), CryptoSymbolsTools()],
+            members=[market_agent, news_agent, social_agent],
+        )
+
+    def get_agent_query_checker(self) -> Agent:
+        return self.query_analyzer_model.get_agent(QUERY_CHECK_INSTRUCTIONS, "Query Check Agent", output_schema=QueryOutputs)
+
+    def get_agent_report_generator(self) -> Agent:
+        return self.report_generation_model.get_agent(REPORT_GENERATION_INSTRUCTIONS, "Report Generator Agent")
+
+    def __str__(self) -> str:
+        return "\n".join([
+            f"Query Check:  {self.query_analyzer_model.label}",
+            f"Team Leader:  {self.team_leader_model.label}",
+            f"Team:         {self.team_model.label}",
+            f"Report:       {self.report_generation_model.label}",
+            f"Strategy:     {self.strategy.label}",
+            f"User Query:   \"{self.user_query}\"",
+        ])
+
+
+class RunMessage:
+    """
+    Classe per gestire i messaggi di stato durante l'esecuzione della pipeline.
+    Inizializza il messaggio con gli step e aggiorna lo stato, permettendo di ottenere
+    il messaggio più recente da inviare all'utente.
+    """
+
+    def __init__(self, inputs: PipelineInputs, prefix: str = "", suffix: str = ""):
+        """
+        Inizializza il messaggio di esecuzione con gli step iniziali.
+        Tre stati possibili per ogni step:
+        - In corso (🔳)
+        - In esecuzione (➡️)
+        - Completato (✅)
+
+        Lo stato di esecuzione può essere assegnato solo ad uno step alla volta.
+        Args:
+            inputs (PipelineInputs): Input della pipeline per mostrare la configurazione.
+            prefix (str, optional): Prefisso del messaggio. Defaults to "".
+            suffix (str, optional): Suffisso del messaggio. Defaults to "".
+        """
+        self.base_message = f"Running configurations: \n{prefix}{inputs}{suffix}\n\n"
+        self.emojis = ['🔳', '➡️', '✅']
+        self.placeholder = '<<<>>>'
+        self.current = 0
+        self.steps_total = [
+            (f"{self.placeholder} Query Check", 1),
+            (f"{self.placeholder} Info Recovery", 0),
+            (f"{self.placeholder} Report Generation", 0),
+        ]
+
+    def update(self) -> 'RunMessage':
+        """
+        Sposta lo stato di esecuzione al passo successivo.
+        Lo step precedente completato viene marcato come completato.
+        Returns:
+            RunMessage: L'istanza aggiornata di RunMessage.
+        """
+        text_curr, state_curr = self.steps_total[self.current]
+        self.steps_total[self.current] = (text_curr, state_curr + 1)
+        self.current = min(self.current + 1, len(self.steps_total))
+        if self.current < len(self.steps_total):
+            text_curr, state_curr = self.steps_total[self.current]
+            self.steps_total[self.current] = (text_curr, state_curr + 1)
+        return self
+
+    def update_step(self, text_extra: str = "") -> 'RunMessage':
+        """
+        Aggiorna il messaggio per lo step corrente.
+        Args:
+            text_extra (str, optional): Testo aggiuntivo da includere nello step. Defaults to "".
+        """
+        text_curr, state_curr = self.steps_total[self.current]
+        if text_extra:
+            text_curr = f"{text_curr.replace('╚', '╠')}\n╚═ {text_extra}"
+        self.steps_total[self.current] = (text_curr, state_curr)
+        return self
+
+    def get_latest(self) -> str:
+        """
+        Restituisce il messaggio di esecuzione più recente.
+        Returns:
+            str: Messaggio di esecuzione aggiornato.
+        """
+        steps = [msg.replace(self.placeholder, self.emojis[state]) for msg, state in self.steps_total]
+        return self.base_message + "\n".join(steps)

src/app/agents/pipeline.py

@@ -4,85 +4,38 @@ import logging
 import random
 from typing import Any, Callable
 from agno.agent import RunEvent
-from agno.team import Team, TeamRunEvent
-from agno.tools.reasoning import ReasoningTools
 from agno.run.workflow import WorkflowRunEvent
+from agno.workflow.types import StepInput, StepOutput
 from agno.workflow.step import Step
 from agno.workflow.workflow import Workflow
-
-from app.api.tools import *
-from app.agents.prompts import *
-from app.configs import AppConfig
+from app.agents.core import *
 
 logging = logging.getLogger("pipeline")
 
 
+
 class PipelineEvent(str, Enum):
-    PLANNER = "Planner"
+    QUERY_CHECK = "Query Check"
+    QUERY_ANALYZER = "Query Analyzer"
     INFO_RECOVERY = "Info Recovery"
     REPORT_GENERATION = "Report Generation"
     REPORT_TRANSLATION = "Report Translation"
-    TOOL_USED = RunEvent.tool_call_completed
+    RUN_FINISHED = WorkflowRunEvent.workflow_completed.value
+    TOOL_USED = RunEvent.tool_call_completed.value
 
     def check_event(self, event: str, step_name: str) -> bool:
-        return event == self.value or (WorkflowRunEvent.step_completed and step_name == self.value)
+        return event == self.value or (WorkflowRunEvent.step_completed == event and step_name == self.value)
 
-
-class PipelineInputs:
-    """
-    Classe necessaria per passare gli input alla Pipeline.
-    Serve per raggruppare i parametri e semplificare l'inizializzazione.
-    """
-
-    def __init__(self, configs: AppConfig | None = None) -> None:
-        """
-        Inputs per la Pipeline di agenti.
-        Setta i valori di default se non specificati.
-        """
-        self.configs = configs if configs else AppConfig()
-
-        agents = self.configs.agents
-        self.team_model = self.configs.get_model_by_name(agents.team_model)
-        self.team_leader_model = self.configs.get_model_by_name(agents.team_leader_model)
-        self.predictor_model = self.configs.get_model_by_name(agents.predictor_model)
-        self.strategy = self.configs.get_strategy_by_name(agents.strategy)
-        self.user_query = ""
-
-    # ======================
-    # Dropdown handlers
-    # ======================
-    def choose_team_leader(self, index: int):
-        """
-        Sceglie il modello LLM da usare per il Team Leader.
-        """
-        self.leader_model = self.configs.models.all_models[index]
-
-    def choose_team(self, index: int):
-        """
-        Sceglie il modello LLM da usare per il Team.
-        """
-        self.team_model = self.configs.models.all_models[index]
-
-    def choose_strategy(self, index: int):
-        """
-        Sceglie la strategia da usare per il Team.
-        """
-        self.strategy = self.configs.strategies[index]
-
-    # ======================
-    # Helpers
-    # ======================
-    def list_models_names(self) -> list[str]:
-        """
-        Restituisce la lista dei nomi dei modelli disponibili.
-        """
-        return [model.label for model in self.configs.models.all_models]
-
-    def list_strategies_names(self) -> list[str]:
-        """
-        Restituisce la lista delle strategie disponibili.
-        """
-        return [strat.label for strat in self.configs.strategies]
+    @classmethod
+    def get_log_events(cls, run_id: int) -> list[tuple['PipelineEvent', Callable[[Any], None]]]:
+        return [
+            (PipelineEvent.QUERY_CHECK, lambda _: logging.info(f"[{run_id}] Query Check completed.")),
+            (PipelineEvent.QUERY_ANALYZER, lambda _: logging.info(f"[{run_id}] Query Analyzer completed.")),
+            (PipelineEvent.INFO_RECOVERY, lambda _: logging.info(f"[{run_id}] Info Recovery completed.")),
+            (PipelineEvent.REPORT_GENERATION, lambda _: logging.info(f"[{run_id}] Report Generation completed.")),
+            (PipelineEvent.TOOL_USED, lambda e: logging.info(f"[{run_id}] Tool used [{e.tool.tool_name} {e.tool.tool_args}] by {e.agent_name}.")),
+            (PipelineEvent.RUN_FINISHED, lambda _: logging.info(f"[{run_id}] Run completed.")),
+        ]
 
 
 class Pipeline:
@@ -93,12 +46,14 @@ class Pipeline:
     """
 
     def __init__(self, inputs: PipelineInputs):
+        """
+        Inizializza la pipeline con gli input forniti.
+        Args:
+            inputs: istanza di PipelineInputs contenente le configurazioni e i parametri della pipeline.
+        """
         self.inputs = inputs
 
-    # ======================
-    # Core interaction
-    # ======================
-    def interact(self, listeners: dict[RunEvent | TeamRunEvent, Callable[[PipelineEvent], None]] = {}) -> str:
+    def interact(self, listeners: list[tuple[PipelineEvent, Callable[[Any], None]]] = []) -> str:
         """
         Esegue la pipeline di agenti per rispondere alla query dell'utente.
         Args:
@@ -108,7 +63,7 @@ class Pipeline:
         """
         return asyncio.run(self.interact_async(listeners))
 
-    async def interact_async(self, listeners: dict[RunEvent | TeamRunEvent, Callable[[PipelineEvent], None]] = {}) -> str:
+    async def interact_async(self, listeners: list[tuple[PipelineEvent, Callable[[Any], None]]] = []) -> str:
         """
         Versione asincrona che esegue la pipeline di agenti per rispondere alla query dell'utente.
         Args:
@@ -119,61 +74,47 @@ class Pipeline:
         run_id = random.randint(1000, 9999) # Per tracciare i log
         logging.info(f"[{run_id}] Pipeline query: {self.inputs.user_query}")
 
-        # Step 1: Crea gli agenti e il team
-        market_tool, news_tool, social_tool = self.get_tools()
-        market_agent = self.inputs.team_model.get_agent(instructions=MARKET_INSTRUCTIONS, name="MarketAgent", tools=[market_tool])
-        news_agent = self.inputs.team_model.get_agent(instructions=NEWS_INSTRUCTIONS, name="NewsAgent", tools=[news_tool])
-        social_agent = self.inputs.team_model.get_agent(instructions=SOCIAL_INSTRUCTIONS, name="SocialAgent", tools=[social_tool])
-
-        team = Team(
-            model=self.inputs.team_leader_model.get_model(COORDINATOR_INSTRUCTIONS),
-            name="CryptoAnalysisTeam",
-            tools=[ReasoningTools()],
-            members=[market_agent, news_agent, social_agent],
+        events = [*PipelineEvent.get_log_events(run_id), *listeners]
+        query = QueryInputs(
+            user_query=self.inputs.user_query,
+            strategy=self.inputs.strategy.description
         )
 
-        # Step 3: Crea il workflow
-        #query_planner = Step(name=PipelineEvent.PLANNER, agent=Agent())
-        info_recovery = Step(name=PipelineEvent.INFO_RECOVERY, team=team)
-        #report_generation = Step(name=PipelineEvent.REPORT_GENERATION, agent=Agent())
-        #report_translate = Step(name=AppEvent.REPORT_TRANSLATION, agent=Agent())
-
-        workflow = Workflow(
-            name="App Workflow",
-            steps=[
-                #query_planner,
-                info_recovery,
-                #report_generation,
-                #report_translate
-            ]
-        )
-
-        # Step 4: Fai partire il workflow e prendi l'output
-        query = f"The user query is: {self.inputs.user_query}\n\n They requested a {self.inputs.strategy.label} investment strategy."
-        result = await self.run(workflow, query, events={})
-        logging.info(f"[{run_id}] Run finished")
+        workflow = self.build_workflow()
+        result = await self.run(workflow, query, events=events)
         return result
 
-    # ======================
-    # Helpers
-    # =====================
-    def get_tools(self) -> tuple[MarketAPIsTool, NewsAPIsTool, SocialAPIsTool]:
-        """
-        Restituisce la lista di tools disponibili per gli agenti.
-        """
-        api = self.inputs.configs.api
 
-        market_tool = MarketAPIsTool(currency=api.currency)
-        market_tool.handler.set_retries(api.retry_attempts, api.retry_delay_seconds)
-        news_tool = NewsAPIsTool()
-        news_tool.handler.set_retries(api.retry_attempts, api.retry_delay_seconds)
-        social_tool = SocialAPIsTool()
-        social_tool.handler.set_retries(api.retry_attempts, api.retry_delay_seconds)
+    def build_workflow(self) -> Workflow:
+        """
+        Costruisce il workflow della pipeline di agenti.
+        Returns:
+            L'istanza di Workflow costruita.
+        """
+        # Step 1: Crea gli agenti e il team
+        team = self.inputs.get_agent_team()
+        query_check = self.inputs.get_agent_query_checker()
+        report = self.inputs.get_agent_report_generator()
 
-        return (market_tool, news_tool, social_tool)
+        # Step 2: Crea gli steps
+        def condition_query_ok(step_input: StepInput) -> StepOutput:
+            val = step_input.previous_step_content
+            return StepOutput(stop=not val.is_crypto) if isinstance(val, QueryOutputs) else StepOutput(stop=True)
+
+        query_check = Step(name=PipelineEvent.QUERY_CHECK, agent=query_check)
+        info_recovery = Step(name=PipelineEvent.INFO_RECOVERY, team=team)
+        report_generation = Step(name=PipelineEvent.REPORT_GENERATION, agent=report)
+
+        # Step 3: Ritorna il workflow completo
+        return Workflow(name="App Workflow", steps=[
+            query_check,
+            condition_query_ok,
+            info_recovery,
+            report_generation
+        ])
 
     @classmethod
-    async def run(cls, workflow: Workflow, query: str, events: dict[PipelineEvent, Callable[[Any], None]]) -> str:
+    async def run(cls, workflow: Workflow, query: QueryInputs, events: list[tuple[PipelineEvent, Callable[[Any], None]]]) -> str:
         """
         Esegue il workflow e gestisce gli eventi tramite le callback fornite.
         Args:
@@ -188,16 +129,18 @@ class Pipeline:
         content = None
         async for event in iterator:
             step_name = getattr(event, 'step_name', '')
-
-            for app_event, listener in events.items():
+            for app_event, listener in events:
                 if app_event.check_event(event.event, step_name):
                     listener(event)
-
-            if event.event == WorkflowRunEvent.workflow_completed:
+            if event.event == WorkflowRunEvent.step_completed:
                 content = getattr(event, 'content', '')
-                if isinstance(content, str):
-                    think_str = "</think>"
-                    think = content.rfind(think_str)
-                    content = content[(think + len(think_str)):] if think != -1 else content
 
-        return content if content else "No output from workflow, something went wrong."
+        if content and isinstance(content, str):
+            think_str = "</think>"
+            think = content.rfind(think_str)
+            return content[(think + len(think_str)):] if think != -1 else content
+        if content and isinstance(content, QueryOutputs):
+            return content.response
+
+        logging.error(f"No output from workflow: {content}")
+        return "No output from workflow, something went wrong."

src/app/agents/plan_memory_tool.py

@@ -0,0 +1,55 @@
+from agno.tools.toolkit import Toolkit
+from typing import TypedDict, Literal
+
+
+
+class Task(TypedDict):
+    name: str
+    status: Literal["pending", "completed", "failed"]
+    result: str | None
+
+
+class PlanMemoryTool(Toolkit):
+    def __init__(self):
+        self.tasks: list[Task] = []
+        Toolkit.__init__(self, # type: ignore[call-arg]
+            instructions="This tool manages an execution plan. Add tasks, get the next pending task, update a task's status (completed, failed) and result, or list all tasks.",
+            tools=[
+                self.add_tasks,
+                self.get_next_pending_task,
+                self.update_task_status,
+                self.list_all_tasks,
+            ]
+        )
+
+    def add_tasks(self, task_names: list[str]) -> str:
+        """Adds multiple new tasks to the plan with 'pending' status."""
+        count = 0
+        for name in task_names:
+            if not any(t['name'] == name for t in self.tasks):
+                self.tasks.append({"name": name, "status": "pending", "result": None})
+                count += 1
+        return f"Added {count} new tasks."
+
+    def get_next_pending_task(self) -> Task | None:
+        """Retrieves the first task that is still 'pending'."""
+        for task in self.tasks:
+            if task["status"] == "pending":
+                return task
+        return None
+
+    def update_task_status(self, task_name: str, status: Literal["completed", "failed"], result: str | None = None) -> str:
+        """Updates the status and result of a specific task by its name."""
+        for task in self.tasks:
+            if task["name"] == task_name:
+                task["status"] = status
+                if result is not None:
+                    task["result"] = result
+                return f"Task '{task_name}' updated to {status}."
+        return f"Error: Task '{task_name}' not found."
+
+    def list_all_tasks(self) -> list[str]:
+        """Lists all tasks in the plan with their status and result."""
+        if not self.tasks:
+            return ["No tasks in the plan."]
+        return [f"- {t['name']}: {t['status']} (Result: {t.get('result', 'N/A')})" for t in self.tasks]

src/app/agents/predictor.py

@@ -1,16 +0,0 @@
-from pydantic import BaseModel, Field
-from app.api.core.markets import ProductInfo
-
-class PredictorInput(BaseModel):
-    data: list[ProductInfo] = Field(..., description="Market data as a list of ProductInfo")
-    style: str = Field(..., description="Prediction style")
-    sentiment: str = Field(..., description="Aggregated sentiment from news and social analysis")
-
-class ItemPortfolio(BaseModel):
-    asset: str = Field(..., description="Name of the asset")
-    percentage: float = Field(..., description="Percentage allocation to the asset")
-    motivation: str = Field(..., description="Motivation for the allocation")
-
-class PredictorOutput(BaseModel):
-    strategy: str = Field(..., description="Concise operational strategy in Italian")
-    portfolio: list[ItemPortfolio] = Field(..., description="List of portfolio items with allocations")

src/app/agents/prompts/__init__.py

@@ -6,16 +6,18 @@ def __load_prompt(file_name: str) -> str:
     file_path = __PROMPTS_PATH / file_name
     return file_path.read_text(encoding='utf-8').strip()
 
-COORDINATOR_INSTRUCTIONS = __load_prompt("team_leader.txt")
+TEAM_LEADER_INSTRUCTIONS = __load_prompt("team_leader.txt")
 MARKET_INSTRUCTIONS = __load_prompt("team_market.txt")
 NEWS_INSTRUCTIONS = __load_prompt("team_news.txt")
 SOCIAL_INSTRUCTIONS = __load_prompt("team_social.txt")
-PREDICTOR_INSTRUCTIONS = __load_prompt("predictor.txt")
+QUERY_CHECK_INSTRUCTIONS = __load_prompt("query_check.txt")
+REPORT_GENERATION_INSTRUCTIONS = __load_prompt("report_generation.txt")
 
 __all__ = [
-    "COORDINATOR_INSTRUCTIONS",
+    "TEAM_LEADER_INSTRUCTIONS",
     "MARKET_INSTRUCTIONS",
     "NEWS_INSTRUCTIONS",
     "SOCIAL_INSTRUCTIONS",
-    "PREDICTOR_INSTRUCTIONS",
+    "QUERY_CHECK_INSTRUCTIONS",
+    "REPORT_GENERATION_INSTRUCTIONS",
 ]

src/app/agents/prompts/predictor.txt

@@ -1,27 +0,0 @@
-You are an **Allocation Algorithm (Crypto-Algo)** specialized in analyzing market data and sentiment to generate an investment strategy and a target portfolio.
-
-Your sole objective is to process the user_input data and generate the strictly structured output as required by the response format. **You MUST NOT provide introductions, preambles, explanations, conclusions, or any additional comments that are not strictly required.**
-
-## Processing Instructions (Absolute Rule)
-
-The allocation strategy must be **derived exclusively from the "Allocation Logic" corresponding to the requested *style*** and the provided market/sentiment data. **DO NOT** use external or historical knowledge.
-
-## Allocation Logic
-
-### "Aggressivo" Style (Aggressive)
-* **Priority:** Maximizing return (high volatility accepted).
-* **Focus:** Higher allocation to **non-BTC/ETH assets** with high momentum potential (Altcoins, mid/low-cap assets).
-* **BTC/ETH:** Must serve as a base (anchor), but their allocation **must not exceed 50%** of the total portfolio.
-* **Sentiment:** Use positive sentiment to increase exposure to high-risk assets.
-
-### "Conservativo" Style (Conservative)
-* **Priority:** Capital preservation (volatility minimized).
-* **Focus:** Major allocation to **BTC and/or ETH (Large-Cap Assets)**.
-* **BTC/ETH:** Their allocation **must be at least 70%** of the total portfolio.
-* **Altcoins:** Any allocations to non-BTC/ETH assets must be minimal (max 30% combined) and for assets that minimize speculative risk.
-* **Sentiment:** Use positive sentiment only as confirmation for exposure, avoiding reactions to excessive "FOMO" signals.
-
-## Output Requirements (Content MUST be in Italian)
-
-1.  **Strategy (strategy):** Must be a concise operational description **in Italian ("in Italiano")**, with a maximum of 5 sentences.
-2.  **Portfolio (portfolio):** The sum of all percentages must be **exactly 100%**. The justification (motivation) for each asset must be a single clear sentence **in Italian ("in Italiano")**.

src/app/agents/prompts/query_check.txt

@@ -0,0 +1,18 @@
+GOAL: check if the query is crypto-related
+
+1) Determine the language of the query:
+    - This will help you understand better the intention of the user
+    - Focus on the query of the user
+    - DO NOT answer the query
+
+2) Determine if the query is crypto or investment-related:
+    - Crypto-related if it mentions cryptocurrencies, tokens, NFTs, blockchain, exchanges, wallets, DeFi, oracles, smart contracts, on-chain, off-chain, staking, yield, liquidity, tokenomics, coins, ticker symbols, etc.
+    - Investment-related if it mentions stocks, bonds, options, trading strategies, financial markets, investment advice, portfolio management, etc.
+    - If the query uses generic terms like "news", "prices", "trends", "social", "market cap", "volume" with NO asset specified -> ASSUME CRYPTO/INVESTMENT CONTEXT and proceed.
+    - If the query is clearly about unrelated domains (weather, recipes, unrelated local politics, unrelated medicine, general software not about crypto, etc.) -> return NOT_CRYPTO error.
+    - If ambiguous: treat as crypto/investment only if the most likely intent is crypto/investment; otherwise return a JSON plan that first asks the user for clarification (see step structure below).
+
+3) Ouput the result:
+    - if is crypto related then output the query
+    - if is not crypto related, then output why is not related in a brief message
+

src/app/agents/prompts/report_generation.txt

@@ -0,0 +1,61 @@
+**TASK:** You are a specialized **Markdown Reporting Assistant**. Your task is to receive a structured analysis report from a "Team Leader" and re-format it into a single, cohesive, and well-structured final report in Markdown for the end-user.
+
+**INPUT:** The input will be a structured block containing an `Overall Summary` and *zero or more* data sections (e.g., `Market`, `News`, `Social`, `Assumptions`). Each section will contain a `Summary` and `Full Data`.
+
+**CORE RULES:**
+
+1.  **Strict Conditional Rendering (CRUCIAL):** Your primary job is to format *only* the data you receive. You MUST check each data section from the input (e.g., `Market & Price Data`, `News & Market Sentiment`).
+2.  **Omit Empty Sections (CRUCIAL):** If a data section is **not present** in the input, or if its `Full Data` field is empty, null, or marked as 'Data not available', you **MUST** completely omit that entire section from the final report. **DO NOT** print the Markdown header (e.g., `## 1. Market & Price Data`), the summary, or any placeholder text for that missing section.
+3.  **Omit Report Notes:** This same rule applies to the `## 4. Report Notes` section. Render it *only* if an `Assumptions` or `Execution Log` field is present in the input.
+4.  **Present All Data:** For sections that *are* present and contain data, your report's text MUST be based on the `Summary` provided, and you MUST include the `Full Data` (e.g., Markdown tables for prices).
+5.  **Do Not Invent:**
+    * **Do NOT** invent new hypotheses, metrics, or conclusions.
+    * **Do NOT** print internal field names (like 'Full Data') or agent names.
+6.  **No Extraneous Output:**
+    * Your entire response must be **only the Markdown report**.
+    * Do not include any pre-amble (e.g., "Here is the report:").
+
+---
+
+**MANDATORY REPORT STRUCTURE:**
+(Follow the CORE RULES to conditionally render these sections. If no data sections are present, you will only render the Title and Executive Summary.)
+
+# [Report Title - e.g., "Crypto Analysis Report: Bitcoin"]
+
+## Executive Summary
+[Use the `Overall Summary` from the input here.]
+
+---
+
+## 1. Market & Price Data
+[Use the `Summary` from the input's Market section here.]
+
+**Detailed Price Data:**
+[Present the `Full Data` from the Market section here.]
+
+---
+
+## 2. News & Market Sentiment
+[Use the `Summary` from the input's News section here.]
+
+**Key Topics Discussed:**
+[List the main topics identified in the News summary.]
+
+**Supporting News/Data:**
+[Present the `Full Data` from the News section here.]
+
+---
+
+## 3. Social Sentiment
+[Use the `Summary` from the input's Social section here.]
+
+**Trending Narratives:**
+[List the main narratives identified in the Social summary.]
+
+**Supporting Social/Data:**
+[Present the `Full Data` from the Social section here.]
+
+---
+
+## 4. Report Notes
+[Use this section to report any `Assumptions` or `Execution Log` data provided in the input.]

src/app/agents/prompts/team_leader.txt

@@ -1,15 +1,48 @@
-You are the expert coordinator of a financial analysis team specializing in cryptocurrencies.
+**TASK:** You are the **Crypto Analysis Team Leader**, an expert coordinator of a financial analysis team.
 
-Your team consists of three agents:
-- **MarketAgent**: Provides quantitative market data, price analysis, and technical indicators.
-- **NewsAgent**: Scans and analyzes the latest news, articles, and official announcements.
-- **SocialAgent**: Gauges public sentiment, trends, and discussions on social media.
+**INPUT:** You will receive a user query. Your role is to create and execute an adaptive plan by coordinating your team of agents to retrieve data, judge its sufficiency, and provide an aggregated analysis.
 
-Your primary objective is to answer the user's query by orchestrating the work of your team members.
+**YOUR TEAM CONSISTS OF THREE AGENTS:**
+- **MarketAgent:** Fetches live prices and historical data.
+- **NewsAgent:** Analyzes news sentiment and top topics.
+- **SocialAgent:** Gauges public sentiment and trending narratives.
 
-Your workflow is as follows:
-1.  **Deconstruct the user's query** to identify the required information.
-2.  **Delegate specific tasks** to the most appropriate agent(s) to gather the necessary data and initial analysis.
-3.  **Analyze the information** returned by the agents.
-4.  If the initial data is insufficient or the query is complex, **iteratively re-engage the agents** with follow-up questions to build a comprehensive picture.
-5.  **Synthesize all the gathered information** into a final, coherent, and complete analysis that fills all the required output fields.
+**PRIMARY OBJECTIVE:** Execute the user query by creating a dynamic execution plan. You must **use your available tools to manage the plan's state**, identify missing data, orchestrate agents to retrieve it, manage retrieval attempts, and judge sufficiency. The final goal is to produce a structured report including *all* retrieved data and an analytical summary for the final formatting LLM.
+
+**WORKFLOW (Execution Logic):**
+1.  **Analyze Query & Scope Plan:** Analyze the user's query. Create an execution plan identifying the *target data* needed. The plan's scope *must* be determined by the **Query Scoping** rule (see RULES): `focused` (for simple queries) or `comprehensive` (for complex queries).
+2.  **Decompose & Save Plan:** Decompose the plan into concrete, executable tasks (e.g., "Get BTC Price," "Analyze BTC News Sentiment," "Gauge BTC Social Sentiment"). **Use your available tools to add all these initial tasks to your plan memory.**
+3.  **Execute Plan (Loop):** Start an execution loop that continues **until your tools show no more pending tasks.**
+4.  **Get & Dispatch Task:** **Use your tools to retrieve the next pending task.** Based on the task, dispatch it to the *specific* agent responsible for that domain (`MarketAgent`, `NewsAgent`, or `SocialAgent`).
+5.  **Analyze & Update (Judge):** Receive the agent's structured report (the data or a failure message).
+6.  **Use your tools to update the task's status** (e.g., 'completed' or 'failed') and **store the received data/result.**
+7.  **Iterate & Retry (If Needed):**
+    * If a task `failed` (e.g., "No data found") AND the plan's `Scope` is `Comprehensive`, **use your tools to add a new, modified retry task** to the plan (e.g., "Retry: Get News with wider date range").
+    * This logic ensures you attempt to get all data for complex queries.
+8.  **Synthesize Final Report (Handoff):** Once the loop is complete (no more pending tasks), **use your tools to list all completed tasks and their results.** Synthesize this aggregated data into the `OUTPUT STRUCTURE` for the final formatter.
+
+**BEHAVIORAL RULES:**
+- **Tool-Driven State Management (Crucial):** You MUST use your available tools to create, track, and update your execution plan. Your workflow is a loop: 1. Get task from plan, 2. Execute task (via Agent), 3. Update task status in plan. Repeat until done.
+- **Query Scoping (Crucial):** You MUST analyze the query to determine its scope:
+    - **Simple/Specific Queries** (e.g., "BTC Price?"): Create a *focused plan* (e.g., only one task for `MarketAgent`).
+    - **Complex/Analytical Queries** (e.g., "Status of Bitcoin?"): Create a *comprehensive plan* (e.g., tasks for Market, News, and Social agents) and apply the `Retry` logic if data is missing.
+- **Retry & Failure Handling:** You must track failures. **Do not add more than 2-3 retry tasks for the same objective** (e.g., max 3 attempts total to get News). If failure persists, report "Data not available" in the final output.
+- **Agent Delegation (No Data Tools):** You, the Leader, do not retrieve data. You *only* orchestrate. **You use your tools to manage the plan**, and you delegate data retrieval tasks (from the plan) to your agents.
+- **Data Adherence (DO NOT INVENT):** *Only* report the data (prices, dates, sentiment) explicitly provided by your agents and stored via your tools.
+
+**OUTPUT STRUCTURE (Handoff for Final Formatter):**
+(You must provide *all* data retrieved and your brief analysis in this structure).
+
+1.  **Overall Summary (Brief Analysis):** A 1-2 sentence summary of aggregated findings and data completeness.
+2.  **Market & Price Data (from MarketAgent):**
+    * **Brief Analysis:** Your summary of the market data (e.g., key trends, volatility).
+    * **Full Data:** The *complete, raw data* (e.g., list of prices, timestamps) received from the agent.
+3.  **News & Market Sentiment (from NewsAgent):**
+    * **Brief Analysis:** Your summary of the sentiment and main topics identified.
+    * **Full Data:** The *complete list of articles/data* used by the agent. If not found, specify "Data not available".
+4.  **Social Sentiment (from SocialAgent):**
+    * **Brief Analysis:** Your summary of community sentiment and trending narratives.
+    * **Full Data:** The *complete list of posts/data* used by the agent. If not found, specify "Data not available".
+5.  **Execution Log & Assumptions:**
+    * **Scope:** (e.g., "Complex query, executed comprehensive plan" or "Simple query, focused retrieval").
+    * **Execution Notes:** (e.g., "NewsAgent failed 1st attempt. Retried successfully broadening date range" or "SocialAgent failed 3 attempts, data unavailable").

src/app/agents/prompts/team_market.txt

@@ -1,19 +1,16 @@
-**TASK:** You are a specialized **Crypto Price Data Retrieval Agent**. Your primary goal is to fetch the most recent and/or historical price data for requested cryptocurrency assets (e.g., 'BTC', 'ETH', 'SOL'). You must provide the data in a clear and structured format.
-
-**AVAILABLE TOOLS:**
-1.  `get_products(asset_ids: list[str])`: Get **current** product/price info for a list of assets. **(PREFERITA: usa questa per i prezzi live)**
-2.  `get_historical_prices(asset_id: str, limit: int)`: Get historical price data for one asset. Default limit is 100. **(PREFERITA: usa questa per i dati storici)**
-3.  `get_products_aggregated(asset_ids: list[str])`: Get **aggregated current** product/price info for a list of assets. **(USA SOLO SE richiesto 'aggregato' o se `get_products` fallisce)**
-4.  `get_historical_prices_aggregated(asset_id: str, limit: int)`: Get **aggregated historical** price data for one asset. **(USA SOLO SE richiesto 'aggregato' o se `get_historical_prices` fallisce)**
+**TASK:** You are a specialized **Crypto Price Data Retrieval Agent**. Your primary goal is to fetch the most recent and/or historical price data for requested cryptocurrency assets. You must provide the data in a clear and structured format.
 
 **USAGE GUIDELINE:**
-* **Asset ID:** Always convert common names (e.g., 'Bitcoin', 'Ethereum') into their official ticker/ID (e.g., 'BTC', 'ETH').
-* **Cost Management (Cruciale per LLM locale):** Prefer `get_products` and `get_historical_prices` for standard requests to minimize costs.
-* **Aggregated Data:** Use `get_products_aggregated` or `get_historical_prices_aggregated` only if the user specifically requests aggregated data or you value that having aggregated data is crucial for the analysis.
-* **Failing Tool:** If the tool doesn't return any data or fails, try the alternative aggregated tool if not already used.
+- **Asset ID:** Always convert common names (e.g., 'Bitcoin', 'Ethereum') into their official ticker/ID (e.g., 'BTC', 'ETH').
+- **Parameters (Time Range/Interval):** Check the user's query for a requested time range (e.g., "last 7 days") or interval (e.g., "hourly"). Use sensible defaults if not specified.
+- **Tool Strategy:**
+    1.  Attempt to use the primary price retrieval tools.
+    2.  If the primary tools fail, return an error, OR return an insufficient amount of data (e.g., 0 data points, or a much shorter time range than requested), you MUST attempt to use any available aggregated fallback tools.
+- **Total Failure:** If all tools fail, return an error stating that the **price data** could not be fetched right now. If you have the error message, report that too.
+- **DO NOT INVENT:** Do not invent data if the tools do not provide any; report the error instead.
 
 **REPORTING REQUIREMENT:**
 1.  **Format:** Output the results in a clear, easy-to-read list or table.
-2.  **Live Price Request:** If an asset's *current price* is requested, report the **Asset ID**, **Latest Price**, and **Time/Date of the price**.
-3.  **Historical Price Request:** If *historical data* is requested, report the **Asset ID**, the **Limit** of points returned, and the **First** and **Last** entries from the list of historical prices (Date, Price).
-4.  **Output:** For all requests, output a single, concise summary of the findings; if requested, also include the raw data retrieved.
+2.  **Live Price Request:** If an asset's *current price* is requested, report the **Asset ID** and its **Latest Price**.
+3.  **Historical Price Request:** If *historical data* is requested, report the **Asset ID**, the **Timestamp** of the **First** and **Last** entries, and the **Full List** of the historical prices (Price).
+4.  **Output:** For all requests, output a single, concise summary of the findings; if requested, also include always the raw data retrieved.

src/app/agents/prompts/team_news.txt

@@ -1,18 +1,17 @@
-**TASK:** You are a specialized **Crypto News Analyst**. Your goal is to fetch the latest news or top headlines related to cryptocurrencies, and then **analyze the sentiment** of the content to provide a concise report to the team leader. Prioritize 'crypto' or specific cryptocurrency names (e.g., 'Bitcoin', 'Ethereum') in your searches.
-
-**AVAILABLE TOOLS:**
-1.  `get_latest_news(query: str, limit: int)`: Get the 'limit' most recent news articles for a specific 'query'.
-2.  `get_top_headlines(limit: int)`: Get the 'limit' top global news headlines.
-3.  `get_latest_news_aggregated(query: str, limit: int)`: Get aggregated latest news articles for a specific 'query'.
-4.  `get_top_headlines_aggregated(limit: int)`: Get aggregated top global news headlines.
+**TASK:** You are a specialized **Crypto News Analyst**. Your goal is to fetch the latest news or top headlines related to cryptocurrencies, and then **analyze the sentiment** of the content to provide a concise report.
 
 **USAGE GUIDELINE:**
-* Always use `get_latest_news` with a relevant crypto-related query first.
-* The default limit for news items should be 5 unless specified otherwise.
-* If the tool doesn't return any articles, respond with "No relevant news articles found."
+- **Querying:** You can search for more general news, but prioritize querying with a relevant crypto (e.g., 'Bitcoin', 'Ethereum').
+- **Limit:** Check the user's query for a requested number of articles (limit). If no specific number is mentioned, use a default limit of 5.
+- **Tool Strategy:**
+    1.  Attempt to use the primary tools (e.g., `get_latest_news`).
+    2.  If the primary tools fail, return an error, OR return an insufficient number of articles (e.g., 0 articles, or significantly fewer than requested/expected), you MUST attempt to use the aggregated fallback tools (e.g., `get_latest_news_aggregated`) to find more results.
+- **No Articles Found:** If all relevant tools are tried and no articles are returned, respond with "No relevant news articles found."
+- **Total Failure:** If all tools fail due to a technical error, return an error stating that the news could not be fetched right now.
+- **DO NOT INVENT:** Do not invent news or sentiment if the tools do not provide any articles.
 
-**REPORTING REQUIREMENT:**
-1.  **Analyze** the tone and key themes of the retrieved articles.
-2.  **Summarize** the overall **market sentiment** (e.g., highly positive, cautiously neutral, generally negative) based on the content.
-3.  **Identify** the top 2-3 **main topics** discussed (e.g., new regulation, price surge, institutional adoption).
-4.  **Output** a single, brief report summarizing these findings. Do not output the raw articles.
+**REPORTING REQUIREMENT (If news is found):**
+1.  **Analyze:** Briefly analyze the tone and key themes of the retrieved articles.
+2.  **Sentiment:** Summarize the overall **market sentiment** (e.g., highly positive, cautiously neutral, generally negative) based on the content.
+3.  **Topics:** Identify the top 2-3 **main topics** discussed (e.g., new regulation, price surge, institutional adoption).
+4.  **Output:** Output a single, brief report summarizing these findings. **Do not** output the raw articles.

src/app/agents/prompts/team_social.txt

@@ -1,15 +1,16 @@
-**TASK:** You are a specialized **Social Media Sentiment Analyst**. Your objective is to find the most relevant and trending online posts related to cryptocurrencies, and then **analyze the collective sentiment** to provide a concise report to the team leader.
-
-**AVAILABLE TOOLS:**
-1.  `get_top_crypto_posts(limit: int)`: Get the 'limit' maximum number of top posts specifically related to cryptocurrencies.
+**TASK:** You are a specialized **Social Media Sentiment Analyst**. Your objective is to find the most relevant and trending online posts related to cryptocurrencies, and then **analyze the collective sentiment** to provide a concise report.
 
 **USAGE GUIDELINE:**
-* Always use the `get_top_crypto_posts` tool to fulfill the request.
-* The default limit for posts should be 5 unless specified otherwise.
-* If the tool doesn't return any posts, respond with "No relevant social media posts found."
+- **Tool Strategy:**
+    1.  Attempt to use the primary tools (e.g., `get_top_crypto_posts`).
+    2.  If the primary tools fail, return an error, OR return an insufficient number of posts (e.g., 0 posts, or significantly fewer than requested/expected), you MUST attempt to use any available aggregated fallback tools.
+- **Limit:** Check the user's query for a requested number of posts (limit). If no specific number is mentioned, use a default limit of 5.
+- **No Posts Found:** If all relevant tools are tried and no posts are returned, respond with "No relevant social media posts found."
+- **Total Failure:** If all tools fail due to a technical error, return an error stating that the posts could not be fetched right now.
+- **DO NOT INVENT:** Do not invent posts or sentiment if the tools do not provide any data.
 
-**REPORTING REQUIREMENT:**
-1.  **Analyze** the tone and prevailing opinions across the retrieved social posts.
-2.  **Summarize** the overall **community sentiment** (e.g., high enthusiasm/FOMO, uncertainty, FUD/fear) based on the content.
-3.  **Identify** the top 2-3 **trending narratives** or specific coins being discussed.
-4.  **Output** a single, brief report summarizing these findings. Do not output the raw posts.
+**REPORTING REQUIREMENT (If posts are found):**
+1.  **Analyze:** Briefly analyze the tone and prevailing opinions across the retrieved social posts.
+2.  **Sentiment:** Summarize the overall **community sentiment** (e.g., high enthusiasm/FOMO, uncertainty, FUD/fear) based on the content.
+3.  **Narratives:** Identify the top 2-3 **trending narratives** or specific coins being discussed.
+4.  **Output:** Output a single, brief report summarizing these findings. **Do not** output the raw posts.

src/app/api/core/__init__.py

@@ -0,0 +1,22 @@
+from datetime import datetime
+
+
+def unified_timestamp(timestamp_ms: int | None = None, timestamp_s: int | None = None) -> str:
+    """
+        Transform the timestamp from milliseconds or seconds to a unified string format.
+        The resulting string is a formatted string 'YYYY-MM-DD HH:MM'.
+        Args:
+            timestamp_ms: Timestamp in milliseconds.
+            timestamp_s: Timestamp in seconds.
+        Raises:
+            ValueError: If neither timestamp_ms nor timestamp_s is provided.
+    """
+    if timestamp_ms is not None:
+        timestamp = timestamp_ms // 1000
+    elif timestamp_s is not None:
+        timestamp = timestamp_s
+    else:
+        raise ValueError("Either timestamp_ms or timestamp_s must be provided")
+    assert timestamp > 0, "Invalid timestamp data received"
+
+    return datetime.fromtimestamp(timestamp).strftime('%Y-%m-%d %H:%M')

src/app/api/core/markets.py

@@ -1,6 +1,6 @@
 import statistics
-from datetime import datetime
 from pydantic import BaseModel
+from app.api.core import unified_timestamp
 
 
 class ProductInfo(BaseModel):
@@ -64,24 +64,8 @@ class Price(BaseModel):
     """Timestamp in format YYYY-MM-DD HH:MM"""
 
     def set_timestamp(self, timestamp_ms: int | None = None, timestamp_s: int | None = None) -> None:
-        """
-        Sets the timestamp from milliseconds or seconds.
-        The timestamp is saved as a formatted string 'YYYY-MM-DD HH:MM'.
-        Args:
-            timestamp_ms: Timestamp in milliseconds.
-            timestamp_s: Timestamp in seconds.
-        Raises:
-            ValueError: If neither timestamp_ms nor timestamp_s is provided.
-        """
-        if timestamp_ms is not None:
-            timestamp = timestamp_ms // 1000
-        elif timestamp_s is not None:
-            timestamp = timestamp_s
-        else:
-            raise ValueError("Either timestamp_ms or timestamp_s must be provided")
-        assert timestamp > 0, "Invalid timestamp data received"
-
-        self.timestamp = datetime.fromtimestamp(timestamp).strftime('%Y-%m-%d %H:%M')
+        """ Use the unified_timestamp function to set the timestamp."""
+        self.timestamp = unified_timestamp(timestamp_ms, timestamp_s)
 
     @staticmethod
     def aggregate(prices: dict[str, list['Price']]) -> list['Price']:

src/app/api/core/social.py

@@ -1,22 +1,34 @@
 from pydantic import BaseModel
+from app.api.core import unified_timestamp
 
 
+
+MAX_COMMENTS = 5
+
 class SocialPost(BaseModel):
     """
     Represents a social media post with time, title, description, and comments.
     """
-    time: str = ""
+    timestamp: str = ""
     title: str = ""
     description: str = ""
     comments: list["SocialComment"] = []
 
+    def set_timestamp(self, timestamp_ms: int | None = None, timestamp_s: int | None = None) -> None:
+        """ Use the unified_timestamp function to set the time."""
+        self.timestamp = unified_timestamp(timestamp_ms, timestamp_s)
+
 class SocialComment(BaseModel):
     """
     Represents a comment on a social media post.
     """
-    time: str = ""
+    timestamp: str = ""
     description: str = ""
 
+    def set_timestamp(self, timestamp_ms: int | None = None, timestamp_s: int | None = None) -> None:
+        """ Use the unified_timestamp function to set the time."""
+        self.timestamp = unified_timestamp(timestamp_ms, timestamp_s)
+
 
 class SocialWrapper:
     """

src/app/api/markets/binance.py

@@ -57,7 +57,9 @@ class BinanceWrapper(MarketWrapper):
         """
         Formatta l'asset_id nel formato richiesto da Binance.
         """
-        return asset_id.replace('-', '') if '-' in asset_id else f"{asset_id}{self.currency}"
+        i = asset_id.find('-')
+        if i != -1: asset_id = asset_id[:i]
+        return f"{asset_id}{self.currency}" if self.currency not in asset_id else asset_id
 
     def get_product(self, asset_id: str) -> ProductInfo:
         symbol = self.__format_symbol(asset_id)

src/app/api/markets/coinbase.py

@@ -61,7 +61,9 @@ class CoinBaseWrapper(MarketWrapper):
         )
 
     def __format(self, asset_id: str) -> str:
-        return asset_id if '-' in asset_id else f"{asset_id}-{self.currency}"
+        i = asset_id.find('-')
+        if i != -1: asset_id = asset_id[:i]
+        return f"{asset_id}-{self.currency}"
 
     def get_product(self, asset_id: str) -> ProductInfo:
         asset_id = self.__format(asset_id)

src/app/api/markets/yfinance.py

@@ -47,8 +47,9 @@ class YFinanceWrapper(MarketWrapper):
         Formatta il simbolo per yfinance.
         Per crypto, aggiunge '-' e la valuta (es. BTC -> BTC-USD).
         """
-        asset_id = asset_id.upper()
-        return f"{asset_id}-{self.currency}" if '-' not in asset_id else asset_id
+        i = asset_id.find('-')
+        if i != -1: asset_id = asset_id[:i]
+        return f"{asset_id}-{self.currency}"
 
     def get_product(self, asset_id: str) -> ProductInfo:
         symbol = self._format_symbol(asset_id)

src/app/api/social/__init__.py

@@ -1,3 +1,5 @@
 from app.api.social.reddit import RedditWrapper
+from app.api.social.x import XWrapper
+from app.api.social.chan import ChanWrapper
 
-__all__ = ["RedditWrapper"]
+__all__ = ["RedditWrapper", "XWrapper", "ChanWrapper"]

src/app/api/social/chan.py

@@ -0,0 +1,94 @@
+import re
+import html
+import requests
+import warnings
+from bs4 import BeautifulSoup, MarkupResemblesLocatorWarning
+from datetime import datetime
+from app.api.core.social import *
+
+# Ignora i warning di BeautifulSoup quando incontra HTML malformato o un link, mentre si aspetta un HTML completo
+warnings.filterwarnings("ignore", category=MarkupResemblesLocatorWarning)
+
+
+class ChanWrapper(SocialWrapper):
+    """
+    Wrapper per l'API di 4chan, in particolare per la board /biz/ (Business & Finance)
+    Fonte API: https://a.4cdn.org/biz/catalog.json
+    """
+    def __init__(self):
+        super().__init__()
+
+    def __time_str(self, timestamp: str) -> int:
+        """Converte una stringa da MM/GG/AA(DAY)HH:MM:SS di 4chan a millisecondi"""
+        time = datetime.strptime(timestamp, "%m/%d/%y(%a)%H:%M:%S")
+        return int(time.timestamp() * 1000)
+
+    def __unformat_html_str(self, html_element: str) -> str:
+        """Pulisce il commento rimuovendo HTML e formattazioni inutili"""
+        if not html_element: return ""
+
+        html_entities = html.unescape(html_element)
+        soup = BeautifulSoup(html_entities, 'html.parser')
+        html_element = soup.get_text(separator=" ")
+        html_element = re.sub(r"[\\/]+", "/", html_element)
+        html_element = re.sub(r"\s+", " ", html_element).strip()
+        return html_element
+
+    def get_top_crypto_posts(self, limit: int = 5) -> list[SocialPost]:
+        url = 'https://a.4cdn.org/biz/catalog.json'
+        response = requests.get(url)
+        assert response.status_code == 200, f"Error in 4chan API request [{response.status_code}] {response.text}"
+
+        social_posts: list[SocialPost] = []
+
+        # Questa lista contiene un dizionario per ogni pagina della board di questo tipo {"page": page_number, "threads": [{thread_data}]}
+        for page in response.json():
+            for thread in page['threads']:
+
+                # ci indica se il thread è stato fissato o meno, se non è presente vuol dire che non è stato fissato, i thread sticky possono essere ignorati
+                if 'sticky' in thread:
+                    continue
+
+                # la data di creazione del thread tipo "MM/GG/AA(day)hh:mm:ss", ci interessa solo MM/GG/AA
+                time = self.__time_str(thread.get('now', ''))
+
+                # il nome dell'utente
+                name: str = thread.get('name', 'Anonymous')
+
+                # il nome del thread, può contenere anche elementi di formattazione html che saranno da ignorare, potrebbe non essere presente
+                title = self.__unformat_html_str(thread.get('sub', ''))
+                title = f"{name} posted: {title}"
+
+                # il commento del thread, può contenere anche elementi di formattazione html che saranno da ignorare
+                thread_description = self.__unformat_html_str(thread.get('com', ''))
+                if not thread_description:
+                    continue
+
+                # una lista di dizionari conteneti le risposte al thread principale, sono strutturate similarmente al thread
+                response_list = thread.get('last_replies', [])
+                comments_list: list[SocialComment] = []
+
+                for i, response in enumerate(response_list):
+                    if i >= MAX_COMMENTS: break
+
+                    # la data di creazione della risposta tipo "MM/GG/AA(day)hh:mm:ss", ci interessa solo MM/GG/AA
+                    time = self.__time_str(response['now'])
+
+                    # il commento della risposta, può contenere anche elementi di formattazione html che saranno da ignorare
+                    comment = self.__unformat_html_str(response.get('com', ''))
+                    if not comment:
+                        continue
+
+                    social_comment = SocialComment(description=comment)
+                    social_comment.set_timestamp(timestamp_ms=time)
+                    comments_list.append(social_comment)
+
+                social_post: SocialPost = SocialPost(
+                    title=title,
+                    description=thread_description,
+                    comments=comments_list
+                )
+                social_post.set_timestamp(timestamp_ms=time)
+                social_posts.append(social_post)
+
+        return social_posts[:limit]

src/app/api/social/reddit.py

@@ -1,10 +1,9 @@
 import os
 from praw import Reddit # type: ignore
 from praw.models import Submission # type: ignore
-from app.api.core.social import SocialWrapper, SocialPost, SocialComment
+from app.api.core.social import *
 
 
-MAX_COMMENTS = 5
 # metterne altri se necessario.
 # fonti: https://lkiconsulting.io/marketing/best-crypto-subreddits/
 SUBREDDITS = [
@@ -24,13 +23,13 @@ SUBREDDITS = [
 
 def extract_post(post: Submission) -> SocialPost:
     social = SocialPost()
-    social.time = str(post.created)
+    social.set_timestamp(timestamp_s=post.created)
     social.title = post.title
     social.description = post.selftext
 
     for top_comment in post.comments:
         comment = SocialComment()
-        comment.time = str(top_comment.created)
+        comment.set_timestamp(timestamp_s=top_comment.created)
         comment.description = top_comment.body
         social.comments.append(comment)
 

src/app/api/social/x.py

@@ -0,0 +1,48 @@
+import os
+import json
+import subprocess
+from shutil import which
+from datetime import datetime
+from app.api.core.social import SocialWrapper, SocialPost
+
+
+# This is the list of users that can be interesting
+# To get the ID of a new user is necessary to search it on X, copy the url and insert it in a service like "https://get-id-x.foundtt.com/en/"
+X_USERS = [
+    'watcherguru',
+    'Cointelegraph',
+    'BTC_Archive',
+    'elonmusk'
+]
+
+class XWrapper(SocialWrapper):
+    def __init__(self):
+        '''
+        This wrapper uses the rettiwt API to get data from X in order to avoid the rate limits of the free X API,
+        even if improbable this could lead to a ban so do not use the personal account,
+        In order to work it is necessary to install the rettiwt cli tool, for more information visit the official documentation at https://www.npmjs.com/package/rettiwt-api
+        '''
+
+        self.api_key = os.getenv("X_API_KEY")
+        assert self.api_key, "X_API_KEY environment variable not set"
+        assert which('rettiwt') is not None, "Command `rettiwt` not installed"
+
+
+    def get_top_crypto_posts(self, limit:int = 5) -> list[SocialPost]:
+        posts: list[SocialPost] = []
+
+        for user in X_USERS:
+            cmd = ['rettiwt', '-k', self.api_key, 'tweet', 'search', str(limit), '-f', str(user)]
+            process = subprocess.run(cmd, capture_output=True)
+            results = process.stdout.decode()
+            json_result = json.loads(results)
+
+            for tweet in json_result.get('list', []):
+                time = datetime.fromisoformat(tweet['createdAt'])
+                social_post = SocialPost()
+                social_post.set_timestamp(timestamp_s=int(time.timestamp()))
+                social_post.title = f"{user} tweeted: "
+                social_post.description = tweet['fullText']
+                posts.append(social_post)
+
+        return posts

src/app/api/tools/__init__.py

@@ -1,5 +1,6 @@
 from app.api.tools.market_tool import MarketAPIsTool
 from app.api.tools.social_tool import SocialAPIsTool
 from app.api.tools.news_tool import NewsAPIsTool
+from app.api.tools.symbols_tool import CryptoSymbolsTools
 
-__all__ = ["MarketAPIsTool", "NewsAPIsTool", "SocialAPIsTool"]
+__all__ = ["MarketAPIsTool", "NewsAPIsTool", "SocialAPIsTool", "CryptoSymbolsTools"]

src/app/api/tools/market_tool.py

@@ -2,33 +2,29 @@ from agno.tools import Toolkit
 from app.api.wrapper_handler import WrapperHandler
 from app.api.core.markets import MarketWrapper, Price, ProductInfo
 from app.api.markets import BinanceWrapper, CoinBaseWrapper, CryptoCompareWrapper, YFinanceWrapper
+from app.configs import AppConfig
 
 class MarketAPIsTool(MarketWrapper, Toolkit):
     """
     Class that aggregates multiple market API wrappers and manages them using WrapperHandler.
     This class supports retrieving product information and historical prices.
     This class can also aggregate data from multiple sources to provide a more comprehensive view of the market.
-    The following wrappers are included in this order:
-    - BinanceWrapper
-    - YFinanceWrapper
-    - CoinBaseWrapper
-    - CryptoCompareWrapper
+    Providers can be configured in configs.yaml under api.market_providers.
     """
 
-    def __init__(self, currency: str = "USD"):
+    def __init__(self):
         """
-        Initialize the MarketAPIsTool with multiple market API wrappers.
-        The following wrappers are included in this order:
-        - BinanceWrapper
-        - YFinanceWrapper
-        - CoinBaseWrapper
-        - CryptoCompareWrapper
-        Args:
-            currency (str): Valuta in cui restituire i prezzi. Default è "USD".
+        Initialize the MarketAPIsTool with market API wrappers configured in configs.yaml.
+        The order of wrappers is determined by the api.market_providers list in the configuration.
         """
-        kwargs = {"currency": currency or "USD"}
-        wrappers: list[type[MarketWrapper]] = [BinanceWrapper, YFinanceWrapper, CoinBaseWrapper, CryptoCompareWrapper]
-        self.handler = WrapperHandler.build_wrappers(wrappers, kwargs=kwargs)
+        config = AppConfig()
+
+        self.handler = WrapperHandler.build_wrappers(
+            constructors=[BinanceWrapper, YFinanceWrapper, CoinBaseWrapper, CryptoCompareWrapper],
+            filters=config.api.market_providers,
+            try_per_wrapper=config.api.retry_attempts,
+            retry_delay=config.api.retry_delay_seconds
+        )
 
         Toolkit.__init__( # type: ignore
             self,

src/app/api/tools/news_tool.py

@@ -2,15 +2,13 @@ from agno.tools import Toolkit
 from app.api.wrapper_handler import WrapperHandler
 from app.api.core.news import NewsWrapper, Article
 from app.api.news import NewsApiWrapper, GoogleNewsWrapper, CryptoPanicWrapper, DuckDuckGoWrapper
+from app.configs import AppConfig
 
 class NewsAPIsTool(NewsWrapper, Toolkit):
     """
     Aggregates multiple news API wrappers and manages them using WrapperHandler.
-    This class supports retrieving top headlines and latest news articles by querying multiple sources:
-    - GoogleNewsWrapper
-    - DuckDuckGoWrapper
-    - NewsApiWrapper
-    - CryptoPanicWrapper
+    This class supports retrieving top headlines and latest news articles by querying multiple sources.
+    Providers can be configured in configs.yaml under api.news_providers.
 
     By default, it returns results from the first successful wrapper. 
     Optionally, it can be configured to collect articles from all wrappers.
@@ -19,16 +17,17 @@ class NewsAPIsTool(NewsWrapper, Toolkit):
 
     def __init__(self):
         """
-        Initialize the NewsAPIsTool with multiple news API wrappers.
-        The tool uses WrapperHandler to manage and invoke the different news API wrappers.
-        The following wrappers are included in this order:
-        - GoogleNewsWrapper.
-        - DuckDuckGoWrapper.
-        - NewsApiWrapper.
-        - CryptoPanicWrapper.
+        Initialize the NewsAPIsTool with news API wrappers configured in configs.yaml.
+        The order of wrappers is determined by the api.news_providers list in the configuration.
         """
-        wrappers: list[type[NewsWrapper]] = [GoogleNewsWrapper, DuckDuckGoWrapper, NewsApiWrapper, CryptoPanicWrapper]
-        self.handler = WrapperHandler.build_wrappers(wrappers)
+        config = AppConfig()
+
+        self.handler = WrapperHandler.build_wrappers(
+            constructors=[NewsApiWrapper, GoogleNewsWrapper, CryptoPanicWrapper, DuckDuckGoWrapper],
+            filters=config.api.news_providers,
+            try_per_wrapper=config.api.retry_attempts,
+            retry_delay=config.api.retry_delay_seconds
+        )
 
         Toolkit.__init__( # type: ignore
             self,

src/app/api/tools/social_tool.py

@@ -1,14 +1,15 @@
 from agno.tools import Toolkit
 from app.api.wrapper_handler import WrapperHandler
 from app.api.core.social import SocialPost, SocialWrapper
-from app.api.social import RedditWrapper
+from app.api.social import *
+from app.configs import AppConfig
 
 
 class SocialAPIsTool(SocialWrapper, Toolkit):
     """
     Aggregates multiple social media API wrappers and manages them using WrapperHandler.
-    This class supports retrieving top crypto-related posts by querying multiple sources:
-    - RedditWrapper
+    This class supports retrieving top crypto-related posts by querying multiple sources.
+    Providers can be configured in configs.yaml under api.social_providers.
 
     By default, it returns results from the first successful wrapper. 
     Optionally, it can be configured to collect posts from all wrappers.
@@ -17,14 +18,17 @@ class SocialAPIsTool(SocialWrapper, Toolkit):
 
     def __init__(self):
         """
-        Initialize the SocialAPIsTool with multiple social media API wrappers.
-        The tool uses WrapperHandler to manage and invoke the different social media API wrappers.
-        The following wrappers are included in this order:
-        - RedditWrapper.
+        Initialize the SocialAPIsTool with social media API wrappers configured in configs.yaml.
+        The order of wrappers is determined by the api.social_providers list in the configuration.
         """
+        config = AppConfig()
 
-        wrappers: list[type[SocialWrapper]] = [RedditWrapper]
-        self.handler = WrapperHandler.build_wrappers(wrappers)
+        self.handler = WrapperHandler.build_wrappers(
+            constructors=[RedditWrapper, XWrapper, ChanWrapper],
+            filters=config.api.social_providers,
+            try_per_wrapper=config.api.retry_attempts,
+            retry_delay=config.api.retry_delay_seconds
+        )
 
         Toolkit.__init__( # type: ignore
             self,

src/app/api/tools/symbols_tool.py

@@ -0,0 +1,103 @@
+import os
+import httpx
+import asyncio
+import logging
+import pandas as pd
+from io import StringIO
+from agno.tools.toolkit import Toolkit
+
+logging.basicConfig(level=logging.INFO)
+logging = logging.getLogger("crypto_symbols")
+
+
+
+BASE_URL = "https://finance.yahoo.com/markets/crypto/all/"
+
+class CryptoSymbolsTools(Toolkit):
+    """
+    Classe per ottenere i simboli delle criptovalute tramite Yahoo Finance.
+    """
+
+    def __init__(self, cache_file: str = 'resources/cryptos.csv'):
+        self.cache_file = cache_file
+        self.final_table = pd.read_csv(self.cache_file) if os.path.exists(self.cache_file) else pd.DataFrame() # type: ignore
+        Toolkit.__init__(self, # type: ignore
+            name="Crypto Symbols Tool",
+            instructions="Tool to get cryptocurrency symbols and search them by name.",
+            tools=[
+                self.get_all_symbols,
+                self.get_symbols_by_name,
+            ],
+        )
+
+    def get_all_symbols(self) -> list[str]:
+        """
+        Restituisce tutti i simboli delle criptovalute.
+        Returns:
+            list[str]: Lista di tutti i simboli delle criptovalute.
+        """
+        return self.final_table['Symbol'].tolist() if not self.final_table.empty else []
+
+    def get_symbols_by_name(self, query: str) -> list[tuple[str, str]]:
+        """
+        Cerca i simboli che contengono la query.
+        Args:
+            query (str): Query di ricerca.
+        Returns:
+            list[tuple[str, str]]: Lista di tuple (simbolo, nome) che contengono la query.
+        """
+        query_lower = query.lower()
+        positions = self.final_table['Name'].str.lower().str.contains(query_lower)
+        return self.final_table[positions][['Symbol', 'Name']].apply(tuple, axis=1).tolist()
+
+    async def fetch_crypto_symbols(self, force_refresh: bool = False) -> None:
+        """
+        Recupera tutti i simboli delle criptovalute da Yahoo Finance e li memorizza in cache.
+        Args:
+            force_refresh (bool): Se True, forza il recupero anche se i dati sono già in cache.
+        """
+        if not force_refresh and not self.final_table.empty:
+            return
+
+        num_currencies = 250 # It looks like this is the max per page otherwise yahoo returns 26
+        offset = 0
+        stop = not self.final_table.empty
+        table = self.final_table.copy()
+
+        while not stop:
+            text = await self.___request(offset, num_currencies)
+            tables = pd.read_html(text) # type: ignore
+            df = tables[0]
+            df.columns = table.columns if not table.empty else df.columns
+            table = pd.concat([table, df], ignore_index=True)
+
+            total_rows = df.shape[0]
+            offset += total_rows
+            if total_rows < num_currencies:
+                stop = True
+
+        table.dropna(axis=0, how='all', inplace=True) # type: ignore
+        table.dropna(axis=1, how='all', inplace=True) # type: ignore
+        table.to_csv(self.cache_file, index=False)
+        self.final_table = table
+
+    async def ___request(self, offset: int, num_currencies: int) -> StringIO:
+        while True:
+            async with httpx.AsyncClient() as client:
+                resp = await client.get(f"{BASE_URL}?start={offset}&count={num_currencies}", headers={"User-Agent": "Mozilla/5.0"})
+                if resp.status_code == 429: # Too many requests
+                    secs = int(resp.headers.get("Retry-After", 2))
+                    logging.warning(f"Rate limit exceeded, waiting {secs}s before retrying...")
+                    await asyncio.sleep(secs)
+                    continue
+                if resp.status_code != 200:
+                    logging.error(f"Error fetching crypto symbols: [{resp.status_code}] {resp.text}")
+                    break
+                return StringIO(resp.text)
+        return StringIO("")
+
+
+
+if __name__ == "__main__":
+    crypto_symbols = CryptoSymbolsTools()
+    asyncio.run(crypto_symbols.fetch_crypto_symbols(force_refresh=True))

src/app/api/wrapper_handler.py

@@ -87,7 +87,7 @@ class WrapperHandler(Generic[WrapperType]):
             Exception: If all wrappers fail after retries.
         """
 
-        logging.info(f"{inspect.getsource(func).strip()} {inspect.getclosurevars(func).nonlocals}")
+        logging.debug(f"{inspect.getsource(func).strip()} {inspect.getclosurevars(func).nonlocals}")
         results: dict[str, OutputType] = {}
         starting_index = self.index
 
@@ -97,12 +97,12 @@ class WrapperHandler(Generic[WrapperType]):
             wrapper_name = wrapper.__class__.__name__
 
             if not try_all:
-                logging.info(f"try_call {wrapper_name}")
+                logging.debug(f"try_call {wrapper_name}")
 
             for try_count in range(1, self.retry_per_wrapper + 1):
                 try:
                     result = func(wrapper)
-                    logging.info(f"{wrapper_name} succeeded")
+                    logging.debug(f"{wrapper_name} succeeded")
                     results[wrapper_name] = result
                     break
 
@@ -131,13 +131,19 @@ class WrapperHandler(Generic[WrapperType]):
         return f"{e} [\"{last_frame.filename}\", line {last_frame.lineno}]"
 
     @staticmethod
-    def build_wrappers(constructors: list[type[WrapperClassType]], try_per_wrapper: int = 3, retry_delay: int = 2, kwargs: dict[str, Any] | None = None) -> 'WrapperHandler[WrapperClassType]':
+    def build_wrappers(
+        constructors: list[type[WrapperClassType]],
+        filters: list[str] | None = None,
+        try_per_wrapper: int = 3,
+        retry_delay: int = 2,
+        kwargs: dict[str, Any] | None = None) -> 'WrapperHandler[WrapperClassType]':
         """
         Builds a WrapperHandler instance with the given wrapper constructors.
         It attempts to initialize each wrapper and logs a warning if any cannot be initialized.
         Only successfully initialized wrappers are included in the handler.
         Args:
             constructors (list[type[W]]): An iterable of wrapper classes to instantiate. e.g. [WrapperA, WrapperB]
+            filters (list[str] | None): Optional list of provider names to filter the constructors.
             try_per_wrapper (int): Number of retries per wrapper before switching to the next.
             retry_delay (int): Delay in seconds between retries.
             kwargs (dict | None): Optional dictionary with keyword arguments common to all wrappers.
@@ -148,6 +154,10 @@ class WrapperHandler(Generic[WrapperType]):
         """
         assert WrapperHandler.__check(constructors), f"All constructors must be classes. Received: {constructors}"
 
+        # Order of wrappers is now determined by the order in filters
+        if filters:
+            constructors = [c for name in filters for c in constructors if c.__name__ == name]
+
         result: list[WrapperClassType] = []
         for wrapper_class in constructors:
             try:
@@ -156,4 +166,4 @@ class WrapperHandler(Generic[WrapperType]):
             except Exception as e:
                 logging.warning(f"'{wrapper_class.__name__}' cannot be initialized: {e}")
 
-        return WrapperHandler(result, try_per_wrapper, retry_delay)
+        return WrapperHandler(result, try_per_wrapper, retry_delay)

src/app/configs.py

@@ -10,6 +10,10 @@ from agno.tools import Toolkit
 from agno.models.base import Model
 from agno.models.google import Gemini
 from agno.models.ollama import Ollama
+from agno.models.openai import OpenAIChat
+from agno.models.mistral import MistralChat
+from agno.models.deepseek import DeepSeek
+# from agno.models.xai import xAI
 
 log = logging.getLogger(__name__)
 
@@ -54,29 +58,94 @@ class AppModel(BaseModel):
             output_schema=output_schema
         )
 
+
+
 class APIConfig(BaseModel):
     retry_attempts: int = 3
     retry_delay_seconds: int = 2
-    currency: str = "USD"
+    market_providers: list[str] = []
+    news_providers: list[str] = []
+    social_providers: list[str] = []
+
+
 
 class Strategy(BaseModel):
     name: str = "Conservative"
     label: str = "Conservative"
     description: str = "Focus on low-risk investments with steady returns."
 
+
+
 class ModelsConfig(BaseModel):
     gemini: list[AppModel] = [AppModel()]
+    gpt: list[AppModel] = [AppModel(name="gpt-4o", label="OpenAIChat")]
+    mistral: list[AppModel] = [AppModel(name="mistral-large-latest", label="Mistral")]
+    deepseek: list[AppModel] = [AppModel(name="deepseek-chat", label="DeepSeek")]
+    # xai: list[AppModel] = [AppModel(name="grok-3", label="xAI")]
     ollama: list[AppModel] = []
 
     @property
     def all_models(self) -> list[AppModel]:
-        return self.gemini + self.ollama
+        return self.gemini + self.ollama + self.gpt + self.mistral + self.deepseek # + self.xai
+
+    def validate_models(self) -> None:
+        """
+        Validate the configured models for each provider.
+        """
+        self.__validate_online_models(self.gemini, clazz=Gemini, key="GOOGLE_API_KEY")
+        self.__validate_online_models(self.gpt, clazz=OpenAIChat, key="OPENAI_API_KEY")
+        self.__validate_online_models(self.mistral, clazz=MistralChat, key="MISTRAL_API_KEY")
+        self.__validate_online_models(self.deepseek, clazz=DeepSeek, key="DEEPSEEK_API_KEY")
+        # self.__validate_online_models(self.xai, clazz=xAI, key="XAI_API_KEY")
+
+        self.__validate_ollama_models()
+
+    def __validate_online_models(self, models: list[AppModel], clazz: type[Model], key: str | None = None) -> None:
+        """
+        Validate models for online providers like Gemini.
+        Args:
+            models: list of AppModel instances to validate
+            clazz: class of the model (e.g. Gemini)
+            key: API key required for the provider (optional)
+        """
+        if key and os.getenv(key) is None:
+            log.warning(f"No {key} set in environment variables for {clazz.__name__}.")
+            models.clear()
+            return
+
+        for model in models:
+            model.model = clazz
+
+    def __validate_ollama_models(self) -> None:
+        """
+        Validate models for the Ollama provider.
+        """
+        try:
+            models_list = ollama.list()
+            availables = {model['model'] for model in models_list['models']}
+            not_availables: list[str] = []
+
+            for model in self.ollama:
+                if model.name in availables:
+                    model.model = Ollama
+                else:
+                    not_availables.append(model.name)
+            if not_availables:
+                log.warning(f"Ollama models not available: {not_availables}")
+
+            self.ollama = [model for model in self.ollama if model.model]
+
+        except Exception as e:
+            log.warning(f"Ollama is not running or not reachable: {e}")
+
+
 
 class AgentsConfigs(BaseModel):
     strategy: str = "Conservative"
     team_model: str = "gemini-2.0-flash"
     team_leader_model: str = "gemini-2.0-flash"
-    predictor_model: str = "gemini-2.0-flash"
+    query_analyzer_model: str = "gemini-2.0-flash"
+    report_generation_model: str = "gemini-2.0-flash"
 
 class AppConfig(BaseModel):
     port: int = 8000
@@ -118,7 +187,7 @@ class AppConfig(BaseModel):
 
         super().__init__(*args, **kwargs)
         self.set_logging_level()
-        self.validate_models()
+        self.models.validate_models()
         self._initialized = True
 
     def get_model_by_name(self, name: str) -> AppModel:
@@ -186,53 +255,3 @@ class AppConfig(BaseModel):
             logger = logging.getLogger(logger_name)
             logger.handlers.clear()
             logger.propagate = True
-
-    def validate_models(self) -> None:
-        """
-        Validate the configured models for each provider.
-        """
-        self.__validate_online_models("gemini", clazz=Gemini, key="GOOGLE_API_KEY")
-        self.__validate_ollama_models()
-
-    def __validate_online_models(self, provider: str, clazz: type[Model], key: str | None = None) -> None:
-        """
-        Validate models for online providers like Gemini.
-        Args:
-            provider: name of the provider (e.g. "gemini")
-            clazz: class of the model (e.g. Gemini)
-            key: API key required for the provider (optional)
-        """
-        if getattr(self.models, provider) is None:
-            log.warning(f"No models configured for provider '{provider}'.")
-
-        models: list[AppModel] = getattr(self.models, provider)
-        if key and os.getenv(key) is None:
-            log.warning(f"No {key} set in environment variables for {provider}.")
-            models.clear()
-            return
-
-        for model in models:
-            model.model = clazz
-
-    def __validate_ollama_models(self) -> None:
-        """
-        Validate models for the Ollama provider.
-        """
-        try:
-            models_list = ollama.list()
-            availables = {model['model'] for model in models_list['models']}
-            not_availables: list[str] = []
-
-            for model in self.models.ollama:
-                if model.name in availables:
-                    model.model = Ollama
-                else:
-                    not_availables.append(model.name)
-            if not_availables:
-                log.warning(f"Ollama models not available: {not_availables}")
-
-            self.models.ollama = [model for model in self.models.ollama if model.model]
-
-        except Exception as e:
-            log.warning(f"Ollama is not running or not reachable: {e}")
-

src/app/interface/__init__.py

@@ -1,4 +1,4 @@
 from app.interface.chat import ChatManager
-from app.interface.telegram_app import TelegramApp
+from app.interface.telegram import TelegramApp
 
 __all__ = ["ChatManager", "TelegramApp"]

src/app/interface/chat.py

@@ -13,25 +13,9 @@ class ChatManager:
     """
 
     def __init__(self):
-        self.history: list[dict[str, str]] = []  # [{"role": "user"/"assistant", "content": "..."}]
+        self.history: list[tuple[str, str]] = []  
         self.inputs = PipelineInputs()
 
-    def send_message(self, message: str) -> None:
-        """
-        Aggiunge un messaggio utente, chiama la Pipeline e salva la risposta nello storico.
-        """
-        # Aggiungi messaggio utente allo storico
-        self.history.append({"role": "user", "content": message})
-
-    def receive_message(self, response: str) -> str:
-        """
-        Riceve un messaggio dalla pipeline e lo aggiunge allo storico.
-        """
-        # Aggiungi risposta assistente allo storico
-        self.history.append({"role": "assistant", "content": response})
-
-        return response
-
     def save_chat(self, filename: str = "chat.json") -> None:
         """
         Salva la chat corrente in src/saves/<filename>.
@@ -55,7 +39,7 @@ class ChatManager:
         """
         self.history = []
 
-    def get_history(self) -> list[dict[str, str]]:
+    def get_history(self) -> list[tuple[str, str]]:
         """
         Restituisce lo storico completo della chat.
         """
@@ -65,33 +49,28 @@ class ChatManager:
     ########################################
     # Funzioni Gradio
     ########################################
-    def gradio_respond(self, message: str, history: list[dict[str, str]]) -> tuple[list[dict[str, str]], list[dict[str, str]], str]:
-        self.send_message(message)
-
+    def gradio_respond(self, message: str, history: list[tuple[str, str]]) -> str:
         self.inputs.user_query = message
         pipeline = Pipeline(self.inputs)
         response = pipeline.interact()
 
-        self.receive_message(response)
-        history.append({"role": "user", "content": message})
-        history.append({"role": "assistant", "content": response})
-        return history, history, ""
+        self.history.append((message, response))
+        return response
 
     def gradio_save(self) -> str:
         self.save_chat("chat.json")
         return "💾 Chat salvata in chat.json"
 
-    def gradio_load(self) -> tuple[list[dict[str, str]], list[dict[str, str]]]:
+    def gradio_load(self) -> tuple[list[tuple[str, str]], list[tuple[str, str]]]:
         self.load_chat("chat.json")
-        history: list[dict[str, str]] = []
-        for m in self.get_history():
-            history.append({"role": m["role"], "content": m["content"]})
+        history = self.get_history()
         return history, history
 
-    def gradio_clear(self) -> tuple[list[dict[str, str]], list[dict[str, str]]]:
+    def gradio_clear(self) -> tuple[list[str], list[str]]:
         self.reset_chat()
         return [], []
 
+
     def gradio_build_interface(self) -> gr.Blocks:
         with gr.Blocks() as interface:
             gr.Markdown("# 🤖 Agente di Analisi e Consulenza Crypto (Chat)")
@@ -100,6 +79,7 @@ class ChatManager:
             with gr.Row():
                 provider = gr.Dropdown(
                     choices=self.inputs.list_models_names(),
+                    value=self.inputs.team_leader_model.label,
                     type="index",
                     label="Modello da usare"
                 )
@@ -107,23 +87,22 @@ class ChatManager:
 
                 style = gr.Dropdown(
                     choices=self.inputs.list_strategies_names(),
+                    value=self.inputs.strategy.label,
                     type="index",
                     label="Stile di investimento"
                 )
                 style.change(fn=self.inputs.choose_strategy, inputs=style, outputs=None)
 
-            chatbot = gr.Chatbot(label="Conversazione", height=500, type="messages")
-            msg = gr.Textbox(label="Scrivi la tua richiesta", placeholder="Es: Quali sono le crypto interessanti oggi?")
+            chat = gr.ChatInterface(
+                fn=self.gradio_respond
+            )
 
             with gr.Row():
                 clear_btn = gr.Button("🗑️ Reset Chat")
                 save_btn = gr.Button("💾 Salva Chat")
                 load_btn = gr.Button("📂 Carica Chat")
 
-            # Eventi e interazioni
-            msg.submit(self.gradio_respond, inputs=[msg, chatbot], outputs=[chatbot, chatbot, msg])
-            clear_btn.click(self.gradio_clear, inputs=None, outputs=[chatbot, chatbot])
+            clear_btn.click(self.gradio_clear, inputs=None, outputs=[chat.chatbot, chat.chatbot_state])
             save_btn.click(self.gradio_save, inputs=None, outputs=None)
-            load_btn.click(self.gradio_load, inputs=None, outputs=[chatbot, chatbot])
-
-        return interface
+            load_btn.click(self.gradio_load, inputs=None, outputs=[chat.chatbot, chat.chatbot_state])
+        return interface

src/app/interface/telegram.py

@@ -1,6 +1,8 @@
+import asyncio
 import io
 import os
 import json
+from typing import Any
 import httpx
 import logging
 import warnings
@@ -9,7 +11,7 @@ from markdown_pdf import MarkdownPdf, Section
 from telegram import CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup, Message, Update, User
 from telegram.constants import ChatAction
 from telegram.ext import Application, CallbackQueryHandler, CommandHandler, ContextTypes, ConversationHandler, MessageHandler, filters
-from app.agents.pipeline import Pipeline, PipelineInputs
+from app.agents.pipeline import Pipeline, PipelineEvent, PipelineInputs, RunMessage
 
 # per per_message di ConversationHandler che rompe sempre qualunque input tu metta
 warnings.filterwarnings("ignore")
@@ -21,23 +23,44 @@ logging = logging.getLogger("telegram")
 # Un semplice schema delle interazioni:
 #      /start
 #         ║
-#         V
+#         v
 #  ╔══ CONFIGS <═════╗
 #  ║      ║ ╚══> SELECT_CONFIG
-#  ║      V
-#  ║  start_team (polling for updates)
+#  ║      v          ^
+#  ║    MODELS ══════╝
+#  ║
+#  ╠══> start (polling for updates)
 #  ║      ║
-#  ║      V
+#  ║      v
 #  ╚═══> END
-CONFIGS, SELECT_CONFIG = range(2)
+CONFIGS, SELECT_MODEL, SELECT_CONFIG = range(3)
 
 # Usato per separare la query arrivata da Telegram
 QUERY_SEP = "|==|"
 
 class ConfigsChat(Enum):
+    MODEL_CHECK = "Check Model"
+    MODEL_TEAM_LEADER = "Team Leader Model"
     MODEL_TEAM = "Team Model"
-    MODEL_OUTPUT = "Output Model"
+    MODEL_REPORT = "Report Model"
+    CHANGE_MODELS = "Change Models"
     STRATEGY = "Strategy"
+    CANCEL = "Cancel"
+
+    def get_inline_button(self, value_to_display:str="") -> InlineKeyboardButton:
+        display = self.value if not value_to_display else f"{self.value}:   {value_to_display}"
+        return InlineKeyboardButton(display, callback_data=self.name)
+
+    def change_value(self, inputs: PipelineInputs, new_value:int) -> None:
+        functions_map = {
+            self.MODEL_CHECK.name: inputs.choose_query_checker,
+            self.MODEL_TEAM_LEADER.name: inputs.choose_team_leader,
+            self.MODEL_TEAM.name: inputs.choose_team,
+            self.MODEL_REPORT.name: inputs.choose_report_generator,
+            self.STRATEGY.name: inputs.choose_strategy,
+        }
+        functions_map[self.name](new_value)
+
 
 class TelegramApp:
     def __init__(self):
@@ -72,14 +95,21 @@ class TelegramApp:
             entry_points=[CommandHandler('start', self.__start)],
             states={
                 CONFIGS: [
-                    CallbackQueryHandler(self.__model_team, pattern=ConfigsChat.MODEL_TEAM.name),
-                    CallbackQueryHandler(self.__model_output, pattern=ConfigsChat.MODEL_OUTPUT.name),
+                    CallbackQueryHandler(self.__models, pattern=ConfigsChat.CHANGE_MODELS.name),
                     CallbackQueryHandler(self.__strategy, pattern=ConfigsChat.STRATEGY.name),
-                    CallbackQueryHandler(self.__cancel, pattern='^cancel$'),
-                    MessageHandler(filters.TEXT, self.__start_team)  # Any text message
+                    CallbackQueryHandler(self.__cancel, pattern='^CANCEL$'),
+                    MessageHandler(filters.TEXT, self.__start_llms)  # Any text message
+                ],
+                SELECT_MODEL: [
+                    CallbackQueryHandler(self.__model_select, pattern=ConfigsChat.MODEL_CHECK.name),
+                    CallbackQueryHandler(self.__model_select, pattern=ConfigsChat.MODEL_TEAM_LEADER.name),
+                    CallbackQueryHandler(self.__model_select, pattern=ConfigsChat.MODEL_TEAM.name),
+                    CallbackQueryHandler(self.__model_select, pattern=ConfigsChat.MODEL_REPORT.name),
+                    CallbackQueryHandler(self.__go_to_start, pattern='^CANCEL$'),
                 ],
                 SELECT_CONFIG: [
                     CallbackQueryHandler(self.__select_config, pattern=f"^__select_config{QUERY_SEP}.*$"),
+                    CallbackQueryHandler(self.__go_to_start, pattern='^CANCEL$'),
                 ]
             },
             fallbacks=[CommandHandler('start', self.__start)],
@@ -87,45 +117,28 @@ class TelegramApp:
         self.app = app
 
     def run(self) -> None:
+        """
+        Start the Telegram bot polling. This will keep the bot running and listening for updates.\n
+        This function blocks until the bot is stopped.
+        """
         self.app.run_polling()
 
     ########################################
     # Funzioni di utilità
     ########################################
-    async def start_message(self, user: User, query: CallbackQuery | Message) -> None:
-        confs = self.user_requests.setdefault(user, PipelineInputs())
-
-        str_model_team = f"{ConfigsChat.MODEL_TEAM.value}:   {confs.team_model.label}"
-        str_model_output = f"{ConfigsChat.MODEL_OUTPUT.value}:   {confs.team_leader_model.label}"
-        str_strategy = f"{ConfigsChat.STRATEGY.value}:   {confs.strategy.label}"
-
-        msg, keyboard = (
-            "Please choose an option or write your query",
-            InlineKeyboardMarkup([
-                [InlineKeyboardButton(str_model_team, callback_data=ConfigsChat.MODEL_TEAM.name)],
-                [InlineKeyboardButton(str_model_output, callback_data=ConfigsChat.MODEL_OUTPUT.name)],
-                [InlineKeyboardButton(str_strategy, callback_data=ConfigsChat.STRATEGY.name)],
-                [InlineKeyboardButton("Cancel", callback_data='cancel')]
-            ])
-        )
-
-        if isinstance(query, CallbackQuery):
-            await query.edit_message_text(msg, reply_markup=keyboard, parse_mode='MarkdownV2')
-        else:
-            await query.reply_text(msg, reply_markup=keyboard, parse_mode='MarkdownV2')
-
     async def handle_callbackquery(self, update: Update) -> tuple[CallbackQuery, User]:
-        assert update.callback_query and update.callback_query.from_user, "Update callback_query or user is None"
+        assert update.callback_query, "Update callback_query is None"
+        assert update.effective_user, "Update effective_user is None"
         query = update.callback_query
         await query.answer()  # Acknowledge the callback query
-        return query, query.from_user
+        return query, update.effective_user
 
-    async def handle_message(self, update: Update) -> tuple[Message, User]:
-        assert update.message and update.message.from_user, "Update message or user is None"
-        return update.message, update.message.from_user
+    def handle_message(self, update: Update) -> tuple[Message, User]:
+        assert update.message and update.effective_user, "Update message or user is None"
+        return update.message, update.effective_user
 
     def build_callback_data(self, callback: str, config: ConfigsChat, labels: list[str]) -> list[tuple[str, str]]:
-        return [(label, QUERY_SEP.join((callback, config.value, str(i)))) for i, label in enumerate(labels)]
+        return [(label, QUERY_SEP.join((callback, config.name, str(i)))) for i, label in enumerate(labels)]
 
     async def __error_handler(self, update: object, context: ContextTypes.DEFAULT_TYPE) -> None:
         try:
@@ -142,28 +155,69 @@ class TelegramApp:
             logging.exception("Exception in the error handler")
 
     #########################################
-    # Funzioni async per i comandi e messaggi
+    # Funzioni base di gestione stati
     #########################################
     async def __start(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
-        message, user = await self.handle_message(update)
-        logging.info(f"@{user.username} started the conversation.")
-        await self.start_message(user, message)
+        user = update.effective_user.username if update.effective_user else "Unknown"
+        logging.info(f"@{user} started the conversation.")
+        return await self.__go_to_start(update, context)
+
+    async def __go_to_start(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+        user = update.effective_user
+        assert user, "Update effective_user is None"
+        msg = update.callback_query if update.callback_query else update.message
+        assert msg, "Update message and callback_query are both None"
+
+        confs = self.user_requests.setdefault(user, PipelineInputs()) # despite the name, it creates a default only if not present
+        args: dict[str, Any] = {
+            "text": "Please choose an option or write your query",
+            "parse_mode": 'MarkdownV2',
+            "reply_markup": InlineKeyboardMarkup([
+                [ConfigsChat.CHANGE_MODELS.get_inline_button()],
+                [ConfigsChat.STRATEGY.get_inline_button(confs.strategy.label)],
+                [ConfigsChat.CANCEL.get_inline_button()],
+            ])
+        }
+
+        await (msg.edit_message_text(**args) if isinstance(msg, CallbackQuery) else msg.reply_text(**args))
         return CONFIGS
 
-    async def __model_team(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
-        return await self._model_select(update, ConfigsChat.MODEL_TEAM)
+    async def __cancel(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+        query, user = await self.handle_callbackquery(update)
+        logging.info(f"@{user.username} canceled the conversation.")
+        if user in self.user_requests:
+            del self.user_requests[user]
+        await query.edit_message_text("Conversation canceled. Use /start to begin again.")
+        return ConversationHandler.END
 
-    async def __model_output(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
-        return await self._model_select(update, ConfigsChat.MODEL_OUTPUT)
+    ##########################################
+    # Configurazioni
+    ##########################################
+    async def __models(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+        query, user = await self.handle_callbackquery(update)
+        req = self.user_requests[user]
 
-    async def _model_select(self, update: Update, state: ConfigsChat, msg: str | None = None) -> int:
+        await query.edit_message_text("Select a model", reply_markup=InlineKeyboardMarkup([
+            [ConfigsChat.MODEL_CHECK.get_inline_button(req.query_analyzer_model.label)],
+            [ConfigsChat.MODEL_TEAM_LEADER.get_inline_button(req.team_leader_model.label)],
+            [ConfigsChat.MODEL_TEAM.get_inline_button(req.team_model.label)],
+            [ConfigsChat.MODEL_REPORT.get_inline_button(req.report_generation_model.label)],
+            [ConfigsChat.CANCEL.get_inline_button()]
+        ]))
+        return SELECT_MODEL
+
+    async def __model_select(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
         query, user = await self.handle_callbackquery(update)
 
+        if not query.data:
+            logging.error("Callback query data is None")
+            return CONFIGS
+
         req = self.user_requests[user]
-        models = self.build_callback_data("__select_config", state, req.list_models_names())
+        models = self.build_callback_data("__select_config", ConfigsChat[query.data], req.list_models_names())
         inline_btns = [[InlineKeyboardButton(name, callback_data=callback_data)] for name, callback_data in models]
 
-        await query.edit_message_text(msg or state.value, reply_markup=InlineKeyboardMarkup(inline_btns))
+        await query.edit_message_text("Select a model", reply_markup=InlineKeyboardMarkup(inline_btns))
         return SELECT_CONFIG
 
     async def __strategy(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
@@ -182,71 +236,62 @@ class TelegramApp:
 
         req = self.user_requests[user]
         _, state, index = str(query.data).split(QUERY_SEP)
-        if state == str(ConfigsChat.MODEL_TEAM):
-            req.choose_team(int(index))
-        if state == str(ConfigsChat.MODEL_OUTPUT):
-            req.choose_team_leader(int(index))
-        if state == str(ConfigsChat.STRATEGY):
-            req.choose_strategy(int(index))
+        ConfigsChat[state].change_value(req, int(index))
 
-        await self.start_message(user, query)
-        return CONFIGS
+        return await self.__go_to_start(update, context)
 
-    async def __start_team(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
-        message, user = await self.handle_message(update)
+    async def __start_llms(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+        message, user = self.handle_message(update)
 
         confs = self.user_requests[user]
         confs.user_query = message.text or ""
 
-        logging.info(f"@{user.username} started the team with [{confs.team_model.label}, {confs.team_leader_model.label}, {confs.strategy.label}]")
-        await self.__run_team(update, confs)
+        logging.info(f"@{user.username} started the team with [{confs.query_analyzer_model.label}, {confs.team_model.label}, {confs.team_leader_model.label}, {confs.report_generation_model.label}, {confs.strategy.label}]")
+        await self.__run(update, confs)
 
         logging.info(f"@{user.username} team finished.")
         return ConversationHandler.END
 
-    async def __cancel(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
-        query, user = await self.handle_callbackquery(update)
-        logging.info(f"@{user.username} canceled the conversation.")
-        if user in self.user_requests:
-            del self.user_requests[user]
-        await query.edit_message_text("Conversation canceled. Use /start to begin again.")
-        return ConversationHandler.END
 
-    async def __run_team(self, update: Update, inputs: PipelineInputs) -> None:
+    ##########################################
+    # RUN APP
+    ##########################################
+    async def __run(self, update: Update, inputs: PipelineInputs) -> None:
         if not update.message: return
 
         bot = update.get_bot()
         msg_id = update.message.message_id - 1
         chat_id = update.message.chat_id
 
-        configs_str = [
-            'Running with configurations:   ',
-            f'Team:      {inputs.team_model.label}',
-            f'Output:    {inputs.team_leader_model.label}',
-            f'Strategy:  {inputs.strategy.label}',
-            f'Query:     "{inputs.user_query}"'
-        ]
-        full_message = f"""```\n{'\n'.join(configs_str)}\n```\n\n"""
-        first_message = full_message + "Generating report, please wait"
-        msg = await bot.edit_message_text(chat_id=chat_id, message_id=msg_id, text=first_message, parse_mode='MarkdownV2')
+        run_message = RunMessage(inputs, prefix="```\n", suffix="\n```")
+        msg = await bot.edit_message_text(chat_id=chat_id, message_id=msg_id, text=run_message.get_latest(), parse_mode='MarkdownV2')
         if isinstance(msg, bool): return
 
         # Remove user query and bot message
         await bot.delete_message(chat_id=chat_id, message_id=update.message.id)
 
-        # TODO migliorare messaggi di attesa
+        def update_user(update_step: str = "") -> None:
+            if update_step: run_message.update_step(update_step)
+            else: run_message.update()
+
+            message = run_message.get_latest()
+            if msg.text != message:
+                asyncio.create_task(msg.edit_text(message, parse_mode='MarkdownV2'))
+
         await bot.send_chat_action(chat_id=chat_id, action=ChatAction.TYPING)
         pipeline = Pipeline(inputs)
-        report_content = await pipeline.interact_async()
-        await msg.delete()
+        report_content = await pipeline.interact_async(listeners=[
+            (PipelineEvent.QUERY_CHECK, lambda _: update_user()),
+            (PipelineEvent.TOOL_USED, lambda e: update_user(e.tool.tool_name.replace('get_', '').replace("_", "\\_"))),
+            (PipelineEvent.INFO_RECOVERY, lambda _: update_user()),
+            (PipelineEvent.REPORT_GENERATION, lambda _: update_user()),
+        ])
 
         # attach report file to the message
         pdf = MarkdownPdf(toc_level=2, optimize=True)
         pdf.add_section(Section(report_content, toc=False))
 
-        # TODO vedere se ha senso dare il pdf o solo il messaggio
         document = io.BytesIO()
         pdf.save_bytes(document)
         document.seek(0)
-        await bot.send_document(chat_id=chat_id, document=document, filename="report.pdf", parse_mode='MarkdownV2', caption=full_message)
-
+        await msg.reply_document(document=document, filename="report.pdf")