python-codex 0.3.3__py3-none-any.whl → 0.4.1__py3-none-any.whl

pycodex/feishu_link.py

@@ -1,440 +0,0 @@
-import asyncio
-import threading
-import time
-import typing
-
-from .events import SessionStateEvent
-from .feishu_card import PycodexCard
-from .runtime import AgentRuntime
-
-CARD_UPDATE_FLUSH_INTERVAL_SECONDS = 0.5
-_LISTENER = None
-_LISTENER_LOCK = threading.Lock()
-
-
-class PycodexRuntimeLink:
-    def __init__(
-        self,
-        runtime: "AgentRuntime",
-        target: str,
-        loop=None,
-        card: "typing.Union[PycodexCard, None]" = None,
-    ) -> None:
-        self.runtime = runtime
-        self.target = target
-        self.loop = loop
-        self.card = card or PycodexCard.from_env()
-        self.session_key = None
-        self.message_id = None
-        self._listener = None
-        self._frontend_id = None
-        self._detached = False
-        self._update_thread = None
-        self._update_stop = threading.Event()
-        self._update_lock = threading.Lock()
-        self._update_pending = False
-
-    async def start_async(self) -> "PycodexRuntimeLink":
-        self.loop = asyncio.get_event_loop()
-        self.card.apply_event(SessionStateEvent("attach", self.runtime.snapshot()))
-        try:
-            await self.loop.run_in_executor(None, self.start)
-        except Exception:
-            await self.loop.run_in_executor(None, self.stop)
-            raise
-        self._frontend_id = self.runtime.attach(self._handle_runtime_event)
-        return self
-
-    def start(self) -> "PycodexRuntimeLink":
-        if self.loop is None:
-            raise RuntimeError("PycodexRuntimeLink.start_async() is required")
-        self.card.send(self.target)
-        self.session_key = self.card.session_key
-        self.message_id = self.card.message_id
-        self._listener = _feishu_listener(self.card)
-        self._listener.register(self)
-        self._listener.start()
-        self._start_update_thread()
-        return self
-
-    def stop(self) -> None:
-        self._detach_frontend()
-        if self._listener is not None:
-            _release_feishu_listener(self._listener, self)
-            self._listener = None
-        self._stop_update_thread()
-
-    def detach(self) -> None:
-        self._detached = True
-        self._detach_frontend()
-        if self._listener is not None:
-            _release_feishu_listener(self._listener, self)
-            self._listener = None
-        self.card.detach()
-        self._safe_update_card()
-        self._stop_update_thread()
-
-    def _detach_frontend(self) -> None:
-        if self._frontend_id is not None:
-            self.runtime.detach(self._frontend_id)
-            self._frontend_id = None
-
-    def _handle_runtime_event(self, event) -> None:
-        if self._detached:
-            return
-        self.card.apply_event(event)
-        self._update_card()
-
-    async def _submit(
-        self, action: "typing.Dict[str, object]"
-    ) -> "typing.Dict[str, object]":
-        if self._detached:
-            return {"toast": {"type": "warning", "content": "pycodex is detached."}}
-        if action.get("action") == "history":
-            try:
-                self.card.show_history(action.get("history_index"))
-            except ValueError as exc:
-                return {"toast": {"type": "warning", "content": str(exc)}}
-            self._update_card()
-            return {}
-        if action.get("action") != "send":
-            return {
-                "toast": {
-                    "type": "info",
-                    "content": "Unsupported action: {0}".format(action.get("action")),
-                }
-            }
-        prompt = str(action.get("prompt") or "").strip()
-        future = asyncio.run_coroutine_threadsafe(
-            self.runtime.submit_input(
-                prompt, sender=str(action.get("sender") or "feishu")
-            ),
-            self.loop,
-        )
-        try:
-            await asyncio.wrap_future(future)
-        except (ValueError, RuntimeError) as exc:
-            return {"toast": {"type": "warning", "content": str(exc)}}
-        return {"toast": {"type": "info", "content": "Input submitted."}}
-
-    def _update_card(self) -> None:
-        with self._update_lock:
-            self._update_pending = True
-
-    def _safe_update_card(self) -> None:
-        try:
-            self.card.update()
-        except Exception as e:
-            print(e)
-
-    def _start_update_thread(self) -> None:
-        if self._update_thread is not None and self._update_thread.is_alive():
-            return
-        self._update_stop.clear()
-        self._update_thread = threading.Thread(
-            target=self._run_update_loop,
-            name="pycodex-feishu-card",
-        )
-        self._update_thread.daemon = True
-        self._update_thread.start()
-
-    def _stop_update_thread(self) -> None:
-        self._update_stop.set()
-        thread = self._update_thread
-        if thread is not None and thread.is_alive():
-            thread.join(timeout=2.0)
-        self._update_thread = None
-
-    def _run_update_loop(self) -> None:
-        while not self._update_stop.wait(CARD_UPDATE_FLUSH_INTERVAL_SECONDS):
-            with self._update_lock:
-                if not self._update_pending:
-                    continue
-                self._update_pending = False
-            self._safe_update_card()
-
-
-def _feishu_listener(card: PycodexCard) -> "_FeishuCardActionListener":
-    global _LISTENER
-    with _LISTENER_LOCK:
-        if _LISTENER is None:
-            _LISTENER = _FeishuCardActionListener(card)
-        else:
-            _LISTENER.assert_compatible(card)
-        return _LISTENER
-
-
-def _release_feishu_listener(
-    listener: "_FeishuCardActionListener",
-    link: PycodexRuntimeLink,
-) -> None:
-    global _LISTENER
-    with _LISTENER_LOCK:
-        listener.unregister(link)
-        if listener.empty():
-            listener.stop()
-            if _LISTENER is listener:
-                _LISTENER = None
-
-
-class _FeishuCardActionListener:
-    def __init__(self, card: PycodexCard) -> None:
-        self.app_id = card.app_id
-        self.app_secret = card.app_secret
-        self.domain = card.domain
-        self.encrypt_key = card.encrypt_key
-        self.verification_token = card.verification_token
-        self._links = {}
-        self._links_lock = threading.Lock()
-        self._async_thread = _AsyncLoopThread()
-        self._thread = None
-        self._client = None
-        self._client_loop = None
-        self._stop_requested = threading.Event()
-
-    def assert_compatible(self, card: PycodexCard) -> None:
-        if self.app_id != card.app_id or self.domain != card.domain:
-            raise RuntimeError("Feishu listener is already running for another app")
-
-    def start(self) -> None:
-        if not self.app_id or not self.app_secret:
-            raise RuntimeError("FEISHU_APP_ID and FEISHU_APP_SECRET are required")
-        if self._thread is not None and self._thread.is_alive():
-            return
-        self._stop_requested.clear()
-        self._async_thread.start()
-        self._thread = threading.Thread(
-            target=self._listen,
-            name="pycodex-feishu-link",
-        )
-        self._thread.daemon = True
-        self._thread.start()
-
-    def register(self, link: PycodexRuntimeLink) -> None:
-        message_id = str(getattr(link, "message_id", "") or "").strip()
-        if not message_id:
-            raise RuntimeError("Feishu linked card message_id is required")
-        with self._links_lock:
-            self._links[message_id] = link
-
-    def unregister(self, link: PycodexRuntimeLink) -> None:
-        message_id = str(getattr(link, "message_id", "") or "").strip()
-        with self._links_lock:
-            if message_id and self._links.get(message_id) is link:
-                del self._links[message_id]
-                return
-            stale_ids = [
-                registered_id
-                for registered_id, registered_link in self._links.items()
-                if registered_link is link
-            ]
-            for registered_id in stale_ids:
-                del self._links[registered_id]
-
-    def empty(self) -> bool:
-        with self._links_lock:
-            return not self._links
-
-    def stop(self) -> None:
-        self._stop_requested.set()
-        client = self._client
-        loop = self._client_loop
-        if loop is not None:
-            _stop_lark_client(client, loop)
-        thread = self._thread
-        if thread is not None and thread.is_alive():
-            thread.join(timeout=2.0)
-        self._thread = None
-        self._async_thread.stop()
-
-    def _listen(self) -> None:
-        try:
-            import lark_oapi as lark
-            import lark_oapi.ws as lark_ws
-            from lark_oapi.event.callback.model.p2_card_action_trigger import (
-                P2CardActionTriggerResponse,
-            )
-        except ImportError as exc:
-            raise RuntimeError(
-                "lark-oapi is required for Feishu long-connection mode"
-            ) from exc
-
-        def on_card_action(event):
-            return P2CardActionTriggerResponse(self._handle_card_action(event))
-
-        handler = (
-            lark.EventDispatcherHandler.builder(
-                self.encrypt_key or "",
-                self.verification_token or "",
-                lark.LogLevel.INFO,
-            )
-            .register_p2_card_action_trigger(on_card_action)
-            .build()
-        )
-        import lark_oapi.ws.client as lark_ws_client
-
-        client = None
-        loop = asyncio.new_event_loop()
-        self._client_loop = loop
-        asyncio.set_event_loop(loop)
-        lark_ws_client.loop = loop
-        try:
-            if self._stop_requested.is_set():
-                return
-            client = lark_ws.Client(
-                self.app_id,
-                self.app_secret,
-                event_handler=handler,
-                domain=self.domain,
-            )
-            self._client = client
-            if self._stop_requested.is_set():
-                return
-            client.start()
-        except RuntimeError as exc:
-            stopped = "Event loop stopped before Future completed" in str(exc)
-            if not self._stop_requested.is_set() or not stopped:
-                raise
-        finally:
-            if self._client is client:
-                self._client = None
-            if self._client_loop is loop:
-                self._client_loop = None
-            _close_loop(loop)
-            asyncio.set_event_loop(None)
-
-    def _handle_card_action(self, event) -> "typing.Dict[str, object]":
-        try:
-            message_id = _event_message_id(event)
-            link = self._resolve_link(message_id)
-            if link is None or link._detached:
-                return {
-                    "toast": {
-                        "type": "warning",
-                        "content": "pycodex is detached.",
-                    }
-                }
-            action = link.card.parse_action(event)
-            return self._async_thread.run(link._submit(action))
-        except Exception as exc:
-            return {
-                "toast": {
-                    "type": "error",
-                    "content": "pycodex error: {0}".format(exc),
-                }
-            }
-
-    def _resolve_link(self, message_id):
-        message_id = str(message_id or "").strip()
-        with self._links_lock:
-            if message_id:
-                return self._links.get(message_id)
-            if len(self._links) == 1:
-                return next(iter(self._links.values()))
-            return None
-
-
-def _event_message_id(event) -> "typing.Union[str, None]":
-    event_data = getattr(event, "event", None)
-    context = getattr(event_data, "context", None)
-    for name in ("open_message_id", "message_id"):
-        value = str(getattr(context, name, None) or "").strip()
-        if value:
-            return value
-    return None
-
-
-def _stop_lark_client(client, loop) -> None:
-    if loop.is_closed():
-        return
-    disconnect = getattr(client, "_disconnect", None) if client is not None else None
-    if loop.is_running():
-        future = asyncio.run_coroutine_threadsafe(
-            _disconnect_then_stop(disconnect, loop),
-            loop,
-        )
-        try:
-            future.result(timeout=2.0)
-        except Exception as exc:
-            future.cancel()
-            print(exc)
-            loop.call_soon_threadsafe(loop.stop)
-        return
-    if callable(disconnect):
-        try:
-            loop.run_until_complete(disconnect())
-        except Exception as exc:
-            print(exc)
-
-
-async def _disconnect_then_stop(disconnect, loop) -> None:
-    try:
-        if callable(disconnect):
-            await disconnect()
-    except Exception as exc:
-        print(exc)
-    finally:
-        loop.stop()
-
-
-def _close_loop(loop) -> None:
-    if loop.is_closed():
-        return
-    tasks = list(_all_loop_tasks(loop))
-    for task in tasks:
-        task.cancel()
-    if tasks:
-        loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True))
-    shutdown_asyncgens = getattr(loop, "shutdown_asyncgens", None)
-    if callable(shutdown_asyncgens):
-        loop.run_until_complete(shutdown_asyncgens())
-    loop.close()
-
-
-def _all_loop_tasks(loop):
-    all_tasks = getattr(asyncio, "all_tasks", None)
-    if callable(all_tasks):
-        return all_tasks(loop)
-    return asyncio.Task.all_tasks(loop)
-
-
-class _AsyncLoopThread:
-    def __init__(self) -> None:
-        self.loop = None
-        self.thread = None
-        self._started = threading.Event()
-
-    def start(self) -> None:
-        if self.loop is not None and self.loop.is_running():
-            return
-        self.loop = asyncio.new_event_loop()
-        self._started.clear()
-        self.thread = threading.Thread(
-            target=self._run_loop,
-            name="pycodex-feishu-asyncio",
-        )
-        self.thread.daemon = True
-        self.thread.start()
-        self._started.wait()
-
-    def run(self, coro):
-        if self.loop is None or not self.loop.is_running():
-            raise RuntimeError("Feishu asyncio loop is not running")
-        return asyncio.run_coroutine_threadsafe(coro, self.loop).result()
-
-    def stop(self) -> None:
-        loop = self.loop
-        if loop is None:
-            return
-        if loop.is_running():
-            loop.call_soon_threadsafe(loop.stop)
-        if self.thread is not None:
-            self.thread.join()
-        loop.close()
-        self.loop = None
-        self.thread = None
-
-    def _run_loop(self) -> None:
-        asyncio.set_event_loop(self.loop)
-        self._started.set()
-        self.loop.run_forever()

