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

python_codex-0.3.0.dist-info/RECORD

@@ -0,0 +1,90 @@
+pycodex/__init__.py,sha256=4BBGUXImsNBdSQjp2KtshkjQK9BMz5gK93DzpWokkWY,3235
+pycodex/agent.py,sha256=zCIG2DV0oQntLXHFj8FVRkgBp5TCC0YJ7sz0lni9J1s,21177
+pycodex/bootstrap.py,sha256=DSVx8u94tHRYbUa_e9zdKPqozOv_CrfctbTKZ4JG064,13765
+pycodex/cli.py,sha256=m5IJhnodNqsfMTIzdwbuaHBl2r-N8x1MxYSpe_hlHiM,12997
+pycodex/compat.py,sha256=yoQQWMiAQ6ytZv3DAMIbp66ImA0kyY4G5eKHrtwmj6c,3490
+pycodex/context.py,sha256=nkq2Y0coZNpWs5IJj7uVVT65fDqh58Z9c07y_Wy0f4Q,26604
+pycodex/doctor.py,sha256=9p624b1zloXbhyMRi1-Of1YtnYeoF4zHxfGFhfujDS4,10620
+pycodex/events.py,sha256=MZljtqra6-Hnt9Emjbn_wgp5cGaODx1w3CbmIKd5htI,29692
+pycodex/feishu_card.py,sha256=Gclo4TI3KTfdT5NDLiv58CRg6hH3sUCRXuSrHgXgYjI,27767
+pycodex/feishu_link.py,sha256=yUbEvO-8g-Bxo8_cF9s6vLZguz3NA6q3qt2A9Q09fsE,14523
+pycodex/model.py,sha256=cKG2STZ_Kc3ThelY6KTTRkBTCrIwcmF74Rhfhj71N08,44175
+pycodex/model_metadata.py,sha256=RMYhvgkm2v1nhCslSiDXPAwrRAx8FPz9QJqv8QTbWlc,1332
+pycodex/portable.py,sha256=rfOpVnBZ01RS0Kyjo_w2FNKHY2t-lUcHVtWhPsbp1-k,16158
+pycodex/portable_server.py,sha256=A4IY3xHtBQLRxdHQ4O5zdaVGjqENaLvypsSkLGZvCZ0,7498
+pycodex/protocol.py,sha256=dRcTVKTaE7Eaq_jiSYdCzBMebIo3gnL7wB1x-NJqY5E,12027
+pycodex/runtime.py,sha256=bRlqrmXqK6kPndAG96QoGALKicbWmfuXgo2jDvbQzdE,23806
+pycodex/runtime_services.py,sha256=4jDCMlXHwgbJZPJkWzVEPCRHPxrD0mpCBbDInVToGG8,15033
+pycodex/prompts/default_base_instructions.md,sha256=D65mcj6bo4CDvVom-D9cbJRJVNquo0NghKt164_fRsg,20923
+pycodex/prompts/models.json,sha256=9UUBlKwpQSrt53WS-D--I3pQVBhRUe9XhDpEHUS6be8,330811
+pycodex/prompts/permissions/approval_policy/never.md,sha256=QceTG6wjkaJARjYr0HYV1aPnPcpGcrkRUW-smWRr6MQ,120
+pycodex/prompts/permissions/approval_policy/on_failure.md,sha256=dfJjpXkpO6_ANdCKxbVJ8o4vyLxevrJWfKsGHTqtbkc,289
+pycodex/prompts/permissions/approval_policy/on_request.md,sha256=hVQalzh0FAdkKzw5u-N4H7-LtC9ijVDlYsh3OKsZKzo,3661
+pycodex/prompts/permissions/approval_policy/on_request_rule_request_permission.md,sha256=mOinishp1k-wlPsaEuIOMn5GoVm_dAIsWIuEMmv2r7o,1725
+pycodex/prompts/permissions/approval_policy/unless_trusted.md,sha256=XHpi1Lfx1iIXFbbQ_ho_kGstA3JN-RLho291HM30UNw,247
+pycodex/prompts/permissions/sandbox_mode/danger_full_access.md,sha256=nZ7YHacBd3cAHKRZc9XClOOOnXJPXPh0WFBueh5C2D0,197
+pycodex/prompts/permissions/sandbox_mode/read_only.md,sha256=2rAPEXsBYCcuttI5j3euS-3uv_v97catIsnhxlSQSIM,173
+pycodex/prompts/permissions/sandbox_mode/workspace_write.md,sha256=lVN-LwrBbHqlv5yVjcd_mU8tzZW8jfKpTatJKIZu9HI,277
+pycodex/tools/__init__.py,sha256=UYwmsX_Ckw_YaYQ6TYhUU6w5pxi2qzZoTrq6BAgNErM,1857
+pycodex/tools/agent_tool_schemas.py,sha256=8cL9ml4So0H6IIeK0ZzjAo9bk3VeprDOSYPpIamOqEU,2048
+pycodex/tools/apply_patch_tool.py,sha256=t8XFCGZ7q-s9C1Ty6qkReBRk-QD3ONvcKXLAz9djKRY,13956
+pycodex/tools/base_tool.py,sha256=kNNzPWijtdl4C_GunyR5G1qvsr7KQtnFJ2RiRHHnAYo,6478
+pycodex/tools/clock_tool.py,sha256=2_RYbBEw4V9_f1L-qZl3hhJ6XNPM_gBDmOlCh1cCAjo,6575
+pycodex/tools/close_agent_tool.py,sha256=zQtvd5iGW6YCPFiec8zc2OdGtgNIxoA4p2ZTuCoJOaI,2031
+pycodex/tools/code_mode_manager.py,sha256=VFVn7S_qUHCOHW952CMeGxTIE-7CPOx2uuXJZgBml8o,19160
+pycodex/tools/exec_command_tool.py,sha256=iqRiKaaX-AjG6LjATAMOakHIP0gpCWCj2o8af_8eAiQ,4464
+pycodex/tools/exec_runtime.js,sha256=DR1uocKailTqNWAcJNFJuQgFFMSUzTpT_uQsRaneg2s,3643
+pycodex/tools/exec_tool.py,sha256=tuC21rlhP8CPSYml4XnSDSRV0UPGkQ6aHj0DLIoOOvM,2274
+pycodex/tools/grep_files_tool.py,sha256=Ysw68VKI9OEvUH5haYx8FWuthkHykc1wskbuzjj8gTk,5293
+pycodex/tools/ipython_tool.py,sha256=SKVYpJEwlYjOQZQWbpqvrA-3K9aJTlIG9KM50p5JYUM,4496
+pycodex/tools/list_dir_tool.py,sha256=_U6ouRcVbGHT5mChVyUsiMgDGrFK7EFMFaspPLAHtH8,5337
+pycodex/tools/read_file_tool.py,sha256=YK__uhIVldBjAQega5S_ZuZU5jgP_kLOwr-YhjAmRo4,9735
+pycodex/tools/request_permissions_tool.py,sha256=n8eg29SgRbx1DUxxLbAztnc5i-0j2N2WnDupspjwWbE,3979
+pycodex/tools/request_user_input_tool.py,sha256=_7siHF2p3KiNDFwsTqKKIUw2kPCXMzLaR12PkZ1wdIQ,4050
+pycodex/tools/resume_agent_tool.py,sha256=D_OcWQbIbsWf-2NrRgDab4hB6BUbay0XidfPInhg88Y,1614
+pycodex/tools/send_input_tool.py,sha256=J91LLz4RpvHmBWti0XZgI9xWipWwD8-1hQIdC8-Jd5E,3762
+pycodex/tools/shell_command_tool.py,sha256=US63I5xiV5zfO1Oox2yHUg7F6XoKzmyxtohfaQIsmrw,4216
+pycodex/tools/shell_tool.py,sha256=lqFH2XosfBg7yQKhpB7i4vLGz9sNQtEZihD0rjsmBCQ,4068
+pycodex/tools/spawn_agent_tool.py,sha256=n_WZi1IX4Waj-GQ-hR1BVlk3zzw_ssvem7zcj3tYI38,6209
+pycodex/tools/unified_exec_manager.py,sha256=sO1H3uoXyZ6DiyF98-eidQ77mS-P5gSWyPqM3L50yTQ,14538
+pycodex/tools/update_plan_tool.py,sha256=8zyANrQgj8u2LBJ2yz_0Cg5jP3S6ibp6eASxUupX9C8,3199
+pycodex/tools/view_image_tool.py,sha256=UZRkBEwuCkqxOw7XBwacdgPZAtbnD6uSHTdm-6amUo4,3902
+pycodex/tools/wait_agent_tool.py,sha256=2OWfb9FCGu5SjbRp33dVEJWG3apMtQgczvQR1V_rm6I,3829
+pycodex/tools/wait_tool.py,sha256=0_OO_DvMsBhG3oDKZePTOjZTBq1lmWntXAzqIqvebdA,3206
+pycodex/tools/web_search_tool.py,sha256=3ao1IvJw7MwcP35UKLbqrM-nlm5Z-UUFVdEzkJYOV1o,988
+pycodex/tools/write_stdin_tool.py,sha256=jvBDchLLmoDITd7g-ZVeEVXHRhWKkmnjM5laL-53FOM,3609
+pycodex/utils/__init__.py,sha256=lbf-jbo6JS7t1wfFkQqLHlG4zZVqXYGkOIj2cvtrjx8,591
+pycodex/utils/async_bridge.py,sha256=d21Pjim-nsQbSG5pJddd0WaQ03CzA3w3TINWDmmjWbg,1815
+pycodex/utils/compactor.py,sha256=0tlszw1n54aMEGH6sL1U1dEgFSU5ioYL2NI5uSvHSiM,6119
+pycodex/utils/debug.py,sha256=BdXmuAQVWVB1BONKRDlkMpgXpkt4M1jhvEAq5n2AumI,296
+pycodex/utils/dotenv.py,sha256=h7ZgvqpEswetqjhtwfiaHyokAHwNKPakizTAHPHz5Ds,1865
+pycodex/utils/event_helpers.py,sha256=pnxL0-nBC7cnOheHPCIfkHqJjMbkJg3C348_EzAVhFA,6342
+pycodex/utils/get_env.py,sha256=L4S8h84tkgxZKvrxY7ezTgePbXepG-yIigUTKeY6uuE,6094
+pycodex/utils/image_utils.py,sha256=1kXhtTqL4xtazpEABHhtvJBUJlceo8hSzg6ukmf_4FA,2407
+pycodex/utils/random_ids.py,sha256=jLTxZZ0MBbRdQOFDFWGVRjWzIo6FKSQ5ADXbQSLPp1s,379
+pycodex/utils/session_persist.py,sha256=v9KhmjUB2yCg55c85i8ZU1BWfc-WEMDPmpT0Rv4K8a8,22489
+pycodex/utils/truncation.py,sha256=5D6vAorT8EgXgjd7ASwtraAyIZdlCR-w5jKZqJxDzho,5446
+responses_server/__init__.py,sha256=sx9C88YWqmehASZy24FUMqT14A36doM_rj0MIZtQ9iQ,377
+responses_server/__main__.py,sha256=876xZTqhPeDBD2GKKr8pKX33Af8PhFTosAI8bYQsFgQ,61
+responses_server/app.py,sha256=DtA1Sck-6FDyCww3MLkLIMs-fDacY1d-lqZLWoUn-KM,7874
+responses_server/config.py,sha256=sCJYGisPHW9Uup26-R9Zv0o9W_kRVt-ETc2MFCVjG90,2795
+responses_server/messages_api.py,sha256=ialAYTMmN0y-uxQB3Y51ukq-kvkSVO84WVLXaqLsKw0,18775
+responses_server/payload_processors.py,sha256=dqPwqHD-FhyiIwjzFEMf2wCtQDxkRyerZzbdqnH1aDE,3561
+responses_server/server.py,sha256=k4DbsOYkaHHcy38uF9u_QXahJC1cplKsTu-MdC3DCIs,2286
+responses_server/session_store.py,sha256=nwGxQL6nUVKnDVeDHz8IzqNQ7dWk8Ybf0URekOHdxTo,1133
+responses_server/stream_router.py,sha256=xoHwegjziLOgrzvkdAtJbKGoSBn6sBF-unUSo6QxStc,41402
+responses_server/trajectory_dump.py,sha256=5_Wy6tslszrqx3j1JeP_boyTbzIicKy8No84PzMnmHk,5111
+responses_server/tools/__init__.py,sha256=ivsBSEy0SBUhY-Uea5v1XMLXShkwHdCVl0id-1FwdZg,150
+responses_server/tools/custom_adapter.py,sha256=SnIiNUdomff3APtTriURAC9YCeEdhCDjzGMEYusfUdk,8340
+responses_server/tools/web_search.py,sha256=pnKH9JyTScRehWpZS3HpXRvjWsQvC0QZqxjEOCT4ndg,8936
+workspace_server/__init__.py,sha256=PRM4ONODb6hxjBUHkBD4TprE_pkTCIlT9sfftK5ic6M,866
+workspace_server/__main__.py,sha256=876xZTqhPeDBD2GKKr8pKX33Af8PhFTosAI8bYQsFgQ,61
+workspace_server/app.py,sha256=iYUMziweCnsLX0EyT3jnswyVM4x2FhacrlinhBhymHo,59130
+workspace_server/workspace.html,sha256=6UmGemYZfxFFX1qZNhGsVmD_BDWu6qhoPy3zyfd5_po,71483
+workspace_server/workspaces.html,sha256=TpmfzpuCIXTVdFQzQrojxSCtBTHMSESn1zNGOmNz_W8,15787
+workspace_server/workspaces.py,sha256=0oOk1xj7FxoJkLe2OyFDYVwWV4HHyNAwVaF-3Ln3NiY,22660
+python_codex-0.3.0.dist-info/METADATA,sha256=Crsk3zCk6n-qeqnK7DoyH0GkSP4uUdf2f3TR5rTtUBs,35836
+python_codex-0.3.0.dist-info/WHEEL,sha256=KGYbc1zXlYddvwxnNty23BeaKzh7YuoSIvIMO4jEhvw,87
+python_codex-0.3.0.dist-info/entry_points.txt,sha256=vkV2UWCtEKvQNMJuPNjt8HyBKiwp83JyqBatrBNGDp8,80
+python_codex-0.3.0.dist-info/licenses/LICENSE,sha256=0X8ifk312hYAORM4hlzg8wVSEXYKNmiPgWlB1YIy2Nw,10926
+python_codex-0.3.0.dist-info/RECORD,,

