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

pycodex/__init__.py

@@ -39,6 +39,8 @@ from .runtime_services import (
 from .tools import (
     ApplyPatchTool,
     BaseTool,
+    ClockManager,
+    ClockTool,
     CloseAgentTool,
     CodeModeManager,
     ExecTool,
@@ -96,6 +98,8 @@ __all__ = [
     "ApplyPatchTool",
     "AssistantMessage",
     "BaseTool",
+    "ClockManager",
+    "ClockTool",
     "CloseAgentTool",
     "create_agent_runtime_environment",
     "CodeModeManager",

pycodex/agent.py

@@ -17,7 +17,14 @@ from .protocol import (
     TurnResult,
     UserMessage,
 )
-from .tools import ExecCommandTool, ToolContext, ToolRegistry, UnifiedExecManager
+from .tools import (
+    ClockManager,
+    ClockTool,
+    ExecCommandTool,
+    ToolContext,
+    ToolRegistry,
+    UnifiedExecManager,
+)
 from .utils.truncation import truncate_tool_results_for_history
 from .utils import uuid7_string
 import typing
@@ -96,6 +103,14 @@ class Agent:
         )
         if self._exec_manager is not None:
             self._exec_manager.set_notify_hook(self.maybe_invoke)
+        clock_tool = self._tool_registry.get_tool("clock")
+        self._clock_manager: 'typing.Union[ClockManager, None]' = (
+            clock_tool._manager
+            if isinstance(clock_tool, ClockTool)
+            else None
+        )
+        if self._clock_manager is not None:
+            self._clock_manager.set_notify_hook(self.maybe_invoke)
 
     @property
     def history(self) -> 'typing.Tuple[ConversationItem, ...]':
@@ -141,6 +156,8 @@ class Agent:
         self, texts: 'typing.List[str]', turn_id: 'typing.Union[str, None]' = None
     ) -> 'TurnResult':
         self._turn_running = True
+        if self._clock_manager is not None:
+            self._clock_manager.turn_started()
         turn_id = turn_id or uuid7_string()
         self.interrupt_asap = False
         new_user_messages = [UserMessage(text=text) for text in texts]
@@ -198,6 +215,8 @@ class Agent:
                         output_text=last_assistant_message,
                     )
                     self._turn_running = False
+                    if self._clock_manager is not None:
+                        self._clock_manager.arm_after_reply()
                     return TurnResult(
                         turn_id=turn_id,
                         output_text=last_assistant_message,
@@ -240,17 +259,28 @@ class Agent:
             raise
 
     async def maybe_invoke(self, event: 'typing.Dict[str, object]') -> 'bool':
-        if self._turn_running or event.get("type") != "exec_command_completed":
+        if self._turn_running:
+            return False
+        event_type = event.get("type")
+        if event_type == "exec_command_completed":
+            payload = {
+                "session_id": event.get("session_id"),
+                "exit_code": event.get("exit_code"),
+                "command": event.get("command"),
+            }
+            tag = "exec_command_completed"
+        elif event_type == "clock_tick":
+            payload = {
+                "period_m": event.get("period_m"),
+                "current_time": event.get("current_time"),
+            }
+            tag = "clock_tick"
+        else:
             return False
-        payload = {
-            "session_id": event.get("session_id"),
-            "exit_code": event.get("exit_code"),
-            "command": event.get("command"),
-        }
         text = (
-            "<exec_command_completed>\n"
+            f"<{tag}>\n"
             f"{json.dumps(payload, ensure_ascii=False, separators=(',', ':'))}\n"
-            "</exec_command_completed>"
+            f"</{tag}>"
         )
         self._turn_running = True
         task = asyncio.create_task(self.run_turn([text]))
@@ -259,6 +289,10 @@ class Agent:
         )
         return True
 
