fix: preserve hosted-agent response input text

Author: Cataldir

lib/src/holiday_peak_lib/agents/hosted.py

@@ -171,15 +171,91 @@ def get_session(self, service_session_id: str, *, session_id: str | None = None)
 
 
 def _extract_user_text(messages: Any) -> str:
-    """Pull the most recent user-message text from a MAF message sequence."""
+    """Pull the most recent user-message text from MAF/OpenAI shapes."""
     if not messages:
         return ""
-    seq = messages if isinstance(messages, (list, tuple)) else [messages]
-    for msg in reversed(seq):
-        for content in getattr(msg, "contents", None) or []:
-            text = getattr(content, "text", None)
+    sequence = messages if isinstance(messages, (list, tuple)) else [messages]
+    for message in reversed(sequence):
+        role = _message_role(message)
+        if role is not None and role != "user":
+            continue
+        text = _extract_message_text(message)
+        if text:
+            return text
+    return ""
+
+
+def _message_role(message: Any) -> str | None:
+    """Return a normalized role from dict-like or object-like messages."""
+    role = _message_field(message, "role")
+    if role is None:
+        return None
+    return str(role).lower()
+
+
+def _message_field(message: Any, field_name: str) -> Any:
+    """Read one field from a dict-like or object-like message."""
+    if isinstance(message, dict):
+        return message.get(field_name)
+    return getattr(message, field_name, None)
+
+
+def _extract_message_text(message: Any) -> str:
+    """Return the first non-empty text value from a single message."""
+    if isinstance(message, str):
+        return message
+
+    for field_name in ("contents", "content"):
+        text = _extract_content_text(_message_field(message, field_name))
+        if text:
+            return text
+
+    text = _extract_input_text(_message_field(message, "input"))
+    if text:
+        return text
+
+    return _extract_content_text(_message_field(message, "text"))
+
+
+def _extract_input_text(value: Any) -> str:
+    """Extract text from Responses ``input`` values."""
+    if _looks_like_message_sequence(value):
+        return _extract_user_text(value)
+    return _extract_content_text(value)
+
+
+def _looks_like_message_sequence(value: Any) -> bool:
+    """Return whether a value looks like a list of chat messages."""
+    if not isinstance(value, (list, tuple)):
+        return False
+    return any(
+        _message_field(item, "role") is not None
+        or _message_field(item, "contents") is not None
+        or _message_field(item, "content") is not None
+        for item in value
+    )
+
+
+def _extract_content_text(value: Any) -> str:
+    """Return the first non-empty text value from content parts."""
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value
+    if isinstance(value, (list, tuple)):
+        for item in value:
+            text = _extract_content_text(item)
             if text:
-                return str(text)
+                return text
+        return ""
+    for field_name in ("contents", "content", "input", "text"):
+        field_value = _message_field(value, field_name)
+        if field_name == "input":
+            text = _extract_input_text(field_value)
+        else:
+            text = _extract_content_text(field_value)
+        if text:
+            return text
     return ""
 
 

lib/tests/test_agents_hosted.py

@@ -13,7 +13,7 @@
 from typing import Any
 
 import pytest
-from agent_framework import Message
+from agent_framework import Content, Message
 from holiday_peak_lib.agents.base_agent import AgentDependencies, BaseRetailAgent
 from holiday_peak_lib.agents.hosted import (
     _extract_text_from_handle_result,
@@ -35,14 +35,87 @@ async def handle(self, request: dict[str, Any]) -> dict[str, Any]:
         return self.next_response
 
 
+class _MessageLike:
+    def __init__(
+        self,
+        *,
+        role: str | None = "user",
+        contents: list[Any] | None = None,
+        content: Any = None,
+        text: str | None = None,
+        input_value: Any = None,
+    ) -> None:
+        self.role = role
+        self.contents = contents
+        self.content = content
+        self.text = text
+        self.input = input_value
+
+
 def test_extract_user_text_pulls_last_text_message() -> None:
     msgs = [
-        Message(role="user", contents=["earlier"]),
-        Message(role="user", contents=["latest input text"]),
+        Message(role="user", contents=[Content(type="text", text="earlier")]),
+        Message(
+            role="user",
+            contents=[Content(type="text", text="latest input text")],
+        ),
     ]
     assert _extract_user_text(msgs) == "latest input text"
 
 
+@pytest.mark.parametrize(
+    ("message", "expected"),
+    [
+        (_MessageLike(content="plain object content"), "plain object content"),
+        (
+            _MessageLike(content=[{"type": "input_text", "text": "object part"}]),
+            "object part",
+        ),
+        ({"role": "user", "content": "plain dict content"}, "plain dict content"),
+        (
+            {"role": "user", "content": [{"type": "input_text", "text": "dict part"}]},
+            "dict part",
+        ),
+        (_MessageLike(role=None, text="object direct text"), "object direct text"),
+        ({"text": "dict direct text"}, "dict direct text"),
+        ({"input": "direct input text"}, "direct input text"),
+        (
+            {
+                "input": [
+                    {"role": "user", "content": "earlier nested input"},
+                    {
+                        "role": "user",
+                        "content": [{"type": "input_text", "text": "latest nested input"}],
+                    },
+                ]
+            },
+            "latest nested input",
+        ),
+    ],
+)
+def test_extract_user_text_handles_common_maf_and_openai_shapes(
+    message: Any, expected: str
+) -> None:
+    assert _extract_user_text(message) == expected
+
+
+def test_extract_user_text_prefers_most_recent_user_message() -> None:
+    messages = [
+        {"role": "user", "content": "older user text"},
+        {"role": "assistant", "content": "assistant text should be ignored"},
+        {"role": "user", "content": "latest user text"},
+    ]
+    assert _extract_user_text(messages) == "latest user text"
+
+
+def test_extract_user_text_skips_later_non_user_messages() -> None:
+    messages = [
+        {"role": "user", "content": "latest user text"},
+        {"role": "assistant", "content": "assistant text should be ignored"},
+    ]
+    assert _extract_user_text(messages) == "latest user text"
+
+
 def test_extract_user_text_handles_empty_inputs() -> None:
     assert _extract_user_text(None) == ""
     assert _extract_user_text([]) == ""