Compactor: garantizar emparejamiento tool_use/tool_result (sesiones largas bloqueadas)

Las sesiones largas con DeepSeek quedaban bloqueadas permanentemente con
400 "Messages with role 'tool' must be a response to a preceding message
with 'tool_calls'": el paso de ultimo recurso del compactor colapsaba
assistants con tool_use a un string placeholder dejando huerfanos los
tool_result del user siguiente.

- compactor: paso de ultimo recurso pair-aware + _enforce_tool_pairing
  como invariante final (matching por IDs, ambas direcciones, repara
  tambien historiales ya corruptos persistidos).
- openai_adapter: _repair_tool_sequence como guard defensivo del contrato
  del proveedor (tool huerfano -> user; tool_call sin respuesta -> fuera),
  con warning para detectar regresiones.
- recent_messages: trim por presupuesto de tokens al persistir
  (AGENTIC_RECENT_MESSAGES_MAX_TOKENS, default 60k) sin cortar pares;
  cierra el crecimiento sin limite que empujaba al paso destructivo.
- tests/test_tool_pairing_real.py: 23 tests que importan el codigo REAL
  (a diferencia de los tests standalone existentes). Suite completa: 92 ok.

Verificado offline contra los recent_messages reales de la sesion
bloqueada en prod: 0 violaciones con presupuesto normal y agresivo.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

src/adapters/openai_adapter.py

@@ -444,4 +444,106 @@ class OpenAIAdapter(ModelAdapter):
                         text_parts.append(b.get("text", ""))
                 if text_parts:
                     out.append({"role": "user", "content": "\n".join(text_parts)})
-        return out
+        # Guard defensivo: el compactor ya garantiza el invariante tool_use ↔
+        # tool_result (`_enforce_tool_pairing`), pero si algo se escapa el
+        # proveedor devuelve 400 y la sesion queda bloqueada. Cinturon y tirantes.
+        return self._repair_tool_sequence(out)
+
+    @staticmethod
+    def _repair_tool_sequence(out: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        """Garantiza el contrato OpenAI sobre la secuencia ya convertida:
+
+        - Todo `role: tool` debe responder a un tool_call_id del assistant
+          inmediatamente anterior (o de su bloque contiguo de tool messages).
+          Si no → se convierte a user con placeholder.
+        - Todo assistant con `tool_calls` debe tener respuesta para CADA id.
+          Los tool_calls sin respuesta se eliminan; si la lista queda vacia se
+          elimina la key (y se asegura `content` no-None — "content or
+          tool_calls must be set").
+
+        No deberia activarse nunca (el compactor repara antes); si se activa,
+        loguea warning para detectar regresiones del compactor.
+        """
+        repaired: list[dict[str, Any]] = []
+        i = 0
+        n = len(out)
+        while i < n:
+            msg = out[i]
+            role = msg.get("role")
+
+            if role == "assistant" and msg.get("tool_calls"):
+                # Bloque contiguo de tool messages que responden a este assistant.
+                j = i + 1
+                block: list[dict[str, Any]] = []
+                while j < n and out[j].get("role") == "tool":
+                    block.append(out[j])
+                    j += 1
+                answered = {t.get("tool_call_id", "") for t in block}
+                kept_calls = [
+                    tc for tc in msg["tool_calls"] if tc.get("id", "") in answered
+                ]
+                dropped = [
+                    tc for tc in msg["tool_calls"] if tc.get("id", "") not in answered
+                ]
+                new_msg = dict(msg)
+                if dropped:
+                    for tc in dropped:
+                        logger.warning(
+                            "repaired unanswered tool_call at index %d (tool_call_id=%s)",
+                            i,
+                            tc.get("id", ""),
+                        )
+                    if kept_calls:
+                        new_msg["tool_calls"] = kept_calls
+                    else:
+                        new_msg.pop("tool_calls", None)
+                        if new_msg.get("content") is None:
+                            # Promover reasoning a content si existe (mismo
+                            # criterio que el quirk DeepSeek de arriba); si no,
+                            # placeholder para no enviar content=None sin tools.
+                            rc = new_msg.pop("reasoning_content", None)
+                            new_msg["content"] = rc or "[ASSISTANT COMPACTADO]"
+                repaired.append(new_msg)
+                valid_ids = {tc.get("id", "") for tc in kept_calls}
+                converted: list[dict[str, Any]] = []
+                for t in block:
+                    if t.get("tool_call_id", "") in valid_ids:
+                        repaired.append(t)
+                    else:
+                        logger.warning(
+                            "repaired orphan tool message (tool_call_id=%s)",
+                            t.get("tool_call_id", ""),
+                        )
+                        converted.append(
+                            {
+                                "role": "user",
+                                "content": "[Resultado de herramienta (contexto compactado)]: "
+                                + str(t.get("content", ""))[:500],
+                            }
+                        )
+                # Los huerfanos convertidos van DESPUES del bloque de tools
+                # validos para no romper la contiguidad assistant → tools.
+                repaired.extend(converted)
+                i = j
+                continue
+
+            if role == "tool":
+                # Tool message sin assistant con tool_calls delante → huerfano.
+                logger.warning(
+                    "repaired orphan tool message at index %d (tool_call_id=%s)",
+                    i,
+                    msg.get("tool_call_id", ""),
+                )
+                repaired.append(
+                    {
+                        "role": "user",
+                        "content": "[Resultado de herramienta (contexto compactado)]: "
+                        + str(msg.get("content", ""))[:500],
+                    }
+                )
+                i += 1
+                continue
+
+            repaired.append(msg)
+            i += 1
+        return repaired

src/config.py

@@ -102,6 +102,10 @@ class Settings(BaseSettings):
     conversation_recent_raw_limit: int = 2
     task_history_max_entries: int = 20
     task_history_max_tokens: int = 1500
+    # Presupuesto de tokens para la ventana de recent_messages persistida en
+    # sesion. Sin esto crece sin limite y empuja al compactor a su paso
+    # destructivo (colapsar bloques perdiendo tool_use ids). 0 = sin limite.
+    recent_messages_max_tokens: int = 60_000
 
     # --- MCP ---
     mcp_config_path: str = ""  # Path to mcp.json; empty = legacy single-server mode

src/context/compactor.py

@@ -180,7 +180,13 @@ class ContextCompactor:
             "raw_tool_results_kept": 0,
         }
         if total <= max_tokens:
