add staking + registry swap

src/agents/metadata.py

@@ -5,6 +5,7 @@ from typing import Any, Dict
 from src.agents.swap.storage import SwapStateRepository
 from src.agents.dca.storage import DcaStateRepository
 from src.agents.lending.storage import LendingStateRepository
+from src.agents.staking.storage import StakingStateRepository
 
 
 class Metadata:
@@ -13,6 +14,7 @@ class Metadata:
         self._swap_repo = SwapStateRepository.instance()
         self._dca_repo = DcaStateRepository.instance()
         self._lending_repo = LendingStateRepository.instance()
+        self._staking_repo = StakingStateRepository.instance()
 
     def get_crypto_data_agent(self):
         return self.crypto_data_agent
@@ -126,5 +128,42 @@ class Metadata:
         except ValueError:
             return []
 
+    def get_staking_agent(self, user_id: str | None = None, conversation_id: str | None = None):
+        try:
+            return self._staking_repo.get_metadata(user_id, conversation_id)
+        except ValueError:
+            return {}
+
+    def set_staking_agent(
+        self,
+        staking_agent: Dict[str, Any] | None,
+        user_id: str | None = None,
+        conversation_id: str | None = None,
+    ):
+        try:
+            if staking_agent:
+                self._staking_repo.set_metadata(user_id, conversation_id, staking_agent)
+            else:
+                self._staking_repo.clear_metadata(user_id, conversation_id)
+        except ValueError:
+            return
+
+    def clear_staking_agent(self, user_id: str | None = None, conversation_id: str | None = None) -> None:
+        try:
+            self._staking_repo.clear_metadata(user_id, conversation_id)
+        except ValueError:
+            return
+
+    def get_staking_history(
+        self,
+        user_id: str | None = None,
+        conversation_id: str | None = None,
+        limit: int | None = None,
+    ):
+        try:
+            return self._staking_repo.get_history(user_id, conversation_id, limit)
+        except ValueError:
+            return []
+
 
 metadata = Metadata()

src/agents/staking/__init__.py

@@ -0,0 +1 @@
+"""Staking agent for Lido on Ethereum."""

src/agents/staking/agent.py

@@ -0,0 +1,16 @@
+import logging
+from src.agents.staking.tools import get_tools
+from langgraph.prebuilt import create_react_agent
+
+logger = logging.getLogger(__name__)
+
+
+class StakingAgent:
+    """Agent for handling staking operations (stake ETH, unstake stETH) via Lido on Ethereum."""
+    def __init__(self, llm):
+        self.llm = llm
+        self.agent = create_react_agent(
+            model=llm,
+            tools=get_tools(),
+            name="staking_agent"
+        )

src/agents/staking/config.py

@@ -0,0 +1,92 @@
+"""Configuration for the Staking Agent (Lido on Ethereum)."""
+from typing import List
+
+
+class StakingConfig:
+    """Static configuration for Lido staking on Ethereum Mainnet."""
+
+    # Fixed network - Lido staking is only on Ethereum Mainnet
+    NETWORK = "ethereum"
+    CHAIN_ID = 1
+    PROTOCOL = "lido"
+
+    # Supported actions
+    SUPPORTED_ACTIONS = ["stake", "unstake"]
+
+    # Token addresses on Ethereum Mainnet
+    ETH_ADDRESS = "0x0000000000000000000000000000000000000000"
+    STETH_ADDRESS = "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84"
+    WSTETH_ADDRESS = "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0"
+
+    # Token configuration
+    TOKENS = {
+        "ETH": {
+            "symbol": "ETH",
+            "address": ETH_ADDRESS,
+            "decimals": 18,
+        },
+        "stETH": {
+            "symbol": "stETH",
+            "address": STETH_ADDRESS,
+            "decimals": 18,
+        },
+        "wstETH": {
+            "symbol": "wstETH",
+            "address": WSTETH_ADDRESS,
+            "decimals": 18,
+        },
+    }
+
+    # Minimum amounts (in ETH)
+    MIN_STAKE_AMOUNT = "0.0001"
+    MIN_UNSTAKE_AMOUNT = "0.0001"
+
+    @classmethod
+    def get_network(cls) -> str:
+        return cls.NETWORK
+
+    @classmethod
+    def get_chain_id(cls) -> int:
+        return cls.CHAIN_ID
+
+    @classmethod
+    def get_protocol(cls) -> str:
+        return cls.PROTOCOL
+
+    @classmethod
+    def list_actions(cls) -> List[str]:
+        return cls.SUPPORTED_ACTIONS
+
+    @classmethod
+    def validate_action(cls, action: str) -> str:
+        act = action.lower().strip()
+        if act not in cls.SUPPORTED_ACTIONS:
+            raise ValueError(f"Action '{action}' is not supported. Supported: {cls.SUPPORTED_ACTIONS}")
+        return act
+
+    @classmethod
+    def get_input_token(cls, action: str) -> str:
+        """Get the input token based on action."""
+        if action == "stake":
+            return "ETH"
+        return "stETH"
+
+    @classmethod
+    def get_output_token(cls, action: str) -> str:
+        """Get the output token based on action."""
+        if action == "stake":
+            return "stETH"
+        return "ETH"
+
+    @classmethod
+    def get_token_decimals(cls, token: str) -> int:
+        token_info = cls.TOKENS.get(token.upper()) or cls.TOKENS.get(token)
+        if token_info:
+            return token_info.get("decimals", 18)
+        return 18
+
+    @classmethod
+    def get_min_amount(cls, action: str) -> str:
+        if action == "stake":
+            return cls.MIN_STAKE_AMOUNT
+        return cls.MIN_UNSTAKE_AMOUNT

src/agents/staking/intent.py

