python-codex 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

{python_codex-0.1.2.dist-info → python_codex-0.1.4.dist-info}/METADATA

@@ -1,16 +1,22 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: python-codex
-Version: 0.1.2
+Version: 0.1.4
 Summary: A minimal Python extraction of Codex's main agent loop
 License-File: LICENSE
-Requires-Python: >=3.10
-Requires-Dist: cryptography>=3.4
-Requires-Dist: fastapi>=0.115
+Requires-Python: >=3.6.2
+Requires-Dist: cryptography<41,>=40.0.2; python_version < '3.7'
+Requires-Dist: cryptography>=40.0.2; python_version >= '3.7'
+Requires-Dist: dataclasses>=0.8; python_version < '3.7'
+Requires-Dist: fastapi<0.84,>=0.83.0; python_version < '3.7'
+Requires-Dist: fastapi>=0.83.0; python_version >= '3.7'
+Requires-Dist: importlib-metadata>=4.8.3; python_version < '3.8'
 Requires-Dist: loguru>=0.7.3
-Requires-Dist: prompt-toolkit>=3.0
-Requires-Dist: requests>=2.31
-Requires-Dist: tomli>=2.0; python_version < '3.11'
-Requires-Dist: uvicorn>=0.32
+Requires-Dist: prompt-toolkit>=3.0.36
+Requires-Dist: requests>=2.27.1
+Requires-Dist: tomli<2,>=1.2.3; python_version < '3.11'
+Requires-Dist: typing-extensions>=4.1.1; python_version < '3.8'
+Requires-Dist: uvicorn<0.17,>=0.16.0; python_version < '3.7'
+Requires-Dist: uvicorn>=0.16.0; python_version >= '3.7'
 Description-Content-Type: text/markdown
 
 # pycodex
@@ -66,7 +72,7 @@ Intentionally not included yet:
 
 - TUI / streaming incremental rendering
 - MCP / connectors / sandbox / approvals
-- memory / compact / hooks / review mode
+- memory / compact / review mode
 - a full production OpenAI adapter surface
 
 All of those can be layered on later. For now, the project is focused on
@@ -168,9 +174,24 @@ Current behavior:
 - interactive mode shows a compact event stream for user-visible phases such as
   tool execution and model follow-up after tool results
 - assistant text is printed from streaming deltas directly
-- interactive mode supports `/history`, `/title`, and `/model`
+- interactive mode supports `/history`, `/title`, `/model`, `/resume`, and `/compact`
 - `/model <name>` switches the model used by later turns in the current
   interactive session; `/model` shows the current model and available choices
+- `/resume` with no argument lists the currently resumable sessions by their
+  first user-message preview; `/resume 1` resumes the first listed session
+- `/resume <number>` replaces the in-memory history with the selected recorded
+  Codex rollout from `CODEX_HOME/sessions`
+- `/compact` synthesizes a local handoff summary, replaces the in-memory
+  conversation history with the compacted view, and appends a compacted-history
+  entry to the rollout so later `/resume` sees the same state
+- new sessions are now recorded under `CODEX_HOME/sessions/.../rollout-*.jsonl`
+  with a stable session/thread id and per-item append+flush semantics so
+  `/resume` reads back the same rollout format
+- if `TURN_HOOK.md` exists in the workspace root and is non-empty, each
+  completed turn also forks the just-finished history into a temporary,
+  non-persisted follow-up session and submits the file contents as the next
+  user instruction; this is intended for side-effect follow-ups such as
+  Feishu notifications
 - steer is enabled by default in interactive mode: normal input goes into the
   runtime steer path, the current request stops at the next safe boundary, and
   later steer text is appended to the next model request's `input` in order;

python_codex-0.1.4.dist-info/RECORD

