python-codex 0.2.7__py3-none-any.whl → 0.3.1__py3-none-any.whl

responses_server/stream_router.py

@@ -1,25 +1,22 @@
-
-import json
 import http.client
+import json
 import ssl
+import time
+import typing
 import urllib.error
 import urllib.request
+from contextlib import contextmanager
 
 from .config import CompatServerConfig
-from .messages_api import (
-    MessagesAPIAdapterError,
-    build_messages_request,
-    iter_chat_chunks as iter_chat_chunks_from_messages,
-    saw_message_stop as messages_saw_message_stop,
-)
+from .messages_api import MessagesAPIAdapterError, build_messages_request
+from .messages_api import iter_chat_chunks as iter_chat_chunks_from_messages
+from .messages_api import saw_message_stop as messages_saw_message_stop
 from .session_store import StoredResponse
 from .tools import WebSearchTool, collect_custom_tool_names
-from .tools.custom_adapter import (
-    CustomToolAdapterError,
-    build_output_item as build_custom_output_item,
-    build_tool_call as build_custom_tool_call,
-    build_tool_definition as build_custom_tool_definition,
-)
+from .tools.custom_adapter import CustomToolAdapterError
+from .tools.custom_adapter import build_output_item as build_custom_output_item
+from .tools.custom_adapter import build_tool_call as build_custom_tool_call
+from .tools.custom_adapter import build_tool_definition as build_custom_tool_definition
 from .tools.web_search import (
     build_followup_request,
     build_output_items,
@@ -28,7 +25,6 @@ from .tools.web_search import (
     partition_tool_calls,
 )
 from .trajectory_dump import TrajectoryDumpWriter
-import typing
 
 
 class UnsupportedIncommingFeature(ValueError):
@@ -38,23 +34,23 @@ class UnsupportedIncommingFeature(ValueError):
 class OutcommingChatError(RuntimeError):
     def __init__(
         self,
-        message: 'str',
-        error_type: 'typing.Union[str, None]' = None,
-    ) -> 'None':
+        message: "str",
+        error_type: "typing.Union[str, None]" = None,
+    ) -> "None":
         super().__init__(message)
         self.error_type = error_type
 
 
 class StreamRouter:
-    def __init__(self, config: 'CompatServerConfig') -> 'None':
+    def __init__(self, config: "CompatServerConfig") -> "None":
         self._config = config
         self._mock_web_search = WebSearchTool()
 
     def _provider_capability(
         self,
-        explicit_support: 'typing.Dict[str, bool]',
-        default: 'typing.Union[bool, None]' = None,
-    ) -> 'bool':
+        explicit_support: "typing.Dict[str, bool]",
+        default: "typing.Union[bool, None]" = None,
+    ) -> "bool":
         provider_name = str(self._config.model_provider or "").strip().lower()
         if provider_name in explicit_support:
             return explicit_support[provider_name]
@@ -64,7 +60,7 @@ class StreamRouter:
             return default
         raise KeyError("provider capability map is missing `vllm` fallback")
 
-    def _supports_chat_reasoning(self) -> 'bool':
+    def _supports_chat_reasoning(self) -> "bool":
         # Unknown providers inherit the vLLM compatibility behavior unless a
         # provider is explicitly declared otherwise.
         return self._provider_capability(
@@ -74,7 +70,7 @@ class StreamRouter:
             }
         )
 
-    def _supports_stream_usage(self) -> 'bool':
+    def _supports_stream_usage(self) -> "bool":
         return self._provider_capability(
             {
                 "vllm": True,
@@ -84,8 +80,8 @@ class StreamRouter:
 
     def validate_incomming_request(
         self,
-        incomming_request: 'typing.Dict[str, object]',
-    ) -> 'None':
+        incomming_request: "typing.Dict[str, object]",
+    ) -> "None":
         model = str(incomming_request.get("model", "")).strip()
         if not model:
             raise UnsupportedIncommingFeature("incomming request is missing `model`")
@@ -104,11 +100,11 @@ class StreamRouter:
 
     def collect_custom_tool_names(
         self,
-        incomming_request: 'typing.Dict[str, object]',
-    ) -> 'typing.Set[str]':
+        incomming_request: "typing.Dict[str, object]",
+    ) -> "typing.Set[str]":
         return collect_custom_tool_names(incomming_request.get("tools") or [])
 