@@ -0,0 +1,122 @@
+"""Staking intent definition and validation."""
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from decimal import Decimal, InvalidOperation
+from typing import Any, Dict, List, Optional
+
+from src.agents.staking.config import StakingConfig
+
+
+def _format_decimal(value: Decimal) -> str:
+    normalized = value.normalize()
+    exponent = normalized.as_tuple().exponent
+    if exponent > 0:
+        normalized = normalized.quantize(Decimal(1))
+    text = format(normalized, "f")
+    if "." in text:
+        text = text.rstrip("0").rstrip(".")
+    return text
+
+
+def _to_decimal(value: Any) -> Optional[Decimal]:
+    if value is None:
+        return None
+    try:
+        return Decimal(str(value))
+    except (InvalidOperation, TypeError, ValueError):
+        return None
+
+
+@dataclass
+class StakingIntent:
+    user_id: str
+    conversation_id: str
+    action: Optional[str] = None  # stake or unstake
+    amount: Optional[Decimal] = None
+    updated_at: float = field(default_factory=lambda: time.time())
+
+    # Fixed values for Lido on Ethereum
+    network: str = field(default_factory=lambda: StakingConfig.NETWORK)
+    protocol: str = field(default_factory=lambda: StakingConfig.PROTOCOL)
+    chain_id: int = field(default_factory=lambda: StakingConfig.CHAIN_ID)
+
+    def touch(self) -> None:
+        self.updated_at = time.time()
+
+    def is_complete(self) -> bool:
+        return all([
+            self.action,
+            self.amount is not None,
+        ])
+
+    def missing_fields(self) -> List[str]:
+        fields: List[str] = []
+        if not self.action:
+            fields.append("action")
+        if self.amount is None:
+            fields.append("amount")
+        return fields
+
+    def amount_as_str(self) -> Optional[str]:
+        if self.amount is None:
+            return None
+        return _format_decimal(self.amount)
+
+    def get_input_token(self) -> str:
+        """Get the token being sent based on action."""
+        if self.action == "stake":
+            return "ETH"
+        return "stETH"
+
+    def get_output_token(self) -> str:
+        """Get the token being received based on action."""
+        if self.action == "stake":
+            return "stETH"
+        return "ETH"
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "user_id": self.user_id,
+            "conversation_id": self.conversation_id,
+            "action": self.action,
+            "amount": self.amount_as_str(),
+            "network": self.network,
+            "protocol": self.protocol,
+            "chain_id": self.chain_id,
+            "input_token": self.get_input_token() if self.action else None,
+            "output_token": self.get_output_token() if self.action else None,
+            "updated_at": self.updated_at,
+        }
+
+    def to_public(self) -> Dict[str, Optional[str]]:
+        public = self.to_dict()
+        public["amount"] = self.amount_as_str()
+        return public
+
+    def to_summary(self, status: str, error: Optional[str] = None) -> Dict[str, Any]:
+        summary: Dict[str, Any] = {
+            "status": status,
+            "action": self.action,
+            "amount": self.amount_as_str(),
+            "network": self.network,
+            "protocol": self.protocol,
+            "input_token": self.get_input_token() if self.action else None,
+            "output_token": self.get_output_token() if self.action else None,
+        }
+        if error:
+            summary["error"] = error
+        return summary
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "StakingIntent":
+        amount = _to_decimal(data.get("amount"))
+        intent = cls(
+            user_id=(data.get("user_id") or "").strip(),
+            conversation_id=(data.get("conversation_id") or "").strip(),
+            action=data.get("action"),
+            amount=amount,
+        )
+        intent.updated_at = float(data.get("updated_at", time.time()))
+        return intent

src/agents/staking/prompt.py

@@ -0,0 +1,51 @@
+"""System prompt for the specialized staking agent."""
+
+STAKING_AGENT_SYSTEM_PROMPT = """
+You are Zico's staking orchestrator for Lido on Ethereum.
+Your goal is to help the user stake ETH to earn rewards (receiving stETH) or unstake stETH back to ETH.
+
+Always respond in English, regardless of the user's language.
+
+# Protocol Information
+- Protocol: Lido (liquid staking)
+- Network: Ethereum Mainnet
+- Stake: ETH -> stETH (start earning rewards)
+- Unstake: stETH -> ETH (stop earning rewards)
+
+# Responsibilities
+1. Collect all staking intent fields (`action`, `amount`) by invoking the `update_staking_intent` tool.
+2. If the tool returns a question (`ask`), present it to the user clearly.
+3. If the tool returns an error, explain it and ask for correction.
+4. Only confirm that the intent is ready once the tool reports `event == "staking_intent_ready"`.
+
+# Rules
+- ALWAYS call `update_staking_intent` when the user provides new staking information.
+- Do NOT ask for all fields at once if the user only provided some. Let the tool guide the flow.
+- When the intent is ready, summarize the operation and confirm it's ready for execution.
+- Use `get_staking_info` if the user asks about how staking works or wants more information.
+
+# Examples
+
+Example 1 - User wants to stake:
+User: I want to stake some ETH
+Assistant: (call `update_staking_intent` with `action="stake"`)
+Tool: `ask` -> "How much ETH do you want to stake?"
+Assistant: "Sure! How much ETH would you like to stake?"
+
+User: 2 ETH
+Assistant: (call `update_staking_intent` with `amount=2`)
+Tool: `event` -> `staking_intent_ready`
+Assistant: "All set! Ready to stake 2 ETH on Lido. You will receive stETH in return and start earning staking rewards."
+
+Example 2 - User wants to unstake:
+User: I want to unstake 1.5 stETH
+Assistant: (call `update_staking_intent` with `action="unstake"`, `amount=1.5`)
+Tool: `event` -> `staking_intent_ready`
+Assistant: "All set! Ready to unstake 1.5 stETH. You will receive ETH in return."
+
+Example 3 - User asks about staking:
+User: How does staking work?
+Assistant: (call `get_staking_info`)
+Tool: Returns staking information
+Assistant: "Lido is a liquid staking solution for Ethereum. When you stake ETH, you receive stETH which automatically accrues staking rewards. You can unstake anytime to convert your stETH back to ETH. Would you like to stake or unstake?"
+"""

src/agents/staking/storage.py