pycodex/tools/ipython_tool.py

@@ -1,142 +0,0 @@
-"""Optional tool that executes code in the current IPython kernel."""
-
-from ..events import ToolCompletedEvent
-from ..utils.event_helpers import colorize_tool_message
-from .base_tool import BaseTool, ToolContext
-
-
-class IPythonTool(BaseTool):
-    name = "ipython"
-    description = (
-        "Execute Python code in the current IPython kernel namespace. Use this "
-        "only when running inside IPython and live notebook/session variables "
-        "need to be inspected."
-    )
-    input_schema = {
-        "type": "object",
-        "properties": {
-            "code": {
-                "type": "string",
-                "description": "Python code to execute in the current IPython session.",
-            },
-        },
-        "required": ["code"],
-        "additionalProperties": False,
-    }
-    supports_parallel = False
-
-    def __init__(self, shell, name="ipython"):
-        self._shell = shell
-        self.name = name
-
-    async def run(self, context: "ToolContext", args):
-        del context
-        if not isinstance(args, dict):
-            return {"error": "arguments must be an object"}
-
-        code = args.get("code", "")
-        if not isinstance(code, str) or not code.strip():
-            return {"error": "`code` must be a non-empty string"}
-
-        from IPython.display import Code, display
-        from IPython.utils.capture import capture_output
-
-        display(Code(code, language="python"))
-        with capture_output() as captured:
-            result = self._shell.run_cell(code, store_history=False)
-        captured.show()
-
-        output = {
-            "stdout": captured.stdout,
-            "stderr": captured.stderr,
-        }
-
-        display_outputs = []
-        for item in captured.outputs:
-            data = getattr(item, "data", None)
-            if isinstance(data, dict):
-                display_outputs.append(
-                    data.get("text/plain") or data.get("text/html") or repr(data)
-                )
-            else:
-                display_outputs.append(repr(item))
-        if display_outputs:
-            output["display"] = display_outputs
-
-        if getattr(result, "result", None) is not None:
-            output["result"] = repr(result.result)
-
-        error = result.error_before_exec or result.error_in_exec
-        if error is not None:
-            output["error"] = f"{type(error).__name__}: {error}"
-
-        return output
-
-
-def _install_agent_shortcut(shell):
-    existing = shell.user_ns.get("_pycodex_agent_shortcut_transform")
-    if existing in shell.input_transformers_cleanup:
-        return existing
-
-    def transform(lines):
-        if len(lines) != 1:
-            return lines
-
-        line = lines[0]
-        stripped = line.lstrip()
-        indent = line[: len(line) - len(stripped)]
-        if not stripped.startswith("@"):
-            return lines
-
-        body = stripped[1:].rstrip("\n")
-        parts = body.split(None, 1)
-        if not parts:
-            return lines
-
-        agent_name = parts[0]
-        if not agent_name.isidentifier():
-            return lines
-
-        agent = shell.user_ns.get(agent_name)
-        if agent is None or not callable(getattr(agent, "run_turn", None)):
-            return lines
-
-        prompt = "" if len(parts) == 1 else parts[1]
-        if not prompt.strip():
-            return [f"{indent}print('Usage: @{agent_name} <prompt>')\n"]
-
-        return [f"{indent}print({agent_name}.ask({prompt!r}).output_text)\n"]
-
-    shell.input_transformers_cleanup.append(transform)
-    shell.user_ns["_pycodex_agent_shortcut_transform"] = transform
-    return transform
-
-
-def attach_ipython_event_printer(agent, color=True):
-    def handle_event(event):
-        if isinstance(event, ToolCompletedEvent):
-            tool_name = event.call.name
-            message = event.visualize()
-            for line in message.splitlines() or [""]:
-                print(colorize_tool_message(line, color, tool_name), flush=True)
-
-    agent.event_handler = handle_event
-    return handle_event
-
-
-def attach_ipython_tool(
-    agent, name="current_ipython", shortcut=True, print_tool_events=True, color=True
-):
-    from IPython import get_ipython
-
-    shell = get_ipython()
-    if shell is None:
-        raise RuntimeError("not running inside IPython")
-
-    tool = IPythonTool(shell, name=name)
-    agent.tool_registry.register(tool)
-    if shortcut:
-        _install_agent_shortcut(shell)
-    if print_tool_events:
-        attach_ipython_event_printer(agent, color=color)
-    return tool