-    def list_models(self) -> 'typing.Dict[str, object]':
+    def list_models(self) -> "typing.Dict[str, object]":
         request = urllib.request.Request(
             self._config.outcomming_models_url(),
             headers=self._build_headers(accept="application/json"),
@@ -118,8 +114,8 @@ class StreamRouter:
 
     def build_outcomming_request(
         self,
-        incomming_request: 'typing.Dict[str, object]',
-    ) -> 'typing.Dict[str, object]':
+        incomming_request: "typing.Dict[str, object]",
+    ) -> "typing.Dict[str, object]":
         model = str(incomming_request.get("model", "")).strip()
         if not model:
             raise UnsupportedIncommingFeature("incomming request is missing `model`")
@@ -135,7 +131,7 @@ class StreamRouter:
         if not isinstance(input_items, list):
             raise UnsupportedIncommingFeature("incomming `input` must be a list")
 
-        payload: 'typing.Dict[str, object]' = {
+        payload: "typing.Dict[str, object]" = {
             "model": model,
             "messages": self._responses_input_to_chat_messages(
                 instructions,
@@ -180,7 +176,7 @@ class StreamRouter:
 
         return payload
 
-    def open_outcomming_stream(self, outcomming_request: 'typing.Dict[str, object]'):
+    def open_outcomming_stream(self, outcomming_request: "typing.Dict[str, object]"):
         outcomming_api = self._config.normalized_outcomming_api()
         if outcomming_api == "messages":
             return self._open_outcomming_messages_stream(outcomming_request)
@@ -192,7 +188,7 @@ class StreamRouter:
 
     def _open_outcomming_chat_stream(
         self,
-        outcomming_request: 'typing.Dict[str, object]',
+        outcomming_request: "typing.Dict[str, object]",
     ):
         request = urllib.request.Request(
             self._config.outcomming_chat_completions_url(),
@@ -200,12 +196,19 @@ class StreamRouter:
             headers=self._build_headers(accept="text/event-stream"),
             method="POST",
         )
+        with self._request_diagnostics(request) as progress:
+            yield from self._read_outcomming_chat_stream(request, progress)
+
+    def _read_outcomming_chat_stream(self, request, progress):
         try:
             with urllib.request.urlopen(
                 request,
                 context=ssl.create_default_context(),
                 timeout=self._config.timeout_seconds,
             ) as response:
+                progress["headers_at"] = time.monotonic()
+                progress["status"] = response.status
+                progress["phase"] = "waiting_first_chunk"
                 try:
                     saw_done = False
                     for _event_name, data in self._iter_sse_events(response):
@@ -214,7 +217,14 @@ class StreamRouter:
                         if data == "[DONE]":
                             saw_done = True
                             break
-                        yield json.loads(data)
+                        payload = json.loads(data)
+                        self._received_chunk(progress)
+                        if isinstance(payload, dict) and payload.get("error") is not None:
+                            raise OutcommingChatError(
+                                "outcomming chat stream returned an error: "
+                                + json.dumps(payload["error"], ensure_ascii=False)[:500]
+                            )
+                        yield payload
                     if not saw_done:
                         raise OutcommingChatError(
                             "outcomming chat stream ended before [DONE]"
@@ -231,6 +241,9 @@ class StreamRouter:
                         f"{exc}"
                     ) from exc
         except urllib.error.HTTPError as exc:
+            progress["headers_at"] = time.monotonic()
+            progress["status"] = exc.code
+            progress["phase"] = "reading_error_body"
             body = exc.read().decode("utf-8", errors="replace")
             raise OutcommingChatError(
                 f"outcomming chat request failed with status {exc.code}: {body[:500]}"
@@ -244,10 +257,15 @@ class StreamRouter:
             raise OutcommingChatError(
                 f"outcomming chat request failed: {exc.reason}"
             ) from exc
+        except (OSError, EOFError, http.client.HTTPException) as exc:
+            raise OutcommingChatError(
+                "outcomming chat request failed while opening response: "
+                f"{type(exc).__name__}: {exc}"
+            ) from exc
 
     def _open_outcomming_messages_stream(
         self,
-        outcomming_request: 'typing.Dict[str, object]',
+        outcomming_request: "typing.Dict[str, object]",
     ):
         try:
             messages_request = build_messages_request(outcomming_request)
@@ -260,20 +278,28 @@ class StreamRouter:
             headers=self._build_headers(accept="text/event-stream"),
             method="POST",
         )
+        with self._request_diagnostics(request) as progress:
+            yield from self._read_outcomming_messages_stream(request, progress)
+
+    def _read_outcomming_messages_stream(self, request, progress):
         try:
             with urllib.request.urlopen(
                 request,
                 context=ssl.create_default_context(),
                 timeout=self._config.timeout_seconds,
             ) as response:
+                progress["headers_at"] = time.monotonic()
+                progress["status"] = response.status
+                progress["phase"] = "waiting_first_chunk"
                 try:
-                    stream_state: 'typing.Dict[str, object]' = {}
+                    stream_state: "typing.Dict[str, object]" = {}
                     for event_name, data in self._iter_sse_events(response):
                         if not data:
                             continue
                         payload = json.loads(data)
                         if not isinstance(payload, dict):
                             continue
+                        self._received_chunk(progress)
                         for chunk in iter_chat_chunks_from_messages(
                             event_name,
                             payload,
@@ -297,6 +323,9 @@ class StreamRouter:
                         f"{exc}"
                     ) from exc
         except urllib.error.HTTPError as exc:
+            progress["headers_at"] = time.monotonic()
+            progress["status"] = exc.code
+            progress["phase"] = "reading_error_body"
             body = exc.read().decode("utf-8", errors="replace")
             raise OutcommingChatError(
                 f"outcomming messages request failed with status {exc.code}: {body[:500]}"
@@ -310,13 +339,18 @@ class StreamRouter:
             raise OutcommingChatError(
                 f"outcomming messages request failed: {exc.reason}"
             ) from exc
+        except (OSError, EOFError, http.client.HTTPException) as exc:
+            raise OutcommingChatError(
+                "outcomming messages request failed while opening response: "
+                f"{type(exc).__name__}: {exc}"
+            ) from exc
 
     def route_stream(
         self,
-        stored_response: 'StoredResponse',
-        outcomming_request: 'typing.Dict[str, object]',
-        custom_tool_names: 'typing.Union[typing.Set[str], None]' = None,
-        trajectory_dump: 'typing.Union[TrajectoryDumpWriter, None]' = None,
+        stored_response: "StoredResponse",
+        outcomming_request: "typing.Dict[str, object]",
+        custom_tool_names: "typing.Union[typing.Set[str], None]" = None,
+        trajectory_dump: "typing.Union[TrajectoryDumpWriter, None]" = None,
     ):
         yield (
             "response.created",
@@ -331,9 +365,9 @@ class StreamRouter:
             },
         )
 
-        text_parts: 'typing.List[str]' = []
-        reasoning_parts: 'typing.List[str]' = []
-        latest_usage: 'typing.Dict[str, object]' = {}
+        text_parts: "typing.List[str]" = []
+        reasoning_parts: "typing.List[str]" = []
+        latest_usage: "typing.Dict[str, object]" = {}
         current_request = json.loads(json.dumps(outcomming_request))
         current_stream = self._open_tracked_outcomming_stream(
             current_request,
@@ -342,9 +376,9 @@ class StreamRouter:
         retried_reasoning_only_output = False
 
         while True:
-            tool_calls: 'typing.Dict[int, typing.Dict[str, object]]' = {}
-            finish_reasons: 'typing.List[str]' = []
-            current_usage: 'typing.Dict[str, object]' = {}
+            tool_calls: "typing.Dict[int, typing.Dict[str, object]]" = {}
+            finish_reasons: "typing.List[str]" = []
+            current_usage: "typing.Dict[str, object]" = {}
             reasoning_start = len(reasoning_parts)
             text_start = len(text_parts)
             for chunk in current_stream:
@@ -458,8 +492,8 @@ class StreamRouter:
 
     def _open_tracked_outcomming_stream(
         self,
-        outcomming_request: 'typing.Dict[str, object]',
-        trajectory_dump: 'typing.Union[TrajectoryDumpWriter, None]' = None,
+        outcomming_request: "typing.Dict[str, object]",
+        trajectory_dump: "typing.Union[TrajectoryDumpWriter, None]" = None,
     ):
         outcomming_stream = self.open_outcomming_stream(outcomming_request)
         if trajectory_dump is None:
@@ -469,19 +503,71 @@ class StreamRouter:
             outcomming_request,
         )
 
+    @contextmanager
+    def _request_diagnostics(self, request):
+        started = time.monotonic()
+        progress = {
+            "phase": "waiting_response_headers",
+            "headers_at": None,
+            "first_chunk_at": None,
+            "last_chunk_at": None,
+            "chunks": 0,
+            "status": None,
+        }
+        try:
+            yield progress
+        except OutcommingChatError as exc:
+            now = time.monotonic()
+            cause = exc.__cause__ or exc
+            if isinstance(cause, urllib.error.URLError) and isinstance(
+                cause.reason, BaseException
+            ):
+                cause = cause.reason
+
+            def timing(received_at):
+                if received_at is None:
+                    return "not_received"
+                return f"{received_at - started:.2f}s"
+
+            idle = (
+                f"{now - progress['last_chunk_at']:.2f}s"
+                if progress["last_chunk_at"] is not None
+                else "not_started"
+            )
+            details = (
+                f"phase={progress['phase']}, elapsed={now - started:.2f}s, "
+                f"timeout={self._config.timeout_seconds:g}s\n"
+                f"headers={timing(progress['headers_at'])}, "
+                f"first_chunk={timing(progress['first_chunk_at'])}, "
+                f"chunks={progress['chunks']}, idle={idle}\n"
+                f"status={progress['status']}, "
+                f"request_bytes={len(request.data or b'')}, "
+                f"exception={type(cause).__name__}"
+            )
+            exc.args = (f"{exc}\n{details}",)
+            raise
+
+    def _received_chunk(self, progress):
+        now = time.monotonic()
+        if progress["chunks"] == 0:
+            progress["first_chunk_at"] = now
+        progress["last_chunk_at"] = now
+        progress["chunks"] += 1
+        progress["phase"] = "reading_stream"
+
     def _responses_input_to_chat_messages(
         self,
-        instructions: 'str',
-        input_items: 'typing.List[object]',
-    ) -> 'typing.List[typing.Dict[str, object]]':
-        messages: 'typing.List[typing.Dict[str, object]]' = []
+        instructions: "str",
+        input_items: "typing.List[object]",
+    ) -> "typing.List[typing.Dict[str, object]]":
+        messages: "typing.List[typing.Dict[str, object]]" = []
         if instructions:
             messages.append({"role": "developer", "content": instructions})
 
-        pending_assistant: 'typing.Union[typing.Dict[str, object], None]' = None
-        pending_tool_images: 'typing.List[typing.Dict[str, object]]' = []
+        pending_assistant: "typing.Union[typing.Dict[str, object], None]" = None
+        pending_tool_images: "typing.List[typing.Dict[str, object]]" = []
 
-        def flush_pending_assistant() -> 'None':
+        def flush_pending_assistant() -> "None":
             nonlocal pending_assistant
             if pending_assistant is None:
                 return
@@ -495,7 +581,7 @@ class StreamRouter:
             messages.append(pending_assistant)
             pending_assistant = None
 
-        def flush_pending_tool_images() -> 'None':
+        def flush_pending_tool_images() -> "None":
             if not pending_tool_images:
                 return
             messages.append({"role": "user", "content": list(pending_tool_images)})
@@ -531,9 +617,9 @@ class StreamRouter:
                     continue
                 flush_pending_assistant()
                 if image_parts:
-                    content: 'object' = (
-                        ([{"type": "text", "text": text}] if text else []) + image_parts
-                    )
+                    content: "object" = (
+                        [{"type": "text", "text": text}] if text else []
+                    ) + image_parts
                 else:
                     content = text
                 messages.append({"role": role, "content": content})
@@ -625,7 +711,7 @@ class StreamRouter:
         flush_pending_tool_images()
         return messages
 
-    def _coerce_positive_int(self, raw_value: 'object') -> 'typing.Union[int, None]':
+    def _coerce_positive_int(self, raw_value: "object") -> "typing.Union[int, None]":
         if isinstance(raw_value, bool):
             return None
         if isinstance(raw_value, int) and raw_value > 0:
@@ -634,8 +720,8 @@ class StreamRouter:
 
     def _split_content_parts(
         self,
-        raw_content: 'object',
-    ) -> 'typing.Tuple[str, typing.List[typing.Dict[str, object]]]':
+        raw_content: "object",
+    ) -> "typing.Tuple[str, typing.List[typing.Dict[str, object]]]":
         if raw_content is None:
             return "", []
         if isinstance(raw_content, str):
@@ -645,8 +731,8 @@ class StreamRouter:
                 "message `content` must be a list or string"
             )
 
