python-codex 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

pycodex/context.py

@@ -1,8 +1,6 @@
 
 from dataclasses import dataclass
 from datetime import datetime
-from functools import lru_cache
-import json
 from pathlib import Path
 import typing
 
@@ -12,6 +10,7 @@ except ModuleNotFoundError:  # pragma: no cover - Python 3.10 path
     import tomli as tomllib
 
 from .collaboration import DEFAULT_COLLABORATION_MODE, CollaborationMode
+from .model_metadata import load_models_by_slug
 from .protocol import ContextMessage, ConversationItem, JSONDict, Prompt, ToolSpec
 from .utils.get_env import (
     get_sandbox_tag,
@@ -23,7 +22,6 @@ from .utils.get_env import (
 DEFAULT_BASE_INSTRUCTIONS_PATH = (
     Path(__file__).resolve().parent / "prompts" / "default_base_instructions.md"
 )
-DEFAULT_MODELS_PATH = Path(__file__).resolve().parent / "prompts" / "models.json"
 DEFAULT_COLLABORATION_INSTRUCTIONS_PATH = (
     Path(__file__).resolve().parent / "prompts" / "collaboration_default.md"
 )
@@ -270,7 +268,7 @@ class ContextManager:
         model_metadata = None
         model_slug = self._config.model
         if model_slug is not None:
-            model_metadata = _load_models_by_slug().get(model_slug)
+            model_metadata = load_models_by_slug().get(model_slug)
 
         context_window = self._config.model_context_window
         if context_window is None and model_metadata is not None:
@@ -293,7 +291,7 @@ class ContextManager:
         model_slug = self._config.model
         if model_slug is None:
             return None
-        model_metadata = _load_models_by_slug().get(model_slug)
+        model_metadata = load_models_by_slug().get(model_slug)
         if model_metadata is None:
             return None
         return _normalize_int(model_metadata.get("auto_compact_token_limit"))
@@ -302,7 +300,7 @@ class ContextManager:
         model_slug = self._config.model
         if model_slug is None:
             return None
-        model_metadata = _load_models_by_slug().get(model_slug)
+        model_metadata = load_models_by_slug().get(model_slug)
         if model_metadata is None:
             return None
 
@@ -560,18 +558,6 @@ def _read_first_instruction_file(base: 'Path') -> 'typing.Union[str, None]':
     return None
 
 
-@lru_cache(maxsize=1)
-def _load_models_by_slug() -> 'typing.Dict[str, JSONDict]':
-    payload = json.loads(DEFAULT_MODELS_PATH.read_text(encoding="utf-8"))
-    models = payload.get("models", [])
-    by_slug: 'typing.Dict[str, JSONDict]' = {}
-    for model in models:
-        slug = model.get("slug")
-        if isinstance(slug, str):
-            by_slug[slug] = model
-    return by_slug
-
-
 def _resolve_personality_message(variables, personality: 'typing.Union[str, None]') -> 'str':
     if not isinstance(variables, dict):
         return ""

pycodex/interactive_session.py

@@ -25,10 +25,11 @@ MODEL_COMMAND = "/model"
 QUEUE_COMMAND = "/queue"
 RESUME_COMMAND = "/resume"
 COMPACT_COMMAND = "/compact"
+FORK_COMMAND = "/fork"
 LINK_COMMAND = "/link"
 UNLINK_COMMAND = "/unlink"
 EXTRA_COMMANDS_LINE = (
-    "Extra commands: /help, /history, /title, /model, /resume, /compact, /link, /unlink"
+    "Extra commands: /help, /history, /title, /model, /resume, /compact, /fork, /link, /unlink"
 )
 
 
@@ -301,6 +302,19 @@ async def run_interactive_session(
                 except Exception as exc:  # pragma: no cover - defensive surface
                     view.show_error(str(exc))
                 continue
+            if prompt_text == FORK_COMMAND:
+                if has_pending_turn_tasks():
+                    view.write_line(
+                        "Cannot fork while work is running or queued."
+                    )
+                    continue
+                if not hasattr(model_client, "_session_id"):
+                    view.write_line("Current model does not support session IDs.")
+                    continue
+                new_session_id = uuid7_string()
+                model_client._session_id = new_session_id
+                view.write_line(f"Forked session: {new_session_id}")
+                continue
             if prompt_text.startswith(f"{LINK_COMMAND} "):
                 link_target = prompt_text[len(LINK_COMMAND) :].strip()
                 if not link_target:

pycodex/model.py

@@ -19,16 +19,19 @@ except ModuleNotFoundError:  # pragma: no cover - Python 3.10 path
 
 from .protocol import (
     AssistantMessage,
+    JSONDict,
     ModelResponse,
     ModelStreamEvent,
     Prompt,
     ReasoningItem,
     ToolCall,
 )
+from .model_metadata import model_metadata
 from .utils import build_user_agent, uuid7_string
 
 DEFAULT_CODEX_CONFIG_PATH = Path.home() / ".codex" / "config.toml"
 DEFAULT_ORIGINATOR = "pycodex"
+RESPONSES_LITE_HEADER = "x-openai-internal-codex-responses-lite"
 ModelStreamEventHandler = Callable[[ModelStreamEvent], None]
 NOOP_MODEL_STREAM_EVENT_HANDLER: 'ModelStreamEventHandler' = lambda _event: None
 DEFAULT_STREAM_MAX_RETRIES = 5
@@ -65,6 +68,7 @@ class ResponsesProviderConfig:
     beta_features_header: 'typing.Union[str, None]' = None
     stream_max_retries: 'typing.Union[int, None]' = None
     stream_idle_timeout_ms: 'typing.Union[int, None]' = None
+    service_tier: 'typing.Union[str, None]' = None
 
     @classmethod
     def from_codex_config(
@@ -116,6 +120,7 @@ class ResponsesProviderConfig:
             reasoning_effort=selected.get("model_reasoning_effort"),
             reasoning_summary=selected.get("model_reasoning_summary"),
             verbosity=selected.get("model_verbosity"),
+            service_tier=selected.get("service_tier"),
             sandbox_mode=selected.get("sandbox_mode"),
             beta_features_header=",".join(beta_features) or None,
             stream_max_retries=_optional_int(provider.get("stream_max_retries")),
@@ -157,6 +162,65 @@ class ResponsesProviderConfig:
             return DEFAULT_STREAM_IDLE_TIMEOUT_MS / 1000.0
         return max(int(self.stream_idle_timeout_ms), 1) / 1000.0
 
+    def metadata(self) -> 'typing.Union[JSONDict, None]':
+        return model_metadata(self.model)
+
+    def use_responses_lite(self) -> 'bool':
+        metadata = self.metadata()
+        if metadata is None:
+            return False
+        return metadata.get("use_responses_lite") is True
+
+    def effective_reasoning_effort(self) -> 'typing.Union[str, None]':
+        if self.reasoning_effort is not None:
+            return str(self.reasoning_effort)
+        metadata = self.metadata()
+        if not _metadata_supports_reasoning(metadata):
+            return None
+        return _optional_metadata_string(metadata, "default_reasoning_level")
+
+    def effective_reasoning_summary(self) -> 'typing.Union[str, None]':
+        summary = self.reasoning_summary
+        if summary is None:
+            metadata = self.metadata()
+            if not _metadata_supports_reasoning(metadata):
+                return None
+            summary = _optional_metadata_string(metadata, "default_reasoning_summary")
+        if summary is None:
+            return None
+        if str(summary).strip().lower() == "none":
+            return None
+        return str(summary)
+
+    def effective_verbosity(self) -> 'typing.Union[str, None]':
+        if self.verbosity is not None:
+            return str(self.verbosity)
+        metadata = self.metadata()
+        if metadata is None or metadata.get("support_verbosity") is not True:
+            return None
+        return _optional_metadata_string(metadata, "default_verbosity")
+
+    def effective_service_tier(self) -> 'typing.Union[str, None]':
+        service_tier = self.service_tier
+        if service_tier is None:
+            return None
+        service_tier = str(service_tier).strip()
+        if service_tier == "fast":
+            service_tier = "priority"
+        if not service_tier or service_tier == "default":
+            return None
+
+        metadata = self.metadata()
+        if metadata is None:
+            return None
+        supported = metadata.get("service_tiers")
+        if not isinstance(supported, list):
+            return None
+        for tier in supported:
+            if isinstance(tier, dict) and tier.get("id") == service_tier:
+                return service_tier
+        return None
+
 
 def _optional_bool(value: 'typing.Union[bool, str, int, None]') -> 'typing.Union[bool, None]':
     if value is None:
@@ -171,6 +235,43 @@ def _optional_bool(value: 'typing.Union[bool, str, int, None]') -> 'typing.Union
     raise ValueError(f"invalid boolean config value: {value!r}")
 
 
+def _metadata_supports_reasoning(
+    metadata: 'typing.Union[JSONDict, None]',
+) -> 'bool':
+    return metadata is not None and metadata.get("supports_reasoning_summaries") is True
+
+
+def _optional_metadata_string(
+    metadata: 'typing.Union[JSONDict, None]',
+    key: 'str',
+) -> 'typing.Union[str, None]':
+    if metadata is None:
+        return None
+    value = metadata.get(key)
+    if value is None:
+        return None
+    text = str(value).strip()
+    return text or None
+
+
+def _strip_image_details(items: 'typing.Iterable[object]') -> 'None':
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        content = item.get("content")
+        if isinstance(content, list):
+            _strip_image_detail_from_content_items(content)
+        output = item.get("output")
+        if isinstance(output, list):
+            _strip_image_detail_from_content_items(output)
+
+
+def _strip_image_detail_from_content_items(items: 'typing.Iterable[object]') -> 'None':
+    for item in items:
+        if isinstance(item, dict) and item.get("type") == "input_image":
+            item.pop("detail", None)
+
+
 class ResponsesApiError(RuntimeError):
     pass
 
@@ -392,34 +493,73 @@ class ResponsesModelClient:
             ) from exc
 
     def _build_payload(self, prompt: 'Prompt') -> 'typing.Dict[str, object]':
+        use_responses_lite = self._config.use_responses_lite()
+        input_items = [item.serialize() for item in prompt.input]
+        if use_responses_lite:
+            _strip_image_details(input_items)
+
+        tools = [tool.serialize() for tool in prompt.tools]
         payload: 'typing.Dict[str, object]' = {
             "model": self.model,
-            "instructions": prompt.base_instructions or "",
-            "input": [item.serialize() for item in prompt.input],
-            "tools": [tool.serialize() for tool in prompt.tools],
-            "parallel_tool_calls": prompt.parallel_tool_calls,
+            "input": input_items,
+            "parallel_tool_calls": prompt.parallel_tool_calls and not use_responses_lite,
             "store": False,
             "stream": True,
             "include": ["reasoning.encrypted_content"],
             "prompt_cache_key": self._session_id,
         }
-        if prompt.tools:
+        if use_responses_lite:
+            prefix: 'typing.List[typing.Dict[str, object]]' = [
+                {
+                    "type": "additional_tools",
+                    "role": "developer",
+                    "tools": tools,
+                }
+            ]
+            if prompt.base_instructions:
+                prefix.append(
+                    {
+                        "type": "message",
+                        "role": "developer",
+                        "content": [
+                            {
+                                "type": "input_text",
+                                "text": prompt.base_instructions,
+                            }
+                        ],
+                    }
+                )
+            payload["input"] = prefix + input_items
+        else:
+            payload["instructions"] = prompt.base_instructions or ""
+            payload["tools"] = tools
+
+        if prompt.tools or use_responses_lite:
             payload["tool_choice"] = "auto"
 
         reasoning: 'typing.Dict[str, str]' = {}
-        if self._config.reasoning_effort is not None:
-            reasoning["effort"] = self._config.reasoning_effort
-        if self._config.reasoning_summary is not None:
-            reasoning["summary"] = self._config.reasoning_summary
+        reasoning_effort = self._config.effective_reasoning_effort()
+        reasoning_summary = self._config.effective_reasoning_summary()
+        if reasoning_effort is not None:
+            reasoning["effort"] = reasoning_effort
+        if reasoning_summary is not None:
+            reasoning["summary"] = reasoning_summary
+        if use_responses_lite and reasoning:
+            reasoning["context"] = "all_turns"
         if reasoning:
             payload["reasoning"] = reasoning
 
         text = None
-        if self._config.verbosity is not None:
-            text = {"verbosity": self._config.verbosity}
+        verbosity = self._config.effective_verbosity()
+        if verbosity is not None:
+            text = {"verbosity": verbosity}
         if text is not None:
             payload["text"] = text
 
+        service_tier = self._config.effective_service_tier()
+        if service_tier is not None:
+            payload["service_tier"] = service_tier
+
         return payload
 
     def _list_models_sync(self) -> 'typing.List[str]':
@@ -483,6 +623,8 @@ class ResponsesModelClient:
             headers["authorization"] = f"Bearer {api_key}"
         if self._config.beta_features_header is not None:
             headers["x-codex-beta-features"] = self._config.beta_features_header
+        if self._config.use_responses_lite():
+            headers[RESPONSES_LITE_HEADER] = "true"
         if self._openai_subagent is not None:
             headers["x-openai-subagent"] = self._openai_subagent
         if prompt.turn_metadata is not None:

pycodex/model_metadata.py

@@ -0,0 +1,31 @@
+"""Shared loader for vendored Codex model metadata."""
+
+from functools import lru_cache
+import json
+from pathlib import Path
+import typing
+
+from .protocol import JSONDict
+
+
+DEFAULT_MODELS_PATH = Path(__file__).resolve().parent / "prompts" / "models.json"
+
+
+@lru_cache(maxsize=1)
+def load_models_by_slug() -> 'typing.Dict[str, JSONDict]':
+    payload = json.loads(DEFAULT_MODELS_PATH.read_text(encoding="utf-8"))
+    models = payload.get("models", [])
+    by_slug: 'typing.Dict[str, JSONDict]' = {}
+    for model in models:
+        if not isinstance(model, dict):
+            continue
+        slug = model.get("slug")
+        if isinstance(slug, str):
+            by_slug[slug] = model
+    return by_slug
+
+
+def model_metadata(slug: 'typing.Union[str, None]') -> 'typing.Union[JSONDict, None]':
+    if slug is None:
+        return None
+    return load_models_by_slug().get(slug)