responses_server/__init__.py

@@ -1,8 +1,4 @@
-from .app import (
-    ManagedResponseServer,
-    launch_chat_completion_compat_server,
-    run_server,
-)
+from .app import ManagedResponseServer, launch_chat_completion_compat_server, run_server
 from .config import CompatServerConfig
 from .server import ResponseServer
 from .stream_router import StreamRouter

responses_server/__main__.py

@@ -1,5 +1,4 @@
 from .app import main
 
-
 if __name__ == "__main__":
     main()

responses_server/app.py

@@ -1,44 +1,52 @@
-
 import argparse
 import asyncio
-from dataclasses import replace
 import json
 import socket
 import threading
 import time
+import typing
+from dataclasses import replace
 from typing import Iterator
 
+import uvicorn
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse, StreamingResponse
-import uvicorn
 
 from .config import CompatServerConfig
 from .server import ResponseServer
 from .stream_router import OutcommingChatError, UnsupportedIncommingFeature
-import typing
 
 
-def _run_uvicorn_server(server) -> 'None':
+def _run_uvicorn_server(server) -> "None":
     asyncio.set_event_loop(asyncio.new_event_loop())
     server.run()
 
 
-def _format_sse_event(event_name: 'str', payload: 'typing.Dict[str, object]') -> 'bytes':
+def _format_sse_event(
+    event_name: "str", payload: "typing.Dict[str, object]"
+) -> "bytes":
     data = json.dumps(payload, ensure_ascii=False)
     return f"event: {event_name}\ndata: {data}\n\n".encode("utf-8")
 
 