python_codex-0.3.3.dist-info/RECORD

@@ -1,98 +0,0 @@
-pycodex/__init__.py,sha256=4BBGUXImsNBdSQjp2KtshkjQK9BMz5gK93DzpWokkWY,3235
-pycodex/__main__.py,sha256=MHKZ_ae3fSLGTLUUMOx15fWdeOnJSHhq-zslRP5F5Lc,79
-pycodex/agent.py,sha256=zCIG2DV0oQntLXHFj8FVRkgBp5TCC0YJ7sz0lni9J1s,21177
-pycodex/bootstrap.py,sha256=DSVx8u94tHRYbUa_e9zdKPqozOv_CrfctbTKZ4JG064,13765
-pycodex/cli.py,sha256=m5IJhnodNqsfMTIzdwbuaHBl2r-N8x1MxYSpe_hlHiM,12997
-pycodex/compat.py,sha256=yoQQWMiAQ6ytZv3DAMIbp66ImA0kyY4G5eKHrtwmj6c,3490
-pycodex/context.py,sha256=nkq2Y0coZNpWs5IJj7uVVT65fDqh58Z9c07y_Wy0f4Q,26604
-pycodex/doctor.py,sha256=9p624b1zloXbhyMRi1-Of1YtnYeoF4zHxfGFhfujDS4,10620
-pycodex/events.py,sha256=MZljtqra6-Hnt9Emjbn_wgp5cGaODx1w3CbmIKd5htI,29692
-pycodex/feishu_card.py,sha256=Gclo4TI3KTfdT5NDLiv58CRg6hH3sUCRXuSrHgXgYjI,27767
-pycodex/feishu_link.py,sha256=yUbEvO-8g-Bxo8_cF9s6vLZguz3NA6q3qt2A9Q09fsE,14523
-pycodex/model.py,sha256=HeHeaYEC06idh_66mM4uzyc7IZc_AS789ajByvOqbr8,44571
-pycodex/model_metadata.py,sha256=RMYhvgkm2v1nhCslSiDXPAwrRAx8FPz9QJqv8QTbWlc,1332
-pycodex/portable.py,sha256=rfOpVnBZ01RS0Kyjo_w2FNKHY2t-lUcHVtWhPsbp1-k,16158
-pycodex/portable_server.py,sha256=A4IY3xHtBQLRxdHQ4O5zdaVGjqENaLvypsSkLGZvCZ0,7498
-pycodex/protocol.py,sha256=dRcTVKTaE7Eaq_jiSYdCzBMebIo3gnL7wB1x-NJqY5E,12027
-pycodex/runtime.py,sha256=bRlqrmXqK6kPndAG96QoGALKicbWmfuXgo2jDvbQzdE,23806
-pycodex/runtime_services.py,sha256=4jDCMlXHwgbJZPJkWzVEPCRHPxrD0mpCBbDInVToGG8,15033
-pycodex/prompts/default_base_instructions.md,sha256=D65mcj6bo4CDvVom-D9cbJRJVNquo0NghKt164_fRsg,20923
-pycodex/prompts/models.json,sha256=u-bS5xtI7ZHbrG_nbzrt-xmp5RtQT6YL8PHbd_4XZB4,397650
-pycodex/prompts/permissions/approval_policy/never.md,sha256=QceTG6wjkaJARjYr0HYV1aPnPcpGcrkRUW-smWRr6MQ,120
-pycodex/prompts/permissions/approval_policy/on_failure.md,sha256=dfJjpXkpO6_ANdCKxbVJ8o4vyLxevrJWfKsGHTqtbkc,289
-pycodex/prompts/permissions/approval_policy/on_request.md,sha256=hVQalzh0FAdkKzw5u-N4H7-LtC9ijVDlYsh3OKsZKzo,3661
-pycodex/prompts/permissions/approval_policy/on_request_rule_request_permission.md,sha256=mOinishp1k-wlPsaEuIOMn5GoVm_dAIsWIuEMmv2r7o,1725
-pycodex/prompts/permissions/approval_policy/unless_trusted.md,sha256=XHpi1Lfx1iIXFbbQ_ho_kGstA3JN-RLho291HM30UNw,247
-pycodex/prompts/permissions/sandbox_mode/danger_full_access.md,sha256=nZ7YHacBd3cAHKRZc9XClOOOnXJPXPh0WFBueh5C2D0,197
-pycodex/prompts/permissions/sandbox_mode/read_only.md,sha256=2rAPEXsBYCcuttI5j3euS-3uv_v97catIsnhxlSQSIM,173
-pycodex/prompts/permissions/sandbox_mode/workspace_write.md,sha256=lVN-LwrBbHqlv5yVjcd_mU8tzZW8jfKpTatJKIZu9HI,277
-pycodex/tools/__init__.py,sha256=UYwmsX_Ckw_YaYQ6TYhUU6w5pxi2qzZoTrq6BAgNErM,1857
-pycodex/tools/agent_tool_schemas.py,sha256=8cL9ml4So0H6IIeK0ZzjAo9bk3VeprDOSYPpIamOqEU,2048
-pycodex/tools/apply_patch_tool.py,sha256=t8XFCGZ7q-s9C1Ty6qkReBRk-QD3ONvcKXLAz9djKRY,13956
-pycodex/tools/base_tool.py,sha256=kNNzPWijtdl4C_GunyR5G1qvsr7KQtnFJ2RiRHHnAYo,6478
-pycodex/tools/clock_tool.py,sha256=2_RYbBEw4V9_f1L-qZl3hhJ6XNPM_gBDmOlCh1cCAjo,6575
-pycodex/tools/close_agent_tool.py,sha256=zQtvd5iGW6YCPFiec8zc2OdGtgNIxoA4p2ZTuCoJOaI,2031
-pycodex/tools/code_mode_manager.py,sha256=VFVn7S_qUHCOHW952CMeGxTIE-7CPOx2uuXJZgBml8o,19160
-pycodex/tools/exec_command_tool.py,sha256=iqRiKaaX-AjG6LjATAMOakHIP0gpCWCj2o8af_8eAiQ,4464
-pycodex/tools/exec_runtime.js,sha256=DR1uocKailTqNWAcJNFJuQgFFMSUzTpT_uQsRaneg2s,3643
-pycodex/tools/exec_tool.py,sha256=tuC21rlhP8CPSYml4XnSDSRV0UPGkQ6aHj0DLIoOOvM,2274
-pycodex/tools/grep_files_tool.py,sha256=Ysw68VKI9OEvUH5haYx8FWuthkHykc1wskbuzjj8gTk,5293
-pycodex/tools/ipython_tool.py,sha256=SKVYpJEwlYjOQZQWbpqvrA-3K9aJTlIG9KM50p5JYUM,4496
-pycodex/tools/list_dir_tool.py,sha256=_U6ouRcVbGHT5mChVyUsiMgDGrFK7EFMFaspPLAHtH8,5337
-pycodex/tools/read_file_tool.py,sha256=YK__uhIVldBjAQega5S_ZuZU5jgP_kLOwr-YhjAmRo4,9735
-pycodex/tools/request_permissions_tool.py,sha256=n8eg29SgRbx1DUxxLbAztnc5i-0j2N2WnDupspjwWbE,3979
-pycodex/tools/request_user_input_tool.py,sha256=_7siHF2p3KiNDFwsTqKKIUw2kPCXMzLaR12PkZ1wdIQ,4050
-pycodex/tools/resume_agent_tool.py,sha256=D_OcWQbIbsWf-2NrRgDab4hB6BUbay0XidfPInhg88Y,1614
-pycodex/tools/send_input_tool.py,sha256=J91LLz4RpvHmBWti0XZgI9xWipWwD8-1hQIdC8-Jd5E,3762
-pycodex/tools/shell_command_tool.py,sha256=US63I5xiV5zfO1Oox2yHUg7F6XoKzmyxtohfaQIsmrw,4216
-pycodex/tools/shell_tool.py,sha256=lqFH2XosfBg7yQKhpB7i4vLGz9sNQtEZihD0rjsmBCQ,4068
-pycodex/tools/spawn_agent_tool.py,sha256=n_WZi1IX4Waj-GQ-hR1BVlk3zzw_ssvem7zcj3tYI38,6209
-pycodex/tools/unified_exec_manager.py,sha256=sO1H3uoXyZ6DiyF98-eidQ77mS-P5gSWyPqM3L50yTQ,14538
-pycodex/tools/update_plan_tool.py,sha256=8zyANrQgj8u2LBJ2yz_0Cg5jP3S6ibp6eASxUupX9C8,3199
-pycodex/tools/view_image_tool.py,sha256=UZRkBEwuCkqxOw7XBwacdgPZAtbnD6uSHTdm-6amUo4,3902
-pycodex/tools/wait_agent_tool.py,sha256=2OWfb9FCGu5SjbRp33dVEJWG3apMtQgczvQR1V_rm6I,3829
-pycodex/tools/wait_tool.py,sha256=0_OO_DvMsBhG3oDKZePTOjZTBq1lmWntXAzqIqvebdA,3206
-pycodex/tools/web_search_tool.py,sha256=3ao1IvJw7MwcP35UKLbqrM-nlm5Z-UUFVdEzkJYOV1o,988
-pycodex/tools/write_stdin_tool.py,sha256=jvBDchLLmoDITd7g-ZVeEVXHRhWKkmnjM5laL-53FOM,3609
-pycodex/utils/__init__.py,sha256=lbf-jbo6JS7t1wfFkQqLHlG4zZVqXYGkOIj2cvtrjx8,591
-pycodex/utils/async_bridge.py,sha256=d21Pjim-nsQbSG5pJddd0WaQ03CzA3w3TINWDmmjWbg,1815
-pycodex/utils/compactor.py,sha256=0tlszw1n54aMEGH6sL1U1dEgFSU5ioYL2NI5uSvHSiM,6119
-pycodex/utils/debug.py,sha256=BdXmuAQVWVB1BONKRDlkMpgXpkt4M1jhvEAq5n2AumI,296
-pycodex/utils/dotenv.py,sha256=h7ZgvqpEswetqjhtwfiaHyokAHwNKPakizTAHPHz5Ds,1865
-pycodex/utils/event_helpers.py,sha256=pnxL0-nBC7cnOheHPCIfkHqJjMbkJg3C348_EzAVhFA,6342
-pycodex/utils/get_env.py,sha256=L4S8h84tkgxZKvrxY7ezTgePbXepG-yIigUTKeY6uuE,6094
-pycodex/utils/image_utils.py,sha256=1kXhtTqL4xtazpEABHhtvJBUJlceo8hSzg6ukmf_4FA,2407
-pycodex/utils/random_ids.py,sha256=jLTxZZ0MBbRdQOFDFWGVRjWzIo6FKSQ5ADXbQSLPp1s,379
-pycodex/utils/session_persist.py,sha256=v9KhmjUB2yCg55c85i8ZU1BWfc-WEMDPmpT0Rv4K8a8,22489
-pycodex/utils/truncation.py,sha256=5D6vAorT8EgXgjd7ASwtraAyIZdlCR-w5jKZqJxDzho,5446
-responses_server/__init__.py,sha256=sx9C88YWqmehASZy24FUMqT14A36doM_rj0MIZtQ9iQ,377
-responses_server/__main__.py,sha256=876xZTqhPeDBD2GKKr8pKX33Af8PhFTosAI8bYQsFgQ,61
-responses_server/app.py,sha256=9uhglqUaRXhotYDkGFemnETopgx9Moi2wHOE0pDCwtU,7755
-responses_server/config.py,sha256=sCJYGisPHW9Uup26-R9Zv0o9W_kRVt-ETc2MFCVjG90,2795
-responses_server/messages_api.py,sha256=ialAYTMmN0y-uxQB3Y51ukq-kvkSVO84WVLXaqLsKw0,18775
-responses_server/payload_processors.py,sha256=dqPwqHD-FhyiIwjzFEMf2wCtQDxkRyerZzbdqnH1aDE,3561
-responses_server/server.py,sha256=k4DbsOYkaHHcy38uF9u_QXahJC1cplKsTu-MdC3DCIs,2286
-responses_server/session_store.py,sha256=nwGxQL6nUVKnDVeDHz8IzqNQ7dWk8Ybf0URekOHdxTo,1133
-responses_server/stream_router.py,sha256=TQX2-8uOGad3TBJnRu9SOtDaHBHjYwE-WERYz6rcuo8,46274
-responses_server/trajectory_dump.py,sha256=5_Wy6tslszrqx3j1JeP_boyTbzIicKy8No84PzMnmHk,5111
-responses_server/tools/__init__.py,sha256=ivsBSEy0SBUhY-Uea5v1XMLXShkwHdCVl0id-1FwdZg,150
-responses_server/tools/custom_adapter.py,sha256=SnIiNUdomff3APtTriURAC9YCeEdhCDjzGMEYusfUdk,8340
-responses_server/tools/web_search.py,sha256=pnKH9JyTScRehWpZS3HpXRvjWsQvC0QZqxjEOCT4ndg,8936
-workspace_server/__init__.py,sha256=PRM4ONODb6hxjBUHkBD4TprE_pkTCIlT9sfftK5ic6M,866
-workspace_server/__main__.py,sha256=876xZTqhPeDBD2GKKr8pKX33Af8PhFTosAI8bYQsFgQ,61
-workspace_server/app.py,sha256=aoo5vq5AciEHe3r5gcgt2B349uuWLY6fbFYbOQ2CRAE,67164
-workspace_server/content_views.LICENSE.txt,sha256=PUOceZvrZI9c2LeLVh6wJNv5wwALKoJ8jOOfq-05WmQ,64183
-workspace_server/content_views.css,sha256=n1yPrOZbzNS0phv2JGwaYbK8t81MI2kKe9rc3sY2TRI,1662
-workspace_server/content_views.mjs,sha256=8sbYqAgwYrAE9SMd3bO6jv6DlHwWru1gboID8h2oTLE,16241
-workspace_server/editor.css,sha256=4qBe2ZLqloAFQ2YNyJYvsJelvTHIIQCxpfg4EVTubk8,346450
-workspace_server/editor.mjs,sha256=oZpBsmnA56VIogpbg_NDg8cs4bIQZkuUCtXPJnVLook,4110455
-workspace_server/owned_process.py,sha256=j1cJ89Nm7gS91Zj62kYKabFbb9qhbU7-q1YDsWcVcn8,895
-workspace_server/workspace.html,sha256=r1cBihjnyt8cxjI9xGqTVBs3zboMcoYHemgvwNMpN2A,74728
-workspace_server/workspace_views.py,sha256=acV-SS3Uw-Qy5AI_KV16AowB1R3cbJN4Okk6CDbpPzw,22172
-workspace_server/workspaces.html,sha256=72WEextEEUZeAYCmZ5UcWbg1m7voFezxgL6j48koRuU,15794
-workspace_server/workspaces.py,sha256=hMvGyZtuFshGV3l56AMhGJN0vDOvvVj8iv9-VAJJHhw,22524
-python_codex-0.3.3.dist-info/METADATA,sha256=ucgUraJ7rlCeUstF-FlAE8qiURNuqF-qOw6xKMbYF7M,42715
-python_codex-0.3.3.dist-info/WHEEL,sha256=KGYbc1zXlYddvwxnNty23BeaKzh7YuoSIvIMO4jEhvw,87
-python_codex-0.3.3.dist-info/entry_points.txt,sha256=vkV2UWCtEKvQNMJuPNjt8HyBKiwp83JyqBatrBNGDp8,80
-python_codex-0.3.3.dist-info/licenses/LICENSE,sha256=0X8ifk312hYAORM4hlzg8wVSEXYKNmiPgWlB1YIy2Nw,10926
-python_codex-0.3.3.dist-info/RECORD,,