Merge pull request #562 from matdev83/codex/fix-bug-in-request/response-rewriting-mvce3a

Fix rewriting of OpenAI Responses API instructions

Author: matdev83

src/core/app/middleware/content_rewriting_middleware.py

@@ -165,6 +165,59 @@ def _rewrite_responses_input(self, payload: dict[str, Any]) -> bool:
 
         return is_rewritten
 
+    def _rewrite_responses_instructions(self, payload: dict[str, Any]) -> bool:
+        """Rewrite OpenAI Responses API instructions in-place."""
+
+        instructions = payload.get("instructions")
+        if instructions is None:
+            return False
+
+        if isinstance(instructions, str):
+            rewritten = self.rewriter.rewrite_prompt(instructions, "system")
+            if rewritten != instructions:
+                payload["instructions"] = rewritten
+                return True
+            return False
+
+        if isinstance(instructions, dict):
+            text_value = instructions.get("text")
+            if isinstance(text_value, str):
+                rewritten_text = self.rewriter.rewrite_prompt(
+                    text_value, "system"
+                )
+                if rewritten_text != text_value:
+                    instructions["text"] = rewritten_text
+                    return True
+            return False
+
+        if isinstance(instructions, list):
+            is_rewritten = False
+            for index, block in enumerate(instructions):
+                if not isinstance(block, dict):
+                    if isinstance(block, str):
+                        rewritten_text = self.rewriter.rewrite_prompt(
+                            block, "system"
+                        )
+                        if rewritten_text != block:
+                            instructions[index] = rewritten_text
+                            is_rewritten = True
+                    continue
+
+                text_value = block.get("text")
+                if not isinstance(text_value, str):
+                    continue
+
+                rewritten_text = self.rewriter.rewrite_prompt(
+                    text_value, "system"
+                )
+                if rewritten_text != text_value:
+                    block["text"] = rewritten_text
+                    is_rewritten = True
+
+            return is_rewritten
+
+        return False
+
     def _rewrite_chat_response(self, payload: dict[str, Any]) -> bool:
         """Rewrite OpenAI chat completion responses in-place."""
 
@@ -304,6 +357,9 @@ async def dispatch(
                 if self._rewrite_responses_input(data):
                     is_rewritten = True
 
+                if self._rewrite_responses_instructions(data):
+                    is_rewritten = True
+
                 if is_rewritten:
                     body_bytes = json.dumps(data).encode("utf-8")
                     scope_for_next_call = dict(request.scope)

tests/integration/test_content_rewriting_middleware.py

@@ -255,6 +255,121 @@ async def run_test():
 
         asyncio.run(run_test())
 
+    def test_request_rewriting_responses_instructions_string(self):
+        """Ensure Responses API instructions strings are rewritten."""
+
+        rewriter = ContentRewriterService(config_path=self.test_config_dir)
+        middleware = ContentRewritingMiddleware(app=None, rewriter=rewriter)
+
+        request_payload = {
+            "instructions": "original system guidance",  # matches rule in setUp
+            "input": "user input",
+        }
+
+        async def call_next(request):
+            data = await request.json()
+            self.assertEqual(data["instructions"], "rewritten system guidance")
+            return Response(
+                content=json.dumps({"ok": True}), media_type="application/json"
+            )
+
+        async def receive():
+            return {
+                "type": "http.request",
+                "body": json.dumps(request_payload).encode("utf-8"),
+                "more_body": False,
+            }
+
+        request = Request(
+            {
+                "type": "http",
+                "method": "POST",
+                "headers": Headers({"content-type": "application/json"}).raw,
+                "http_version": "1.1",
+                "server": ("testserver", 80),
+                "client": ("testclient", 123),
+                "scheme": "http",
+                "root_path": "",
+                "path": "/test",
+                "raw_path": b"/test",
+                "query_string": b"",
+            },
+            receive=receive,
+        )
+
+        async def run_test():
+            response = await middleware.dispatch(request, call_next)
+            self.assertEqual(response.status_code, 200)
+
+        import asyncio
+
+        asyncio.run(run_test())
+
+    def test_request_rewriting_responses_instructions_blocks(self):
+        """Ensure Responses API instruction content blocks are rewritten."""
+
+        rewriter = ContentRewriterService(config_path=self.test_config_dir)
+        middleware = ContentRewritingMiddleware(app=None, rewriter=rewriter)
+
+        request_payload = {
+            "instructions": [
+                {"type": "text", "text": "original system guidance"},
+                {"type": "image", "image_url": {"url": "https://example.com"}},
+            ],
+            "input": [
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": "This should remain unchanged."}
+                    ],
+                }
+            ],
+        }
+
+        async def call_next(request):
+            data = await request.json()
+            instructions = data["instructions"]
+            self.assertIsInstance(instructions, list)
+            self.assertEqual(instructions[0]["text"], "rewritten system guidance")
+            self.assertEqual(
+                instructions[1]["image_url"]["url"], "https://example.com"
+            )
+            return Response(
+                content=json.dumps({"ok": True}), media_type="application/json"
+            )
+
+        async def receive():
+            return {
+                "type": "http.request",
+                "body": json.dumps(request_payload).encode("utf-8"),
+                "more_body": False,
+            }
+
+        request = Request(
+            {
+                "type": "http",
+                "method": "POST",
+                "headers": Headers({"content-type": "application/json"}).raw,
+                "http_version": "1.1",
+                "server": ("testserver", 80),
+                "client": ("testclient", 123),
+                "scheme": "http",
+                "root_path": "",
+                "path": "/test",
+                "raw_path": b"/test",
+                "query_string": b"",
+            },
+            receive=receive,
+        )
+
+        async def run_test():
+            response = await middleware.dispatch(request, call_next)
+            self.assertEqual(response.status_code, 200)
+
+        import asyncio
+
+        asyncio.run(run_test())
+
     def test_outbound_prompt_rewriting(self):
         """Verify that outbound prompts are rewritten correctly."""