-def _stream_events(response_server: 'ResponseServer', request_body: 'typing.Dict[str, object]', request_headers: 'typing.Dict[str, str]') -> 'Iterator[bytes]':
+def _stream_events(
+    response_server: "ResponseServer",
+    request_body: "typing.Dict[str, object]",
+    request_headers: "typing.Dict[str, str]",
+) -> "Iterator[bytes]":
     try:
-        event_iter = response_server.start_response_stream(request_body, request_headers)
+        event_iter = response_server.start_response_stream(
+            request_body, request_headers
+        )
         for event_name, payload in event_iter:
             yield _format_sse_event(event_name, payload)
     except OutcommingChatError as exc:
-        
+
         import traceback
+
         exc_info = traceback.format_exception(type(exc), exc, exc.__traceback__)
         error = {
-            "message": '\n'.join(exc_info),
+            "message": "\n".join(exc_info),
         }
         error_type = getattr(exc, "error_type", None)
         if error_type:
@@ -54,7 +62,7 @@ def _stream_events(response_server: 'ResponseServer', request_body: 'typing.Dict
         )
 
 
-def build_parser() -> 'argparse.ArgumentParser':
+def build_parser() -> "argparse.ArgumentParser":
     parser = argparse.ArgumentParser(
         prog="python -m responses_server",
         description=(
@@ -77,7 +85,7 @@ def build_parser() -> 'argparse.ArgumentParser':
     return parser
 
 
-def run_server(config: 'CompatServerConfig') -> 'None':
+def run_server(config: "CompatServerConfig") -> "None":
     uvicorn.run(
         ManagedResponseServer.build_app(config),
         host=config.host,
@@ -87,10 +95,10 @@ def run_server(config: 'CompatServerConfig') -> 'None':
 
 
 def launch_chat_completion_compat_server(
-    base_url: 'str',
-    api_key_env: 'typing.Union[str, None]' = None,
-    model_provider: 'typing.Union[str, None]' = None,
-    outcomming_api: 'str' = "chat_completions",
+    base_url: "str",
+    api_key_env: "typing.Union[str, None]" = None,
+    model_provider: "typing.Union[str, None]" = None,
+    outcomming_api: "str" = "chat_completions",
 ):
     config = CompatServerConfig.from_base_url(
         base_url,
@@ -106,10 +114,10 @@ def launch_chat_completion_compat_server(
 class ManagedResponseServer:
     @staticmethod
     def build_app(
-        config: 'CompatServerConfig',
+        config: "CompatServerConfig",
         session_store=None,
         stream_router=None,
-    ) -> 'FastAPI':
+    ) -> "FastAPI":
         response_server = ResponseServer(
             config,
             session_store=session_store,
@@ -120,7 +128,7 @@ class ManagedResponseServer:
 
         @app.get("/health")
         @app.get("/healthz")
-        async def health() -> 'typing.Dict[str, bool]':
+        async def health() -> "typing.Dict[str, bool]":
             return {"ok": True}
 
         @app.get("/models")
@@ -136,7 +144,7 @@ class ManagedResponseServer:
 
         @app.post("/responses")
         @app.post("/v1/responses")
-        async def responses(request: 'Request'):
+        async def responses(request: "Request"):
             try:
                 request_body = await request.json()
             except Exception as exc:
@@ -151,8 +159,7 @@ class ManagedResponseServer:
                 )
 
             request_headers = {
-                str(key).lower(): str(value)
-                for key, value in request.headers.items()
+                str(key).lower(): str(value) for key, value in request.headers.items()
             }
             try:
                 response_server.stream_router.validate_incomming_request(request_body)
@@ -173,7 +180,7 @@ class ManagedResponseServer:
 
         return app
 
-    def __init__(self, config: 'CompatServerConfig') -> 'None':
+    def __init__(self, config: "CompatServerConfig") -> "None":
         port = config.port or _reserve_free_port()
         self._config = replace(config, port=port)
         self._app = self.build_app(self._config)
@@ -193,10 +200,10 @@ class ManagedResponseServer:
         )
 
     @property
-    def base_url(self) -> 'str':
+    def base_url(self) -> "str":
         return f"http://{self._config.host}:{self._config.port}/v1"
 
-    def start(self, timeout_seconds: 'float' = 10.0) -> 'None':
+    def start(self, timeout_seconds: "float" = 10.0) -> "None":
         self._thread.start()
         deadline = time.time() + timeout_seconds
         while not self._server.started:
@@ -206,16 +213,14 @@ class ManagedResponseServer:
                 )
             time.sleep(0.01)
 
-    def stop(self, timeout_seconds: 'float' = 5.0) -> 'None':
+    def stop(self, timeout_seconds: "float" = 5.0) -> "None":
         self._server.should_exit = True
         self._thread.join(timeout=timeout_seconds)
         if self._thread.is_alive():
-            raise RuntimeError(
-                "timed out waiting for managed responses server to stop"
-            )
+            raise RuntimeError("timed out waiting for managed responses server to stop")
 
 
-def main() -> 'None':
+def main() -> "None":
     args = build_parser().parse_args()
     run_server(
         CompatServerConfig(
@@ -234,7 +239,7 @@ if __name__ == "__main__":
     main()
 
 
-def _reserve_free_port() -> 'int':
+def _reserve_free_port() -> "int":
     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     try:
         sock.bind(("127.0.0.1", 0))

responses_server/config.py

@@ -1,46 +1,46 @@
-
 import os
-from dataclasses import dataclass
-import urllib.parse
 import typing
-
+import urllib.parse
+from dataclasses import dataclass
 
 DEFAULT_OUTCOMMING_TIMEOUT_SECONDS = 300.0
 
 
-@dataclass(frozen=True, )
+@dataclass(
+    frozen=True,
+)
 class CompatServerConfig:
-    host: 'str' = "127.0.0.1"
-    port: 'int' = 0
-    outcomming_base_url: 'str' = "http://127.0.0.1:8000/v1"
-    outcomming_api: 'str' = "chat_completions"
-    outcomming_api_key_env: 'typing.Union[str, None]' = None
-    model_provider: 'typing.Union[str, None]' = None
-    timeout_seconds: 'float' = DEFAULT_OUTCOMMING_TIMEOUT_SECONDS
+    host: "str" = "127.0.0.1"
+    port: "int" = 0
+    outcomming_base_url: "str" = "http://127.0.0.1:8000/v1"
+    outcomming_api: "str" = "chat_completions"
+    outcomming_api_key_env: "typing.Union[str, None]" = None
+    model_provider: "typing.Union[str, None]" = None
+    timeout_seconds: "float" = DEFAULT_OUTCOMMING_TIMEOUT_SECONDS
 
-    def outcomming_api_key(self) -> 'typing.Union[str, None]':
+    def outcomming_api_key(self) -> "typing.Union[str, None]":
         if self.outcomming_api_key_env is None:
             return None
         value = os.environ.get(self.outcomming_api_key_env, "").strip()
         return value or None
 
-    def outcomming_chat_completions_url(self) -> 'str':
+    def outcomming_chat_completions_url(self) -> "str":
         base = self.outcomming_base_url.rstrip("/")
         return f"{base}/chat/completions"
 
-    def outcomming_messages_url(self) -> 'str':
+    def outcomming_messages_url(self) -> "str":
         base = self.outcomming_base_url.rstrip("/")
         return f"{base}/messages"
 
-    def outcomming_models_url(self) -> 'str':
+    def outcomming_models_url(self) -> "str":
         base = self.outcomming_base_url.rstrip("/")
         return f"{base}/models"
 
-    def normalized_outcomming_api(self) -> 'str':
+    def normalized_outcomming_api(self) -> "str":
         value = str(self.outcomming_api or "").strip().lower()
         return value or "chat_completions"
 
-    def with_ephemeral_port(self) -> 'CompatServerConfig':
+    def with_ephemeral_port(self) -> "CompatServerConfig":
         return CompatServerConfig(
             host=self.host,
             port=0,
@@ -54,11 +54,11 @@ class CompatServerConfig:
     @classmethod
     def from_base_url(
         cls,
-        outcomming_base_url: 'str',
-        api_key_env: 'typing.Union[str, None]' = None,
-        model_provider: 'typing.Union[str, None]' = None,
-        outcomming_api: 'str' = "chat_completions",
-    ) -> 'CompatServerConfig':
+        outcomming_base_url: "str",
+        api_key_env: "typing.Union[str, None]" = None,
+        model_provider: "typing.Union[str, None]" = None,
+        outcomming_api: "str" = "chat_completions",
+    ) -> "CompatServerConfig":
         parsed = urllib.parse.urlparse(outcomming_base_url)
         if not parsed.scheme or not parsed.netloc:
             raise ValueError(f"invalid outcomming base url: {outcomming_base_url}")

responses_server/messages_api.py

@@ -9,8 +9,8 @@ class MessagesAPIAdapterError(ValueError):
 
 
 def build_messages_request(
-    outcomming_request: 'typing.Dict[str, object]',
-) -> 'typing.Dict[str, object]':
+    outcomming_request: "typing.Dict[str, object]",
+) -> "typing.Dict[str, object]":
     model = str(outcomming_request.get("model", "")).strip()
     if not model:
         raise MessagesAPIAdapterError("outcomming request is missing `model`")
@@ -19,13 +19,11 @@ def build_messages_request(
     if not isinstance(raw_messages, list):
         raise MessagesAPIAdapterError("outcomming request `messages` must be a list")
 
-    system_blocks: 'typing.List[typing.Dict[str, object]]' = []
-    messages: 'typing.List[typing.Dict[str, object]]' = []
+    system_blocks: "typing.List[typing.Dict[str, object]]" = []
+    messages: "typing.List[typing.Dict[str, object]]" = []
     for raw_message in raw_messages:
         if not isinstance(raw_message, dict):
-            raise MessagesAPIAdapterError(
-                "outcomming request messages must be objects"
-            )
+            raise MessagesAPIAdapterError("outcomming request messages must be objects")
         role = str(raw_message.get("role", "")).strip()
         if role in {"developer", "system"}:
             text = str(raw_message.get("content", "") or "")
@@ -60,7 +58,7 @@ def build_messages_request(
             f"unsupported outcomming message role for messages API: {role!r}"
         )
 
-    payload: 'typing.Dict[str, object]' = {
+    payload: "typing.Dict[str, object]" = {
         "model": model,
         "messages": messages,
         "max_tokens": _resolve_max_tokens(outcomming_request),
@@ -84,12 +82,12 @@ def build_messages_request(
 
 
 def iter_chat_chunks(
-    event_name: 'typing.Union[str, None]',
-    payload: 'typing.Dict[str, object]',
-    state: 'typing.Dict[str, object]',
-) -> 'typing.List[typing.Dict[str, object]]':
+    event_name: "typing.Union[str, None]",
+    payload: "typing.Dict[str, object]",
+    state: "typing.Dict[str, object]",
+) -> "typing.List[typing.Dict[str, object]]":
     event_type = str(payload.get("type") or event_name or "").strip()
-    chunks: 'typing.List[typing.Dict[str, object]]' = []
+    chunks: "typing.List[typing.Dict[str, object]]" = []
 
     if event_type == "message_start":
         message = payload.get("message") or {}
@@ -188,13 +186,15 @@ def iter_chat_chunks(
     return chunks
 
 
-def saw_message_stop(state: 'typing.Dict[str, object]') -> 'bool':
+def saw_message_stop(state: "typing.Dict[str, object]") -> "bool":
     return bool(state.get("saw_message_stop"))
 
 
-def _build_text_blocks(raw_content: 'object') -> 'typing.List[typing.Dict[str, object]]':
+def _build_text_blocks(
+    raw_content: "object",
+) -> "typing.List[typing.Dict[str, object]]":
     if isinstance(raw_content, list):
-        blocks: 'typing.List[typing.Dict[str, object]]' = []
+        blocks: "typing.List[typing.Dict[str, object]]" = []
         for raw_part in raw_content:
             if not isinstance(raw_part, dict):
                 raise MessagesAPIAdapterError("message content parts must be objects")
@@ -219,8 +219,8 @@ def _build_text_blocks(raw_content: 'object') -> 'typing.List[typing.Dict[str, o
 
 
 def _build_image_block(
-    raw_part: 'typing.Dict[str, object]',
-) -> 'typing.Dict[str, object]':
+    raw_part: "typing.Dict[str, object]",
+) -> "typing.Dict[str, object]":
     image_url = raw_part.get("image_url") or {}
     if not isinstance(image_url, dict):
         raise MessagesAPIAdapterError("`image_url` content parts must be objects")
@@ -233,7 +233,7 @@ def _build_image_block(
         return {"type": "image", "source": {"type": "url", "url": url}}
 
     header, _, data = url.partition(",")
-    media_type = header[len("data:"):].split(";")[0].strip()
+    media_type = header[len("data:") :].split(";")[0].strip()
     if not media_type or not header.endswith(";base64"):
         raise MessagesAPIAdapterError(
             "`image_url` data URLs must be base64 encoded with a media type"
@@ -249,9 +249,9 @@ def _build_image_block(
 
 
 def _build_assistant_blocks(
-    raw_message: 'typing.Dict[str, object]',
-) -> 'typing.List[typing.Dict[str, object]]':
-    blocks: 'typing.List[typing.Dict[str, object]]' = []
+    raw_message: "typing.Dict[str, object]",
+) -> "typing.List[typing.Dict[str, object]]":
+    blocks: "typing.List[typing.Dict[str, object]]" = []
     reasoning = str(raw_message.get("reasoning", "") or "")
     if reasoning:
         blocks.append({"type": "thinking", "thinking": reasoning})
@@ -284,8 +284,8 @@ def _build_assistant_blocks(
 
 
 def _build_tool_result_block(
-    raw_message: 'typing.Dict[str, object]',
-) -> 'typing.Dict[str, object]':
+    raw_message: "typing.Dict[str, object]",
+) -> "typing.Dict[str, object]":
     return {
         "type": "tool_result",
         "tool_use_id": str(raw_message.get("tool_call_id", "")).strip(),
@@ -294,9 +294,9 @@ def _build_tool_result_block(
 
 
 def _translate_tools(
-    raw_tools: 'object',
-) -> 'typing.List[typing.Dict[str, object]]':
-    translated: 'typing.List[typing.Dict[str, object]]' = []
+    raw_tools: "object",
+) -> "typing.List[typing.Dict[str, object]]":
+    translated: "typing.List[typing.Dict[str, object]]" = []
     if not isinstance(raw_tools, list):
         return translated
     for raw_tool in raw_tools:
@@ -321,9 +321,9 @@ def _translate_tools(
 
 
 def _translate_tool_choice(
-    raw_tool_choice: 'object',
-    parallel_tool_calls: 'object',
-) -> 'typing.Union[typing.Dict[str, object], None]':
+    raw_tool_choice: "object",
+    parallel_tool_calls: "object",
+) -> "typing.Union[typing.Dict[str, object], None]":
     if raw_tool_choice is None:
         if parallel_tool_calls is False:
             return {
@@ -332,7 +332,7 @@ def _translate_tool_choice(
             }
         return None
 
-    translated: 'typing.Dict[str, object]'
+    translated: "typing.Dict[str, object]"
     if isinstance(raw_tool_choice, str):
         choice = raw_tool_choice.strip()
         if choice == "auto":
@@ -355,9 +355,7 @@ def _translate_tool_choice(
             if not name:
                 name = str(raw_tool_choice.get("name", "")).strip()
             if not name:
-                raise MessagesAPIAdapterError(
-                    "function tool_choice is missing `name`"
-                )
+                raise MessagesAPIAdapterError("function tool_choice is missing `name`")
             translated = {
                 "type": "tool",
                 "name": name,
@@ -376,7 +374,7 @@ def _translate_tool_choice(
     return translated
 
 
-def _parse_json_object(raw_value: 'object') -> 'typing.Dict[str, object]':
+def _parse_json_object(raw_value: "object") -> "typing.Dict[str, object]":
     if isinstance(raw_value, dict):
         return dict(raw_value)
     if isinstance(raw_value, str):
@@ -399,7 +397,7 @@ def _parse_json_object(raw_value: 'object') -> 'typing.Dict[str, object]':
     )
 
 
-def _resolve_max_tokens(outcomming_request: 'typing.Dict[str, object]') -> 'int':
+def _resolve_max_tokens(outcomming_request: "typing.Dict[str, object]") -> "int":
     raw_value = outcomming_request.get("max_tokens")
     if isinstance(raw_value, bool):
         return DEFAULT_MESSAGES_MAX_TOKENS
@@ -408,7 +406,7 @@ def _resolve_max_tokens(outcomming_request: 'typing.Dict[str, object]') -> 'int'
     return DEFAULT_MESSAGES_MAX_TOKENS
 
 
-def _usage_chunk(raw_usage: 'object') -> 'typing.Union[typing.Dict[str, object], None]':
+def _usage_chunk(raw_usage: "object") -> "typing.Union[typing.Dict[str, object], None]":
     usage = _translate_usage(raw_usage)
     if not usage:
         return None
@@ -418,10 +416,10 @@ def _usage_chunk(raw_usage: 'object') -> 'typing.Union[typing.Dict[str, object],
     }
 
 
-def _translate_usage(raw_usage: 'object') -> 'typing.Dict[str, object]':
+def _translate_usage(raw_usage: "object") -> "typing.Dict[str, object]":
     if not isinstance(raw_usage, dict):
         return {}
-    usage: 'typing.Dict[str, object]' = {}
+    usage: "typing.Dict[str, object]" = {}
     input_tokens = raw_usage.get("input_tokens")
     output_tokens = raw_usage.get("output_tokens")
     if isinstance(input_tokens, int):
@@ -434,7 +432,7 @@ def _translate_usage(raw_usage: 'object') -> 'typing.Dict[str, object]':
     elif isinstance(input_tokens, int) and isinstance(output_tokens, int):
         usage["total_tokens"] = input_tokens + output_tokens
 
-    input_details: 'typing.Dict[str, int]' = {}
+    input_details: "typing.Dict[str, int]" = {}
     cache_creation = raw_usage.get("cache_creation_input_tokens")
     if isinstance(cache_creation, int):
         input_details["cache_creation_input_tokens"] = cache_creation
@@ -446,7 +444,7 @@ def _translate_usage(raw_usage: 'object') -> 'typing.Dict[str, object]':
     return usage
 
 
-def _normalize_index(raw_index: 'object') -> 'int':
+def _normalize_index(raw_index: "object") -> "int":
     if isinstance(raw_index, int):
         return raw_index
     try:
@@ -455,7 +453,7 @@ def _normalize_index(raw_index: 'object') -> 'int':
         return 0
 
 
-def _translate_stop_reason(raw_stop_reason: 'object') -> 'typing.Union[str, None]':
+def _translate_stop_reason(raw_stop_reason: "object") -> "typing.Union[str, None]":
     if not isinstance(raw_stop_reason, str):
         return None
     stop_reason = raw_stop_reason.strip()
@@ -470,21 +468,21 @@ def _translate_stop_reason(raw_stop_reason: 'object') -> 'typing.Union[str, None
     return stop_reason
 
 
-def _chat_text_chunk(text: 'str') -> 'typing.Dict[str, object]':
+def _chat_text_chunk(text: "str") -> "typing.Dict[str, object]":
     return _chat_delta_chunk({"content": text})
 
 
-def _chat_reasoning_chunk(reasoning: 'str') -> 'typing.Dict[str, object]':
+def _chat_reasoning_chunk(reasoning: "str") -> "typing.Dict[str, object]":
     return _chat_delta_chunk({"reasoning_content": reasoning})
 
 
 def _chat_tool_chunk(
-    index: 'int',
-    call_id: 'str' = "",
-    name: 'str' = "",
-    arguments: 'str' = "",
-) -> 'typing.Dict[str, object]':
-    tool_call: 'typing.Dict[str, object]' = {
+    index: "int",
+    call_id: "str" = "",
+    name: "str" = "",
+    arguments: "str" = "",
+) -> "typing.Dict[str, object]":
+    tool_call: "typing.Dict[str, object]" = {
         "index": index,
         "function": {},
     }
@@ -502,7 +500,7 @@ def _chat_tool_chunk(
     return _chat_delta_chunk({"tool_calls": [tool_call]})
 
 
-def _chat_delta_chunk(delta: 'typing.Dict[str, object]') -> 'typing.Dict[str, object]':
+def _chat_delta_chunk(delta: "typing.Dict[str, object]") -> "typing.Dict[str, object]":
     return {
         "choices": [
             {
@@ -514,7 +512,7 @@ def _chat_delta_chunk(delta: 'typing.Dict[str, object]') -> 'typing.Dict[str, ob
     }
 
 
-def _chat_finish_chunk(finish_reason: 'str') -> 'typing.Dict[str, object]':
+def _chat_finish_chunk(finish_reason: "str") -> "typing.Dict[str, object]":
     return {
         "choices": [
             {
@@ -526,5 +524,5 @@ def _chat_finish_chunk(finish_reason: 'str') -> 'typing.Dict[str, object]':
     }
 
 
-def _dump_json(raw_value: 'object') -> 'str':
+def _dump_json(raw_value: "object") -> "str":
     return json.dumps(raw_value, ensure_ascii=False, separators=(",", ":"))