-        text_parts: 'typing.List[str]' = []
-        image_parts: 'typing.List[typing.Dict[str, object]]' = []
+        text_parts: "typing.List[str]" = []
+        image_parts: "typing.List[typing.Dict[str, object]]" = []
         for part in raw_content:
             if not isinstance(part, dict):
                 raise UnsupportedIncommingFeature(
@@ -666,14 +752,14 @@ class StreamRouter:
 
     def _build_chat_image_part(
         self,
-        part: 'typing.Dict[str, object]',
-    ) -> 'typing.Dict[str, object]':
+        part: "typing.Dict[str, object]",
+    ) -> "typing.Dict[str, object]":
         image_url = str(part.get("image_url", "") or "").strip()
         if not image_url:
             raise UnsupportedIncommingFeature(
                 "`input_image` content parts must carry a non-empty `image_url`"
             )
-        image_payload: 'typing.Dict[str, object]' = {"url": image_url}
+        image_payload: "typing.Dict[str, object]" = {"url": image_url}
         detail = part.get("detail")
         if isinstance(detail, str) and detail in {"auto", "low", "high"}:
             image_payload["detail"] = detail
@@ -681,18 +767,18 @@ class StreamRouter:
 
     def _split_tool_output_parts(
         self,
-        raw_output: 'object',
-    ) -> 'typing.Tuple[str, typing.List[typing.Dict[str, object]]]':
+        raw_output: "object",
+    ) -> "typing.Tuple[str, typing.List[typing.Dict[str, object]]]":
         if isinstance(raw_output, str):
             return raw_output, []
         if isinstance(raw_output, list):
             return self._split_content_parts(raw_output)
         return json.dumps(raw_output, ensure_ascii=False), []
 
