Fix Codex continuation keying and delta reuse

Author: Mateusz

src/connectors/_openai_codex_connector.py

@@ -48,9 +48,15 @@
 from src.connectors._openai_codex_request_translator import CodexRequestTranslator
 from src.connectors._openai_codex_session_detector import SessionDetector
 from src.connectors.base import add_vendor_prefix, strip_vendor_prefix
-from src.connectors.contracts import ConnectorChatCompletionsRequest
+from src.connectors.contracts import (
+    ConnectorChatCompletionsRequest,
+    ConnectorRequestContext,
+)
 from src.connectors.openai import OpenAIConnector
 from src.connectors.openai_codex.compat import CompatibilityLayer
+from src.connectors.openai_codex.continuation import (
+    InMemoryCodexContinuationCoordinator,
+)
 from src.connectors.openai_codex.contracts import (
     CodexConnectorDependencies,
     CodexConnectorSettings,
@@ -272,6 +278,7 @@ def __init__(
             and self._dependencies.tool_execution_service is not None
             else ToolExecutionService()
         )
+        self._continuation_coordinator = InMemoryCodexContinuationCoordinator()
 
         self._compatibility_layer = (
             self._dependencies.compatibility_layer
@@ -324,6 +331,7 @@ def __init__(
                 max_retries=max_retries,
                 retry_backoff_seconds=retry_backoff_seconds,
                 compatibility_layer=self._compatibility_layer,
+                continuation_coordinator=self._continuation_coordinator,
                 use_websocket=use_websocket,
             )
         )
@@ -1342,6 +1350,7 @@ async def _call_codex_responses_api(
         domain_request: Any,
         *,
         options_metadata: Mapping[str, Any] | None = None,
+        request_context: ConnectorRequestContext | None = None,
     ) -> Any:
         """Call the Codex-specific Responses API endpoint."""
         capabilities = self._resolve_capabilities(request_data)
@@ -1469,6 +1478,11 @@ async def _call_codex_responses_api(
             if executor_metadata is None:
                 executor_metadata = {}
             executor_metadata["compatibility_state"] = compatibility_state
+        if request_context is not None:
+            if executor_metadata is None:
+                executor_metadata = {}
+            executor_metadata["connector_request_context"] = request_context
+            executor_metadata["capture_key_name"] = self.backend_type
 
         executor_context = CodexRequestContext.model_construct(
             request=request_data,
@@ -2065,6 +2079,7 @@ async def chat_completions(
                             if isinstance((md_raw := kwargs.get("metadata")), Mapping)
                             else None
                         ),
+                        request_context=request.context,
                     ),
                 )
                 if not self.is_functional:

src/connectors/openai_codex/client_families/opencode_adapter.py

@@ -73,15 +73,11 @@ def adapt_payload_dict(
         if not isinstance(instructions, str) or not instructions.strip():
             instructions = resolved_instructions or ""
 
-        bridge_prompt = self._build_bridge_prompt()
-        if bridge_prompt in instructions:
-            result["instructions"] = instructions
-            return result
-
-        if instructions.strip():
-            result["instructions"] = f"{instructions.rstrip()}\n\n{bridge_prompt}"
-        else:
-            result["instructions"] = bridge_prompt
+        result["instructions"] = self._append_instruction_block(
+            instructions,
+            marker=_OPENCODE_BRIDGE_MARKER,
+            block=self._build_bridge_prompt(),
+        )
         return result
 
     def _adapt_input_items(
@@ -144,15 +140,6 @@ def _normalize_input_item(item: object) -> dict[str, Any] | None:
         else:
             return None
 
-        if str(normalized.get("type") or "").strip().lower() == "item_reference":
-            return None
-
-        normalized.pop("id", None)
-        nested_item = normalized.get("item")
-        if isinstance(nested_item, Mapping):
-            nested_copy = dict(nested_item)
-            nested_copy.pop("id", None)
-            normalized["item"] = nested_copy
         return normalized
 
     def _is_opencode_system_prompt_item(self, item: Mapping[str, Any]) -> bool:
@@ -299,12 +286,16 @@ def append_incompatible_tool_steering(
             context,
         )
         instructions = result.get("instructions")
-        if isinstance(instructions, str) and steering in instructions:
+        if (
+            isinstance(instructions, str)
+            and _OPENCODE_INCOMPATIBLE_MARKER in instructions
+        ):
             return result
-        if isinstance(instructions, str) and instructions.strip():
-            result["instructions"] = f"{instructions.rstrip()}\n\n{steering}"
-        else:
-            result["instructions"] = steering
+        result["instructions"] = self._append_instruction_block(
+            instructions if isinstance(instructions, str) else "",
+            marker=_OPENCODE_INCOMPATIBLE_MARKER,
+            block=steering,
+        )
         return result
 
     def _resolve_supported_tool_names(self, context: CodexRequestContext) -> set[str]:
@@ -360,3 +351,16 @@ def _build_incompatible_tool_steering(
             "- For shell execution, arguments MUST be a JSON object with string "
             "`command` and string `description`."
         )
+
+    @staticmethod
+    def _append_instruction_block(
+        instructions: str,
+        *,
+        marker: str,
+        block: str,
+    ) -> str:
+        if marker in instructions:
+            return instructions
+        if instructions.strip():
+            return f"{instructions.rstrip()}\n\n{block}"
+        return block