@@ -0,0 +1,76 @@
+pycodex/__init__.py,sha256=jCnC_Bgotlxa4GwO3Re2sChKGY49TRM-uVZEQ9uBpfw,3106
+pycodex/agent.py,sha256=s0FrF_XG2pHKryooS461Jr_acmQ_TKTp2JLGQNiny6w,11888
+pycodex/cli.py,sha256=ntgC0LWlSOhuYAUOBgSEeVIjBTKS91klyvkTO9QtFoE,29559
+pycodex/collaboration.py,sha256=yQ6pBD-R3ZWR4_FAYQFoS7KF0m4LLD42otXIbPqw2ys,641
+pycodex/compat.py,sha256=IO0X7AgcYhlHnYnpvBZ6leCh_UjoQzg5HLT5wYBNNIw,3155
+pycodex/context.py,sha256=R5tuMcNrX1F-Lh9ymsSbnfRbKLJ19TWrtQoZ3tWlHvM,24982
+pycodex/doctor.py,sha256=De3M4hRBJq8ZeqsUJgHz0vitqrH18YugrEnz7oHhTdQ,10572
+pycodex/model.py,sha256=Mk9LZKmFcXG71I18-gs4dUWNn0GIM1rbMhFfKDut_3w,32790
+pycodex/portable.py,sha256=kZ5XVOMZq0l6xXsx3FY9C3DfB4Jra5Hw38qTMH0TEwg,15597
+pycodex/portable_server.py,sha256=6I3pQkWj3e_SFlDXY2mGdCPns1w_3PSxByBV9wv5epI,7331
+pycodex/protocol.py,sha256=LYDzJefu1tugqQzee4NuZzxhGAv3hXrNcnlw04CudAY,11106
+pycodex/runtime.py,sha256=gpDDxQKfp1Cqh1U0uslI3rCoXEN7XpJGuHlV-bsveM0,7983
+pycodex/runtime_services.py,sha256=OJjBWMjLAoc1cxLPKmz03XhMN5jOiBBNhxiKROytIbc,13118
+pycodex/prompts/collaboration_default.md,sha256=MBTmPuMubeWfZgIeFVj49wwnwD4n_o3fVYAbgWKwu6Q,955
+pycodex/prompts/collaboration_plan.md,sha256=IzjQAA5oHJz-3FmJdOjsJ4LHq6LW1tlEYMoy09n0HKk,8777
+pycodex/prompts/default_base_instructions.md,sha256=D65mcj6bo4CDvVom-D9cbJRJVNquo0NghKt164_fRsg,20923
+pycodex/prompts/exec_tools.json,sha256=2wYLsjL6VGzMnhFNCxE9IA_kxsxUspN68lr7JOlZq54,23369
+pycodex/prompts/models.json,sha256=u4u2bylNZnMw_qKtvn_iZMUwS4wEq1JBMwHcetC3Spo,285814
+pycodex/prompts/subagent_tools.json,sha256=2ZOXyAiAaai2aazIlXdjjXb7cra5gZ2WYYbPltPaiYg,6199
+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=aSLXrr_31KGQgDfRow5zVIc-2-KdXlHaCE6qUnE4HWI,1772
+pycodex/tools/agent_tool_schemas.py,sha256=r7pBICcx8fb0Rg6IzIg8-u3um2z11TogQ4yCzuiO-4o,2033
+pycodex/tools/apply_patch_tool.py,sha256=aFob-gzaCXlzPdCIvRXVKm1NrQqqhqe8CVkFVAhqiTc,13955
+pycodex/tools/base_tool.py,sha256=FLtbb6KPUKyhHRMrR6_anYi_GmpJFCaX1ch5aRnjQjo,5527
+pycodex/tools/close_agent_tool.py,sha256=nY3l_UOX6NyTgUqdXag3yRpdyQScV0g0Vv4HE3ElLwg,1597
+pycodex/tools/code_mode_manager.py,sha256=Wow42H_9IomUKUjjjU8rrAFAklhE-UlgxgrbgHRU_4M,19031
+pycodex/tools/exec_command_tool.py,sha256=l8GWlZKTvlWWAd_OPKsnnt3m0woMWXK8NkilmspnaQQ,3485
+pycodex/tools/exec_runtime.js,sha256=DR1uocKailTqNWAcJNFJuQgFFMSUzTpT_uQsRaneg2s,3643
+pycodex/tools/exec_tool.py,sha256=pwzFCyjQMw2O9A6JDSTyOz6wmwg-UkFh_4wTY9rPLTI,1389
+pycodex/tools/grep_files_tool.py,sha256=OiMKpM9vfaTpfEllQaI6Td39NnQ0gRDXqxMfmBwV2yQ,4797
+pycodex/tools/list_dir_tool.py,sha256=qX4AGkmKkEt7qJaYTsaGIB0zCiyzcU5U8IBapAjEIQ0,4792
+pycodex/tools/read_file_tool.py,sha256=xJk4f-lI-CJm50d5EThzWCz-7l2IX8s2gVwp-evsAJE,8148
+pycodex/tools/request_permissions_tool.py,sha256=n0V0WvpaW3HBnBbdQoyi9CfL1dRBJDn7t9sWpg8wZ4g,3010
+pycodex/tools/request_user_input_tool.py,sha256=mm3MbFIj6PYGgX4dv8MKSFCuiEFvHp23YGoJM2jv1ks,5734
+pycodex/tools/resume_agent_tool.py,sha256=o62xdrsRxGFdRLxEhKEny-YEcaBOeqIneImrkME35II,1614
+pycodex/tools/send_input_tool.py,sha256=P4VvZlNcHbfjhWF4vfEyHwDpyeyrhYJWLvvlWfvub2M,3608
+pycodex/tools/shell_command_tool.py,sha256=hC2sg_ishmrqFIVyY5ngKnMOXjjIDL3xQ-gg40R1OQI,3520
+pycodex/tools/shell_tool.py,sha256=7WaCWJM_-VeqyL5do_Qc8D-OZFWMXXY5Eo-ApSSsO9U,3698
+pycodex/tools/spawn_agent_tool.py,sha256=YO5RLZpgv6uQPaEiCnOIGGBmGWREknUavvyAOFWWWeE,3563
+pycodex/tools/unified_exec_manager.py,sha256=dSKv5fTSTWlSTktWyUXshGVijH9J74iuCYQxuse0oCY,13699
+pycodex/tools/update_plan_tool.py,sha256=CiTTGAtG2b0EJyYsm2MgN_GXEKvCN8fvTgJGAcUCu-M,2884
+pycodex/tools/view_image_tool.py,sha256=s3P1wPZioKrjjNXbwYEz9pzfVsnlPY79LzL-vujqRfY,3940
+pycodex/tools/wait_agent_tool.py,sha256=0xjr5M2S0SNZaSr1o4U0RXI6dTJfMVpBB8Uclm_402I,2570
+pycodex/tools/wait_tool.py,sha256=EJcW2Ev9jUD9eZ7cFDNOLDzlywS2BD3ll6pArXyxfrI,2331
+pycodex/tools/web_search_tool.py,sha256=_7r2ltWhnBM0ZCgweA5a0GbEi0qSFAHOyi1RHrl6tfQ,957
+pycodex/tools/write_stdin_tool.py,sha256=nCuProkbeewfQ_yS8CgBajo--K3EmkXzJYh1D2QtAM4,2549
+pycodex/utils/__init__.py,sha256=XawMC7CRm9bt3wPWyithj5x7YQvYrggn2_DcGGSTnCY,1162
+pycodex/utils/compactor.py,sha256=ZCzGc02xHmXq1rIjnG2gATKcFtt6r-OGsCIK0ypjnyI,6467
+pycodex/utils/dotenv.py,sha256=EDBXdn93ewmq9zhJki5_LsJJXe0wMIQJ6VfCE1r7voQ,1818
+pycodex/utils/get_env.py,sha256=jR8G0Xco57jX-71E1oHIcl3-Kz9Ltc0kzxj04DKzt80,7316
+pycodex/utils/random_ids.py,sha256=zBphjVGc7OXk9ZNExAbxRi_bk7ipyLG491qTv7hi8jM,380
+pycodex/utils/session_persist.py,sha256=dUvo3Z1QBB4HJT1tLerDlLD3ZB25umB6FP6JORg9V40,16414
+pycodex/utils/visualize.py,sha256=9S3oOUAnI_SbVvoFJ18dzq8MLE5v6kAsNiYsMTtqKAc,40022
+responses_server/__init__.py,sha256=3yPv_zeGT7P11tTnmj5kXktISLNsNW-02MUnnbiZcb0,394
+responses_server/__main__.py,sha256=9SRp-Yw7ShGxc6DhSIXcDLKgGEdAVm3oBZ59rBOPjT0,62
+responses_server/app.py,sha256=AtysZYL6ViheHYISS8eCK_iyr7CwUfF3wrt86ekh79U,7371
+responses_server/config.py,sha256=wEcZbXZclTYz4fI_oy_sSMglWPeEITWlFeglQrrr6HE,2236
+responses_server/payload_processors.py,sha256=AcOipqVQyo4wKw_pb3ABlarwIK1VjcnQTlgPehRVGO8,3412
+responses_server/server.py,sha256=isyzN-p-Ir8LLycN_dQfcanvie2ZqqSu52mOPz_wYD4,2095
+responses_server/session_store.py,sha256=ZD3cH2aEOkWaQsu5qTzcal2mThTSFQPAhAhPUN9srgI,1115
+responses_server/stream_router.py,sha256=zWC4yyZ3I8E-Zgco844tIhRMWOwIkjOV0s-G-a9-B8k,30861
+responses_server/tools/__init__.py,sha256=ivsBSEy0SBUhY-Uea5v1XMLXShkwHdCVl0id-1FwdZg,150
+responses_server/tools/custom_adapter.py,sha256=LxO7ldydvR-GWachDz8GKC0Q8KGGFoFPbZxM0QvxuZ0,8350
+responses_server/tools/web_search.py,sha256=pm4ZUiHUfxc0bGY1kEvt-BCzDrZIyP24xzPUcga2ul0,8908
+python_codex-0.1.4.dist-info/METADATA,sha256=fSNjm5GPh613W0ZFzU3UJFatqKUUs0xWYW17aOY4eLg,15451
+python_codex-0.1.4.dist-info/WHEEL,sha256=KGYbc1zXlYddvwxnNty23BeaKzh7YuoSIvIMO4jEhvw,87
+python_codex-0.1.4.dist-info/entry_points.txt,sha256=sNUVakoVuTrzJH505ZgRTQxmtRRPUHV_EH0i6EbYTyM,45
+python_codex-0.1.4.dist-info/licenses/LICENSE,sha256=0X8ifk312hYAORM4hlzg8wVSEXYKNmiPgWlB1YIy2Nw,10926
+python_codex-0.1.4.dist-info/RECORD,,

{python_codex-0.1.2.dist-info → python_codex-0.1.4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.29.0
+Generator: hatchling 1.17.1
 Root-Is-Purelib: true
 Tag: py3-none-any

responses_server/app.py

@@ -1,6 +1,6 @@
-from __future__ import annotations
 
 import argparse
+import asyncio
 from dataclasses import replace
 import json
 import socket
@@ -15,33 +15,41 @@ import uvicorn
 from .config import CompatServerConfig
 from .server import ResponseServer
 from .stream_router import OutcommingChatError, UnsupportedIncommingFeature
+import typing
 
 
-def _format_sse_event(event_name: str, payload: dict[str, object]) -> bytes:
+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':
     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: dict[str, object], request_headers: 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)
         for event_name, payload in event_iter:
             yield _format_sse_event(event_name, payload)
     except OutcommingChatError as exc:
+        
+        import traceback
         yield _format_sse_event(
             "response.failed",
             {
                 "type": "response.failed",
                 "response": {
                     "error": {
-                        "message": str(exc),
+                        "message": '\n'.join(traceback.format_exception(exc)),
                     }
                 },
             },
         )
 
 
-def build_parser() -> argparse.ArgumentParser:
+def build_parser() -> 'argparse.ArgumentParser':
     parser = argparse.ArgumentParser(
         prog="python -m responses_server",
         description=(
@@ -58,7 +66,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,
@@ -68,9 +76,9 @@ def run_server(config: CompatServerConfig) -> None:
 
 
 def launch_chat_completion_compat_server(
-    base_url: str,
-    api_key_env: str | None = None,
-    model_provider: str | None = None,
+    base_url: 'str',
+    api_key_env: 'typing.Union[str, None]' = None,
+    model_provider: 'typing.Union[str, None]' = None,
 ):
     config = CompatServerConfig.from_base_url(
         base_url,
@@ -85,10 +93,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,
@@ -99,7 +107,7 @@ class ManagedResponseServer:
 
         @app.get("/health")
         @app.get("/healthz")
-        async def health() -> dict[str, bool]:
+        async def health() -> 'typing.Dict[str, bool]':
             return {"ok": True}
 
         @app.get("/models")
@@ -115,7 +123,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:
@@ -152,7 +160,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)
@@ -164,13 +172,17 @@ class ManagedResponseServer:
             access_log=False,
         )
         self._server = uvicorn.Server(self._uvicorn_config)
-        self._thread = threading.Thread(target=self._server.run, daemon=True)
+        self._thread = threading.Thread(
+            target=_run_uvicorn_server,
+            args=(self._server,),
+            daemon=True,
+        )
 
     @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:
@@ -180,7 +192,7 @@ 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():
@@ -189,7 +201,7 @@ class ManagedResponseServer:
             )
 
 
-def main() -> None:
+def main() -> 'None':
     args = build_parser().parse_args()
     run_server(
         CompatServerConfig(
@@ -207,7 +219,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,34 +1,34 @@
-from __future__ import annotations
 
 import os
 from dataclasses import dataclass
 import urllib.parse
+import typing
 
 
-@dataclass(frozen=True, slots=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_key_env: str | None = None
-    model_provider: str | None = None
-    timeout_seconds: float = 120.0
-
-    def outcomming_api_key(self) -> str | None:
+    host: 'str' = "127.0.0.1"
+    port: 'int' = 0
+    outcomming_base_url: 'str' = "http://127.0.0.1:8000/v1"
+    outcomming_api_key_env: 'typing.Union[str, None]' = None
+    model_provider: 'typing.Union[str, None]' = None
+    timeout_seconds: 'float' = 120.0
+
+    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_models_url(self) -> str:
+    def outcomming_models_url(self) -> 'str':
         base = self.outcomming_base_url.rstrip("/")
         return f"{base}/models"
 
-    def with_ephemeral_port(self) -> CompatServerConfig:
+    def with_ephemeral_port(self) -> 'CompatServerConfig':
         return CompatServerConfig(
             host=self.host,
             port=0,
@@ -41,10 +41,10 @@ class CompatServerConfig:
     @classmethod
     def from_base_url(
         cls,
-        outcomming_base_url: str,
-        api_key_env: str | None = None,
-        model_provider: str | None = None,
-    ) -> CompatServerConfig:
+        outcomming_base_url: 'str',
+        api_key_env: 'typing.Union[str, None]' = None,
+        model_provider: 'typing.Union[str, None]' = None,
+    ) -> '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/payload_processors.py

@@ -1,4 +1,3 @@
-from __future__ import annotations
 
 """Provider-specific post-process hooks for canonical outgoing chat requests.
 
@@ -9,11 +8,12 @@ building one canonical `outcomming_request`, while `server.py` selects the
 appropriate hook from `CompatServerConfig.model_provider`.
 """
 
-from collections.abc import Callable
 from copy import deepcopy
-from typing import Optional, TypedDict
+from typing import Callable, Optional
+import typing
+from typing_extensions import TypedDict
 
-ChatMessage = dict[str, object]
+ChatMessage = typing.Dict[str, object]
 
 
 class OutgoingRequest(TypedDict):
@@ -25,24 +25,24 @@ class OutgoingRequest(TypedDict):
     not rely on TypedDict inheritance.
     """
 
-    model: str
-    messages: list[ChatMessage]
-    stream: bool
-    tools: Optional[list[dict[str, object]]]
-    tool_choice: Optional[object]
-    parallel_tool_calls: Optional[bool]
+    model: 'str'
+    messages: 'typing.List[ChatMessage]'
+    stream: 'bool'
+    tools: 'Optional[typing.List[typing.Dict[str, object]]]'
+    tool_choice: 'Optional[object]'
+    parallel_tool_calls: 'Optional[bool]'
 
 
 PayloadPostProcessor = Callable[[OutgoingRequest], OutgoingRequest]
 
 
-def _identity(outcomming_request: OutgoingRequest) -> OutgoingRequest:
+def _identity(outcomming_request: 'OutgoingRequest') -> 'OutgoingRequest':
     """Keep the canonical request unchanged."""
 
     return outcomming_request
 
 
-def _drop_developer_messages(outcomming_request: OutgoingRequest) -> OutgoingRequest:
+def _drop_developer_messages(outcomming_request: 'OutgoingRequest') -> 'OutgoingRequest':
     """Remove all developer-role messages for providers that reject them."""
 
     outcomming_request["messages"] = [
@@ -52,18 +52,27 @@ def _drop_developer_messages(outcomming_request: OutgoingRequest) -> OutgoingReq
     ]
     return outcomming_request
 
+def _replace_developer_messages(outcomming_request: 'OutgoingRequest') -> 'OutgoingRequest':
+    """Replace all developer-role messages to system-role messages"""
 
-PAYLOAD_POST_PROCESSORS: dict[str, PayloadPostProcessor] = {
-    "stepfun": _drop_developer_messages,
+    for message in outcomming_request['messages']:
+        if message.get("role") == "developer":
+            message['role'] = "system"
+
+    return outcomming_request
+
+
+PAYLOAD_POST_PROCESSORS: 'typing.Dict[str, PayloadPostProcessor]' = {
+    "stepfun": _replace_developer_messages,
     "vllm": _identity,
 }
 """Mapping from normalized `model_provider` name to payload rewrite hook."""
 
 
 def post_process_outcomming_request(
-    outcomming_request: OutgoingRequest,
-    model_provider: str | None,
-) -> OutgoingRequest:
+    outcomming_request: 'OutgoingRequest',
+    model_provider: 'typing.Union[str, None]',
+) -> 'OutgoingRequest':
     """Apply the provider-specific payload hook to one outgoing request.
 
     This is the single wrapper around `PAYLOAD_POST_PROCESSORS`: it normalizes

responses_server/server.py

@@ -1,41 +1,41 @@
-from __future__ import annotations
 
 from .config import CompatServerConfig
 from .payload_processors import post_process_outcomming_request
 from .session_store import SessionStore
 from .stream_router import StreamRouter
+import typing
 
 
 class ResponseServer:
     def __init__(
         self,
-        config: CompatServerConfig,
-        session_store: SessionStore | None = None,
-        stream_router: StreamRouter | None = None,
-    ) -> None:
+        config: 'CompatServerConfig',
+        session_store: 'typing.Union[SessionStore, None]' = None,
+        stream_router: 'typing.Union[StreamRouter, None]' = None,
+    ) -> 'None':
         self._config = config
         self._session_store = session_store or SessionStore()
         self._stream_router = stream_router or StreamRouter(config)
 
     @property
-    def config(self) -> CompatServerConfig:
+    def config(self) -> 'CompatServerConfig':
         return self._config
 
     @property
-    def session_store(self) -> SessionStore:
+    def session_store(self) -> 'SessionStore':
         return self._session_store
 
     @property
-    def stream_router(self) -> StreamRouter:
+    def stream_router(self) -> 'StreamRouter':
         return self._stream_router
 
-    def list_models(self) -> dict[str, object]:
+    def list_models(self) -> 'typing.Dict[str, object]':
         return self._stream_router.list_models()
 
     def start_response_stream(
         self,
-        request_body: dict[str, object],
-        request_headers: dict[str, str],
+        request_body: 'typing.Dict[str, object]',
+        request_headers: 'typing.Dict[str, str]',
     ):
         outcomming_request = self._stream_router.build_outcomming_request(request_body)
         outcomming_request = post_process_outcomming_request(

responses_server/session_store.py

@@ -1,25 +1,25 @@
-from __future__ import annotations
 
 from dataclasses import dataclass
 import threading
 import time
+import typing
 
 
-@dataclass(frozen=True, slots=True)
+@dataclass(frozen=True, )
 class StoredResponse:
-    response_id: str
-    session_id: str | None
-    model: str
-    created_at: float
+    response_id: 'str'
+    session_id: 'typing.Union[str, None]'
+    model: 'str'
+    created_at: 'float'
 
 
 class SessionStore:
-    def __init__(self) -> None:
+    def __init__(self) -> 'None':
         self._lock = threading.Lock()
         self._next_response_number = 1
-        self._responses: dict[str, StoredResponse] = {}
+        self._responses: 'typing.Dict[str, StoredResponse]' = {}
 
-    def create_response(self, session_id: str | None, model: str) -> StoredResponse:
+    def create_response(self, session_id: 'typing.Union[str, None]', model: 'str') -> 'StoredResponse':
         with self._lock:
             response_id = f"resp_{self._next_response_number:08d}"
             self._next_response_number += 1
@@ -32,6 +32,6 @@ class SessionStore:
             self._responses[response_id] = stored
             return stored
 
-    def get_response(self, response_id: str) -> StoredResponse | None:
+    def get_response(self, response_id: 'str') -> 'typing.Union[StoredResponse, None]':
         with self._lock:
             return self._responses.get(response_id)