@@ -0,0 +1,411 @@
+"""Gateway-backed storage for staking intents with local fallback."""
+from __future__ import annotations
+
+import copy
+import time
+import logging
+from datetime import datetime, timezone
+from threading import Lock
+from typing import Any, Dict, List, Optional
+
+from src.integrations.panorama_gateway import (
+    PanoramaGatewayClient,
+    PanoramaGatewayError,
+    PanoramaGatewaySettings,
+    get_panorama_settings,
+)
+
+STAKING_SESSION_ENTITY = "staking-sessions"
+STAKING_HISTORY_ENTITY = "staking-histories"
+
+
+def _utc_now_iso() -> str:
+    return datetime.utcnow().replace(tzinfo=timezone.utc).isoformat()
+
+
+def _identifier(user_id: str, conversation_id: str) -> str:
+    return f"{user_id}:{conversation_id}"
+
+
+def _as_float(value: Any) -> Optional[float]:
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+class StakingStateRepository:
+    """Stores staking agent state via Panorama's gateway or an in-memory fallback."""
+
+    _instance: "StakingStateRepository" | None = None
+    _instance_lock: Lock = Lock()
+
+    def __init__(
+        self,
+        *,
+        client: PanoramaGatewayClient | None = None,
+        settings: PanoramaGatewaySettings | None = None,
+        history_limit: int = 10,
+    ) -> None:
+        self._logger = logging.getLogger(__name__)
+        self._history_limit = history_limit
+        try:
+            self._settings = settings or get_panorama_settings()
+            self._client = client or PanoramaGatewayClient(self._settings)
+            self._use_gateway = True
+        except ValueError:
+            # PANORAMA_GATEWAY_URL or JWT secrets not configured - fall back to local store.
+            self._settings = None
+            self._client = None
+            self._use_gateway = False
+        self._init_local_store()
+
+    def _init_local_store(self) -> None:
+        if not hasattr(self, "_state"):
+            self._state = {"intents": {}, "metadata": {}, "history": {}}
+
+    def _tenant_id(self) -> str:
+        return self._settings.tenant_id if self._settings else "tenant-agent"
+
+    def _fallback_to_local_store(self) -> None:
+        if self._use_gateway:
+            self._logger.warning("Panorama gateway unavailable for staking state; switching to in-memory fallback.")
+        self._use_gateway = False
+        self._init_local_store()
+
+    def _handle_gateway_failure(self, exc: PanoramaGatewayError) -> None:
+        self._logger.warning(
+            "Panorama gateway error (%s) for staking repository: %s",
+            getattr(exc, "status_code", "unknown"),
+            getattr(exc, "payload", exc),
+        )
+        self._fallback_to_local_store()
+
+    # ---- Singleton helpers -----------------------------------------------
+    @classmethod
+    def instance(cls) -> "StakingStateRepository":
+        if cls._instance is None:
+            with cls._instance_lock:
+                if cls._instance is None:
+                    cls._instance = cls()
+        return cls._instance
+
+    @classmethod
+    def reset(cls) -> None:
+        with cls._instance_lock:
+            cls._instance = None
+
+    # ---- Core API ---------------------------------------------------------
+    def load_intent(self, user_id: str, conversation_id: str) -> Optional[Dict[str, Any]]:
+        if not self._use_gateway:
+            self._init_local_store()
+            record = self._state["intents"].get(_identifier(user_id, conversation_id))
+            if not record:
+                return None
+            return copy.deepcopy(record.get("intent"))
+
+        session = self._get_session(user_id, conversation_id)
+        if not self._use_gateway:
+            return self.load_intent(user_id, conversation_id)
+        if not session:
+            return None
+        return session.get("intent") or None
+
+    def persist_intent(
+        self,
+        user_id: str,
+        conversation_id: str,
+        intent: Dict[str, Any],
+        metadata: Dict[str, Any],
+        done: bool,
+        summary: Optional[Dict[str, Any]] = None,
+    ) -> List[Dict[str, Any]]:
+        if not self._use_gateway:
+            self._init_local_store()
+            key = _identifier(user_id, conversation_id)
+            now = time.time()
+            if done:
+                self._state["intents"].pop(key, None)
+            else:
+                self._state["intents"][key] = {"intent": copy.deepcopy(intent), "updated_at": now}
+            if metadata:
+                meta_copy = copy.deepcopy(metadata)
+                meta_copy["updated_at"] = now
+                self._state["metadata"][key] = meta_copy
+            if done and summary:
+                history = self._state["history"].setdefault(key, [])
+                summary_copy = copy.deepcopy(summary)
+                summary_copy.setdefault("timestamp", now)
+                history.append(summary_copy)
+                self._state["history"][key] = history[-self._history_limit:]
+            return self.get_history(user_id, conversation_id)
+
+        try:
+            if done:
+                if summary:
+                    self._create_history_entry(user_id, conversation_id, summary)
+                self._delete_session(user_id, conversation_id)
+            else:
+                payload = self._session_payload(intent, metadata)
+                self._upsert_session(user_id, conversation_id, payload)
+            return self.get_history(user_id, conversation_id)
+        except PanoramaGatewayError as exc:
+            self._handle_gateway_failure(exc)
+            return self.persist_intent(user_id, conversation_id, intent, metadata, done, summary)
+
+    def set_metadata(
+        self,
+        user_id: str,
+        conversation_id: str,
+        metadata: Dict[str, Any],
+    ) -> None:
+        if not self._use_gateway:
+            self._init_local_store()
+            key = _identifier(user_id, conversation_id)
+            if metadata:
+                meta_copy = copy.deepcopy(metadata)
+                meta_copy["updated_at"] = time.time()
+                self._state["metadata"][key] = meta_copy
+            else:
+                self._state["metadata"].pop(key, None)
+            return
+
+        try:
+            if not metadata:
+                self._delete_session(user_id, conversation_id)
+                return
+
+            session = self._get_session(user_id, conversation_id)
+            if not self._use_gateway:
+                return self.set_metadata(user_id, conversation_id, metadata)
+            intent = session.get("intent") if session else {}
+            payload = self._session_payload(intent or {}, metadata)
+            self._upsert_session(user_id, conversation_id, payload)
+        except PanoramaGatewayError as exc:
+            self._handle_gateway_failure(exc)
+            self.set_metadata(user_id, conversation_id, metadata)
+
+    def clear_metadata(self, user_id: str, conversation_id: str) -> None:
+        self.set_metadata(user_id, conversation_id, {})
+
+    def clear_intent(self, user_id: str, conversation_id: str) -> None:
+        if not self._use_gateway:
+            self._init_local_store()
+            self._state["intents"].pop(_identifier(user_id, conversation_id), None)
+            self._state["metadata"].pop(_identifier(user_id, conversation_id), None)
+            return
+        try:
+            self._delete_session(user_id, conversation_id)
+        except PanoramaGatewayError as exc:
+            self._handle_gateway_failure(exc)
+            self.clear_intent(user_id, conversation_id)
+
+    def get_metadata(self, user_id: str, conversation_id: str) -> Dict[str, Any]:
+        if not self._use_gateway:
+            self._init_local_store()
+            record = self._state["metadata"].get(_identifier(user_id, conversation_id))
+            if not record:
+                return {}
+            entry = copy.deepcopy(record)
+            ts = entry.pop("updated_at", None)
+            if ts is not None:
+                entry["updated_at"] = datetime.fromtimestamp(float(ts), tz=timezone.utc).isoformat()
+            return entry
+
+        session = self._get_session(user_id, conversation_id)
+        if not self._use_gateway:
+            return self.get_metadata(user_id, conversation_id)
+        if not session:
+            return {}
+
+        intent = session.get("intent") or {}
+        metadata: Dict[str, Any] = {
+            "event": session.get("event"),
+            "status": session.get("status"),
+            "missing_fields": session.get("missingFields") or [],
+            "next_field": session.get("nextField"),
+            "pending_question": session.get("pendingQuestion"),
+            "choices": session.get("choices") or [],
+            "error": session.get("errorMessage"),
+            "user_id": user_id,
+            "conversation_id": conversation_id,
+        }
+        metadata["action"] = intent.get("action")
+        metadata["amount"] = intent.get("amount")
+        metadata["network"] = intent.get("network")
+        metadata["protocol"] = intent.get("protocol")
+        metadata["input_token"] = intent.get("input_token")
+        metadata["output_token"] = intent.get("output_token")
+
+        history = self.get_history(user_id, conversation_id)
+        if history:
+            metadata["history"] = history
+
+        updated_at = session.get("updatedAt")
+        if updated_at:
+            metadata["updated_at"] = updated_at
+
+        return metadata
+
+    def get_history(
+        self,
+        user_id: str,
+        conversation_id: str,
+        limit: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
+        if not self._use_gateway:
+            key = _identifier(user_id, conversation_id)
+            history = self._state["history"].get(key, [])
+            effective = limit or self._history_limit
+            result: List[Dict[str, Any]] = []
+            for item in sorted(history, key=lambda entry: entry.get("timestamp", 0), reverse=True)[:effective]:
+                entry = copy.deepcopy(item)
+                ts = entry.get("timestamp")
+                if ts is not None:
+                    entry["timestamp"] = datetime.fromtimestamp(float(ts), tz=timezone.utc).isoformat()
+                result.append(entry)
+            return result
+
+        effective_limit = limit or self._history_limit
+        try:
+            result = self._client.list(
+                STAKING_HISTORY_ENTITY,
+                {
+                    "where": {"userId": user_id, "conversationId": conversation_id},
+                    "orderBy": {"recordedAt": "desc"},
+                    "take": effective_limit,
+                },
+            )
+        except PanoramaGatewayError as exc:
+            if exc.status_code == 404:
+                return []
+            self._handle_gateway_failure(exc)
+            return self.get_history(user_id, conversation_id, limit)
+        except ValueError:
+            self._logger.warning("Invalid staking history response from gateway; falling back to local store.")
+            self._fallback_to_local_store()
+            return self.get_history(user_id, conversation_id, limit)
+        data = result.get("data", []) if isinstance(result, dict) else []
+        history: List[Dict[str, Any]] = []
+        for entry in data:
+            history.append(
+                {
+                    "status": entry.get("status"),
+                    "action": entry.get("action"),
+                    "amount": entry.get("amount"),
+                    "network": entry.get("network"),
+                    "protocol": entry.get("protocol"),
+                    "input_token": entry.get("inputToken"),
+                    "output_token": entry.get("outputToken"),
+                    "error": entry.get("errorMessage"),
+                    "timestamp": entry.get("recordedAt"),
+                }
+            )
+        return history
+
+    # ---- Gateway helpers --------------------------------------------------
+    def _get_session(self, user_id: str, conversation_id: str) -> Optional[Dict[str, Any]]:
+        identifier = _identifier(user_id, conversation_id)
+        try:
+            return self._client.get(STAKING_SESSION_ENTITY, identifier)
+        except PanoramaGatewayError as exc:
+            if exc.status_code == 404:
+                return None
+            self._handle_gateway_failure(exc)
+            return None
+
+    def _delete_session(self, user_id: str, conversation_id: str) -> None:
+        identifier = _identifier(user_id, conversation_id)
+        try:
+            self._client.delete(STAKING_SESSION_ENTITY, identifier)
+        except PanoramaGatewayError as exc:
+            if exc.status_code != 404:
+                self._handle_gateway_failure(exc)
+                raise
+
+    def _upsert_session(
+        self,
+        user_id: str,
+        conversation_id: str,
+        data: Dict[str, Any],
+    ) -> None:
+        identifier = _identifier(user_id, conversation_id)
+        payload = {**data, "updatedAt": _utc_now_iso()}
+        try:
+            self._client.update(STAKING_SESSION_ENTITY, identifier, payload)
+        except PanoramaGatewayError as exc:
+            if exc.status_code != 404:
+                self._handle_gateway_failure(exc)
+                raise
+            create_payload = {
+                "userId": user_id,
+                "conversationId": conversation_id,
+                "tenantId": self._tenant_id(),
+                **payload,
+            }
+            try:
+                self._client.create(STAKING_SESSION_ENTITY, create_payload)
+            except PanoramaGatewayError as create_exc:
+                if create_exc.status_code == 409:
+                    return
+                if create_exc.status_code == 404:
+                    self._handle_gateway_failure(create_exc)
+                    raise
+                self._handle_gateway_failure(create_exc)
+                raise
+
+    def _create_history_entry(
+        self,
+        user_id: str,
+        conversation_id: str,
+        summary: Dict[str, Any],
+    ) -> None:
+        history_payload = {
+            "userId": user_id,
+            "conversationId": conversation_id,
+            "status": summary.get("status"),
+            "action": summary.get("action"),
+            "amount": _as_float(summary.get("amount")),
+            "network": summary.get("network"),
+            "protocol": summary.get("protocol"),
+            "inputToken": summary.get("input_token"),
+            "outputToken": summary.get("output_token"),
+            "errorMessage": summary.get("error"),
+            "recordedAt": _utc_now_iso(),
+            "tenantId": self._tenant_id(),
+        }
+        if self._logger.isEnabledFor(logging.DEBUG):
+            self._logger.debug(
+                "Persisting staking history for user=%s conversation=%s payload=%s",
+                user_id,
+                conversation_id,
+                history_payload,
+            )
+        try:
+            self._client.create(STAKING_HISTORY_ENTITY, history_payload)
+        except PanoramaGatewayError as exc:
+            if exc.status_code == 404:
+                self._handle_gateway_failure(exc)
+                raise
+            elif exc.status_code != 409:
+                self._handle_gateway_failure(exc)
+                raise
+
+    @staticmethod
+    def _session_payload(intent: Dict[str, Any], metadata: Dict[str, Any]) -> Dict[str, Any]:
+        missing = metadata.get("missing_fields") or []
+        if not isinstance(missing, list):
+            missing = list(missing)
+        return {
+            "status": metadata.get("status"),
+            "event": metadata.get("event"),
+            "intent": intent,
+            "missingFields": missing,
+            "nextField": metadata.get("next_field"),
+            "pendingQuestion": metadata.get("pending_question"),
+            "choices": metadata.get("choices"),
+            "errorMessage": metadata.get("error"),
+            "historyCursor": metadata.get("history_cursor") or 0,
+        }

src/agents/staking/tools.py

@@ -0,0 +1,354 @@
+"""Staking tools that manage a conversational staking intent for Lido on Ethereum."""
+
+from __future__ import annotations
+
+import logging
+from contextlib import contextmanager
+from contextvars import ContextVar
+from decimal import Decimal, InvalidOperation
+from typing import Any, Dict, List, Optional
+
+from langchain_core.tools import tool
+from pydantic import BaseModel, Field, field_validator
+
+from src.agents.metadata import metadata
+from src.agents.staking.config import StakingConfig
+from src.agents.staking.intent import StakingIntent, _to_decimal
+from src.agents.staking.storage import StakingStateRepository
+
+
+# ---------- Helpers ----------
+_STORE = StakingStateRepository.instance()
+logger = logging.getLogger(__name__)
+
+
+# ---------- Staking session context ----------
+_CURRENT_SESSION: ContextVar[tuple[str, str]] = ContextVar(
+    "_current_staking_session",
+    default=("", ""),
+)
+
+
+def set_current_staking_session(user_id: Optional[str], conversation_id: Optional[str]) -> None:
+    """Store the active staking session for tool calls executed by the agent."""
+
+    resolved_user = (user_id or "").strip()
+    resolved_conversation = (conversation_id or "").strip()
+    if not resolved_user:
+        raise ValueError("staking_agent requires 'user_id' to identify the staking session.")
+    if not resolved_conversation:
+        raise ValueError("staking_agent requires 'conversation_id' to identify the staking session.")
+    _CURRENT_SESSION.set((resolved_user, resolved_conversation))
+
+
+@contextmanager
+def staking_session(user_id: Optional[str], conversation_id: Optional[str]):
+    """Context manager that guarantees session scoping for staking tool calls."""
+
+    set_current_staking_session(user_id, conversation_id)
+    try:
+        yield
+    finally:
+        clear_current_staking_session()
+
+
+def clear_current_staking_session() -> None:
+    """Reset the active staking session after the agent finishes handling a message."""
+
+    _CURRENT_SESSION.set(("", ""))
+
+
+def _resolve_session(user_id: Optional[str], conversation_id: Optional[str]) -> tuple[str, str]:
+    active_user, active_conversation = _CURRENT_SESSION.get()
+    resolved_user = (user_id or active_user or "").strip()
+    resolved_conversation = (conversation_id or active_conversation or "").strip()
+    if not resolved_user:
+        raise ValueError("user_id is required for staking operations.")
+    if not resolved_conversation:
+        raise ValueError("conversation_id is required for staking operations.")
+    return resolved_user, resolved_conversation
+
+
+def _load_intent(user_id: str, conversation_id: str) -> StakingIntent:
+    stored = _STORE.load_intent(user_id, conversation_id)
+    if stored:
+        intent = StakingIntent.from_dict(stored)
+        intent.user_id = user_id
+        intent.conversation_id = conversation_id
+        return intent
+    return StakingIntent(user_id=user_id, conversation_id=conversation_id)
+
+
+# ---------- Pydantic input schema ----------
+class UpdateStakingIntentInput(BaseModel):
+    user_id: Optional[str] = Field(
+        default=None,
+        description="Stable ID for the end user / chat session. Optional if context manager is set.",
+    )
+    conversation_id: Optional[str] = Field(
+        default=None,
+        description="Conversation identifier to scope staking intents within a user.",
+    )
+    action: Optional[str] = Field(
+        default=None,
+        description="The staking action: 'stake' (ETH -> stETH) or 'unstake' (stETH -> ETH)",
+    )
+    amount: Optional[Decimal] = Field(
+        default=None,
+        gt=Decimal("0"),
+        description="The amount to stake or unstake",
+    )
+
+    @field_validator("action", mode="before")
+    @classmethod
+    def _norm_action(cls, value: Optional[str]) -> Optional[str]:
+        return value.lower() if isinstance(value, str) else value
+
+    @field_validator("amount", mode="before")
+    @classmethod
+    def _norm_amount(cls, value):
+        if value is None or isinstance(value, Decimal):
+            return value
+        decimal_value = _to_decimal(value)
+        if decimal_value is None:
+            raise ValueError("Amount must be a number.")
+        return decimal_value
+
+
+# ---------- Validation utilities ----------
+def _validate_action(action: Optional[str]) -> Optional[str]:
+    if action is None:
+        return None
+    return StakingConfig.validate_action(action)
+
+
+def _validate_amount(amount: Optional[Decimal], action: Optional[str]) -> Optional[Decimal]:
+    if amount is None:
+        return None
+    if action is None:
+        raise ValueError("Please specify the action (stake or unstake) before providing an amount.")
+
+    min_amount = Decimal(StakingConfig.get_min_amount(action))
+    if amount < min_amount:
+        input_token = StakingConfig.get_input_token(action)
+        raise ValueError(f"Minimum amount for {action} is {min_amount} {input_token}.")
+
+    return amount
+
+
+# ---------- Output helpers ----------
+def _store_staking_metadata(
+    intent: StakingIntent,
+    ask: Optional[str],
+    done: bool,
+    error: Optional[str],
+    choices: Optional[List[str]] = None,
+) -> Dict[str, Any]:
+    intent.touch()
+    missing = intent.missing_fields()
+    next_field = missing[0] if missing else None
+    meta: Dict[str, Any] = {
+        "event": "staking_intent_ready" if done else "staking_intent_pending",
+        "status": "ready" if done else "collecting",
+        "action": intent.action,
+        "amount": intent.amount_as_str(),
+        "network": intent.network,
+        "protocol": intent.protocol,
+        "chain_id": intent.chain_id,
+        "input_token": intent.get_input_token() if intent.action else None,
+        "output_token": intent.get_output_token() if intent.action else None,
+        "user_id": intent.user_id,
+        "conversation_id": intent.conversation_id,
+        "missing_fields": missing,
+        "next_field": next_field,
+        "pending_question": ask,
+        "choices": list(choices or []),
+        "error": error,
+    }
+    summary = intent.to_summary("ready" if done else "collecting", error=error) if done else None
+    history = _STORE.persist_intent(
+        intent.user_id,
+        intent.conversation_id,
+        intent.to_dict(),
+        meta,
+        done=done,
+        summary=summary,
+    )
+    if history:
+        meta["history"] = history
+    metadata.set_staking_agent(meta, intent.user_id, intent.conversation_id)
+    if logger.isEnabledFor(logging.DEBUG):
+        logger.debug(
+            "Staking metadata stored for user=%s conversation=%s done=%s error=%s meta=%s",
+            intent.user_id,
+            intent.conversation_id,
+            done,
+            error,
+            meta,
+        )
+    return meta
+
+
+def _build_next_action(meta: Dict[str, Any]) -> Dict[str, Any]:
+    if meta.get("status") == "ready":
+        return {
+            "type": "complete",
+            "prompt": None,
+            "field": None,
+            "choices": [],
+        }
+    return {
+        "type": "collect_field",
+        "prompt": meta.get("pending_question"),
+        "field": meta.get("next_field"),
+        "choices": meta.get("choices", []),
+    }
+
+
+def _response(
+    intent: StakingIntent,
+    ask: Optional[str],
+    choices: Optional[List[str]] = None,
+    done: bool = False,
+    error: Optional[str] = None,
+) -> Dict[str, Any]:
+    meta = _store_staking_metadata(intent, ask, done, error, choices)
+
+    payload: Dict[str, Any] = {
+        "event": meta.get("event"),
+        "intent": intent.to_public(),
+        "ask": ask,
+        "choices": choices or [],
+        "error": error,
+        "next_action": _build_next_action(meta),
+        "history": meta.get("history", []),
+    }
+
+    if done:
+        payload["metadata"] = {
+            key: meta.get(key)
+            for key in (
+                "event",
+                "status",
+                "action",
+                "amount",
+                "network",
+                "protocol",
+                "chain_id",
+                "input_token",
+                "output_token",
+                "user_id",
+                "conversation_id",
+                "history",
+            )
+            if meta.get(key) is not None
+        }
+    return payload
+
+
+# ---------- Core tool ----------
+@tool("update_staking_intent", args_schema=UpdateStakingIntentInput)
+def update_staking_intent_tool(
+    user_id: Optional[str] = None,
+    conversation_id: Optional[str] = None,
+    action: Optional[str] = None,
+    amount: Optional[Decimal] = None,
+):
+    """Update the staking intent and surface the next question or final metadata.
+
+    Call this tool whenever the user provides new staking details. Supply only the
+    fields that were mentioned in the latest message (leave the others as None)
+    and keep calling it until the response event becomes 'staking_intent_ready'.
+
+    Staking is done via Lido protocol on Ethereum Mainnet:
+    - stake: Convert ETH to stETH and start earning rewards
+    - unstake: Convert stETH back to ETH
+    """
+
+    resolved_user, resolved_conversation = _resolve_session(user_id, conversation_id)
+    intent = _load_intent(resolved_user, resolved_conversation)
+    intent.user_id = resolved_user
+    intent.conversation_id = resolved_conversation
+
+    try:
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug(
+                "update_staking_intent_tool input user=%s conversation=%s action=%s amount=%s",
+                user_id,
+                conversation_id,
+                action,
+                amount,
+            )
+
+        if action is not None:
+            intent.action = _validate_action(action)
+
+        if intent.action is None:
+            return _response(
+                intent,
+                "What would you like to do? Stake ETH to earn rewards, or unstake stETH back to ETH?",
+                StakingConfig.SUPPORTED_ACTIONS,
+            )
+
+        if amount is not None:
+            intent.amount = _validate_amount(amount, intent.action)
+
+        if intent.amount is None:
+            input_token = intent.get_input_token()
+            return _response(intent, f"How much {input_token} do you want to {intent.action}?")
+
+    except ValueError as exc:
+        message = str(exc)
+        if logger.isEnabledFor(logging.INFO):
+            logger.info(
+                "Staking intent validation issue for user=%s conversation=%s: %s",
+                intent.user_id,
+                intent.conversation_id,
+                message,
+            )
+        return _response(intent, "Please correct the input.", error=message)
+    except Exception as exc:
+        logger.exception(
+            "Unexpected error updating staking intent for user=%s conversation=%s",
+            intent.user_id,
+            intent.conversation_id,
+        )
+        return _response(intent, "Please try again with the staking details.", error=str(exc))
+
+    response = _response(intent, ask=None, done=True)
+    return response
+
+
+@tool("get_staking_info")
+def get_staking_info_tool():
+    """Get information about the staking service (Lido on Ethereum).
+
+    Returns details about the supported staking protocol, network, and tokens.
+    """
+    return {
+        "protocol": StakingConfig.PROTOCOL,
+        "network": StakingConfig.NETWORK,
+        "chain_id": StakingConfig.CHAIN_ID,
+        "supported_actions": StakingConfig.SUPPORTED_ACTIONS,
+        "tokens": {
+            "stake": {
+                "input": "ETH",
+                "output": "stETH",
+                "description": "Stake ETH to receive stETH and earn rewards",
+            },
+            "unstake": {
+                "input": "stETH",
+                "output": "ETH",
+                "description": "Unstake stETH to receive ETH back",
+            },
+        },
+        "min_amounts": {
+            "stake": StakingConfig.MIN_STAKE_AMOUNT,
+            "unstake": StakingConfig.MIN_UNSTAKE_AMOUNT,
+        },
+        "info": "Lido is a liquid staking solution for Ethereum. When you stake ETH, you receive stETH which accrues staking rewards automatically.",
+    }
+
+
+def get_tools():
+    return [update_staking_intent_tool, get_staking_info_tool]

src/agents/supervisor/agent.py

@@ -23,6 +23,9 @@ from src.agents.lending.agent import LendingAgent
 from src.agents.lending.tools import lending_session
 from src.agents.lending.prompt import LENDING_AGENT_SYSTEM_PROMPT
 from src.agents.lending.config import LendingConfig
+from src.agents.staking.agent import StakingAgent
+from src.agents.staking.tools import staking_session
+from src.agents.staking.prompt import STAKING_AGENT_SYSTEM_PROMPT
 from src.agents.search.agent import SearchAgent
 from src.agents.database.client import is_database_available
 
@@ -86,6 +89,13 @@ class Supervisor:
             "- lending_agent: Handles lending operations (supply, borrow, repay, withdraw) on DeFi protocols like Aave.\n"
         )
 