+    def shutdown(self) -> 'None':
+        if self._clock_manager is not None:
+            self._clock_manager.cancel()
+
     async def _execute_tool_batch(
         self,
         turn_id: 'str',
@@ -328,16 +362,22 @@ class Agent:
 
     def _emit(self, kind: 'str', turn_id: 'str', **payload: 'object') -> 'None':
         if kind in TERMINAL_TURN_EVENTS:
-            payload["background_exec_count"] = self._background_exec_count()
+            payload["background_work_count"] = self._background_work_count(kind)
         self._event_handler(
             AgentEvent(kind=kind, turn_id=turn_id, payload=dict(payload))
         )
 
-    def _background_exec_count(self) -> 'int':
+    def _background_work_count(self, terminal_event: 'str') -> 'int':
         manager: 'typing.Union[UnifiedExecManager, None]' = self._exec_manager
-        if manager is None:
-            return 0
-        return manager.running_session_count()
+        count = 0 if manager is None else manager.running_session_count()
+        clock_manager = self._clock_manager
+        if (
+            terminal_event == "turn_completed"
+            and clock_manager is not None
+            and clock_manager.enabled
+        ):
+            count += 1
+        return count
 
     def _persist_history_items(
         self,

pycodex/cli.py

@@ -46,6 +46,36 @@ def launch_chat_completion_compat_server(*args, **kwargs):
     return launch_compat_server(*args, **kwargs)
 
 
+def _resolve_vllm_model(
+    endpoint: 'str',
+    provider_config: 'ResponsesProviderConfig',
+    timeout_seconds: 'float',
+) -> 'str':
+    from responses_server import CompatServerConfig
+
+    normalized = CompatServerConfig.from_base_url(endpoint)
+    probe_config = replace(
+        provider_config,
+        provider_name="vllm",
+        base_url=normalized.outcomming_base_url,
+        api_key_env=None,
+        query_params={},
+        responses_lite_override=False,
+    )
+    probe_client = ResponsesModelClient(
+        probe_config,
+        timeout_seconds,
+        originator=CLI_ORIGINATOR,
+    )
+    models = probe_client.list_models_sync()
+    if not models:
+        raise RuntimeError(
+            "vLLM endpoint returned no models from "
+            f"{normalized.outcomming_models_url()}"
+        )
+    return models[-1]
+
+
 def configure_loguru() -> 'None':
     try:
         from loguru import logger
@@ -166,9 +196,12 @@ def get_tools(
     runtime_environment: 'typing.Union[AgentRuntimeEnvironment, None]' = None,
     exec_mode: 'bool' = False,
     cwd: 'typing.Union[str, Path, None]' = None,
+    toolset: 'typing.Union[typing.Iterable[str], None]' = None,
 ):
     from .tools import (
         ApplyPatchTool,
+        ClockManager,
+        ClockTool,
         CloseAgentTool,
         CodeModeManager,
         ExecTool,
@@ -197,6 +230,7 @@ def get_tools(
     registry = Registry()
     code_mode_manager = CodeModeManager(registry, cwd=cwd)
     unified_exec_manager = UnifiedExecManager(cwd=cwd)
+    clock_manager = ClockManager()
     exec_tool = ExecTool(code_mode_manager)
     wait_tool = WaitTool(code_mode_manager)
     web_search_tool = WebSearchTool()
@@ -217,45 +251,61 @@ def get_tools(
     shell_command_tool = ShellCommandTool(cwd=cwd)
     exec_command_tool = ExecCommandTool(unified_exec_manager)
     write_stdin_tool = WriteStdinTool(unified_exec_manager)
+    clock_tool = ClockTool(clock_manager)
     grep_files_tool = GrepFilesTool(cwd=cwd)
     read_file_tool = ReadFileTool()
     list_dir_tool = ListDirTool()
     view_image_tool = ViewImageTool(cwd=cwd)
-    if exec_mode:
-        registry.register(exec_command_tool)
-        registry.register(write_stdin_tool)
-        registry.register(update_plan_tool)
-        registry.register(request_user_input_tool)
-        registry.register(apply_patch_tool)
-        registry.register(web_search_tool)
-        registry.register(view_image_tool)
-        registry.register(spawn_agent_tool)
-        registry.register(send_input_tool)
-        registry.register(resume_agent_tool)
-        registry.register(wait_agent_tool)
-        registry.register(close_agent_tool)
-        return registry
-
-    registry.register(shell_tool)
-    registry.register(shell_command_tool)
-    registry.register(exec_command_tool)
-    registry.register(write_stdin_tool)
-    registry.register(exec_tool)
-    registry.register(wait_tool)
-    registry.register(web_search_tool)
-    registry.register(update_plan_tool)
-    registry.register(request_user_input_tool)
-    registry.register(request_permissions_tool)
-    registry.register(spawn_agent_tool)
-    registry.register(send_input_tool)
-    registry.register(resume_agent_tool)
-    registry.register(wait_agent_tool)
-    registry.register(close_agent_tool)
-    registry.register(apply_patch_tool)
-    registry.register(grep_files_tool)
-    registry.register(read_file_tool)
-    registry.register(list_dir_tool)
-    registry.register(view_image_tool)
+    tools = (
+        shell_tool,
+        shell_command_tool,
+        exec_command_tool,
+        write_stdin_tool,
+        clock_tool,
+        exec_tool,
+        wait_tool,
+        web_search_tool,
+        update_plan_tool,
+        request_user_input_tool,
+        request_permissions_tool,
+        spawn_agent_tool,
+        send_input_tool,
+        resume_agent_tool,
+        wait_agent_tool,
+        close_agent_tool,
+        apply_patch_tool,
+        grep_files_tool,
+        read_file_tool,
+        list_dir_tool,
+        view_image_tool,
+    )
+    if toolset is not None:
+        available_tools = {tool.name: tool for tool in tools}
+        toolset = tuple(toolset)
+        unknown_tools = set(toolset) - set(available_tools)
+        if unknown_tools:
+            raise ValueError(
+                "unknown toolset entries: {0}".format(", ".join(sorted(unknown_tools)))
+            )
+        tools = tuple(available_tools[name] for name in toolset)
+    elif exec_mode:
+        tools = (
+            exec_command_tool,
+            write_stdin_tool,
+            clock_tool,
+            update_plan_tool,
+            request_user_input_tool,
+            apply_patch_tool,
+            web_search_tool,
+            view_image_tool,
+            spawn_agent_tool,
+            send_input_tool,
+            resume_agent_tool,
+            wait_agent_tool,
+            close_agent_tool,
+        )
+    for tool in tools:
+        registry.register(tool)
     return registry
 
 
@@ -295,6 +345,7 @@ def build_agent(
     collaboration_mode: 'CollaborationMode' = DEFAULT_COLLABORATION_MODE,
     extra_contextual_user_messages: 'typing.Iterable[str]' = (),
     cwd: 'typing.Union[str, Path, None]' = None,
+    toolset: 'typing.Union[typing.Iterable[str], None]' = None,
 ) -> 'Agent':
     config_path = str(config_path)
     resolved_cwd = Path(cwd or Path.cwd()).resolve()
@@ -365,7 +416,12 @@ def build_agent(
     )
     return Agent(
         client,
-        get_tools(runtime_environment, exec_mode=True, cwd=resolved_cwd),
+        get_tools(
+            runtime_environment,
+            exec_mode=True,
+            cwd=resolved_cwd,
+            toolset=toolset,
+        ),
         context_manager,
         rollout_recorder=rollout_recorder,
         runtime_environment=runtime_environment,
@@ -392,6 +448,21 @@ def build_model(
         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")
+    uses_local_responses_compat = (
+        managed_responses_base_url is not None
+        or vllm_endpoint is not None
+        or bool(use_chat_completion)
+        or use_messages
+    )
+    if vllm_endpoint is not None:
+        provider_config = replace(
+            provider_config,
+            model=_resolve_vllm_model(
+                vllm_endpoint,
+                provider_config,
+                timeout_seconds,
+            ),
+        )
     url, key_env = provider_config.base_url, provider_config.api_key_env
     if managed_responses_base_url is not None:
         url, key_env = (
@@ -425,6 +496,9 @@ def build_model(
         provider_config,
         base_url=url,
         api_key_env=key_env,
+        responses_lite_override=(
+            False if uses_local_responses_compat else provider_config.responses_lite_override
+        ),
     )
     return ResponsesModelClient(
         provider_config,

pycodex/image_utils.py

@@ -0,0 +1,79 @@
+"""Image preparation helpers for the Python Codex prototype.
+
+Original Codex mapping:
+- Corresponds to `codex-rs/utils/image/src/lib.rs`.
+
+Expected behavior:
+- Resize images down to `MAX_DIMENSION` on the longest side before they are
+  attached to a model request, matching upstream `PromptImageMode::ResizeToFit`.
+- Keep the original bytes when the caller asks for `original` detail or the
+  image already fits.
+"""
+
+import base64
+import io
+import mimetypes
+from pathlib import Path
+
+from PIL import Image
+
+import typing
+
+MAX_DIMENSION = 2048
+
+_PRESERVABLE_MIME_TYPES = ("image/png", "image/jpeg", "image/webp")
+
+
+class ImageProcessingError(RuntimeError):
+    pass
+
+
+def load_image_data_url(
+    path: 'Path',
+    resize_to_fit: 'bool' = True,
+) -> 'str':
+    mime_type, _ = mimetypes.guess_type(path.name)
+    if not mime_type or not mime_type.startswith("image/"):
+        raise ImageProcessingError(
+            "`{0}` does not look like an image file".format(path)
+        )
+
+    image_bytes = path.read_bytes()
+    if resize_to_fit:
+        mime_type, image_bytes = _resize_to_fit(mime_type, image_bytes)
+    encoded = base64.b64encode(image_bytes).decode("ascii")
+    return "data:{0};base64,{1}".format(mime_type, encoded)
+
+
+def _resize_to_fit(
+    mime_type: 'str',
+    image_bytes: 'bytes',
+) -> 'typing.Tuple[str, bytes]':
+    with Image.open(io.BytesIO(image_bytes)) as image:
+        width, height = image.size
+        if width <= MAX_DIMENSION and height <= MAX_DIMENSION:
+            return mime_type, image_bytes
+
+        scale = float(MAX_DIMENSION) / float(max(width, height))
+        target_size = (
+            max(1, int(width * scale)),
+            max(1, int(height * scale)),
+        )
+        resized = image.resize(target_size, Image.BILINEAR)
+        target_mime = (
+            mime_type if mime_type in _PRESERVABLE_MIME_TYPES else "image/png"
+        )
+        if target_mime == "image/jpeg":
+            resized = resized.convert("RGB")
+            save_format, save_kwargs = "JPEG", {"quality": 85}
+        elif target_mime == "image/webp":
+            resized = resized.convert("RGBA")
+            save_format, save_kwargs = "WEBP", {"lossless": True}
+        else:
+            resized = resized.convert("RGBA")
+            save_format, save_kwargs = "PNG", {}
+
+        buffer = io.BytesIO()
+        resized.save(buffer, format=save_format, **save_kwargs)
+
+    return target_mime, buffer.getvalue()

pycodex/model.py

@@ -69,6 +69,7 @@ class ResponsesProviderConfig:
     stream_max_retries: 'typing.Union[int, None]' = None
     stream_idle_timeout_ms: 'typing.Union[int, None]' = None
     service_tier: 'typing.Union[str, None]' = None
+    responses_lite_override: 'typing.Union[bool, None]' = None
 
     @classmethod
     def from_codex_config(
@@ -166,6 +167,8 @@ class ResponsesProviderConfig:
         return model_metadata(self.model)
 
     def use_responses_lite(self) -> 'bool':
+        if self.responses_lite_override is not None:
+            return self.responses_lite_override
         metadata = self.metadata()
         if metadata is None:
             return False
@@ -383,7 +386,10 @@ class ResponsesModelClient:
         return url
 
     async def list_models(self) -> 'typing.List[str]':
-        return await asyncio.to_thread(self._list_models_sync)
+        return await asyncio.to_thread(self.list_models_sync)
+
+    def list_models_sync(self) -> 'typing.List[str]':
+        return self._list_models_sync()
 
     async def complete(
         self,

pycodex/portable.py

@@ -11,8 +11,7 @@ from typing import Callable
 from urllib.parse import quote, urlparse
 
 import requests
-from cryptography.exceptions import InvalidTag
-from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+from Cryptodome.Cipher import AES
 import typing
 
 try:
@@ -234,18 +233,26 @@ def _normalize_optional_relative_file(root: 'Path', value: 'str') -> 'typing.Uni
 
 def _encrypt_bundle(bundle_bytes: 'bytes', secret: 'str') -> 'bytes':
     nonce = os.urandom(NONCE_LENGTH)
-    ciphertext = AESGCM(_encryption_key(secret)).encrypt(nonce, bundle_bytes, None)
-    return ENCRYPTED_BUNDLE_MAGIC + nonce + ciphertext
+    cipher = AES.new(_encryption_key(secret), AES.MODE_GCM, nonce=nonce)
+    ciphertext, tag = cipher.encrypt_and_digest(bundle_bytes)
+    return ENCRYPTED_BUNDLE_MAGIC + nonce + ciphertext + tag
 
 
 def _decrypt_bundle(payload: 'bytes', secret: 'str') -> 'bytes':
     if not payload.startswith(ENCRYPTED_BUNDLE_MAGIC):
         raise RemoteStorageError("stored bundle is not a recognized encrypted payload")
     nonce = payload[len(ENCRYPTED_BUNDLE_MAGIC) : len(ENCRYPTED_BUNDLE_MAGIC) + NONCE_LENGTH]
-    ciphertext = payload[len(ENCRYPTED_BUNDLE_MAGIC) + NONCE_LENGTH :]
+    encrypted = payload[len(ENCRYPTED_BUNDLE_MAGIC) + NONCE_LENGTH :]
+    if len(encrypted) < 16:
+        raise RemoteStorageError("call secret is invalid or bundle is corrupted")
+    ciphertext = encrypted[:-16]
+    tag = encrypted[-16:]
     try:
-        return AESGCM(_encryption_key(secret)).decrypt(nonce, ciphertext, None)
-    except InvalidTag as exc:
+        cipher = AES.new(_encryption_key(secret), AES.MODE_GCM, nonce=nonce)
+        plaintext = cipher.decrypt(ciphertext)
+        cipher.verify(tag)
+        return plaintext
+    except ValueError as exc:
         raise RemoteStorageError("call secret is invalid or bundle is corrupted") from exc