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

pycodex/utils/compactor.py

@@ -1,19 +1,21 @@
+import typing
 from dataclasses import dataclass
 
 from ..protocol import (
     AssistantMessage,
+    ContextMessage,
     ConversationItem,
     ModelResponse,
-    ModelStreamEvent,
     ToolCall,
     ToolResult,
     UserMessage,
 )
 from .random_ids import uuid7_string
-import typing
 
 if typing.TYPE_CHECKING:
-    from ..agent import Agent
+    from ..context import ContextManager
+    from ..events import ModelEvent
+    from ..model import ModelClient
 
 DEFAULT_COMPACT_PROMPT = """You are performing a CONTEXT CHECKPOINT COMPACTION. Create a handoff summary for another LLM that will resume the task.
 
@@ -36,33 +38,22 @@ SUMMARY_PREFIX = (
     "not merely repeat or acknowledge the handoff:"
 )
 
+
 @dataclass(frozen=True)
 class CompactResult:
-    history: 'typing.Tuple[ConversationItem, ...]'
-    original_item_count: 'int'
-    pruned_tool_results: 'int' = 0
+    history: "typing.Tuple[ConversationItem, ...]"
+    original_item_count: "int"
+    pruned_tool_results: "int" = 0
 
     @property
-    def retained_item_count(self) -> 'int':
+    def retained_item_count(self) -> "int":
         return max(len(self.history) - 1, 0)
 
-    def display_text(self) -> 'str':
-        retained_label = _pluralize("item", self.retained_item_count)
-        original_label = _pluralize("item", self.original_item_count)
-        text = (
-            f"compact({self.original_item_count} {original_label}) -> "
-            f"{self.retained_item_count} {retained_label} + [summary]"
-        )
-        if self.pruned_tool_results:
-            tool_label = _pluralize("tool response", self.pruned_tool_results)
-            text += f" (dropped {self.pruned_tool_results} old {tool_label})"
-        return text
-
 
 def compact(
-    history: 'typing.Sequence[ConversationItem]',
-    session_file: 'typing.Union[str, None]' = None,
-) -> 'typing.Tuple[ConversationItem, ...]':
+    history: "typing.Sequence[ConversationItem]",
+    session_file: "typing.Union[str, None]" = None,
+) -> "typing.Tuple[ConversationItem, ...]":
     summary_text = _build_summary_message(_last_assistant_message(history))
     if session_file:
         summary_text += (
@@ -75,30 +66,34 @@ def compact(
     return build_compacted_history(summary_text)
 
 
-async def compact_agent(
-    agent: 'Agent',
-    stream_event_handler: 'typing.Union[typing.Callable[[ModelStreamEvent], None], None]' = None,
-    prune_tool_results_on_context_error: 'bool' = False,
-) -> 'typing.Union[CompactResult, None]':
-    from ..model import ResponsesIncompleteError
+async def compact_history(
+    history: "typing.Sequence[ConversationItem]",
+    model_client: "ModelClient",
+    context_manager: "ContextManager",
+    stream_event_handler: "typing.Union[typing.Callable[[ModelEvent], None], None]" = None,
+    prune_tool_results_on_context_error: "bool" = False,
+    session_file: "typing.Union[str, None]" = None,
+    turn_id: "typing.Union[str, None]" = None,
+) -> "typing.Union[CompactResult, None]":
+    from ..model import ContextLengthExceeded, ResponsesIncompleteError
 
-    history = agent.history
     if not history:
         return None
     original_item_count = len(history)
     pruned_tool_results = 0
+    turn_id = turn_id or uuid7_string()
 
     noop_stream_event_handler = lambda _event: None
     while True:
         compact_prompt = UserMessage(text=DEFAULT_COMPACT_PROMPT)
-        prompt = agent._context_manager.build_prompt(
+        prompt = context_manager.build_prompt(
             list(history) + [compact_prompt],
             [],
             False,
-            turn_id=uuid7_string(),
+            turn_id=turn_id,
         )
         try:
-            response = await agent._model_client.complete(
+            response = await model_client.complete(
                 prompt,
                 stream_event_handler or noop_stream_event_handler,
             )
@@ -111,32 +106,22 @@ async def compact_agent(
                 raise
             response = ModelResponse(items=list(exc.partial_items))
             break
-        except Exception as exc:
-            if (
-                not prune_tool_results_on_context_error
-                or not _is_context_length_error(str(exc))
-            ):
+        except ContextLengthExceeded:
+            if not prune_tool_results_on_context_error:
                 raise
             pruned_history = prune_oldest_tool_response(history)
             if pruned_history is None:
                 raise
             history = pruned_history
             pruned_tool_results += 1
-            agent.replace_history(history)
 
-    rollout_recorder = agent._rollout_recorder
-    session_file = (
-        str(rollout_recorder.rollout_path)
-        if rollout_recorder is not None
-        else None
-    )
+    summary = _last_assistant_message(response.items)
+    if summary is None or not summary.strip():
+        raise ValueError("compact response contains no assistant summary")
     compacted_history = compact(
-        list(history) + [compact_prompt] + list(response.items),
+        response.items,
         session_file,
     )
-    agent.replace_history(compacted_history)
-    if rollout_recorder is not None:
-        rollout_recorder.append_compacted_history(compacted_history)
     return CompactResult(
         history=compacted_history,
         original_item_count=original_item_count,
@@ -145,8 +130,8 @@ async def compact_agent(
 
 
 def prune_oldest_tool_response(
-    history: 'typing.Sequence[ConversationItem]',
-) -> 'typing.Union[typing.Tuple[ConversationItem, ...], None]':
+    history: "typing.Sequence[ConversationItem]",
+) -> "typing.Union[typing.Tuple[ConversationItem, ...], None]":
     items = list(history)
     tool_result_index = None
     call_id = None
@@ -170,36 +155,20 @@ def prune_oldest_tool_response(
 
 
 def build_compacted_history(
-    summary_text: 'str',
-) -> 'typing.Tuple[ConversationItem, ...]':
-    return (UserMessage(text=summary_text or _build_summary_message(None)),)
+    summary_text: "str",
+) -> "typing.Tuple[ConversationItem, ...]":
+    return (ContextMessage(text=summary_text or _build_summary_message(None)),)
 
 
 def _last_assistant_message(
-    history: 'typing.Sequence[ConversationItem]',
-) -> 'typing.Union[str, None]':
+    history: "typing.Sequence[ConversationItem]",
+) -> "typing.Union[str, None]":
     for item in reversed(tuple(history)):
         if isinstance(item, AssistantMessage):
             return item.text
     return None
 
 
-def _build_summary_message(summary_text: 'typing.Union[str, None]') -> 'str':
+def _build_summary_message(summary_text: "typing.Union[str, None]") -> "str":
     normalized = (summary_text or "").strip() or "(no summary available)"
     return f"{SUMMARY_PREFIX}\n{normalized}"
-
-
-def _pluralize(noun: 'str', count: 'int') -> 'str':
-    if count == 1:
-        return noun
-    return f"{noun}s"
-
-
-def _is_context_length_error(message: 'str') -> 'bool':
-    lower = message.lower()
-    return (
-        "context_length_exceeded" in lower
-        or "maximum context length" in lower
-        or "exceeds the context window" in lower
-        or "exceeded the context window" in lower
-    )

pycodex/utils/debug.py

@@ -1,9 +1,9 @@
 import os
-from pathlib import Path
 import typing
+from pathlib import Path
 
 
-def get_debug_dir() -> 'typing.Union[Path, None]':
+def get_debug_dir() -> "typing.Union[Path, None]":
     value = os.environ.get("PYCODEX_DEBUG_LOG", "").strip()
     if not value:
         return None

pycodex/utils/dotenv.py

@@ -1,14 +1,13 @@
-
 import os
-from pathlib import Path
 import typing
+from pathlib import Path
 
 ILLEGAL_ENV_VAR_PREFIX = "CODEX_"
 DOTENV_FILENAME = ".env"
-_LOADED_CODEX_DOTENV_HOMES: 'typing.Set[str]' = set()
+_LOADED_CODEX_DOTENV_HOMES: "typing.Set[str]" = set()
 
 
-def load_codex_dotenv(config_path: 'typing.Union[str, Path]') -> 'None':
+def load_codex_dotenv(config_path: "typing.Union[str, Path]") -> "None":
     codex_home = str(Path(config_path).resolve().parent)
     if codex_home in _LOADED_CODEX_DOTENV_HOMES:
         return
@@ -28,8 +27,8 @@ def load_codex_dotenv(config_path: 'typing.Union[str, Path]') -> 'None':
     _LOADED_CODEX_DOTENV_HOMES.add(codex_home)
 
 
-def parse_dotenv(text: 'str') -> 'typing.Dict[str, str]':
-    values: 'typing.Dict[str, str]' = {}
+def parse_dotenv(text: "str") -> "typing.Dict[str, str]":
+    values: "typing.Dict[str, str]" = {}
     for raw_line in text.splitlines():
         line = raw_line.strip()
         if not line or line.startswith("#"):
@@ -47,7 +46,7 @@ def parse_dotenv(text: 'str') -> 'typing.Dict[str, str]':
     return values
 
 
-def parse_dotenv_value(raw_value: 'str') -> 'str':
+def parse_dotenv_value(raw_value: "str") -> "str":
     if not raw_value:
         return ""
 

pycodex/utils/event_helpers.py

@@ -0,0 +1,190 @@
+"""Stateless presentation helpers; no event or frontend dependencies."""
+
+import json
+import typing
+from dataclasses import asdict
+
+PROMPT_CONTEXT_BASELINE_TOKENS = 12_000
+
+
+def render_result(kind, result, json_mode, log):
+    if kind == "turn":
+        text = (
+            json.dumps(asdict(result), ensure_ascii=False, indent=2)
+            if json_mode
+            else (result.output_text or "")
+        )
+        log(text)
+    elif kind == "command":
+        for line in format_command_result(result).splitlines():
+            log(line)
+
+
+def format_command_result(result: "typing.Dict[str, object]") -> "str":
+    kind = result["kind"]
+    if kind == "help":
+        return "Extra commands: " + ", ".join("/" + name for name in result["commands"])
+    if kind in {"title", "title_changed"}:
+        return "Session: " + (result["title"] or "untitled")
+    if kind == "models":
+        return (
+            "Current model: "
+            + result["model"]
+            + "\nAvailable models: "
+            + ", ".join(result["models"])
+        )
+    if kind == "model_changed":
+        return "Switched model to {0}.".format(result["model"])
+    if kind == "sessions":
+        if not result["sessions"]:
+            return "No resumable sessions found."
+        return "\n".join(
+            ["Available sessions:"]
+            + [
+                "[{0}] {1}".format(index, session["preview"])
+                for index, session in enumerate(result["sessions"], 1)
+            ]
+        )
+    if kind in {"history", "resumed"}:
+        state = result["state"]
+        lines = ["Resumed session: " + state["title"]] if kind == "resumed" else []
+        if not state["history"]:
+            return "\n".join(lines + ["No history yet."])
+        lines.append("Session: " + (state["title"] or "untitled"))
+        for index, (prompt, response) in enumerate(state["history"], 1):
+            if prompt:
+                lines.append("[{0}]U> {1}".format(index, prompt))
+            if response:
+                lines.append("[{0}]A> {1}".format(index, response))
+        return "\n".join(lines)
+    if kind == "compact_empty":
+        return "Nothing to compact."
+    if kind == "compacted":
+        return compact_summary(
+            result["original_item_count"],
+            result["retained_item_count"],
+            result["pruned_tool_results"],
+        )
+    if kind == "forked":
+        return "Forked session: " + result["session_id"]
+    if kind == "closed":
+        return ""
+    return "\n".join(result["lines"])
+
+
+def format_error(text, indent=True):
+    if not indent:
+        return "Error: " + str(text)
+    lines = str(text).splitlines() or [""]
+    return "\n".join(
+        ["Error: " + lines[0]] + ["  " + line if line else "" for line in lines[1:]]
+    )
+
+
+def shorten_title(text: "str", limit: "int" = 48) -> "str":
+    return truncate_text(text, limit)
+
+
+def percent_of_context_window_remaining(total_tokens, context_window_tokens):
+    if context_window_tokens <= PROMPT_CONTEXT_BASELINE_TOKENS:
+        return 0
+    effective_window = context_window_tokens - PROMPT_CONTEXT_BASELINE_TOKENS
+    used = max(total_tokens - PROMPT_CONTEXT_BASELINE_TOKENS, 0)
+    remaining = max(effective_window - used, 0)
+    return int(round(max(0.0, min(100.0, (remaining / effective_window) * 100.0))))
+
+
+def completed_history(state):
+    active = state["active_turn"]
+    if active is not None:
+        return active["completed_history"]
+    return state["history"]
+
+
+def colorize_cli_message(text: "str", kind: "str", enabled: "bool") -> "str":
+    if not enabled:
+        return text
+    if kind == "assistant":
+        color = "\x1b[32m"
+    elif kind == "status":
+        color = "\x1b[36m"
+    elif kind == "error":
+        color = "\x1b[31m"
+    else:
+        return text
+    return "\x1b[1m" + color + text + "\x1b[0m"
+
+
+def colorize_tool_message(
+    message: "str", enabled: "bool", tool_name: "str" = None
+) -> "str":
+    if not enabled:
+        return message
+    if message.startswith("[error]"):
+        return colorize_cli_message(message, "error", enabled)
+    if message.startswith("[") and message.find("]") > 1:
+        tool_name = message[1 : message.find("]")]
+    if message.startswith(("  [x]", "  [>]", "  [ ]")) or tool_name == "update_plan":
+        color = "\x1b[36m"
+    elif tool_name == "exec_command" and "session_id=" in message:
+        color = "\x1b[2m"
+    elif tool_name == "exec_command" and not message.startswith("["):
+        color = ""
+    elif tool_name in {"exec_command", "shell", "shell_command", "exec"}:
+        color = "\x1b[33m"
+    elif tool_name in {"write_stdin", "wait", "web_search"}:
+        color = "\x1b[35m"
+    elif tool_name in {
+        "spawn_agent",
+        "send_input",
+        "wait_agent",
+        "resume_agent",
+        "close_agent",
+    }:
+        color = "\x1b[34m"
+    else:
+        color = "\x1b[2m"
+    return "\x1b[1m" + color + message + "\x1b[0m"
+
+
+def compact_summary(original: "int", retained: "int", pruned: "int") -> "str":
+    text = "compact({0} {1}) -> {2} {3} + [summary]".format(
+        original,
+        "item" if original == 1 else "items",
+        retained,
+        "item" if retained == 1 else "items",
+    )
+    if pruned:
+        text += " (dropped {0} old {1})".format(
+            pruned,
+            "tool response" if pruned == 1 else "tool responses",
+        )
+    return text
+
+
+def agent_status_summary(status: "object") -> "str":
+    if isinstance(status, str):
+        return status
+    if isinstance(status, dict):
+        if "completed" in status:
+            completed = status.get("completed")
+            if completed is None:
+                return "completed"
+            return f"completed: {truncate_text(str(completed), 48)}"
+        if "errored" in status:
+            return f"errored: {truncate_text(str(status.get('errored', '')), 48)}"
+    return truncate_text(json.dumps(status, ensure_ascii=False, separators=(",", ":")))
+
+
+def short_id(value: "str", limit: "int" = 8) -> "str":
+    compact = value.strip()
+    if len(compact) <= limit + 4:
+        return compact
+    return f"{compact[:limit]}...{compact[-4:]}"
+
+
+def truncate_text(text: "str", limit: "int" = 96) -> "str":
+    compact = " ".join(text.split())
+    if len(compact) <= limit:
+        return compact
+    return compact[: limit - 3].rstrip() + "..."

pycodex/utils/get_env.py

@@ -1,22 +1,19 @@
 import os
 import platform
-import re
-from datetime import datetime
-from pathlib import Path
 import subprocess
 import typing
-
-from ..compat import importlib_metadata
+from datetime import datetime
+from pathlib import Path
 
 
-def get_shell_name() -> 'str':
+def get_shell_name() -> "str":
     shell_path = os.environ.get("SHELL")
     if shell_path:
         return Path(shell_path).name or shell_path
     return "bash"
 
 
-def get_timezone_name() -> 'str':
+def get_timezone_name() -> "str":
     timezone_env = os.environ.get("TZ")
     if timezone_env:
         return timezone_env
@@ -33,7 +30,9 @@ def get_timezone_name() -> 'str':
         return "Etc/UTC"
     name = str(timezone)
     return name or "Etc/UTC"
-def get_sandbox_tag(sandbox_mode: 'typing.Union[str, None]') -> 'str':
+
+
+def get_sandbox_tag(sandbox_mode: "typing.Union[str, None]") -> "str":
     if sandbox_mode == "danger-full-access":
         return "none"
     if sandbox_mode == "read-only":
@@ -43,7 +42,9 @@ def get_sandbox_tag(sandbox_mode: 'typing.Union[str, None]') -> 'str':
     return "none"
 
 
-def get_workspace_turn_metadata(cwd: 'typing.Union[str, Path]') -> 'typing.Union[typing.Dict[str, object], None]':
+def get_workspace_turn_metadata(
+    cwd: "typing.Union[str, Path]",
+) -> "typing.Union[typing.Dict[str, object], None]":
     resolved_cwd = Path(cwd).resolve()
     repo_root = _git_output(
         resolved_cwd,
@@ -52,7 +53,7 @@ def get_workspace_turn_metadata(cwd: 'typing.Union[str, Path]') -> 'typing.Union
     if repo_root is None:
         return None
 
-    workspace: 'typing.Dict[str, object]' = {}
+    workspace: "typing.Dict[str, object]" = {}
     head = _git_output(resolved_cwd, ["rev-parse", "HEAD"])
     if head is not None:
         workspace["latest_git_commit_hash"] = head
@@ -70,7 +71,7 @@ def get_workspace_turn_metadata(cwd: 'typing.Union[str, Path]') -> 'typing.Union
     return {"workspaces": {repo_root: workspace}}
 
 
-def build_user_agent(originator: 'str') -> 'str':
+def build_user_agent(originator: "str") -> "str":
     version = get_package_version()
     terminal = get_terminal_user_agent_token()
     os_name, os_version = get_os_info()
@@ -79,25 +80,15 @@ def build_user_agent(originator: 'str') -> 'str':
     return f"{originator}/{version} ({os_name} {os_version}; {arch}) {terminal}{suffix}"
 
 
-def get_package_version() -> 'str':
-    detected = _detect_upstream_codex_version()
-    if detected is not None:
-        return detected
-    for distribution_name in ("python-codex", "pycodex"):
-        try:
-            return importlib_metadata.version(distribution_name)
-        except importlib_metadata.PackageNotFoundError:
-            continue
-    local_version = _read_local_package_version()
-    if local_version is not None:
-        return local_version
-    return "0.1.0"
+def get_package_version() -> "str":
+    """Return the upstream alignment version recorded in docs/ALIGNMENT.md."""
+    return "0.153.4"
 
 
-def get_os_info() -> 'typing.Tuple[str, str]':
+def get_os_info() -> "typing.Tuple[str, str]":
     os_release = Path("/etc/os-release")
     if os_release.is_file():
-        values: 'typing.Dict[str, str]' = {}
+        values: "typing.Dict[str, str]" = {}
         os_release_text = os_release.read_text(
             encoding="utf-8",
             errors="replace",
@@ -114,7 +105,7 @@ def get_os_info() -> 'typing.Tuple[str, str]':
     return platform.system(), platform.release()
 
 
-def get_terminal_user_agent_token() -> 'str':
+def get_terminal_user_agent_token() -> "str":
     term_program = os.environ.get("TERM_PROGRAM", "")
     if term_program.lower() == "tmux":
         client_termname = _tmux_display_message("#{client_termname}")
@@ -127,7 +118,7 @@ def get_terminal_user_agent_token() -> 'str':
     return "unknown"
 
 
-def _git_output(cwd: 'Path', args: 'typing.List[str]') -> 'typing.Union[str, None]':
+def _git_output(cwd: "Path", args: "typing.List[str]") -> "typing.Union[str, None]":
     try:
         completed = subprocess.run(
             ["git", *args],
@@ -143,11 +134,11 @@ def _git_output(cwd: 'Path', args: 'typing.List[str]') -> 'typing.Union[str, Non
     return value or None
 
 
-def _git_remote_urls(cwd: 'Path') -> 'typing.Dict[str, str]':
+def _git_remote_urls(cwd: "Path") -> "typing.Dict[str, str]":
     remote_names = _git_output(cwd, ["remote"])
     if remote_names is None:
         return {}
-    remotes: 'typing.Dict[str, str]' = {}
+    remotes: "typing.Dict[str, str]" = {}
     for name in remote_names.splitlines():
         remote_name = name.strip()
         if not remote_name:
@@ -158,7 +149,7 @@ def _git_remote_urls(cwd: 'Path') -> 'typing.Dict[str, str]':
     return remotes
 
 
-def _git_has_changes(cwd: 'Path') -> 'typing.Union[bool, None]':
+def _git_has_changes(cwd: "Path") -> "typing.Union[bool, None]":
     try:
         completed = subprocess.run(
             ["git", "status", "--porcelain"],
@@ -173,7 +164,7 @@ def _git_has_changes(cwd: 'Path') -> 'typing.Union[bool, None]':
     return bool(completed.stdout.strip())
 
 
-def _user_agent_suffix(originator: 'str', version: 'str') -> 'str':
+def _user_agent_suffix(originator: "str", version: "str") -> "str":
     if originator == "codex_exec":
         return f" (codex-exec; {version})"
     if originator == "codex-tui":
@@ -181,7 +172,7 @@ def _user_agent_suffix(originator: 'str', version: 'str') -> 'str':
     return ""
 
 
-def _normalize_os_version(version: 'str') -> 'str':
+def _normalize_os_version(version: "str") -> "str":
     parts = version.split(".")
     if len(parts) == 2 and all(part.isdigit() for part in parts):
         major, minor = parts
@@ -189,21 +180,7 @@ def _normalize_os_version(version: 'str') -> 'str':
     return version
 
 
-def _read_local_package_version() -> 'typing.Union[str, None]':
-    pyproject_path = Path(__file__).resolve().parents[2] / "pyproject.toml"
-    if not pyproject_path.is_file():
-        return None
-    match = re.search(
-        r'^\s*version\s*=\s*"([^"]+)"\s*$',
-        pyproject_path.read_text(encoding="utf-8"),
-        flags=re.MULTILINE,
-    )
-    if match is None:
-        return None
-    return match.group(1).strip() or None
-
-
-def _tmux_display_message(fmt: 'str') -> 'typing.Union[str, None]':
+def _tmux_display_message(fmt: "str") -> "typing.Union[str, None]":
     try:
         output = subprocess.run(
             ["tmux", "display-message", "-p", fmt],
@@ -218,28 +195,8 @@ def _tmux_display_message(fmt: 'str') -> 'typing.Union[str, None]':
     return value or None
 
 
-def _sanitize_header_token(value: 'str') -> 'str':
+def _sanitize_header_token(value: "str") -> "str":
     return "".join(
-        character
-        if (character.isalnum() or character in {"-", "_", ".", "/"})
-        else "_"
+        character if (character.isalnum() or character in {"-", "_", ".", "/"}) else "_"
         for character in value
     )
-
-
-def _detect_upstream_codex_version() -> 'typing.Union[str, None]':
-    try:
-        output = subprocess.run(
-            ["codex", "--version"],
-            check=True,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            universal_newlines=True,
-        )
-    except (OSError, subprocess.CalledProcessError):
-        return None
-
-    match = re.search(r"\b(\d+\.\d+\.\d+)\b", output.stdout)
-    if match is None:
-        return None
-    return match.group(1)