+        stakingAgent = StakingAgent(llm)
+        self.staking_agent = stakingAgent.agent
+        agents.append(self.staking_agent)
+        available_agents_text += (
+            "- staking_agent: Handles staking operations (stake ETH, unstake stETH) via Lido on Ethereum.\n"
+        )
+
         searchAgent = SearchAgent(llm)
         self.search_agent = searchAgent.agent
         agents.append(self.search_agent)
@@ -98,8 +108,8 @@ class Supervisor:
         agents.append(self.default_agent)
 
         # Track known agent names for response extraction
-        self.known_agent_names = {"crypto_agent", "database_agent", "swap_agent", "dca_agent", "lending_agent", "search_agent", "default_agent"}
-        self.specialized_agents = {"crypto_agent", "database_agent", "swap_agent", "dca_agent", "lending_agent", "search_agent"}
+        self.known_agent_names = {"crypto_agent", "database_agent", "swap_agent", "dca_agent", "lending_agent", "staking_agent", "search_agent", "default_agent"}
+        self.specialized_agents = {"crypto_agent", "database_agent", "swap_agent", "dca_agent", "lending_agent", "staking_agent", "search_agent"}
         self.failure_markers = (
             "cannot fulfill",
             "can't fulfill",
@@ -211,6 +221,13 @@ Examples of lending queries to delegate:
 - I want to make a supply of 100 USDC
 - Withdraw my WETH from the lending protocol
 
+Examples of staking queries to delegate:
+- I want to stake ETH
+- I want to stake 2 ETH on Lido
+- Help me unstake my stETH
+- I want to earn staking rewards
+- Convert my ETH to stETH
+
 When a swap conversation is already underway (the user is still providing swap
 details or the swap_agent requested follow-up information), keep routing those
 messages to the swap_agent until it has gathered every field and signals the
@@ -220,6 +237,8 @@ When a DCA conversation is already underway (the user is reviewing strategy reco
 
 When a lending conversation is already underway (the user is providing lending details like asset, amount, network), keep routing messages to the lending_agent until the lending intent is ready or cancelled.
 
+When a staking conversation is already underway (the user is providing staking details like action or amount), keep routing messages to the staking_agent until the staking intent is ready or cancelled.
+
 {database_examples}
 
 {search_examples}
@@ -404,6 +423,25 @@ Examples of general queries to handle directly:
         agent, text, messages_out = self._extract_response_from_graph(response)
         return agent, text, messages_out
 
+    def _invoke_staking_agent(self, langchain_messages):
+        scoped_messages = [SystemMessage(content=STAKING_AGENT_SYSTEM_PROMPT)]
+        scoped_messages.extend(langchain_messages)
+        try:
+            with staking_session(
+                user_id=self._active_user_id,
+                conversation_id=self._active_conversation_id,
+            ):
+                response = self.staking_agent.invoke({"messages": scoped_messages})
+        except Exception as exc:
+            print(f"Error invoking staking agent directly: {exc}")
+            return None
+
+        if not response:
+            return None
+
+        agent, text, messages_out = self._extract_response_from_graph(response)
+        return agent, text, messages_out
+
     def _extract_response_from_graph(self, response: Any) -> Tuple[str, str, list]:
         messages_out = response.get("messages", []) if isinstance(response, dict) else []
         final_response = None
@@ -582,6 +620,22 @@ Examples of general queries to handle directly:
                 else:
                     lending_meta = lending_meta.copy()
             return lending_meta if lending_meta else {}
+        if agent_name == "staking_agent":
+            staking_meta = metadata.get_staking_agent(
+                user_id=self._active_user_id,
+                conversation_id=self._active_conversation_id,
+            )
+            if staking_meta:
+                history = metadata.get_staking_history(
+                    user_id=self._active_user_id,
+                    conversation_id=self._active_conversation_id,
+                )
+                if history:
+                    staking_meta = staking_meta.copy()
+                    staking_meta.setdefault("history", history)
+                else:
+                    staking_meta = staking_meta.copy()
+            return staking_meta if staking_meta else {}
         if agent_name == "crypto_agent":
             tool_meta = self._collect_tool_metadata(messages_out)
             if tool_meta:
@@ -680,6 +734,31 @@ Examples of general queries to handle directly:
             return True
         return False
 
+    def _is_staking_like_request(self, messages: List[ChatMessage]) -> bool:
+        for msg in reversed(messages):
+            if msg.get("role") != "user":
+                continue
+            content = (msg.get("content") or "").strip()
+            if not content:
+                continue
+            lowered = content.lower()
+            staking_keywords = (
+                "stake",
+                "staking",
+                "unstake",
+                "unstaking",
+                "steth",
+                "lido",
+                "liquid staking",
+                "staking rewards",
+                "eth staking",
+            )
+            if not any(keyword in lowered for keyword in staking_keywords):
+                return False
+            # Default to True if the user explicitly mentioned staking-related keywords
+            return True
+        return False
+
     def invoke(
         self,
         messages: List[ChatMessage],
@@ -707,8 +786,24 @@ Examples of general queries to handle directly:
         dca_state = metadata.get_dca_agent(user_id=user_id, conversation_id=conversation_id)
         swap_state = metadata.get_swap_agent(user_id=user_id, conversation_id=conversation_id)
         lending_state = metadata.get_lending_agent(user_id=user_id, conversation_id=conversation_id)
+        staking_state = metadata.get_staking_agent(user_id=user_id, conversation_id=conversation_id)
 
-        # Check for new lending request first
+        # Check for new staking request first
+        if not staking_state and self._is_staking_like_request(messages):
+            staking_result = self._invoke_staking_agent(langchain_messages)
+            if staking_result:
+                final_agent, cleaned_response, messages_out = staking_result
+                meta = self._build_metadata(final_agent, messages_out)
+                self._active_user_id = None
+                self._active_conversation_id = None
+                return {
+                    "messages": messages_out,
+                    "agent": final_agent,
+                    "response": cleaned_response or "Sorry, no meaningful response was returned.",
+                    "metadata": meta,
+                }
+
+        # Check for new lending request
         if not lending_state and self._is_lending_like_request(messages):
             lending_result = self._invoke_lending_agent(langchain_messages)
             if lending_result:
@@ -848,12 +943,41 @@ Examples of general queries to handle directly:
             guidance_text = " ".join(guidance_parts)
             langchain_messages.insert(0, SystemMessage(content=guidance_text))
 
+        # Handle in-progress staking flow
+        if staking_state and staking_state.get("status") == "collecting":
+            staking_result = self._invoke_staking_agent(langchain_messages)
+            if staking_result:
+                final_agent, cleaned_response, messages_out = staking_result
+                meta = self._build_metadata(final_agent, messages_out)
+                self._active_user_id = None
+                self._active_conversation_id = None
+                return {
+                    "messages": messages_out,
+                    "agent": final_agent,
+                    "response": cleaned_response or "Sorry, no meaningful response was returned.",
+                    "metadata": meta,
+                }
+            # If direct staking invocation failed, fall through to supervisor graph with hints
+            next_field = staking_state.get("next_field")
+            pending_question = staking_state.get("pending_question")
+            guidance_parts = [
+                "There is an in-progress staking intent for this conversation.",
+                "Keep routing messages to the staking_agent until the intent is complete unless the user explicitly cancels or changes topic.",
+            ]
+            if next_field:
+                guidance_parts.append(f"The next field to collect is: {next_field}.")
+            if pending_question:
+                guidance_parts.append(f"Continue the staking flow by asking: {pending_question}")
+            guidance_text = " ".join(guidance_parts)
+            langchain_messages.insert(0, SystemMessage(content=guidance_text))
+
         try:
             with swap_session(user_id=user_id, conversation_id=conversation_id):
                 with dca_session(user_id=user_id, conversation_id=conversation_id):
                     with lending_session(user_id=user_id, conversation_id=conversation_id):
-                        response = self.app.invoke({"messages": langchain_messages})
-                        print("DEBUG: response", response)
+                        with staking_session(user_id=user_id, conversation_id=conversation_id):
+                            response = self.app.invoke({"messages": langchain_messages})
+                            print("DEBUG: response", response)
         except Exception as e:
             print(f"Error in Supervisor: {e}")
             return {

src/agents/swap/registry.json

@@ -89,6 +89,17 @@
         {"symbol": "USDT", "aliases": ["usdt"], "decimals": 6, "min_amount": "1", "max_amount": "1000000"},
         {"symbol": "OP", "aliases": ["op"], "decimals": 18, "min_amount": "0.1", "max_amount": "1000000"}
       ]
+    },
+    {
+      "name": "world-chain",
+      "aliases": ["world-chain", "world chain", "worldchain", "wld"],
+      "tokens": [
+        {"symbol": "ETH", "aliases": ["eth"], "decimals": 18, "min_amount": "0.0001", "max_amount": "10000"},
+        {"symbol": "WETH", "aliases": ["weth"], "decimals": 18, "min_amount": "0.0001", "max_amount": "10000"},
+        {"symbol": "WLD", "aliases": ["wld", "worldcoin"], "decimals": 18, "min_amount": "0.1", "max_amount": "1000000"},
+        {"symbol": "USDC", "aliases": ["usdc"], "decimals": 6, "min_amount": "1", "max_amount": "1000000"},
+        {"symbol": "CONFRARIA", "aliases": ["confraria", "mcw", "milhas da confra"], "decimals": 18, "min_amount": "1", "max_amount": "1000000"}
+      ]
     }
   ]
 }

