Fix ASQ API response mapping

Corrects the private ASQ Space initialize and chat API argument counts and response ordering, while retaining cold-start retries for phone-to-glasses interview setup.

README.md

@@ -35,6 +35,8 @@ The phone and glasses use different tokens. The permanent researcher code is nev
 - `TARGET_CHAT_API_NAME`: defaults to `/chat_flow`.
 - `SESSION_TTL_SECONDS`: defaults to 14,400 seconds.
 - `MAX_BACKGROUND_CHARS`: defaults to 20,000 characters.
+- `PREPARE_TIMEOUT_SECONDS`: maximum cold-start retry window, defaults to 600 seconds.
+- `PREPARE_RETRY_SECONDS`: delay between cold-start attempts, defaults to 15 seconds.
 
 ## Endpoints
 

app.py

@@ -3,7 +3,9 @@ import base64
 import hashlib
 import hmac
 import json
+import logging
 import os
+import re
 import secrets
 import time
 from typing import Any, Literal
@@ -25,6 +27,10 @@ TARGET_CHAT_API_NAME = os.getenv("TARGET_CHAT_API_NAME", "/chat_flow")
 TARGET_INITIALIZE_API_NAME = os.getenv("TARGET_INITIALIZE_API_NAME", "/initialize_flow")
 SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "14400"))
 MAX_BACKGROUND_CHARS = int(os.getenv("MAX_BACKGROUND_CHARS", "20000"))
+PREPARE_TIMEOUT_SECONDS = int(os.getenv("PREPARE_TIMEOUT_SECONDS", "600"))
+PREPARE_RETRY_SECONDS = int(os.getenv("PREPARE_RETRY_SECONDS", "15"))
+
+logger = logging.getLogger("asq_gateway")
 
 
 class AuthRequest(BaseModel):
@@ -118,32 +124,54 @@ def _bearer(authorization: str | None, roles: set[str] | None = None) -> tuple[d
     return verify_token(authorization[7:], roles)
 
 
+def _extract_turn_count(value: Any) -> int:
+    if isinstance(value, (int, float)):
+        return int(value)
+    match = re.search(r"\d+", str(value or ""))
+    return int(match.group(0)) if match else 0
+
+
+def _message_text(message: Any) -> str:
+    if isinstance(message, str):
+        return message.strip()
+    if isinstance(message, dict):
+        content = message.get("content", message.get("text", ""))
+        return _message_text(content)
+    if isinstance(message, (list, tuple)):
+        parts = [_message_text(item) for item in message]
+        return "\n".join(part for part in parts if part).strip()
+    return str(message or "").strip()
+
+
 def extract_initial_state(result: Any) -> tuple[str, list[Any], int]:
-    if not isinstance(result, (list, tuple)) or len(result) < 4:
+    # /initialize_flow returns:
+    # turn markdown, interview history, hypotheses, summary, strategy, status.
+    if not isinstance(result, (list, tuple)) or len(result) < 6:
         raise RuntimeError("Unexpected initialization response from the ASQ Space")
-    hypotheses = str(result[0] or "").strip()
-    history = result[3] if isinstance(result[3], list) else []
-    turns = int(result[1] or 0)
+    hypotheses = str(result[2] or "").strip()
+    history = result[1] if isinstance(result[1], list) else []
+    turns = _extract_turn_count(result[0])
     if not hypotheses:
         raise RuntimeError("ASQ returned no initial hypotheses")
     return hypotheses, history, turns
 
 
 def extract_question(result: Any) -> tuple[str, list[Any], int, str | None]:
-    if not isinstance(result, (list, tuple)) or len(result) < 4:
+    # /chat_flow returns:
+    # history, cleared input, turn markdown, hypotheses, summary, strategy, status.
+    if not isinstance(result, (list, tuple)) or len(result) < 7:
         raise RuntimeError("Unexpected response from the ASQ Space")
     history = result[0]
-    turns = int(result[3])
-    hypotheses = str(result[2]).strip() if result[2] is not None else None
+    turns = _extract_turn_count(result[2])
+    hypotheses = str(result[3]).strip() if result[3] is not None else None
     if not isinstance(history, list) or not history:
         raise RuntimeError("ASQ returned no conversation history")
-    last = history[-1]
-    if isinstance(last, dict):
-        question = str(last.get("content", "")).strip()
-    elif isinstance(last, (list, tuple)) and len(last) >= 2:
-        question = str(last[1]).strip()
-    else:
-        question = ""
+    assistant_messages = [
+        message
+        for message in history
+        if isinstance(message, dict) and message.get("role") == "assistant"
+    ]
+    question = _message_text((assistant_messages or history)[-1])
     if not question:
         raise RuntimeError("ASQ returned an empty question")
     return question, history, turns, hypotheses
@@ -165,8 +193,6 @@ def call_asq(transcript: str, session: dict[str, Any]) -> tuple[str, list[Any],
         transcript,
         session["history"],
         session["background"],
-        session["hypotheses"],
-        session["turns"],
         api_name=TARGET_CHAT_API_NAME,
     )
     return extract_question(result)
@@ -176,13 +202,22 @@ async def prepare_session(session_id: str, background: str) -> None:
     session = sessions.get(session_id)
     if not session:
         return
-    try:
-        hypotheses, history, turns = await asyncio.to_thread(initialize_asq, background)
-    except Exception:
-        if session_id in sessions:
-            session["status"] = "error"
-            session["error"] = "Unable to start the model. Please try again."
-        return
+    deadline = time.monotonic() + PREPARE_TIMEOUT_SECONDS
+    attempt = 0
+    while True:
+        attempt += 1
+        try:
+            hypotheses, history, turns = await asyncio.to_thread(initialize_asq, background)
+            break
+        except Exception as error:
+            remaining = deadline - time.monotonic()
+            logger.warning("ASQ preparation attempt %s failed: %s", attempt, type(error).__name__)
+            if remaining <= 0:
+                if session_id in sessions:
+                    session["status"] = "error"
+                    session["error"] = "Unable to start the model. Please try again."
+                return
+            await asyncio.sleep(min(PREPARE_RETRY_SECONDS, remaining))
     if session_id in sessions:
         session.update(
             status="ready",