Deploy from GitHub Actions: 347c54a3c8bb23a024f5952b8812538513a507f7

src/agents/routing/pre_extractor.py

@@ -74,6 +74,19 @@ _SWAP_PATTERN = re.compile(
     re.IGNORECASE,
 )
 
+# Cross-chain pattern: "swap X from Ethereum to Y on Arbitrum"
+# or "swap X on Ethereum for Y on Arbitrum"
+_CROSS_CHAIN_PATTERN = re.compile(
+    r"(?:swap|exchange|convert|trade|troque|trocar)\s+"
+    r"(?:(\d+(?:[.,]\d+)?)\s+)?"                       # optional amount
+    r"(\w+)\s+"                                          # from_token
+    r"(?:from|on|na|no|em)\s+(\S+)\s+"                  # from_network
+    r"(?:for|to|into|por|para)\s+"
+    r"(\w+)"                                             # to_token
+    r"(?:\s+(?:on|na|no|em)\s+(\S+))?",                 # to_network (optional)
+    re.IGNORECASE,
+)
+
 _LENDING_PATTERN = re.compile(
     r"(supply|borrow|repay|withdraw|deposit|lend)\s+"
     r"(?:(\d+(?:[.,]\d+)?)\s+)?"
@@ -124,14 +137,28 @@ def pre_extract(text: str, intent: str) -> PreExtractedParams:
     params = PreExtractedParams()
 
     if intent == "swap":
-        m = _SWAP_PATTERN.search(text)
-        if m:
-            params.amount = _safe_decimal(m.group(1))
-            params.from_token = m.group(2).upper()
-            params.to_token = m.group(3).upper()
-            if m.group(4):
-                params.from_network = m.group(4).lower()
+        # Try cross-chain pattern first: "swap X from Ethereum to Y on Arbitrum"
+        xm = _CROSS_CHAIN_PATTERN.search(text)
+        if xm:
+            params.amount = _safe_decimal(xm.group(1))
+            params.from_token = xm.group(2).upper()
+            params.from_network = xm.group(3).lower()
+            params.to_token = xm.group(4).upper()
+            params.to_network = (xm.group(5) or xm.group(3)).lower()
         else:
+            # Standard pattern: "swap X ETH to USDC on Base"
+            m = _SWAP_PATTERN.search(text)
+            if m:
+                params.amount = _safe_decimal(m.group(1))
+                params.from_token = m.group(2).upper()
+                params.to_token = m.group(3).upper()
+                if m.group(4):
+                    network = m.group(4).lower()
+                    params.from_network = network
+                    # Same-chain swap default: if only one network is
+                    # mentioned (e.g. "on Base"), assume both sides use it.
+                    params.to_network = network
+        if not params.has_any():
             # Try to extract at least amount + token
             am = _AMOUNT_TOKEN.search(text)
             if am:
@@ -139,7 +166,9 @@ def pre_extract(text: str, intent: str) -> PreExtractedParams:
                 params.from_token = am.group(2).upper()
             nm = _NETWORK_MENTION.search(text)
             if nm:
-                params.from_network = nm.group(1).lower()
+                network = nm.group(1).lower()
+                params.from_network = network
+                params.to_network = network
 
     elif intent == "lending":
         m = _LENDING_PATTERN.search(text)

src/agents/swap/agent.py

@@ -1,5 +1,6 @@
 import logging
 from src.agents.swap.tools import get_tools
+from src.agents.portfolio.tools import get_user_portfolio_tool
 from langgraph.prebuilt import create_react_agent
 
 logger = logging.getLogger(__name__)
@@ -11,6 +12,6 @@ class SwapAgent:
         self.llm = llm
         self.agent = create_react_agent(
             model=llm,
-            tools=get_tools(),
+            tools=get_tools() + [get_user_portfolio_tool],
             name="swap_agent"
         )

src/agents/swap/prompt.py

@@ -9,32 +9,45 @@ Always respond in English, regardless of the user's language.
 
 Primary responsibilities:
 1. Collect all swap intent fields (`from_network`, `from_token`, `to_network`, `to_token`, `amount`) by invoking the `update_swap_intent` tool.
-2. Use progressive loading: start with the minimum detail you need, then request the remaining fields one at a time.
+2. ALWAYS pass ALL fields you can infer from the user message in a SINGLE tool call. Never hold back known fields for a later call.
 3. Validate user inputs via tools. Ask the user to pick from the returned choices whenever a value is invalid or missing.
 4. Never fabricate swap rates, quotes, or execution results. Only confirm that the intent is ready once the tool reports `event == "swap_intent_ready"`.
-5. Preserve context: if the tool response says the intent is still collecting, summarize what you know, ask the next question, and remind the user how to continue.
+5. Preserve context: if the tool response says the intent is still collecting, summarize what you know and ask ONLY about the missing field(s).
 6. Reinforce guardrails: warn if the user requests unsupported networks/tokens or amounts outside the allowed range, and guide them back to valid options.
 
-Interaction pattern:
+Critical rules:
 - ALWAYS call `update_swap_intent` when the user provides new swap information.
-- Use `list_networks` or `list_tokens` before suggesting options, so your choices mirror the backend configuration.
-- After each tool call, read the returned `event`, `ask`, and `next_action` fields to decide whether to ask follow-up questions or conclude the intent.
+- Send EVERY field you can extract from the message in one call. For example, if the user says "Swap 0.1 ETH to USDC on Base", you MUST send from_token="ETH", to_token="USDC", amount=0.1, from_network="base", to_network="base" all at once.
+- When the user mentions a single network (e.g. "on Base"), assume both from_network and to_network are the same network unless the user explicitly names two different networks.
+- After each tool call, read the returned `event`, `ask`, and `next_action` fields. If `event` is `swap_intent_ready`, confirm the swap — do NOT ask further questions.
+- Only use `list_networks` or `list_tokens` when the user asks what is available or when you need to present choices for an invalid/missing value.
 
-Example 1 – progressive collection:
+Example 1 – complete in one shot:
+User: Swap 0.1 ETH to USDC on Base.
+Assistant: (call `update_swap_intent` with from_token="ETH", to_token="USDC", amount=0.1, from_network="base", to_network="base")
+Tool: event -> "swap_intent_ready"
+Assistant: "All set! Ready to swap 0.1 ETH for USDC on Base."
+
+Example 2 – partial info, minimal follow-up:
 User: I want to swap some AVAX to USDC.
-Assistant: (call `update_swap_intent` with `from_token="AVAX"`, `to_token="USDC"`)
-Tool: `ask` -> "From which network?"
-Assistant: "Sure — which network will you be swapping from?"
+Assistant: (call `update_swap_intent` with from_token="AVAX", to_token="USDC")
+Tool: ask -> "From which network?"
+Assistant: "Which network are you swapping on?"
 User: Avalanche, amount is 12.
-Assistant: (call `update_swap_intent` with `from_network="avalanche"`, `amount=12`)
-Tool: `ask` -> "To which network?"
-Assistant: "Got it. Which destination network do you prefer?"
+Assistant: (call `update_swap_intent` with from_network="avalanche", to_network="avalanche", amount=12)
+Tool: event -> "swap_intent_ready"
+Assistant: "All set! Ready to swap 12 AVAX for USDC on Avalanche."
 
-Example 2 – validation and completion:
+Example 3 – cross-chain swap:
 User: Swap 50 USDC from Ethereum to WBTC on Arbitrum.
-Assistant: (call `update_swap_intent` with all fields)
-Tool: `event` -> `swap_intent_ready`
-Assistant: "All set. Ready to swap 50 USDC on Ethereum for WBTC on Arbitrum. Let me know if you want to execute or adjust values."
+Assistant: (call `update_swap_intent` with from_token="USDC", to_token="WBTC", amount=50, from_network="ethereum", to_network="arbitrum")
+Tool: event -> "swap_intent_ready"
+Assistant: "All set! Ready to swap 50 USDC on Ethereum for WBTC on Arbitrum."
+
+Balance / Portfolio queries:
+- If the user asks about their balance, holdings, or "how much do I have", call `get_user_portfolio` to fetch their wallet balances.
+- Keep the balance response concise — show only the relevant token(s) and total value. The user is mid-swap, not requesting a full portfolio analysis.
+- After answering the balance question, resume collecting any missing swap fields.
 
-Keep responses concise, reference the remaining required field explicitly, and never skip the tool call even if you believe all details are already known.
+Keep responses concise. Never ask for a field the user already provided.
 {MARKDOWN_INSTRUCTIONS}"""

src/agents/swap/tools.py

@@ -461,6 +461,13 @@ def update_swap_intent_tool(
                     except ValueError:
                         intent.to_token = None
 
+        # Same-chain swap heuristic: if from_network is set but to_network
+        # is missing, default to the same network.  This avoids an extra
+        # round-trip for the very common case where the user mentions only
+        # one network (e.g. "swap 0.1 ETH to USDC on Base").
+        if intent.from_network and not intent.to_network and to_network is None:
+            intent.to_network = intent.from_network
+
         if intent.to_network is None and to_token is not None:
             return _response(
                 intent,

src/graphs/nodes.py

@@ -29,6 +29,7 @@ from src.graphs.utils import (
     detect_pending_followups,
     extract_response_from_graph,
     get_text_content,
+    is_swap_like_request,
 )
 
 # --- Agent imports ---
@@ -402,7 +403,66 @@ def _invoke_defi_agent(
 
 
 def swap_agent_node(state: AgentState, config: RunnableConfig | None = None) -> dict:
-    return _invoke_defi_agent("swap_agent", SWAP_AGENT_SYSTEM_PROMPT, swap_session, state, "swap", config)
+    """Invoke swap agent with both swap and portfolio session contexts.
+
+    The portfolio session gives the swap agent access to ``get_user_portfolio``
+    so users can check balances mid-swap without leaving the flow.
+    """
+    user_id = state.get("user_id")
+    conversation_id = state.get("conversation_id")
+    wallet_address = state.get("wallet_address")
+    langchain_messages = list(state.get("langchain_messages", []))
+    nodes = list(state.get("nodes_executed", []))
+    nodes.append("swap_agent_node")
+
+    agent = _agents.get("swap_agent")
+    if not agent:
+        return {
+            "final_response": "Agent not available.",
+            "response_agent": "swap_agent",
+            "response_metadata": {},
+            "raw_agent_messages": [],
+            "nodes_executed": nodes,
+        }
+
+    # Inject system prompt + DeFi guidance
+    scoped_messages = [SystemMessage(content=SWAP_AGENT_SYSTEM_PROMPT)]
+
+    defi_state = state.get("swap_state")
+    guidance = build_defi_guidance("swap", defi_state)
+    if guidance:
+        scoped_messages.append(SystemMessage(content=guidance))
+
+    hint = state.get("pre_extracted_hint")
+    if hint:
+        scoped_messages.append(SystemMessage(content=hint))
+
+    scoped_messages.extend(langchain_messages)
+
+    try:
+        with swap_session(user_id=user_id, conversation_id=conversation_id):
+            with portfolio_session(user_id=user_id, conversation_id=conversation_id, wallet_address=wallet_address):
+                response = agent.invoke({"messages": scoped_messages}, config=config)
+    except Exception:
+        logger.exception("Error invoking swap_agent")
+        return {
+            "final_response": "Sorry, an error occurred while processing your request.",
+            "response_agent": "swap_agent",
+            "response_metadata": {},
+            "raw_agent_messages": [],
+            "nodes_executed": nodes,
+        }
+
+    agent_name, text, messages_out = extract_response_from_graph(response)
+    meta = build_metadata(agent_name or "swap_agent", user_id, conversation_id, messages_out)
+
+    return {
+        "final_response": text,
+        "response_agent": agent_name or "swap_agent",
+        "response_metadata": meta,
+        "raw_agent_messages": messages_out,
+        "nodes_executed": nodes,
+    }
 
 
 def lending_agent_node(state: AgentState, config: RunnableConfig | None = None) -> dict: