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

pycodex/cli.py

@@ -42,7 +42,6 @@ CliSessionMode = Literal["exec", "tui"]
 LOCAL_RESPONSES_SERVER_API_KEY_ENV = "PYCODEX_LOCAL_RESPONSES_SERVER_KEY"
 CLI_ORIGINATOR = "codex-tui"
 
-
 def launch_chat_completion_compat_server(*args, **kwargs):
     from responses_server import (
         launch_chat_completion_compat_server as launch_compat_server,
@@ -123,6 +122,15 @@ def build_parser() -> 'argparse.ArgumentParser':
             "When set, pycodex starts a local responses compat server for this session."
         ),
     )
+    parser.add_argument(
+        "--use-messages",
+        default=False,
+        action="store_true",
+        help=(
+            "When set, pycodex starts a local responses compat server and routes "
+            "to a downstream /v1/messages backend for this session."
+        ),
+    )
     parser.add_argument(
         "--system-prompt",
         default=None,
@@ -373,12 +381,17 @@ def _build_model_client(
     managed_responses_base_url: 'typing.Union[str, None]' = None,
     vllm_endpoint: 'typing.Union[str, None]' = None,
     use_chat_completion: 'bool' = False,
+    use_messages: 'bool' = False,
 ):
     load_codex_dotenv(config_path)
     provider_config = ResponsesProviderConfig.from_codex_config(
         config_path,
         profile,
     )
+    if use_chat_completion and use_messages:
+        raise ValueError("--use-chat-completion and --use-messages cannot be combined")
+    if vllm_endpoint and use_messages:
+        raise ValueError("--vllm-endpoint and --use-messages cannot be combined")
     url, key_env = provider_config.base_url, provider_config.api_key_env
     if managed_responses_base_url is not None:
         url, key_env = (
@@ -386,7 +399,7 @@ def _build_model_client(
             LOCAL_RESPONSES_SERVER_API_KEY_ENV,
         )
         os.environ.setdefault(LOCAL_RESPONSES_SERVER_API_KEY_ENV, "dummy")
-    elif vllm_endpoint or use_chat_completion:
+    elif vllm_endpoint or use_chat_completion or use_messages:
         if vllm_endpoint:
             managed_server = launch_chat_completion_compat_server(
                 vllm_endpoint,
@@ -397,6 +410,9 @@ def _build_model_client(
                 provider_config.base_url,
                 provider_config.api_key_env,
                 model_provider=provider_config.provider_name,
+                outcomming_api=(
+                    "messages" if use_messages else "chat_completions"
+                ),
             )
         atexit.register(managed_server.stop)
         url, key_env = (
@@ -755,6 +771,7 @@ async def run_cli(args: 'argparse.Namespace') -> 'int':
             args.timeout_seconds,
             vllm_endpoint=args.vllm_endpoint,
             use_chat_completion=args.use_chat_completion,
+            use_messages=args.use_messages,
         )
 
         runtime = build_runtime(

pycodex/utils/visualize.py

@@ -83,7 +83,7 @@ def format_cli_plan_messages(
 
 def build_cli_spinner_frame(index: 'int', label: 'str') -> 'str':
     suffix = f" {label}" if label else ""
-    return f"⏳{suffix} {SPINNER_FRAMES[index % len(SPINNER_FRAMES)]}"
+    return f"{SPINNER_FRAMES[index % len(SPINNER_FRAMES)]}{suffix}"
 
 
 def percent_of_context_window_remaining(
@@ -158,13 +158,29 @@ class Spinner:
             self._paused = False
 
     def clear(self) -> 'None':
-        if not self._enabled or not self._visible:
-            return
         with self._terminal_lock:
+            if not self._visible:
+                return
             self._raw_write("\r\x1b[2K")
             self._raw_flush()
             self._visible = False
 
+    def render_now(self) -> 'None':
+        if not self._turn_active or self._paused:
+            return
+        frame = colorize_cli_message(
+            build_cli_spinner_frame(self._index, self._label),
+            "status",
+            self._color_enabled,
+        )
+        self._index += 1
+        with self._terminal_lock:
+            if not self._turn_active or self._paused:
+                return
+            self._raw_write(f"\r\x1b[2K{frame}")
+            self._raw_flush()
+            self._visible = True
+
     def close(self) -> 'None':
         self.finish_turn()
         if self._thread is not None:
@@ -726,6 +742,7 @@ class CliSessionView:
                 else:
                     self._spinner.resume()
                     self._spinner.set_label("running provider tools")
+                    self._spinner.render_now()
             return
 
         if event.kind == "tool_started":
@@ -740,20 +757,16 @@ class CliSessionView:
             else:
                 self._spinner.resume()
                 if tool_name and args is not None:
-                    self._spinner.set_label(f"running {tool_name}({args})")
+                    self._spinner.set_label(shorten_title(f"running {tool_name}({args})", limit=72))
                 elif tool_name:
                     self._spinner.set_label(f"running {tool_name}")
                 else:
                     self._spinner.set_label("running provider tools")
+                self._spinner.render_now()
             return
 
         if event.kind == "tool_completed":
             self._finish_stream()
-            if self._input_active:
-                self._spinner.pause()
-            else:
-                self._spinner.resume()
-                self._spinner.set_label("thinking")
             tool_name, summary, is_error = extract_tool_event_display(event.payload)
             summary = self._rewrite_agent_summary(tool_name, summary)
             if tool_name == "update_plan" and not is_error:
@@ -762,6 +775,12 @@ class CliSessionView:
                     self._print_line(
                         colorize_cli_message(line, "plan", self._color_enabled)
                     )
+                if self._input_active:
+                    self._spinner.pause()
+                else:
+                    self._spinner.resume()
+                    self._spinner.set_label("thinking")
+                    self._spinner.render_now()
                 return
             message = format_cli_tool_message(
                 tool_name,
@@ -770,6 +789,12 @@ class CliSessionView:
             )
             self._remember_agent_name(tool_name, summary)
             self._print_line(self._colorize_formatted_tool_message(message))
+            if self._input_active:
+                self._spinner.pause()
+            else:
+                self._spinner.resume()
+                self._spinner.set_label("thinking")
+                self._spinner.render_now()
             return
 
         if event.kind == "turn_completed":
@@ -830,6 +855,8 @@ class CliSessionView:
 
     def resume_spinner(self) -> 'None':
         self._spinner.resume()
+        if not self._input_active:
+            self._spinner.render_now()
 
     def set_input_active(self, active: 'bool', resume_spinner: 'bool' = True) -> 'None':
         self._input_active = active

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-codex
-Version: 0.1.4
+Version: 0.1.6
 Summary: A minimal Python extraction of Codex's main agent loop
 License-File: LICENSE
 Requires-Python: >=3.6.2
@@ -159,6 +159,7 @@ pycodex "Summarize this repo in one sentence."
 printf 'Reply with exactly OK.' | pycodex
 pycodex --json "Reply with exactly OK."
 pycodex --profile model_proxy "Reply with exactly OK."
+pycodex --profile opus --use-messages "Reply with exactly OK."
 pycodex --vllm-endpoint http://127.0.0.1:18000 "Reply with exactly OK."
 pycodex --put @127.0.0.1:5577
 pycodex --put /data/.codex/@127.0.0.1:5577
@@ -211,6 +212,9 @@ Current behavior:
   historical `reasoning` items are replayed into downstream assistant messages
   via the `reasoning` field. Streaming token usage is also requested from vLLM
   and forwarded to the final `response.completed.response.usage`
+- standalone `responses_server` now also supports downstream `/v1/messages`
+  backends via `--outcomming-api messages`, while keeping the internal
+  canonical request/route logic in chat-completions shape
 - `pycodex doctor` checks config, `.env`, API keys, DNS, TCP/TLS, and an
   optional live Responses API request
 

{python_codex-0.1.4.dist-info → python_codex-0.1.6.dist-info}/RECORD

@@ -1,6 +1,6 @@
 pycodex/__init__.py,sha256=jCnC_Bgotlxa4GwO3Re2sChKGY49TRM-uVZEQ9uBpfw,3106
 pycodex/agent.py,sha256=s0FrF_XG2pHKryooS461Jr_acmQ_TKTp2JLGQNiny6w,11888
-pycodex/cli.py,sha256=ntgC0LWlSOhuYAUOBgSEeVIjBTKS91klyvkTO9QtFoE,29559
+pycodex/cli.py,sha256=FG0klhVuJiS7797GQZpj6gk1-jChFwgFPEhPXA2vXM8,30316
 pycodex/collaboration.py,sha256=yQ6pBD-R3ZWR4_FAYQFoS7KF0m4LLD42otXIbPqw2ys,641
 pycodex/compat.py,sha256=IO0X7AgcYhlHnYnpvBZ6leCh_UjoQzg5HLT5wYBNNIw,3155
 pycodex/context.py,sha256=R5tuMcNrX1F-Lh9ymsSbnfRbKLJ19TWrtQoZ3tWlHvM,24982
@@ -57,20 +57,21 @@ 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
+pycodex/utils/visualize.py,sha256=JURzq2AbV046bblE5fojcAe885Juda0LDxt_gqT2PUc,41006
 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/app.py,sha256=4SUG8xqKqmVKVY9i1f5WF9QrnmxGbD4mwiI6s13zQDE,7742
+responses_server/config.py,sha256=leb3_uPrCyYdUIkyRyVPX4luGF88dQ62OkhRLPe7uxw,2718
+responses_server/messages_api.py,sha256=3GPMfs3ksQkhezLyWBjeW5zJ1e_MeHXVaq1lALIA7Mk,16815
+responses_server/payload_processors.py,sha256=gfOXqvVwlhCk-yjaDdGU4RKcpDdxIq2y6CmqUCggIjY,3444
 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/stream_router.py,sha256=OVwaDEsUaKVDNGF2vnqNZTo3WA9h3D3uzHeYY-QN9IU,34754
 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.6.dist-info/METADATA,sha256=SYSPoh0NP5qUQKfAu2ncG1_DXQZrWKSPcRGpnqmTVQk,15719
+python_codex-0.1.6.dist-info/WHEEL,sha256=KGYbc1zXlYddvwxnNty23BeaKzh7YuoSIvIMO4jEhvw,87
+python_codex-0.1.6.dist-info/entry_points.txt,sha256=sNUVakoVuTrzJH505ZgRTQxmtRRPUHV_EH0i6EbYTyM,45
+python_codex-0.1.6.dist-info/licenses/LICENSE,sha256=0X8ifk312hYAORM4hlzg8wVSEXYKNmiPgWlB1YIy2Nw,10926
+python_codex-0.1.6.dist-info/RECORD,,

responses_server/app.py

@@ -36,13 +36,14 @@ def _stream_events(response_server: 'ResponseServer', request_body: 'typing.Dict
     except OutcommingChatError as exc:
         
         import traceback
+        exc_info = traceback.format_exception(type(exc), exc, exc.__traceback__)
         yield _format_sse_event(
             "response.failed",
             {
                 "type": "response.failed",
                 "response": {
                     "error": {
-                        "message": '\n'.join(traceback.format_exception(exc)),
+                        "message": '\n'.join(exc_info),
                     }
                 },
             },
@@ -54,12 +55,18 @@ def build_parser() -> 'argparse.ArgumentParser':
         prog="python -m responses_server",
         description=(
             "Standalone localhost `/v1/responses` server that translates the "
-            "Codex/Responses subset onto an outcomming `/v1/chat/completions` backend."
+            "Codex/Responses subset onto an outcomming `/v1/chat/completions` "
+            "or `/v1/messages` backend."
         ),
     )
     parser.add_argument("--host", default="127.0.0.1")
     parser.add_argument("--port", type=int, default=8001)
     parser.add_argument("--outcomming-base-url", required=True)
+    parser.add_argument(
+        "--outcomming-api",
+        default="chat_completions",
+        choices=["chat_completions", "messages"],
+    )
     parser.add_argument("--outcomming-api-key-env", default=None)
     parser.add_argument("--model-provider", default=None)
     parser.add_argument("--timeout-seconds", type=float, default=120.0)
@@ -79,10 +86,12 @@ 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",
 ):
     config = CompatServerConfig.from_base_url(
         base_url,
         api_key_env,
+        outcomming_api=outcomming_api,
         model_provider=model_provider,
     )
     server = ManagedResponseServer(config)
@@ -208,6 +217,7 @@ def main() -> 'None':
             host=args.host,
             port=args.port,
             outcomming_base_url=args.outcomming_base_url,
+            outcomming_api=args.outcomming_api,
             outcomming_api_key_env=args.outcomming_api_key_env,
             model_provider=args.model_provider,
             timeout_seconds=args.timeout_seconds,

responses_server/config.py

@@ -10,6 +10,7 @@ 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' = 120.0
@@ -24,15 +25,24 @@ class CompatServerConfig:
         base = self.outcomming_base_url.rstrip("/")
         return f"{base}/chat/completions"
 
+    def outcomming_messages_url(self) -> 'str':
+        base = self.outcomming_base_url.rstrip("/")
+        return f"{base}/messages"
+
     def outcomming_models_url(self) -> 'str':
         base = self.outcomming_base_url.rstrip("/")
         return f"{base}/models"
 
+    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':
         return CompatServerConfig(
             host=self.host,
             port=0,
             outcomming_base_url=self.outcomming_base_url,
+            outcomming_api=self.outcomming_api,
             outcomming_api_key_env=self.outcomming_api_key_env,
             model_provider=self.model_provider,
             timeout_seconds=self.timeout_seconds,
@@ -44,6 +54,7 @@ class 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:
@@ -58,6 +69,7 @@ class CompatServerConfig:
             )
         return cls(
             outcomming_base_url=outcomming_base_url,
+            outcomming_api=outcomming_api,
             outcomming_api_key_env=api_key_env,
             model_provider=model_provider,
         )

responses_server/messages_api.py

@@ -0,0 +1,479 @@
+import json
+import typing
+
+DEFAULT_MESSAGES_MAX_TOKENS = 32000
+
+
+class MessagesAPIAdapterError(ValueError):
+    pass
+
+
+def build_messages_request(
+    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`")
+
+    raw_messages = outcomming_request.get("messages") or []
+    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]]' = []
+    for raw_message in raw_messages:
+        if not isinstance(raw_message, dict):
+            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 "")
+            if text:
+                system_blocks.append({"type": "text", "text": text})
+            continue
+        if role == "user":
+            messages.append(
+                {
+                    "role": "user",
+                    "content": _build_text_blocks(raw_message.get("content")),
+                }
+            )
+            continue
+        if role == "assistant":
+            messages.append(
+                {
+                    "role": "assistant",
+                    "content": _build_assistant_blocks(raw_message),
+                }
+            )
+            continue
+        if role == "tool":
+            messages.append(
+                {
+                    "role": "user",
+                    "content": [_build_tool_result_block(raw_message)],
+                }
+            )
+            continue
+        raise MessagesAPIAdapterError(
+            f"unsupported outcomming message role for messages API: {role!r}"
+        )
+
+    payload: 'typing.Dict[str, object]' = {
+        "model": model,
+        "messages": messages,
+        "max_tokens": _resolve_max_tokens(outcomming_request),
+        "stream": bool(outcomming_request.get("stream", True)),
+    }
+    if system_blocks:
+        payload["system"] = system_blocks
+
+    tools = _translate_tools(outcomming_request.get("tools"))
+    if tools:
+        payload["tools"] = tools
+        tool_choice = _translate_tool_choice(
+            outcomming_request.get("tool_choice"),
+            outcomming_request.get("parallel_tool_calls"),
+        )
+        if tool_choice is not None:
+            payload["tool_choice"] = tool_choice
+    return payload
+
+
+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_type = str(payload.get("type") or event_name or "").strip()
+    chunks: 'typing.List[typing.Dict[str, object]]' = []
+
+    if event_type == "message_start":
+        message = payload.get("message") or {}
+        if isinstance(message, dict):
+            usage_chunk = _usage_chunk(message.get("usage"))
+            if usage_chunk is not None:
+                chunks.append(usage_chunk)
+        return chunks
+
+    if event_type == "content_block_start":
+        block_index = _normalize_index(payload.get("index"))
+        content_block = payload.get("content_block") or {}
+        if not isinstance(content_block, dict):
+            return chunks
+        content_blocks = state.setdefault("content_blocks", {})
+        if not isinstance(content_blocks, dict):
+            raise MessagesAPIAdapterError("messages stream state is corrupted")
+        content_blocks[block_index] = str(content_block.get("type", "")).strip()
+
+        block_type = str(content_block.get("type", "")).strip()
+        if block_type == "text":
+            text = str(content_block.get("text", "") or "")
+            if text:
+                chunks.append(_chat_text_chunk(text))
+            return chunks
+        if block_type == "thinking":
+            thinking = str(content_block.get("thinking", "") or "")
+            if thinking:
+                chunks.append(_chat_reasoning_chunk(thinking))
+            return chunks
+        if block_type == "tool_use":
+            arguments = _dump_json(content_block.get("input") or {})
+            chunks.append(
+                _chat_tool_chunk(
+                    block_index,
+                    call_id=str(content_block.get("id", "")).strip(),
+                    name=str(content_block.get("name", "")).strip(),
+                    arguments=arguments if arguments != "{}" else "",
+                )
+            )
+            return chunks
+        return chunks
+
+    if event_type == "content_block_delta":
+        block_index = _normalize_index(payload.get("index"))
+        delta = payload.get("delta") or {}
+        if not isinstance(delta, dict):
+            return chunks
+        delta_type = str(delta.get("type", "")).strip()
+        if delta_type == "text_delta":
+            text = str(delta.get("text", "") or "")
+            if text:
+                chunks.append(_chat_text_chunk(text))
+            return chunks
+        if delta_type == "thinking_delta":
+            thinking = str(delta.get("thinking", "") or "")
+            if thinking:
+                chunks.append(_chat_reasoning_chunk(thinking))
+            return chunks
+        if delta_type == "input_json_delta":
+            partial_json = str(delta.get("partial_json", "") or "")
+            chunks.append(_chat_tool_chunk(block_index, arguments=partial_json))
+            return chunks
+        return chunks
+
+    if event_type == "message_delta":
+        usage_chunk = _usage_chunk(payload.get("usage"))
+        if usage_chunk is not None:
+            chunks.append(usage_chunk)
+        delta = payload.get("delta") or {}
+        if not isinstance(delta, dict):
+            return chunks
+        finish_reason = _translate_stop_reason(delta.get("stop_reason"))
+        if finish_reason and not bool(state.get("finish_emitted")):
+            state["finish_reason"] = finish_reason
+            state["finish_emitted"] = True
+            chunks.append(_chat_finish_chunk(finish_reason))
+        return chunks
+
+    if event_type == "message_stop":
+        if not bool(state.get("finish_emitted")):
+            finish_reason = str(state.get("finish_reason") or "stop")
+            state["finish_emitted"] = True
+            chunks.append(_chat_finish_chunk(finish_reason))
+        state["saw_message_stop"] = True
+        return chunks
+
+    if event_type == "error":
+        error = payload.get("error")
+        if isinstance(error, dict):
+            message = str(error.get("message", "") or "").strip()
+            if message:
+                raise MessagesAPIAdapterError(message)
+        raise MessagesAPIAdapterError(_dump_json(payload))
+
+    return chunks
+
+
+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]]':
+    text = str(raw_content or "")
+    if not text:
+        return []
+    return [{"type": "text", "text": text}]
+
+
+def _build_assistant_blocks(
+    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})
+
+    text = str(raw_message.get("content", "") or "")
+    if text:
+        blocks.append({"type": "text", "text": text})
+
+    raw_tool_calls = raw_message.get("tool_calls") or []
+    if raw_tool_calls:
+        if not isinstance(raw_tool_calls, list):
+            raise MessagesAPIAdapterError("assistant `tool_calls` must be a list")
+        for raw_tool_call in raw_tool_calls:
+            if not isinstance(raw_tool_call, dict):
+                raise MessagesAPIAdapterError("assistant tool calls must be objects")
+            function = raw_tool_call.get("function") or {}
+            if not isinstance(function, dict):
+                raise MessagesAPIAdapterError(
+                    "assistant tool call is missing function payload"
+                )
+            blocks.append(
+                {
+                    "type": "tool_use",
+                    "id": str(raw_tool_call.get("id", "")).strip(),
+                    "name": str(function.get("name", "")).strip(),
+                    "input": _parse_json_object(function.get("arguments")),
+                }
+            )
+    return blocks
+
+
+def _build_tool_result_block(
+    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(),
+        "content": str(raw_message.get("content", "") or ""),
+    }
+
+
+def _translate_tools(
+    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:
+        if not isinstance(raw_tool, dict) or raw_tool.get("type") != "function":
+            raise MessagesAPIAdapterError(
+                "messages API backend only supports function-style tools"
+            )
+        function = raw_tool.get("function") or {}
+        if not isinstance(function, dict):
+            raise MessagesAPIAdapterError("tool definition is missing function payload")
+        name = str(function.get("name", raw_tool.get("name", ""))).strip()
+        if not name:
+            raise MessagesAPIAdapterError("tool definition is missing `name`")
+        translated.append(
+            {
+                "name": name,
+                "description": str(function.get("description", "") or ""),
+                "input_schema": function.get("parameters") or {"type": "object"},
+            }
+        )
+    return translated
+
+
+def _translate_tool_choice(
+    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 {
+                "type": "auto",
+                "disable_parallel_tool_use": True,
+            }
+        return None
+
+    translated: 'typing.Dict[str, object]'
+    if isinstance(raw_tool_choice, str):
+        choice = raw_tool_choice.strip()
+        if choice == "auto":
+            translated = {"type": "auto"}
+        elif choice == "required":
+            translated = {"type": "any"}
+        elif choice == "none":
+            return None
+        else:
+            raise MessagesAPIAdapterError(
+                f"unsupported tool_choice for messages API: {raw_tool_choice!r}"
+            )
+    elif isinstance(raw_tool_choice, dict):
+        choice_type = str(raw_tool_choice.get("type", "")).strip()
+        if choice_type == "function":
+            function = raw_tool_choice.get("function") or {}
+            name = ""
+            if isinstance(function, dict):
+                name = str(function.get("name", "")).strip()
+            if not name:
+                name = str(raw_tool_choice.get("name", "")).strip()
+            if not name:
+                raise MessagesAPIAdapterError(
+                    "function tool_choice is missing `name`"
+                )
+            translated = {
+                "type": "tool",
+                "name": name,
+            }
+        else:
+            raise MessagesAPIAdapterError(
+                f"unsupported tool_choice for messages API: {raw_tool_choice!r}"
+            )
+    else:
+        raise MessagesAPIAdapterError(
+            f"unsupported tool_choice for messages API: {raw_tool_choice!r}"
+        )
+
+    if parallel_tool_calls is False:
+        translated["disable_parallel_tool_use"] = True
+    return translated
+
+
+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):
+        text = raw_value.strip()
+        if not text:
+            return {}
+        try:
+            parsed = json.loads(text)
+        except json.JSONDecodeError as exc:
+            raise MessagesAPIAdapterError(
+                f"tool arguments must be valid JSON objects for messages API: {exc}"
+            ) from exc
+        if isinstance(parsed, dict):
+            return dict(parsed)
+        raise MessagesAPIAdapterError(
+            "tool arguments must decode to JSON objects for messages API"
+        )
+    raise MessagesAPIAdapterError(
+        "tool arguments must be strings or objects for messages API"
+    )
+
+
+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
+    if isinstance(raw_value, int) and raw_value > 0:
+        return raw_value
+    return DEFAULT_MESSAGES_MAX_TOKENS
+
+
+def _usage_chunk(raw_usage: 'object') -> 'typing.Union[typing.Dict[str, object], None]':
+    usage = _translate_usage(raw_usage)
+    if not usage:
+        return None
+    return {
+        "choices": [],
+        "usage": usage,
+    }
+
+
+def _translate_usage(raw_usage: 'object') -> 'typing.Dict[str, object]':
+    if not isinstance(raw_usage, dict):
+        return {}
+    usage: 'typing.Dict[str, object]' = {}
+    input_tokens = raw_usage.get("input_tokens")
+    output_tokens = raw_usage.get("output_tokens")
+    if isinstance(input_tokens, int):
+        usage["input_tokens"] = input_tokens
+    if isinstance(output_tokens, int):
+        usage["output_tokens"] = output_tokens
+    total_tokens = raw_usage.get("total_tokens")
+    if isinstance(total_tokens, int):
+        usage["total_tokens"] = total_tokens
+    elif isinstance(input_tokens, int) and isinstance(output_tokens, int):
+        usage["total_tokens"] = input_tokens + output_tokens
+
+    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
+    cache_read = raw_usage.get("cache_read_input_tokens")
+    if isinstance(cache_read, int):
+        input_details["cache_read_input_tokens"] = cache_read
+    if input_details:
+        usage["input_tokens_details"] = input_details
+    return usage
+
+
+def _normalize_index(raw_index: 'object') -> 'int':
+    if isinstance(raw_index, int):
+        return raw_index
+    try:
+        return int(raw_index)
+    except (TypeError, ValueError):
+        return 0
+
+
+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()
+    if not stop_reason:
+        return None
+    if stop_reason == "tool_use":
+        return "tool_calls"
+    if stop_reason == "max_tokens":
+        return "length"
+    if stop_reason in {"end_turn", "stop_sequence"}:
+        return "stop"
+    return stop_reason
+
+
+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]':
+    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": index,
+        "function": {},
+    }
+    if call_id:
+        tool_call["id"] = call_id
+    if name:
+        tool_call["type"] = "function"
+        tool_call["function"] = {"name": name}
+    function = tool_call.get("function")
+    if not isinstance(function, dict):
+        function = {}
+        tool_call["function"] = function
+    if arguments:
+        function["arguments"] = arguments
+    return _chat_delta_chunk({"tool_calls": [tool_call]})
+
+
+def _chat_delta_chunk(delta: 'typing.Dict[str, object]') -> 'typing.Dict[str, object]':
+    return {
+        "choices": [
+            {
+                "index": 0,
+                "delta": delta,
+                "finish_reason": None,
+            }
+        ]
+    }
+
+
+def _chat_finish_chunk(finish_reason: 'str') -> 'typing.Dict[str, object]':
+    return {
+        "choices": [
+            {
+                "index": 0,
+                "delta": {},
+                "finish_reason": finish_reason,
+            }
+        ]
+    }
+
+
+def _dump_json(raw_value: 'object') -> 'str':
+    return json.dumps(raw_value, ensure_ascii=False, separators=(",", ":"))

responses_server/payload_processors.py

@@ -28,6 +28,7 @@ class OutgoingRequest(TypedDict):
     model: 'str'
     messages: 'typing.List[ChatMessage]'
     stream: 'bool'
+    max_tokens: 'Optional[int]'
     tools: 'Optional[typing.List[typing.Dict[str, object]]]'
     tool_choice: 'Optional[object]'
     parallel_tool_calls: 'Optional[bool]'

responses_server/stream_router.py

@@ -6,6 +6,12 @@ import urllib.error
 import urllib.request
 
 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 .session_store import StoredResponse
 from .tools import WebSearchTool, collect_custom_tool_names
 from .tools.custom_adapter import (
@@ -130,6 +136,13 @@ class StreamRouter:
             ),
             "stream": True,
         }
+        max_tokens = self._coerce_positive_int(
+            incomming_request.get("max_output_tokens")
+        )
+        if max_tokens is None:
+            max_tokens = self._coerce_positive_int(incomming_request.get("max_tokens"))
+        if max_tokens is not None:
+            payload["max_tokens"] = max_tokens
         if self._supports_stream_usage():
             payload["stream_options"] = {"include_usage": True}
 
@@ -150,6 +163,19 @@ class StreamRouter:
         return payload
 
     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)
+        if outcomming_api != "chat_completions":
+            raise OutcommingChatError(
+                f"unsupported outcomming API: {self._config.outcomming_api!r}"
+            )
+        return self._open_outcomming_chat_stream(outcomming_request)
+
+    def _open_outcomming_chat_stream(
+        self,
+        outcomming_request: 'typing.Dict[str, object]',
+    ):
         request = urllib.request.Request(
             self._config.outcomming_chat_completions_url(),
             data=json.dumps(outcomming_request).encode("utf-8"),
@@ -196,6 +222,67 @@ class StreamRouter:
                 f"outcomming chat request failed: {exc.reason}"
             ) from exc
 
+    def _open_outcomming_messages_stream(
+        self,
+        outcomming_request: 'typing.Dict[str, object]',
+    ):
+        try:
+            messages_request = build_messages_request(outcomming_request)
+        except MessagesAPIAdapterError as exc:
+            raise OutcommingChatError(str(exc)) from exc
+
+        request = urllib.request.Request(
+            self._config.outcomming_messages_url(),
+            data=json.dumps(messages_request).encode("utf-8"),
+            headers=self._build_headers(accept="text/event-stream"),
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(
+                request,
+                context=ssl.create_default_context(),
+                timeout=self._config.timeout_seconds,
+            ) as response:
+                try:
+                    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
+                        for chunk in iter_chat_chunks_from_messages(
+                            event_name,
+                            payload,
+                            stream_state,
+                        ):
+                            yield chunk
+                    if not messages_saw_message_stop(stream_state):
+                        raise OutcommingChatError(
+                            "outcomming messages stream ended before `message_stop`"
+                        )
+                except (
+                    ConnectionError,
+                    EOFError,
+                    OSError,
+                    http.client.HTTPException,
+                    json.JSONDecodeError,
+                    MessagesAPIAdapterError,
+                ) as exc:
+                    raise OutcommingChatError(
+                        "outcomming messages stream failed while reading response body: "
+                        f"{exc}"
+                    ) from exc
+        except urllib.error.HTTPError as exc:
+            body = exc.read().decode("utf-8", errors="replace")
+            raise OutcommingChatError(
+                f"outcomming messages request failed with status {exc.code}: {body[:500]}"
+            ) from exc
+        except urllib.error.URLError as exc:
+            raise OutcommingChatError(
+                f"outcomming messages request failed: {exc.reason}"
+            ) from exc
+
     def route_stream(
         self,
         incomming_stream,
@@ -439,6 +526,13 @@ class StreamRouter:
         flush_pending_assistant()
         return messages
 
+    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:
+            return raw_value
+        return None
+
     def _coalesce_content_text(self, raw_content: 'object') -> 'str':
         if raw_content is None:
             return ""