-            return messages, meta
+            # Aunque no haga falta compactar, garantizamos el invariante
+            # tool_use/tool_result (repara historiales ya rotos persistidos).
+            repaired = self._enforce_tool_pairing([dict(m) for m in messages])
+            meta["output_tokens"] = sum(
+                self._estimate_message_tokens(m) for m in repaired
+            )
+            return repaired, meta
 
         compacted = [dict(m) for m in messages]
         last_user_idx = max(
@@ -343,20 +349,241 @@ class ContextCompactor:
                         message["content"] = "[USER CONTEXT COMPACTADO]"
                 elif isinstance(content, list) and content:
                     # Anthropic-style: reemplazar lista entera por placeholder string.
-                    # Nota: pierde tool_use ids — solo aplicar al final como ultimo recurso.
+                    # Nota: colapsar pierde los tool_use/tool_result ids, asi que
+                    # lo hacemos PAIR-AWARE (colapsar un lado del par colapsa el
+                    # otro en la misma iteracion) y ademas `_enforce_tool_pairing`
+                    # al final garantiza el invariante aunque algo se escape.
                     if role == "assistant":
                         message["content"] = "[ASSISTANT COMPACTADO]"
+                        # Si este assistant tenia tool_use, colapsar tambien el
+                        # user de tool_results que lo sigue (mismo par).
+                        if self._blocks_have_type(content, "tool_use"):
+                            nxt = idx + 1
+                            if (
+                                nxt < len(compacted)
+                                and nxt != last_user_idx
+                                and compacted[nxt].get("role") == "user"
+                                and self._blocks_have_type(
+                                    compacted[nxt].get("content"), "tool_result"
+                                )
+                            ):
+                                compacted[nxt]["content"] = "[USER CONTEXT COMPACTADO]"
                     elif role == "user":
                         message["content"] = "[USER CONTEXT COMPACTADO]"
+                        # Si este user llevaba tool_results, colapsar tambien el
+                        # assistant anterior con sus tool_use (mismo par).
+                        if self._blocks_have_type(content, "tool_result"):
+                            prv = idx - 1
+                            if (
+                                prv >= 0
+                                and compacted[prv].get("role") == "assistant"
+                                and self._blocks_have_type(
+                                    compacted[prv].get("content"), "tool_use"
+                                )
+                            ):
+                                compacted[prv]["content"] = "[ASSISTANT COMPACTADO]"
                 else:
                     continue
                 total = sum(self._estimate_message_tokens(m) for m in compacted)
                 if total <= max_tokens:
                     break
 
+        # Invariante final: tras toda la compactacion, reparar cualquier par
+        # tool_use/tool_result roto. Sin esto, un tool_result huerfano se emite
+        # como `role: tool` sin `tool_calls` previo y el proveedor devuelve 400
+        # ("Messages with role 'tool' must be a response to a preceding message
+        # with 'tool_calls'").
+        compacted = self._enforce_tool_pairing(compacted)
+        total = sum(self._estimate_message_tokens(m) for m in compacted)
+
         meta["output_tokens"] = total
         return compacted, meta
 
+    # ------------------------------------------------------------------
+    # Invariante tool_use ↔ tool_result
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _blocks_have_type(content: Any, block_type: str) -> bool:
+        """True si `content` es una lista de bloques con alguno del tipo dado."""
+        if not isinstance(content, list):
+            return False
+        return any(
+            isinstance(b, dict) and b.get("type") == block_type for b in content
+        )
+
+    @staticmethod
+    def _tool_use_ids(message: dict[str, Any]) -> set[str]:
+        """IDs de tool calls emitidos por un assistant (bloques `tool_use`
+        estilo Anthropic y/o `tool_calls` estilo OpenAI legacy)."""
+        ids: set[str] = set()
+        content = message.get("content")
+        if isinstance(content, list):
+            for b in content:
+                if isinstance(b, dict) and b.get("type") == "tool_use":
+                    ids.add(str(b.get("id", "")))
+        for tc in message.get("tool_calls") or []:
+            if isinstance(tc, dict):
+                ids.add(str(tc.get("id", "")))
+        ids.discard("")
+        return ids
+
+    def _enforce_tool_pairing(
+        self, messages: list[dict[str, Any]]
+    ) -> list[dict[str, Any]]:
+        """Repara el invariante tool_use ↔ tool_result en ambas direcciones.
+
+        La compactacion puede colapsar el content de un assistant (perdiendo sus
+        bloques `tool_use`) mientras el user siguiente conserva sus `tool_result`,
+        o al reves. El matching es por IDs (`tool_use.id` vs `tool_result.tool_use_id`
+        y `tool_calls[].id` vs `tool_call_id`), no solo por adyacencia, asi que
+        tambien repara desajustes parciales (p.ej. 3 tool_use vs 2 tool_result).
+
+        - tool_result sin tool_use previo → bloque text placeholder.
+        - tool_use sin tool_result siguiente → se elimina el bloque (thinking/text
+          se conservan; si el content queda vacio, placeholder string).
+        - `role: tool` legacy sin assistant con `tool_calls` → user placeholder.
+        """
+        repaired: list[dict[str, Any]] = []
+        for idx, msg in enumerate(messages):
+            role = msg.get("role", "")
+            content = msg.get("content")
+
+            if role == "assistant":
+                tool_ids = self._tool_use_ids(msg)
+                if not tool_ids:
+                    repaired.append(msg)
+                    continue
+                # IDs respondidos: user con tool_results inmediato y/o run
+                # contiguo de mensajes legacy `role: tool`.
+                answered: set[str] = set()
+                j = idx + 1
+                if (
+                    j < len(messages)
+                    and messages[j].get("role") == "user"
+                    and isinstance(messages[j].get("content"), list)
+                ):
+                    for b in messages[j]["content"]:
+                        if isinstance(b, dict) and b.get("type") == "tool_result":
+                            answered.add(str(b.get("tool_use_id", "")))
+                    j += 1
+                while j < len(messages) and messages[j].get("role") == "tool":
+                    answered.add(str(messages[j].get("tool_call_id", "")))
+                    j += 1
+                unanswered = tool_ids - answered
+                if not unanswered:
+                    repaired.append(msg)
+                    continue
+                # Eliminar los tool_use/tool_calls sin respuesta.
+                new_msg = dict(msg)
+                if isinstance(content, list):
+                    new_content = [
+                        b
+                        for b in content
+                        if not (
+                            isinstance(b, dict)
+                            and b.get("type") == "tool_use"
+                            and str(b.get("id", "")) in unanswered
+                        )
+                    ]
+                    if not new_content:
+                        new_msg["content"] = "[ASSISTANT COMPACTADO]"
+                    else:
+                        new_msg["content"] = new_content
+                if isinstance(new_msg.get("tool_calls"), list):
+                    kept_calls = [
+                        tc
+                        for tc in new_msg["tool_calls"]
+                        if isinstance(tc, dict)
+                        and str(tc.get("id", "")) not in unanswered
+                    ]
+                    if kept_calls:
+                        new_msg["tool_calls"] = kept_calls
+                    else:
+                        new_msg.pop("tool_calls", None)
+                        if not new_msg.get("content"):
+                            new_msg["content"] = "[ASSISTANT COMPACTADO]"
+                repaired.append(new_msg)
+                continue
+
+            if role == "user" and self._blocks_have_type(content, "tool_result"):
+                # IDs disponibles en el assistant inmediatamente anterior
+                # (YA reparado — usar `repaired[-1]` refleja los tool_use que
+                # sobrevivieron, no los del mensaje original).
+                available: set[str] = set()
+                if repaired and repaired[-1].get("role") == "assistant":
+                    available = self._tool_use_ids(repaired[-1])
+                new_content: list[Any] = []
+                orphaned = False
+                for b in content:
+                    if (
+                        isinstance(b, dict)
+                        and b.get("type") == "tool_result"
+                        and str(b.get("tool_use_id", "")) not in available
+                    ):
+                        orphaned = True
+                        # Fusionar placeholders consecutivos en un unico bloque text.
+                        if not (
+                            new_content
+                            and isinstance(new_content[-1], dict)
+                            and new_content[-1].get("type") == "text"
+                            and new_content[-1].get("text")
+                            == "[Resultado de herramienta compactado]"
+                        ):
+                            new_content.append(
+                                {
+                                    "type": "text",
+                                    "text": "[Resultado de herramienta compactado]",
+                                }
+                            )
+                        continue
+                    new_content.append(b)
+                if not orphaned:
+                    repaired.append(msg)
+                    continue
+                new_msg = dict(msg)
+                only_placeholders = all(
+                    isinstance(b, dict)
+                    and b.get("type") == "text"
+                    and b.get("text") == "[Resultado de herramienta compactado]"
+                    for b in new_content
+                )
+                if not new_content or only_placeholders:
+                    new_msg["content"] = "[Resultado de herramienta compactado]"
+                else:
+                    new_msg["content"] = new_content
+                repaired.append(new_msg)
+                continue
+
+            if role == "tool":
+                # Legacy: el assistant anterior (saltando otros `role: tool`
+                # contiguos) debe tener este tool_call_id en sus tool_calls.
+                prev_assistant: dict[str, Any] | None = None
+                for prev in reversed(repaired):
+                    if prev.get("role") == "tool":
+                        continue
+                    if prev.get("role") == "assistant":
+                        prev_assistant = prev
+                    break
+                call_id = str(msg.get("tool_call_id", ""))
+                valid = (
+                    prev_assistant is not None
+                    and call_id in self._tool_use_ids(prev_assistant)
+                )
+                if valid:
+                    repaired.append(msg)
+                else:
+                    repaired.append(
+                        {
+                            "role": "user",
+                            "content": "[Resultado de herramienta compactado]",
+                        }
+                    )
+                continue
+
+            repaired.append(msg)
+        return repaired
+
     # ------------------------------------------------------------------
     # Internals
     # ------------------------------------------------------------------

src/orchestrator/engine.py

@@ -14,7 +14,7 @@ from typing import Any
 from ..adapters.base import ModelAdapter
 from ..config import settings
 from ..context.engine import ContextEngine
-from ..context.compactor import estimate_tokens
+from ..context.compactor import ContextCompactor, estimate_tokens
 from ..mcp.manager import MCPManager
 from ..memory.store import MemoryStore
 from ..models.agent import AgentProfile
@@ -260,7 +260,76 @@ class OrchestratorEngine:
                 current_turn.append(sanitized)
 
         merged.extend(current_turn)
-        return merged
+        return OrchestratorEngine._trim_recent_messages(merged)
+
+    @staticmethod
+    def _trim_recent_messages(
+        messages: list[dict[str, Any]],
+    ) -> list[dict[str, Any]]:
+        """Recorta recent_messages a un presupuesto de tokens eliminando
+        mensajes ENTEROS desde el principio (los mas antiguos).
+
+        Dos reglas para no romper el invariante tool_use ↔ tool_result:
+        - Nunca cortar dentro de un par: si se elimina un assistant con
+          tool_use, se eliminan tambien sus tool_results (user carrier o run
+          de mensajes legacy `role: tool`).
+        - El primer mensaje resultante nunca puede ser un carrier de
+          tool_result ni un `role: tool`.
+
+        Mantiene siempre al menos los ultimos 4 mensajes aunque excedan el
+        presupuesto.
+        """
+        budget = settings.recent_messages_max_tokens
+        if budget <= 0 or not messages:
+            return messages
+
+        estimate = ContextCompactor._estimate_message_tokens
+        total = sum(estimate(m) for m in messages)
+        if total <= budget:
+            return messages
+
+        def _is_tool_result_carrier(msg: dict[str, Any]) -> bool:
+            if msg.get("role") == "tool":
+                return True
+            if msg.get("role") != "user":
+                return False
+            content = msg.get("content")
+            return isinstance(content, list) and any(
+                isinstance(b, dict) and b.get("type") == "tool_result"
+                for b in content
+            )
+
+        def _has_tool_use(msg: dict[str, Any]) -> bool:
+            if msg.get("role") != "assistant":
+                return False
+            if msg.get("tool_calls"):
+                return True
+            content = msg.get("content")
+            return isinstance(content, list) and any(
+                isinstance(b, dict) and b.get("type") == "tool_use"
+                for b in content
+            )
+
+        min_keep = 4
+        n = len(messages)
+        start = 0
+        while total > budget and start < n - min_keep:
+            end = start + 1
+            if _has_tool_use(messages[start]):
+                # Arrastrar los tool_results del par (no cortar dentro de el).
+                while end < n and _is_tool_result_carrier(messages[end]):
+                    end += 1
+            if n - end < min_keep:
+                break  # Eliminar el par completo invadiria los ultimos min_keep
+            for k in range(start, end):
+                total -= estimate(messages[k])
+            start = end
+
+        trimmed = messages[start:]
+        # El primer mensaje nunca puede ser un tool_result sin su tool_use.
+        while trimmed and _is_tool_result_carrier(trimmed[0]):
+            trimmed.pop(0)
+        return trimmed
 
     @staticmethod
     def _sanitize_recent_message(message: dict[str, Any]) -> dict[str, Any]:

tests/test_context_budget.py

@@ -294,11 +294,27 @@ class TestTaskHistoryTrim:
 class TestConversationCompaction:
     def test_compactor_preserves_last_user_and_compacts_old_tool_results(self):
         compactor = ContextCompactor(max_tokens=999999)
+        # Los assistants llevan sus tool_calls: sin ellos los `role: tool`
+        # serian huerfanos y `_enforce_tool_pairing` los convertiria a user.
         messages = [
             {"role": "user", "content": "Contexto anterior " * 10},
-            {"role": "assistant", "content": "Voy a revisar el modulo ahora mismo. " * 6},
+            {
+                "role": "assistant",
+                "content": "Voy a revisar el modulo ahora mismo. " * 6,
+                "tool_calls": [
+                    {"id": "tool-1", "type": "function",
+                     "function": {"name": "t", "arguments": "{}"}},
+                ],
+            },
             {"role": "tool", "tool_call_id": "tool-1", "content": "resultado antiguo\n" * 80},
-            {"role": "assistant", "content": "He visto el resultado anterior. " * 6},
+            {
+                "role": "assistant",
+                "content": "He visto el resultado anterior. " * 6,
+                "tool_calls": [
+                    {"id": "tool-2", "type": "function",
+                     "function": {"name": "t", "arguments": "{}"}},
+                ],
+            },
             {"role": "tool", "tool_call_id": "tool-2", "content": "resultado reciente\n" * 80},
             {"role": "user", "content": "Este es el ultimo mensaje del usuario y debe quedar intacto."},
         ]
@@ -358,9 +374,18 @@ class TestConversationCompaction:
 
     def test_compactor_only_touches_user_messages_as_last_resort(self):
         compactor = ContextCompactor(max_tokens=999999)
+        # tool_calls en el assistant para que el `role: tool` no sea huerfano
+        # (el invariante `_enforce_tool_pairing` convertiria un huerfano a user).
         messages = [
             {"role": "user", "content": "Contexto previo del usuario " * 8},
-            {"role": "assistant", "content": "Respuesta previa del asistente " * 6},
+            {
+                "role": "assistant",
+                "content": "Respuesta previa del asistente " * 6,
+                "tool_calls": [
+                    {"id": "tool-1", "type": "function",
+                     "function": {"name": "t", "arguments": "{}"}},
+                ],
+            },
             {"role": "tool", "tool_call_id": "tool-1", "content": "resultado viejo\n" * 80},
             {"role": "user", "content": "Ultimo mensaje del usuario"},
         ]

tests/test_tool_pairing_real.py

@@ -0,0 +1,585 @@
+"""Tests de REGRESION REAL del invariante tool_use ↔ tool_result.
+
+A diferencia del resto de tests (que replican logica), este archivo importa el
+codigo REAL de src/. Cubre el bug de produccion: sesiones largas (~130k tokens)
+donde `compact_conversation` colapsaba assistants a "[ASSISTANT COMPACTADO]"
+perdiendo los bloques `tool_use`, dejando tool_results huerfanos que el adapter
+emitia como `role: tool` sin `tool_calls` → 400 del proveedor en cada reintento.
+
+Requiere las dependencias de src/ (pydantic, Python 3.11+). Si no estan
+disponibles (p.ej. host con Python 3.10), el modulo entero se salta — ejecutar
+dentro del container: `docker exec acai-agentic python3 -m pytest ...`.
+"""
+
+import pytest
+
+try:
+    from src.context.compactor import ContextCompactor
+except Exception as e:  # pragma: no cover - entorno sin deps de src/
+    pytest.skip(f"src/ no importable en este entorno: {e}", allow_module_level=True)
+
+
+# =====================================================================
+# Helper de validacion reutilizable
+# =====================================================================
+
+
+def collect_tool_use_ids(message: dict) -> set:
+    """IDs de tool calls de un assistant (Anthropic blocks + OpenAI legacy)."""
+    ids = set()
+    content = message.get("content")
+    if isinstance(content, list):
+        for b in content:
+            if isinstance(b, dict) and b.get("type") == "tool_use":
+                ids.add(str(b.get("id", "")))
+    for tc in message.get("tool_calls") or []:
+        if isinstance(tc, dict):
+            ids.add(str(tc.get("id", "")))
+    ids.discard("")
+    return ids
+
+
+def assert_tool_pairing_ok(messages: list) -> None:
+    """Valida el invariante completo sobre una lista de mensajes internos:
+
+    - Todo tool_result (block) referencia un tool_use del assistant anterior.
+    - Todo tool_use (block) tiene su tool_result en el mensaje siguiente.
+    - Todo `role: tool` legacy responde a un tool_call del assistant previo.
+    """
+    for i, msg in enumerate(messages):
+        role = msg.get("role")
+        content = msg.get("content")
+
+        if role == "user" and isinstance(content, list):
+            result_ids = {
+                str(b.get("tool_use_id", ""))
+                for b in content
+                if isinstance(b, dict) and b.get("type") == "tool_result"
+            }
+            if result_ids:
+                assert i > 0, f"msg[{i}]: tool_result al inicio de la conversacion"
+                prev = messages[i - 1]
+                assert prev.get("role") == "assistant", (
+                    f"msg[{i}]: tool_result sin assistant inmediatamente anterior"
+                )
+                available = collect_tool_use_ids(prev)
+                orphans = result_ids - available
+                assert not orphans, (
+                    f"msg[{i}]: tool_result huerfanos {orphans} "
+                    f"(assistant previo solo tiene {available})"
+                )
+
+        if role == "assistant":
+            tool_ids = collect_tool_use_ids(msg)
+            if tool_ids:
+                answered = set()
+                j = i + 1
+                if (
+                    j < len(messages)
+                    and messages[j].get("role") == "user"
+                    and isinstance(messages[j].get("content"), list)
+                ):
+                    for b in messages[j]["content"]:
+                        if isinstance(b, dict) and b.get("type") == "tool_result":
+                            answered.add(str(b.get("tool_use_id", "")))
+                    j += 1
+                while j < len(messages) and messages[j].get("role") == "tool":
+                    answered.add(str(messages[j].get("tool_call_id", "")))
+                    j += 1
+                unanswered = tool_ids - answered
+                assert not unanswered, (
+                    f"msg[{i}]: tool_use sin respuesta {unanswered}"
+                )
+
+        if role == "tool":
+            prev_assistant = None
+            for k in range(i - 1, -1, -1):
+                if messages[k].get("role") == "tool":
+                    continue
+                if messages[k].get("role") == "assistant":
+                    prev_assistant = messages[k]
+                break
+            assert prev_assistant is not None, (
+                f"msg[{i}]: role tool sin assistant previo"
+            )
+            call_id = str(msg.get("tool_call_id", ""))
+            assert call_id in collect_tool_use_ids(prev_assistant), (
+                f"msg[{i}]: role tool con tool_call_id={call_id} no presente "
+                f"en el assistant previo"
+            )
+
+
+def make_turn(n: int, payload_chars: int = 4000) -> list:
+    """Genera un turno completo: user → assistant(thinking+text+tool_use) →
+    user(tool_result). Payloads grandes para forzar la compactacion."""
+    tid = f"call_{n}"
+    return [
+        {"role": "user", "content": f"Peticion {n}: " + ("x" * payload_chars)},
+        {
+            "role": "assistant",
+            "content": [
+                {"type": "thinking", "thinking": "razonando " * (payload_chars // 10)},
+                {"type": "text", "text": f"Voy a ejecutar la tool del turno {n}."},
+                {
+                    "type": "tool_use",
+                    "id": tid,
+                    "name": "acai_get_records",
+                    "input": {"tableName": f"tabla_{n}"},
+                },
+            ],
+        },
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "tool_result",
+                    "tool_use_id": tid,
+                    "content": "resultado " * (payload_chars // 10),
+                }
+            ],
+        },
+    ]
+
+
+# =====================================================================
+# (a) compact_conversation end-to-end: el paso de ultimo recurso ya no
+#     deja tool_results huerfanos ni tool_use sin respuesta
+# =====================================================================
+
+
+class TestCompactConversationPairing:
+    def test_last_resort_does_not_orphan_tool_results(self):
+        compactor = ContextCompactor()
+        messages = []
+        for n in range(12):
+            messages.extend(make_turn(n, payload_chars=6000))
+        messages.append({"role": "user", "content": "ultima peticion del usuario"})
+
+        # Presupuesto minusculo: fuerza TODOS los pasos incluida la colapsa
+        # de listas a placeholder string (el paso que causaba el bug).
+        compacted, meta = compactor.compact_conversation(messages, max_tokens=300)
+
+        assert meta["output_tokens"] < meta["input_tokens"]
+        assert_tool_pairing_ok(compacted)
+
+    def test_moderate_budget_keeps_pairing(self):
+        compactor = ContextCompactor()
+        messages = []
+        for n in range(8):
+            messages.extend(make_turn(n, payload_chars=3000))
+        messages.append({"role": "user", "content": "peticion final"})
+
+        compacted, _ = compactor.compact_conversation(messages, max_tokens=2000)
+        assert_tool_pairing_ok(compacted)
+
+    def test_under_budget_passthrough_keeps_pairing(self):
+        compactor = ContextCompactor()
+        messages = make_turn(1, payload_chars=50)
+        compacted, meta = compactor.compact_conversation(messages, max_tokens=100_000)
+        assert meta["messages_compacted"] == 0
+        assert_tool_pairing_ok(compacted)
+        # Los tool_use/tool_result originales se conservan intactos
+        assert collect_tool_use_ids(compacted[1]) == {"call_1"}
+
+    def test_last_user_message_preserved(self):
+        compactor = ContextCompactor()
+        messages = []
+        for n in range(10):
+            messages.extend(make_turn(n, payload_chars=5000))
+        final = "esta es la peticion actual que NO debe perderse"
+        messages.append({"role": "user", "content": final})
+
+        compacted, _ = compactor.compact_conversation(messages, max_tokens=300)
+        assert compacted[-1]["content"] == final
+
+
+# =====================================================================
+# (b) _enforce_tool_pairing directo
+# =====================================================================
+
+
+class TestEnforceToolPairing:
+    def setup_method(self):
+        self.compactor = ContextCompactor()
+
+    def test_collapsed_assistant_with_orphan_tool_results(self):
+        """Assistant colapsado a string + user con tool_results → los
+        tool_result se convierten en placeholder."""
+        messages = [
+            {"role": "assistant", "content": "[ASSISTANT COMPACTADO]"},
+            {
+                "role": "user",
+                "content": [
+                    {"type": "tool_result", "tool_use_id": "call_a", "content": "datos"},
+                    {"type": "tool_result", "tool_use_id": "call_b", "content": "mas datos"},
+                ],
+            },
+        ]
+        repaired = self.compactor._enforce_tool_pairing(messages)
+        assert_tool_pairing_ok(repaired)
+        # Solo placeholders → content string (fusionados en uno)
+        assert repaired[1]["role"] == "user"
+        assert repaired[1]["content"] == "[Resultado de herramienta compactado]"
+
+    def test_orphan_tool_results_mixed_with_text(self):
+        """tool_result huerfano junto a un bloque text → placeholder en lista,
+        el text se conserva."""
+        messages = [
+            {"role": "assistant", "content": "[ASSISTANT COMPACTADO]"},
+            {
+                "role": "user",
+                "content": [
+                    {"type": "tool_result", "tool_use_id": "call_a", "content": "datos"},
+                    {"type": "text", "text": "y ademas haz esto"},
+                ],
+            },
+        ]
+        repaired = self.compactor._enforce_tool_pairing(messages)
+        assert_tool_pairing_ok(repaired)
+        content = repaired[1]["content"]
+        assert isinstance(content, list)
+        types = [b.get("type") for b in content]
+        assert types == ["text", "text"]
+        assert content[0]["text"] == "[Resultado de herramienta compactado]"
+        assert content[1]["text"] == "y ademas haz esto"
+
+    def test_partial_id_mismatch_drops_unanswered_tool_use(self):
+        """Assistant con 3 tool_use, user con solo 2 tool_result → se elimina
+        el tool_use sin respuesta, thinking/text intactos."""
+        messages = [
+            {
+                "role": "assistant",
+                "content": [
+                    {"type": "thinking", "thinking": "pensando"},
+                    {"type": "text", "text": "ejecuto tres tools"},
+                    {"type": "tool_use", "id": "c1", "name": "t1", "input": {}},
+                    {"type": "tool_use", "id": "c2", "name": "t2", "input": {}},
+                    {"type": "tool_use", "id": "c3", "name": "t3", "input": {}},
+                ],
+            },
+            {
+                "role": "user",
+                "content": [
+                    {"type": "tool_result", "tool_use_id": "c1", "content": "r1"},
+                    {"type": "tool_result", "tool_use_id": "c3", "content": "r3"},
+                ],
+            },
+        ]
+        repaired = self.compactor._enforce_tool_pairing(messages)
+        assert_tool_pairing_ok(repaired)
+        assert collect_tool_use_ids(repaired[0]) == {"c1", "c3"}
+        types = [b.get("type") for b in repaired[0]["content"]]
+        assert "thinking" in types and "text" in types
+
+    def test_assistant_tool_use_with_no_results_at_all(self):
+        """Assistant con tool_use y SIN user de resultados detras → se
+        eliminan los tool_use; si el content queda vacio, placeholder."""
+        messages = [
+            {
+                "role": "assistant",
+                "content": [
+                    {"type": "tool_use", "id": "c9", "name": "t", "input": {}},
+                ],
+            },
+            {"role": "user", "content": "otra cosa"},
+        ]
+        repaired = self.compactor._enforce_tool_pairing(messages)
+        assert_tool_pairing_ok(repaired)
+        assert repaired[0]["content"] == "[ASSISTANT COMPACTADO]"
+
+    def test_legacy_orphan_role_tool_converted_to_user(self):
+        """role:tool legacy cuyo assistant anterior no tiene tool_calls →
+        se convierte a user placeholder."""
+        messages = [
+            {"role": "assistant", "content": "[ASSISTANT COMPACTADO]"},
+            {"role": "tool", "tool_call_id": "call_x", "content": "salida tool"},
+        ]
+        repaired = self.compactor._enforce_tool_pairing(messages)
+        assert_tool_pairing_ok(repaired)
+        assert repaired[1]["role"] == "user"
+        assert repaired[1]["content"] == "[Resultado de herramienta compactado]"
+
+    def test_legacy_valid_role_tool_untouched(self):
+        messages = [
+            {
+                "role": "assistant",
+                "content": "lanzo tool",
+                "tool_calls": [
+                    {"id": "call_x", "type": "function",
+                     "function": {"name": "t", "arguments": "{}"}},
+                ],
+            },
+            {"role": "tool", "tool_call_id": "call_x", "content": "salida"},
+        ]
+        repaired = self.compactor._enforce_tool_pairing(messages)
+        assert_tool_pairing_ok(repaired)
+        assert repaired[1]["role"] == "tool"
+
+    def test_well_paired_history_is_noop(self):
+        messages = make_turn(7, payload_chars=50)
+        repaired = self.compactor._enforce_tool_pairing(messages)
+        assert repaired == messages
+
+
+# =====================================================================
+# (c) Trim de recent_messages (OrchestratorEngine._trim_recent_messages)
+# =====================================================================
+
+
+orchestrator_engine = pytest.importorskip(
+    "src.orchestrator.engine",
+    reason="deps del orquestador (mcp, sse, redis) no disponibles",
+)
+OrchestratorEngine = orchestrator_engine.OrchestratorEngine
+
+
+class TestTrimRecentMessages:
+    def _set_budget(self, monkeypatch, tokens: int):
+        from src.config import settings
+        monkeypatch.setattr(settings, "recent_messages_max_tokens", tokens)
+
+    def test_under_budget_untouched(self, monkeypatch):
+        self._set_budget(monkeypatch, 100_000)
+        messages = make_turn(0, payload_chars=100)
+        assert OrchestratorEngine._trim_recent_messages(list(messages)) == messages
+
+    def test_trims_oldest_whole_pairs(self, monkeypatch):
+        self._set_budget(monkeypatch, 500)
+        messages = []
+        for n in range(10):
+            messages.extend(make_turn(n, payload_chars=1000))
+        trimmed = OrchestratorEngine._trim_recent_messages(messages)
+
+        assert len(trimmed) < len(messages)
+        # Nunca se corta dentro de un par
+        assert_tool_pairing_ok(trimmed)
+        # El primer mensaje nunca es un carrier de tool_result ni role tool
+        first = trimmed[0]
+        assert first.get("role") != "tool"
+        if isinstance(first.get("content"), list):
+            assert not any(
+                isinstance(b, dict) and b.get("type") == "tool_result"
+                for b in first["content"]
+            )
+        # Se eliminan los mas antiguos: el final se conserva
+        assert trimmed[-1] == messages[-1]
+
+    def test_keeps_last_four_even_over_budget(self, monkeypatch):
+        self._set_budget(monkeypatch, 10)  # presupuesto imposible
+        messages = []
+        for n in range(5):
+            messages.extend(make_turn(n, payload_chars=2000))
+        trimmed = OrchestratorEngine._trim_recent_messages(messages)
+        assert len(trimmed) >= 4
+
+    def test_pair_dragging_includes_legacy_tool_run(self, monkeypatch):
+        """Un assistant legacy con tool_calls arrastra su run de role:tool."""
+        self._set_budget(monkeypatch, 300)
+        big = "y" * 3000
+        messages = [
+            {
+                "role": "assistant",
+                "content": big,
+                "tool_calls": [
+                    {"id": "c1", "type": "function",
+                     "function": {"name": "t", "arguments": "{}"}},
+                    {"id": "c2", "type": "function",
+                     "function": {"name": "t", "arguments": "{}"}},
+                ],
+            },
+            {"role": "tool", "tool_call_id": "c1", "content": big},
+            {"role": "tool", "tool_call_id": "c2", "content": big},
+            {"role": "user", "content": "pregunta"},
+            {"role": "assistant", "content": "respuesta"},
+            {"role": "user", "content": "otra pregunta"},
+            {"role": "assistant", "content": "otra respuesta"},
+        ]
+        trimmed = OrchestratorEngine._trim_recent_messages(messages)
+        # El par legacy entero (assistant + 2 tools) se elimino junto
+        assert trimmed[0] == {"role": "user", "content": "pregunta"}
+        assert_tool_pairing_ok(trimmed)
+
+    def test_append_recent_messages_applies_trim(self, monkeypatch):
+        self._set_budget(monkeypatch, 500)
+        existing = []
+        for n in range(10):
+            existing.extend(make_turn(n, payload_chars=1000))
+        merged = OrchestratorEngine._append_recent_messages(
+            existing, message="nueva peticion", conversation=[
+                {"role": "assistant", "content": "ok hecho"},
+            ],
+        )
+        assert len(merged) < len(existing) + 2
+        assert merged[-1] == {"role": "assistant", "content": "ok hecho"}
+        assert_tool_pairing_ok(merged)
+
+
+# =====================================================================
+# (d) Guard defensivo del adapter (_repair_tool_sequence)
+# =====================================================================
+
+
+openai_mod = pytest.importorskip("openai", reason="SDK openai no instalado")
+
+
+class TestRepairToolSequence:
+    @property
+    def repair(self):
+        from src.adapters.openai_adapter import OpenAIAdapter
+        return OpenAIAdapter._repair_tool_sequence
+
+    def test_valid_sequence_untouched(self):
+        msgs = [
+            {"role": "system", "content": "sys"},
+            {"role": "user", "content": "hola"},
+            {
+                "role": "assistant",
+                "content": None,
+                "tool_calls": [
+                    {"id": "c1", "type": "function",
+                     "function": {"name": "t", "arguments": "{}"}},
+                ],
+            },
+            {"role": "tool", "tool_call_id": "c1", "content": "resultado"},
+            {"role": "assistant", "content": "listo"},
+        ]
+        assert self.repair(list(msgs)) == msgs
+
+    def test_orphan_tool_message_converted_to_user(self):
+        msgs = [
+            {"role": "assistant", "content": "[ASSISTANT COMPACTADO]"},
+            {"role": "tool", "tool_call_id": "c_orphan", "content": "datos " * 200},
+        ]
+        out = self.repair(msgs)
+        assert out[1]["role"] == "user"
+        assert out[1]["content"].startswith(
+            "[Resultado de herramienta (contexto compactado)]: "
+        )
+        # Content truncado a 500 chars (+ prefijo)
+        assert len(out[1]["content"]) <= 500 + len(
+            "[Resultado de herramienta (contexto compactado)]: "
+        )
+        assert not any(m.get("role") == "tool" for m in out)
+
+    def test_unanswered_tool_calls_removed(self):
+        msgs = [
+            {
+                "role": "assistant",
+                "content": None,
+                "tool_calls": [
+                    {"id": "c1", "type": "function",
+                     "function": {"name": "t", "arguments": "{}"}},
+                    {"id": "c2", "type": "function",
+                     "function": {"name": "t", "arguments": "{}"}},
+                ],
+            },
+            {"role": "tool", "tool_call_id": "c1", "content": "r1"},
+            {"role": "user", "content": "sigue"},
+        ]
+        out = self.repair(msgs)
+        assert [tc["id"] for tc in out[0]["tool_calls"]] == ["c1"]
+        assert out[1] == {"role": "tool", "tool_call_id": "c1", "content": "r1"}
+
+    def test_all_tool_calls_unanswered_drops_key_and_sets_content(self):
+        msgs = [
+            {
+                "role": "assistant",
+                "content": None,
+                "tool_calls": [
+                    {"id": "c1", "type": "function",
+                     "function": {"name": "t", "arguments": "{}"}},
+                ],
+            },
+            {"role": "user", "content": "sigue"},
+        ]
+        out = self.repair(msgs)
+        assert "tool_calls" not in out[0]
+        assert out[0]["content"]  # nunca None sin tool_calls
+
+    def test_reasoning_promoted_when_tool_calls_dropped(self):
+        """No romper la promocion de reasoning a content del fix anterior."""
+        msgs = [
+            {
+                "role": "assistant",
+                "content": None,
+                "reasoning_content": "razonamiento del modelo",
+                "tool_calls": [
+                    {"id": "c1", "type": "function",
+                     "function": {"name": "t", "arguments": "{}"}},
+                ],
+            },
+            {"role": "user", "content": "sigue"},
+        ]
+        out = self.repair(msgs)
+        assert "tool_calls" not in out[0]
+        assert out[0]["content"] == "razonamiento del modelo"
+        assert "reasoning_content" not in out[0]
+
+    def test_mixed_orphan_in_tool_block(self):
+        """Un huerfano en medio de un bloque de tools validos se convierte a
+        user DESPUES del bloque (no rompe la contiguidad assistant→tools)."""
+        msgs = [
+            {
+                "role": "assistant",
+                "content": None,
+                "tool_calls": [
+                    {"id": "c1", "type": "function",
+                     "function": {"name": "t", "arguments": "{}"}},
+                    {"id": "c2", "type": "function",
+                     "function": {"name": "t", "arguments": "{}"}},
+                ],
+            },
+            {"role": "tool", "tool_call_id": "c1", "content": "r1"},
+            {"role": "tool", "tool_call_id": "huerfano", "content": "rx"},
+            {"role": "tool", "tool_call_id": "c2", "content": "r2"},
+            {"role": "user", "content": "sigue"},
+        ]
+        out = self.repair(msgs)
+        roles = [m["role"] for m in out]
+        assert roles == ["assistant", "tool", "tool", "user", "user"]
+        assert out[1]["tool_call_id"] == "c1"
+        assert out[2]["tool_call_id"] == "c2"
+        assert out[3]["content"].startswith("[Resultado de herramienta")
+
+
+class TestAdapterEndToEnd:
+    """_to_openai_messages + guard sobre un historial roto realista."""
+
+    def test_collapsed_assistant_history_produces_valid_openai_sequence(self):
+        from src.adapters.openai_adapter import OpenAIAdapter
+        adapter = OpenAIAdapter.__new__(OpenAIAdapter)  # sin cliente real
+
+        internal = [
+            {"role": "system", "content": "eres un agente"},
+            {"role": "user", "content": "haz algo"},
+            # Assistant colapsado por el compactor (perdio sus tool_use)
+            {"role": "assistant", "content": "[ASSISTANT COMPACTADO]"},
+            # …pero el user conserva sus tool_results (el bug de produccion)
+            {
+                "role": "user",
+                "content": [
+                    {"type": "tool_result", "tool_use_id": "call_1", "content": "datos"},
+                ],
+            },
+            {"role": "assistant", "content": "termine"},
+            {"role": "user", "content": "siguiente peticion"},
+        ]
+        out = adapter._to_openai_messages(internal)
+        # Contrato OpenAI: ningun role:tool sin tool_calls previo
+        for i, m in enumerate(out):
+            if m.get("role") == "tool":
+                assert i > 0
+                prev = out[i - 1]
+                prev_ids = set()
+                k = i - 1
+                while k >= 0 and out[k].get("role") == "tool":
+                    k -= 1
+                if k >= 0 and out[k].get("role") == "assistant":
+                    prev_ids = {
+                        tc.get("id") for tc in out[k].get("tool_calls") or []
+                    }
+                assert m.get("tool_call_id") in prev_ids, (
+                    f"role tool huerfano en out[{i}]"
+                )
+        # El tool_result huerfano acabo como user, no como role tool
+        assert not any(m.get("role") == "tool" for m in out)