-    def _coalesce_reasoning_text(self, raw_item: 'typing.Dict[str, object]') -> 'str':
+    def _coalesce_reasoning_text(self, raw_item: "typing.Dict[str, object]") -> "str":
         content = raw_item.get("content")
         if isinstance(content, list):
-            text_parts: 'typing.List[str]' = []
+            text_parts: "typing.List[str]" = []
             for part in content:
                 if not isinstance(part, dict):
                     continue
@@ -719,8 +805,10 @@ class StreamRouter:
                 return value
         return ""
 
-    def _translate_tools(self, incomming_tools: 'typing.List[object]') -> 'typing.List[typing.Dict[str, object]]':
-        translated: 'typing.List[typing.Dict[str, object]]' = []
+    def _translate_tools(
+        self, incomming_tools: "typing.List[object]"
+    ) -> "typing.List[typing.Dict[str, object]]":
+        translated: "typing.List[typing.Dict[str, object]]" = []
         for raw_tool in incomming_tools:
             if not isinstance(raw_tool, dict):
                 raise UnsupportedIncommingFeature("tool definitions must be objects")
@@ -755,7 +843,7 @@ class StreamRouter:
             )
         return translated
 
-    def _translate_tool_choice(self, raw_tool_choice: 'object') -> 'object':
+    def _translate_tool_choice(self, raw_tool_choice: "object") -> "object":
         if isinstance(raw_tool_choice, str):
             return raw_tool_choice
         if not isinstance(raw_tool_choice, dict):
