Feat/typebot interactive buttons (#12)

* feat: estabiliza integración inicial con Typebot

* feat(typebot): fix choice input detection and complete A2A structured pipeline

- typebot_service: use substring 'choice' check in _extract_structured_input
  to handle ChoiceInput, choice input, multipleChoiceInput (Typebot v6 types)
- typebot_service: add _parse_select_input normalizing items from content/
  title/label/text fields across Typebot API versions
- typebot_service: add _find_items_list recursive deep search for items array
- typebot_service: add _parse_rating_input for numeric rating blocks
- typebot_service: _build_structured_response returns {text, structured} dict
- typebot_service: _format_messages adds plainText fallback, improved richText
  node handling (li, p, ul, ol, a with href)
- external_agent: detect dict response, emit EVO_STRUCTURED: prefixed ADK part
- a2a_routes: extract_structured_from_message_history scans ADK history for
  EVO_STRUCTURED part; build_a2a_artifacts includes select artifact when present

* refactor(typebot): move is_only_registering to __init__ attribute

The inline walrus-operator assignment in start_session was hard to follow.
Compute the flag once during __init__ as self.is_only_registering and
reference it directly in the payload, eliminating the local variable.

---------

Co-authored-by: Milton Sosa <milton.sosa.22@gmail.com>

Author: miltonsosa-info-unlp

src/api/a2a_routes.py

@@ -356,6 +356,7 @@ def create_task_response(
     task_id: str,
     context_id: str,
     final_response: str,
+    artifacts: Optional[List[Dict[str, Any]]] = None,
     conversation_history: Optional[List[Dict[str, Any]]] = None,
     current_user_message: Optional[Dict[str, Any]] = None,
 ) -> Dict[str, Any]:
@@ -366,7 +367,7 @@ def create_task_response(
     )
 
     # Create main response artifact (only the agent's response)
-    artifacts = [
+    artifacts = artifacts or [
         {
             "artifactId": str(uuid.uuid4()),
             "parts": [{"type": "text", "text": final_response}],
@@ -524,6 +525,8 @@ async def extract_conversation_history(
                     if isinstance(part, dict) and part.get("text"):
                         role = "user" if event_dict.get("author") == "user" else "agent"
                         text_content = part["text"]
+                        if isinstance(text_content, str) and text_content.startswith(STRUCTURED_PART_PREFIX):
+                            continue
 
                         # Clean the content to remove JSON artifacts
                         cleaned_content = clean_message_content(text_content, role)
@@ -782,6 +785,75 @@ def extract_metadata_from_request(params: Dict[str, Any]) -> Dict[str, Any]:
     return metadata
 
 
+STRUCTURED_PART_PREFIX = "EVO_STRUCTURED:"
+
+
+def extract_structured_from_message_history(
+    message_history: Optional[List[Dict[str, Any]]],
+) -> Optional[Dict[str, Any]]:
+    if not message_history:
+        return None
+
+    for event in reversed(message_history):
+        content = event.get("content") if isinstance(event, dict) else None
+        parts = content.get("parts") if isinstance(content, dict) else None
+        if not isinstance(parts, list):
+            continue
+
+        for part in parts:
+            if not isinstance(part, dict):
+                continue
+
+            text = part.get("text")
+            if not isinstance(text, str) or not text.startswith(STRUCTURED_PART_PREFIX):
+                continue
+
+            raw = text[len(STRUCTURED_PART_PREFIX):].strip()
+            try:
+                decoded = json.loads(raw)
+                return decoded if isinstance(decoded, dict) else None
+            except Exception:
+                continue
+
+    return None
+
+
+def build_a2a_artifacts(
+    final_response: str,
+    structured: Optional[Dict[str, Any]] = None,
+) -> List[Dict[str, Any]]:
+    artifacts: List[Dict[str, Any]] = [
+        {
+            "artifactId": str(uuid.uuid4()),
+            "parts": [{"type": "text", "text": final_response}],
+        }
+    ]
+
+    if not structured:
+        return artifacts
+
+    input_obj = structured.get("input") if isinstance(structured, dict) else None
+    if not isinstance(input_obj, dict):
+        return artifacts
+
+    if input_obj.get("type") == "select" and isinstance(input_obj.get("items"), list):
+        artifacts.append(
+            {
+                "artifactId": str(uuid.uuid4()),
+                "parts": [
+                    {
+                        "type": "select",
+                        "items": input_obj.get("items", []),
+                        "isMultiple": bool(input_obj.get("isMultiple")),
+                        "sourceType": input_obj.get("sourceType"),
+                    }
+                ],
+            }
+        )
+
+    return artifacts
+
+
 async def handle_message_send(
     agent_id: uuid.UUID, params: Dict[str, Any], request_id: str, request: Request, db: Session
 ) -> JSONResponse:
@@ -985,11 +1057,15 @@ async def handle_message_send(
             "timestamp": None,  # Could add current timestamp
         }
 
+        structured = extract_structured_from_message_history(result.get("message_history"))
+        artifacts = build_a2a_artifacts(final_response, structured)
+
         # Create A2A compliant response with history
         task_response = create_task_response(
             task_id,
             context_id,
             final_response,
+            artifacts,
             combined_history if combined_history else None,
             current_user_message,
         )

src/services/adk/agents/external_agent.py

@@ -9,6 +9,7 @@
 from sqlalchemy.orm import Session
 from typing import AsyncGenerator, Dict, Any
 import logging
+import json
 
 from src.services.providers import (
     FlowiseService,
@@ -33,6 +34,7 @@ class ExternalAgent(BaseAgent):
     provider: str
     integration_config: Dict[str, Any]
     db: Session
+    provider_service: Any = None
 
     def __init__(
         self,
@@ -129,18 +131,28 @@ async def _run_async_impl(
 
             # Send message to provider
             try:
-                response_text = await self.provider_service.send_message(
+                provider_response = await self.provider_service.send_message(
                     message=user_message,
                     session_id=session_id,
                     context=provider_context,
                 )
 
+                response_text = provider_response
+                structured = None
+                if isinstance(provider_response, dict):
+                    response_text = provider_response.get("text", "")
+                    structured = provider_response.get("structured")
+
+                parts = [Part(text=str(response_text) if response_text is not None else "")]
+                if structured is not None:
+                    parts.append(Part(text=f"EVO_STRUCTURED:{json.dumps(structured, ensure_ascii=False)}"))
+
                 # Yield response event
                 yield Event(
                     author=self.name,
                     content=Content(
                         role="agent",
-                        parts=[Part(text=response_text)],
+                        parts=parts,
                     ),
                 )
 
@@ -171,12 +183,14 @@ async def _run_async_impl(
 
     def _get_session_id(self, ctx: InvocationContext) -> str:
         """Get or generate session ID from context."""
+        if ctx.session and ctx.session.id:
+            return ctx.session.id
+
         if ctx.session and ctx.session.state:
             session_id = ctx.session.state.get("session_id")
             if session_id:
                 return session_id
-        
-        # Generate new session ID
+
         import uuid
         return str(uuid.uuid4())
 

src/services/adk/runners/standard_runner.py

@@ -484,14 +484,17 @@ async def run_agent(
                 )
 
                 try:
-                    # Handle both Pydantic v2 (model_dump) and older versions
-                    if hasattr(root_agent.model, "model_dump"):
-                        model_dict = root_agent.model.model_dump()
-                    elif hasattr(root_agent.model, "dict"):
-                        model_dict = root_agent.model.dict()
+                    if not hasattr(root_agent, "model"):
+                        model_str = "external"
                     else:
-                        model_dict = root_agent.model.__dict__
-                    model_str = model_dict.get("model", str(root_agent.model))
+                        # Handle both Pydantic v2 (model_dump) and older versions
+                        if hasattr(root_agent.model, "model_dump"):
+                            model_dict = root_agent.model.model_dump()
+                        elif hasattr(root_agent.model, "dict"):
+                            model_dict = root_agent.model.dict()
+                        else:
+                            model_dict = root_agent.model.__dict__
+                        model_str = model_dict.get("model", str(root_agent.model))
                     metrics_data = ExecutionMetricsCreate(
                         agent_id=uuid.UUID(agent_id),
                         session_id=adk_session_id,