src/app.py

@@ -114,6 +114,7 @@ def _map_agent_type(agent_name: str) -> str:
         "search_agent": "realtime search",
         "swap_agent": "token swap",
         "lending_agent": "lending",
+        "staking_agent": "staking",
         "supervisor": "supervisor",
     }
     return mapping.get(agent_name, "supervisor")
@@ -253,6 +254,13 @@ def chat(request: ChatRequest):
                 )
                 if lending_meta:
                     response_metadata.update(lending_meta)
+            elif agent_name == "staking":
+                staking_meta = metadata.get_staking_agent(
+                    user_id=user_id,
+                    conversation_id=conversation_id,
+                )
+                if staking_meta:
+                    response_metadata.update(staking_meta)
             logger.debug(
                 "Response metadata for user=%s conversation=%s: %s",
                 user_id,
@@ -269,8 +277,8 @@ def chat(request: ChatRequest):
                 metadata=result.get("metadata", {}),
                 conversation_id=conversation_id,
                 user_id=user_id,
-                requires_action=True if agent_name in ["token swap", "lending"] else False,
-                action_type="swap" if agent_name == "token swap" else "lending" if agent_name == "lending" else None
+                requires_action=True if agent_name in ["token swap", "lending", "staking"] else False,
+                action_type="swap" if agent_name == "token swap" else "lending" if agent_name == "lending" else "staking" if agent_name == "staking" else None
             )
             
             # Add the response message to the conversation
@@ -322,6 +330,18 @@ def chat(request: ChatRequest):
                         user_id=user_id,
                         conversation_id=conversation_id,
                     )
+            if agent_name == "staking":
+                should_clear = False
+                if response_meta:
+                    status = response_meta.get("status") if isinstance(response_meta, dict) else None
+                    event = response_meta.get("event") if isinstance(response_meta, dict) else None
+                    should_clear = status == "ready" or event == "staking_intent_ready"
+                if should_clear:
+                    metadata.set_staking_agent(
+                        {},
+                        user_id=user_id,
+                        conversation_id=conversation_id,
+                    )
             return response_payload
         
         return {"response": "No response available", "agent": "supervisor"}