@@ -778,14 +866,14 @@ class StreamRouter:
 
     def _consume_chat_chunk(
         self,
-        payload: 'typing.Dict[str, object]',
-        reasoning_parts: 'typing.List[str]',
-        text_parts: 'typing.List[str]',
-        tool_calls: 'typing.Dict[int, typing.Dict[str, object]]',
-        current_usage: 'typing.Dict[str, object]',
-        finish_reasons: 'typing.List[str]',
-    ) -> 'typing.List[typing.Tuple[str, typing.Dict[str, object]]]':
-        events: 'typing.List[typing.Tuple[str, typing.Dict[str, object]]]' = []
+        payload: "typing.Dict[str, object]",
+        reasoning_parts: "typing.List[str]",
+        text_parts: "typing.List[str]",
+        tool_calls: "typing.Dict[int, typing.Dict[str, object]]",
+        current_usage: "typing.Dict[str, object]",
+        finish_reasons: "typing.List[str]",
+    ) -> "typing.List[typing.Tuple[str, typing.Dict[str, object]]]":
+        events: "typing.List[typing.Tuple[str, typing.Dict[str, object]]]" = []
         usage = payload.get("usage")
         if isinstance(usage, dict):
             self._capture_usage_snapshot(current_usage, usage)
@@ -876,9 +964,9 @@ class StreamRouter:
 
     def _capture_usage_snapshot(
         self,
-        current_usage: 'typing.Dict[str, object]',
-        usage: 'typing.Dict[str, object]',
-    ) -> 'None':
+        current_usage: "typing.Dict[str, object]",
+        usage: "typing.Dict[str, object]",
+    ) -> "None":
         scalar_mappings = (
             ("input_tokens", usage.get("input_tokens", usage.get("prompt_tokens"))),
             (
@@ -910,12 +998,12 @@ class StreamRouter:
 
     def _build_output_items(
         self,
-        reasoning_parts: 'typing.List[str]',
-        text_parts: 'typing.List[str]',
-        tool_calls: 'typing.Dict[int, typing.Dict[str, object]]',
-        custom_tool_names: 'typing.Set[str]',
-    ) -> 'typing.List[typing.Dict[str, object]]':
-        items: 'typing.List[typing.Dict[str, object]]' = []
+        reasoning_parts: "typing.List[str]",
+        text_parts: "typing.List[str]",
+        tool_calls: "typing.Dict[int, typing.Dict[str, object]]",
+        custom_tool_names: "typing.Set[str]",
+    ) -> "typing.List[typing.Dict[str, object]]":
+        items: "typing.List[typing.Dict[str, object]]" = []
         reasoning_text = "".join(reasoning_parts)
         if reasoning_text:
             items.append(
@@ -968,11 +1056,18 @@ class StreamRouter:
                 except CustomToolAdapterError as exc:
                     raise OutcommingChatError(str(exc)) from exc
                 continue
+            try:
+                json.loads(arguments)
+            except json.JSONDecodeError as exc:
+                raise OutcommingChatError(
+                    f"outcomming function call arguments for {name!r} "
+                    f"contain invalid JSON: {exc}",
+                    error_type="server_error",
+                ) from exc
             items.append(
                 {
                     "type": "function_call",
-                    "call_id": str(tool_call.get("id", "")).strip()
-                    or f"call_{index}",
+                    "call_id": str(tool_call.get("id", "")).strip() or f"call_{index}",
                     "name": name,
                     "arguments": arguments,
                 }
@@ -980,15 +1075,27 @@ class StreamRouter:
 
         return items
 
-    def _request_json(self, request: 'urllib.request.Request') -> 'typing.Dict[str, object]':
+    def _request_json(
+        self, request: "urllib.request.Request"
+    ) -> "typing.Dict[str, object]":
+        with self._request_diagnostics(request) as progress:
+            return self._read_json_response(request, progress)
+
+    def _read_json_response(self, request, progress):
         try:
             with urllib.request.urlopen(
                 request,
                 context=ssl.create_default_context(),
                 timeout=self._config.timeout_seconds,
             ) as response:
+                progress["headers_at"] = time.monotonic()
+                progress["status"] = response.status
+                progress["phase"] = "reading_response_body"
                 return json.loads(response.read().decode("utf-8"))
         except urllib.error.HTTPError as exc:
+            progress["headers_at"] = time.monotonic()
+            progress["status"] = exc.code
+            progress["phase"] = "reading_error_body"
             body = exc.read().decode("utf-8", errors="replace")
             raise OutcommingChatError(
                 f"outcomming request failed with status {exc.code}: {body[:500]}"
@@ -1002,8 +1109,12 @@ class StreamRouter:
             raise OutcommingChatError(
                 f"outcomming request failed: {exc.reason}"
             ) from exc
+        except (OSError, EOFError, http.client.HTTPException) as exc:
+            raise OutcommingChatError(
+                f"outcomming request failed: {type(exc).__name__}: {exc}"
+            ) from exc
 
-    def _build_headers(self, accept: 'str') -> 'typing.Dict[str, str]':
+    def _build_headers(self, accept: "str") -> "typing.Dict[str, str]":
         headers = {
             "Accept": accept,
             "Content-Type": "application/json",
@@ -1014,8 +1125,8 @@ class StreamRouter:
         return headers
 
     def _iter_sse_events(self, response):
-        event_name: 'typing.Union[str, None]' = None
-        data_lines: 'typing.List[str]' = []
+        event_name: "typing.Union[str, None]" = None
+        data_lines: "typing.List[str]" = []
 
         for raw_line in response:
             line = raw_line.decode("utf-8", errors="replace").rstrip("\r\n")