python-codex 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

responses_server/tools/__init__.py

@@ -0,0 +1,4 @@
+from .custom_adapter import collect_custom_tool_names
+from .web_search import WebSearchTool
+
+__all__ = ["WebSearchTool", "collect_custom_tool_names"]

responses_server/tools/custom_adapter.py

@@ -0,0 +1,235 @@
+
+from copy import deepcopy
+import json
+import typing
+
+
+class CustomToolAdapterError(ValueError):
+    pass
+
+
+# Mirrors the chat-completions apply_patch function tool text from
+# `codex-rs/core/src/tools/handlers/apply_patch.rs`.
+APPLY_PATCH_NAME = "apply_patch"
+APPLY_PATCH_CHAT_INPUT_DESCRIPTION = "The entire contents of the apply_patch command"
+APPLY_PATCH_CHAT_DESCRIPTION = """Use the `apply_patch` tool to edit files.
+Your patch language is a stripped-down, file-oriented diff format designed to be easy to parse and safe to apply. You can think of it as a high-level envelope:
+
+*** Begin Patch
+[ one or more file sections ]
+*** End Patch
+
+Within that envelope, you get a sequence of file operations.
+You MUST include a header to specify the action you are taking.
+Each operation starts with one of three headers:
+
+*** Add File: <path> - create a new file. Every following line is a + line (the initial contents).
+*** Delete File: <path> - remove an existing file. Nothing follows.
+*** Update File: <path> - patch an existing file in place (optionally with a rename).
+
+May be immediately followed by *** Move to: <new path> if you want to rename the file.
+Then one or more "hunks", each introduced by @@ (optionally followed by a hunk header).
+Within a hunk each line starts with:
+
+For instructions on [context_before] and [context_after]:
+- By default, show 3 lines of code immediately above and 3 lines immediately below each change. If a change is within 3 lines of a previous change, do NOT duplicate the first change's [context_after] lines in the second change's [context_before] lines.
+- If 3 lines of context is insufficient to uniquely identify the snippet of code within the file, use the @@ operator to indicate the class or function to which the snippet belongs. For instance, we might have:
+@@ class BaseClass
+[3 lines of pre-context]
+- [old_code]
++ [new_code]
+[3 lines of post-context]
+
+- If a code block is repeated so many times in a class or function such that even a single `@@` statement and 3 lines of context cannot uniquely identify the snippet of code, you can use multiple `@@` statements to jump to the right context. For instance:
+
+@@ class BaseClass
+@@ \t def method():
+[3 lines of pre-context]
+- [old_code]
++ [new_code]
+[3 lines of post-context]
+
+The full grammar definition is below:
+Patch := Begin { FileOp } End
+Begin := "*** Begin Patch" NEWLINE
+End := "*** End Patch" NEWLINE
+FileOp := AddFile | DeleteFile | UpdateFile
+AddFile := "*** Add File: " path NEWLINE { "+" line NEWLINE }
+DeleteFile := "*** Delete File: " path NEWLINE
+UpdateFile := "*** Update File: " path NEWLINE [ MoveTo ] { Hunk }
+MoveTo := "*** Move to: " newPath NEWLINE
+Hunk := "@@" [ header ] NEWLINE { HunkLine } [ "*** End of File" NEWLINE ]
+HunkLine := (" " | "-" | "+") text NEWLINE
+
+A full patch can combine several operations:
+
+*** Begin Patch
+*** Add File: hello.txt
++Hello world
+*** Update File: src/app.py
+*** Move to: src/main.py
+@@ def greet():
+-print("Hi")
++print("Hello, world!")
+*** Delete File: obsolete.txt
+*** End Patch
+
+It is important to remember:
+
+- You must include a header with your intended action (Add/Delete/Update)
+- You must prefix new lines with `+` even when creating a new file
+- File references can only be relative, NEVER ABSOLUTE.
+"""
+
+
+def collect_custom_tool_names(raw_tools: 'object') -> 'typing.Set[str]':
+    names: 'typing.Set[str]' = set()
+    if not isinstance(raw_tools, list):
+        return names
+    for raw_tool in raw_tools:
+        if not isinstance(raw_tool, dict) or raw_tool.get("type") != "custom":
+            continue
+        name = _tool_name(raw_tool)
+        if name:
+            names.add(name)
+    return names
+
+
+def build_tool_definition(raw_tool: 'typing.Dict[str, object]') -> 'typing.Dict[str, object]':
+    name = _required_tool_name(raw_tool)
+    description = _build_description(raw_tool)
+    input_description = (
+        APPLY_PATCH_CHAT_INPUT_DESCRIPTION
+        if name == APPLY_PATCH_NAME
+        else "Raw tool input. Pass the freeform payload verbatim as a single string."
+    )
+    return {
+        "type": "function",
+        "name": name,
+        "function": {
+            "name": name,
+            "description": description,
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "input": {
+                        "type": "string",
+                        "description": input_description,
+                    }
+                },
+                "required": ["input"],
+                "additionalProperties": False,
+            },
+            "strict": False,
+        },
+    }
+
+
+def build_tool_call(raw_item: 'typing.Dict[str, object]') -> 'typing.Dict[str, object]':
+    name = _required_item_name(raw_item)
+    return {
+        "id": str(raw_item.get("call_id", "")).strip() or name,
+        "type": "function",
+        "function": {
+            "name": name,
+            "arguments": json.dumps(
+                {"input": str(raw_item.get("input", "") or "")},
+                ensure_ascii=False,
+                separators=(",", ":"),
+            ),
+        },
+    }
+
+
+def build_output_item(tool_call: 'typing.Dict[str, object]', index: 'int') -> 'typing.Dict[str, object]':
+    function = tool_call.get("function") or {}
+    if not isinstance(function, dict):
+        raise CustomToolAdapterError(
+            "outcomming custom tool call is missing function payload"
+        )
+    name = str(function.get("name", "")).strip()
+    if not name:
+        raise CustomToolAdapterError(
+            "outcomming custom tool call is missing `name`"
+        )
+    return {
+        "type": "custom_tool_call",
+        "call_id": str(tool_call.get("id", "")).strip() or f"call_{index}",
+        "name": name,
+        "input": extract_input_text(function.get("arguments")),
+    }
+
+
+def extract_input_text(raw_arguments: 'object') -> 'str':
+    if isinstance(raw_arguments, dict):
+        parsed = deepcopy(raw_arguments)
+    else:
+        parsed = None
+
+    raw_text = raw_arguments if isinstance(raw_arguments, str) else None
+    if parsed is None and raw_text is not None:
+        try:
+            parsed = json.loads(raw_text or "{}")
+        except json.JSONDecodeError:
+            return raw_text
+
+    if isinstance(parsed, dict) and "input" in parsed:
+        value = parsed.get("input")
+        if isinstance(value, str):
+            return value
+        return json.dumps(value, ensure_ascii=False)
+
+    if raw_text is not None:
+        return raw_text
+    if parsed is not None:
+        return json.dumps(parsed, ensure_ascii=False)
+    return str(raw_arguments or "")
+
+
+def _build_description(raw_tool: 'typing.Dict[str, object]') -> 'str':
+    name = _tool_name(raw_tool)
+    if name == APPLY_PATCH_NAME:
+        return APPLY_PATCH_CHAT_DESCRIPTION
+
+    description = str(raw_tool.get("description", "") or "").strip()
+    parts = [description] if description else []
+    parts.append(
+        "Chat-completions compatibility: provide the raw tool payload in the "
+        "`input` string field."
+    )
+
+    raw_format = raw_tool.get("format")
+    if isinstance(raw_format, dict):
+        format_lines: 'typing.List[str]' = []
+        format_type = str(raw_format.get("type", "")).strip()
+        syntax = str(raw_format.get("syntax", "")).strip()
+        definition = str(raw_format.get("definition", "") or "").strip()
+        if format_type:
+            format_lines.append(f"Input format type: {format_type}")
+        if syntax:
+            format_lines.append(f"Input format syntax: {syntax}")
+        if definition:
+            format_lines.append("Input format definition:")
+            format_lines.append(definition)
+        if format_lines:
+            parts.append("\n".join(format_lines))
+
+    return "\n\n".join(parts)
+
+
+def _tool_name(raw_tool: 'typing.Dict[str, object]') -> 'str':
+    return str(raw_tool.get("name", "")).strip()
+
+
+def _required_tool_name(raw_tool: 'typing.Dict[str, object]') -> 'str':
+    name = _tool_name(raw_tool)
+    if not name:
+        raise CustomToolAdapterError("custom tool definition is missing `name`")
+    return name
+
+
+def _required_item_name(raw_item: 'typing.Dict[str, object]') -> 'str':
+    name = str(raw_item.get("name", "")).strip()
+    if not name:
+        raise CustomToolAdapterError("custom tool call is missing `name`")
+    return name

responses_server/tools/web_search.py

@@ -0,0 +1,263 @@
+
+from copy import deepcopy
+import json
+
+from pycodex.protocol import JSONValue
+from pycodex.tools.base_tool import BaseTool, ToolContext
+import typing
+
+
+class WebSearchTool(BaseTool):
+    name = "web_search"
+    description = (
+        "Mock web search tool for Responses compatibility. Returns empty results."
+    )
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "query": {
+                "type": "string",
+                "description": "Primary search query.",
+            },
+            "queries": {
+                "type": "array",
+                "description": "Optional batch of search queries.",
+                "items": {"type": "string"},
+            },
+        },
+        "required": ["query"],
+    }
+    supports_parallel = False
+
+    async def run(self, context: 'ToolContext', args: 'JSONValue') -> 'JSONValue':
+        del context
+        query, queries = extract_queries(args)
+        output_payload: 'typing.Dict[str, object]' = {
+            "results": [],
+            "mock": True,
+        }
+        if query:
+            output_payload["query"] = query
+        if queries:
+            output_payload["queries"] = queries
+        return output_payload
+
+
+def build_tool_definition(tool: 'WebSearchTool') -> 'typing.Dict[str, object]':
+    return {
+        "type": "function",
+        "name": tool.name,
+        "function": {
+            "name": tool.name,
+            "description": tool.description,
+            "parameters": deepcopy(tool.input_schema),
+            "strict": False,
+        },
+    }
+
+
+def partition_tool_calls(
+    tool: 'WebSearchTool',
+    tool_calls: 'typing.Dict[int, typing.Dict[str, object]]',
+    outcomming_request: 'typing.Dict[str, object]',
+) -> 'typing.Tuple[typing.List[typing.Dict[str, object]], typing.Dict[int, typing.Dict[str, object]]]':
+    mock_tool_names = _collect_mock_tool_names(tool, outcomming_request)
+    mock_calls: 'typing.List[typing.Dict[str, object]]' = []
+    ordinary_tool_calls: 'typing.Dict[int, typing.Dict[str, object]]' = {}
+    for index in sorted(tool_calls):
+        tool_call = tool_calls[index]
+        function = tool_call.get("function") or {}
+        tool_name = ""
+        if isinstance(function, dict):
+            tool_name = str(function.get("name", "")).strip()
+        if tool_name in mock_tool_names:
+            mock_calls.append(tool_call)
+            continue
+        ordinary_tool_calls[index] = tool_call
+    return mock_calls, ordinary_tool_calls
+
+
+def hydrate_tool_call_names(
+    tool_calls: 'typing.Dict[int, typing.Dict[str, object]]',
+    outcomming_request: 'typing.Dict[str, object]',
+) -> 'None':
+    raw_tools = outcomming_request.get("tools") or []
+    if not isinstance(raw_tools, list):
+        return
+    for index, tool_call in tool_calls.items():
+        function = tool_call.get("function") or {}
+        if not isinstance(function, dict):
+            continue
+        if str(function.get("name", "")).strip():
+            continue
+        if index >= len(raw_tools):
+            continue
+        raw_tool = raw_tools[index]
+        if not isinstance(raw_tool, dict) or raw_tool.get("type") != "function":
+            continue
+        raw_function = raw_tool.get("function") or {}
+        if not isinstance(raw_function, dict):
+            continue
+        name = str(raw_function.get("name", "")).strip()
+        if name:
+            function["name"] = name
+
+
+def build_output_items(
+    mock_search_calls: 'typing.List[typing.Dict[str, object]]',
+) -> 'typing.List[typing.Dict[str, object]]':
+    items: 'typing.List[typing.Dict[str, object]]' = []
+    for tool_call in mock_search_calls:
+        function = tool_call.get("function") or {}
+        if not isinstance(function, dict):
+            continue
+        query, queries = extract_queries(function.get("arguments"))
+        action: 'typing.Dict[str, object]' = {"type": "search"}
+        if query:
+            action["query"] = query
+        if queries:
+            action["queries"] = queries
+        items.append(
+            {
+                "type": "web_search_call",
+                "id": str(tool_call.get("id", "")).strip() or "ws_mock",
+                "action": action,
+            }
+        )
+    return items
+
+
+def build_followup_request(
+    tool: 'WebSearchTool',
+    outcomming_request: 'typing.Dict[str, object]',
+    mock_search_calls: 'typing.List[typing.Dict[str, object]]',
+    reasoning_text: 'typing.Union[str, None]' = None,
+) -> 'typing.Dict[str, object]':
+    followup_request = deepcopy(outcomming_request)
+    messages = followup_request.get("messages") or []
+    if not isinstance(messages, list):
+        raise ValueError("outcomming request messages must be a list")
+
+    assistant_tool_calls: 'typing.List[typing.Dict[str, object]]' = []
+    for tool_call in mock_search_calls:
+        function = tool_call.get("function") or {}
+        if not isinstance(function, dict):
+            continue
+        assistant_tool_calls.append(
+            {
+                "id": str(tool_call.get("id", "")).strip() or "ws_mock",
+                "type": "function",
+                "function": {
+                    "name": str(function.get("name", "")).strip() or tool.name,
+                    "arguments": str(function.get("arguments", "") or "{}"),
+                },
+            }
+        )
+    if assistant_tool_calls:
+        assistant_message: 'typing.Dict[str, object]' = {
+            "role": "assistant",
+            "tool_calls": assistant_tool_calls,
+        }
+        if reasoning_text:
+            assistant_message["reasoning"] = reasoning_text
+        messages.append(assistant_message)
+
+    for tool_call in mock_search_calls:
+        tool_output = _build_mock_output((tool_call.get("function") or {}).get("arguments"))
+        messages.append(
+            {
+                "role": "tool",
+                "tool_call_id": str(tool_call.get("id", "")).strip() or "ws_mock",
+                "content": json.dumps(tool_output, ensure_ascii=False),
+            }
+        )
+
+    followup_request["messages"] = messages
+    raw_tools = followup_request.get("tools") or []
+    if isinstance(raw_tools, list):
+        filtered_tools = [
+            raw_tool for raw_tool in raw_tools if not is_mock_tool(tool, raw_tool)
+        ]
+        if filtered_tools:
+            followup_request["tools"] = filtered_tools
+        else:
+            followup_request.pop("tools", None)
+            followup_request.pop("tool_choice", None)
+            followup_request.pop("parallel_tool_calls", None)
+    return followup_request
+
+
+def extract_queries(raw_arguments: 'JSONValue') -> 'typing.Tuple[str, typing.List[str]]':
+    if isinstance(raw_arguments, dict):
+        parsed = raw_arguments
+    else:
+        parsed = None
+
+    if isinstance(raw_arguments, str):
+        raw_text = raw_arguments
+    else:
+        raw_text = str(raw_arguments or "")
+
+    if parsed is None:
+        try:
+            parsed = json.loads(raw_text or "{}")
+        except json.JSONDecodeError:
+            query = raw_text.strip()
+            return query, [query] if query else []
+
+    if not isinstance(parsed, dict):
+        query = raw_text.strip()
+        return query, [query] if query else []
+
+    query = str(parsed.get("query", "")).strip()
+    queries_value = parsed.get("queries") or []
+    queries: 'typing.List[str]' = []
+    if isinstance(queries_value, list):
+        for value in queries_value:
+            normalized = str(value).strip()
+            if normalized:
+                queries.append(normalized)
+    if not query and queries:
+        query = queries[0]
+    if query and query not in queries:
+        queries.insert(0, query)
+    return query, queries
+
+
+def is_mock_tool(tool: 'WebSearchTool', raw_tool: 'object') -> 'bool':
+    if not isinstance(raw_tool, dict) or raw_tool.get("type") != "function":
+        return False
+    function = raw_tool.get("function") or {}
+    if not isinstance(function, dict):
+        return False
+    return (
+        str(function.get("name", "")).strip() == tool.name
+        and str(function.get("description", "")).strip() == tool.description
+    )
+
+
+def _collect_mock_tool_names(
+    tool: 'WebSearchTool',
+    outcomming_request: 'typing.Dict[str, object]',
+) -> 'typing.Set[str]':
+    names: 'typing.Set[str]' = set()
+    raw_tools = outcomming_request.get("tools") or []
+    if not isinstance(raw_tools, list):
+        return names
+    for raw_tool in raw_tools:
+        if is_mock_tool(tool, raw_tool):
+            names.add(tool.name)
+    return names
+
+
+def _build_mock_output(raw_arguments: 'JSONValue') -> 'typing.Dict[str, object]':
+    query, queries = extract_queries(raw_arguments)
+    output_payload: 'typing.Dict[str, object]' = {
+        "results": [],
+        "mock": True,
+    }
+    if query:
+        output_payload["query"] = query
+    if queries:
+        output_payload["queries"] = queries
+    return output_payload

python_codex-0.1.1.dist-info/RECORD

@@ -1,62 +0,0 @@
-pycodex/__init__.py,sha256=T11JU1QHEk81TchhrTAOqVkvUUiQGlesk9PNaivjPrU,3052
-pycodex/agent.py,sha256=ApIneWSqDxryf9hdmTRFL65AH4e-sn0MWuuR80951Ec,10069
-pycodex/cli.py,sha256=JKHedrIgFaQgAc9h3P1MHvJTvUjL5dv7gxgHh-LCsDs,24520
-pycodex/collaboration.py,sha256=XAM2enljzHMjzZVlLxbOQF0JhWgKW4qaaDfVcUdE47g,632
-pycodex/context.py,sha256=8-Eg1TE4-GVbEfW0fNZjDWhjLypK3jBlKZY1haYYVPY,23143
-pycodex/doctor.py,sha256=VN-qetM2qJCNRNTZXBMe44VSrEOu8kUXE01luLMF050,10357
-pycodex/model.py,sha256=ZqXSucpzBm0kn2XfhBdKebdwvJQH1Jc9xMqBfPwOKGM,19672
-pycodex/portable.py,sha256=Y2pY08pDiWITY0QYgH3F9YKpOe2EYtxE0qqSmrCkp_g,15260
-pycodex/portable_server.py,sha256=xhEwySCJ41WnsowXM-Db6kkmCOVM02Lmd4pbN6hZzh0,7232
-pycodex/protocol.py,sha256=8mQ7I-y9bxYueSr7d_yGj2Tw69t47OCgwvmxhwihdFw,10807
-pycodex/runtime.py,sha256=tfEuyZmnTP625BQ0NMm-AGhjfQpXcv2EaZLtCJTnEmM,7757
-pycodex/runtime_services.py,sha256=IIpv96YuxdWX2D1yu-HmtCx3Og-fYDPrA29vgAlyvJE,12331
-pycodex/prompts/collaboration_default.md,sha256=MBTmPuMubeWfZgIeFVj49wwnwD4n_o3fVYAbgWKwu6Q,955
-pycodex/prompts/collaboration_plan.md,sha256=IzjQAA5oHJz-3FmJdOjsJ4LHq6LW1tlEYMoy09n0HKk,8777
-pycodex/prompts/default_base_instructions.md,sha256=D65mcj6bo4CDvVom-D9cbJRJVNquo0NghKt164_fRsg,20923
-pycodex/prompts/exec_tools.json,sha256=2wYLsjL6VGzMnhFNCxE9IA_kxsxUspN68lr7JOlZq54,23369
-pycodex/prompts/models.json,sha256=Xmuy5-FiiWdAe-Zz9w_-_kdEcRvIVssS1PugQSA64i8,251450
-pycodex/prompts/subagent_tools.json,sha256=2ZOXyAiAaai2aazIlXdjjXb7cra5gZ2WYYbPltPaiYg,6199
-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=aSLXrr_31KGQgDfRow5zVIc-2-KdXlHaCE6qUnE4HWI,1772
-pycodex/tools/agent_tool_schemas.py,sha256=adzoo0L6jCM7rLF-O1mNrq85HENQ_oKakjzwP6id1Yk,2069
-pycodex/tools/apply_patch_tool.py,sha256=8hHxoWxWovAYdhr0XzDCZwljtMlApp7-TMZtyxe3adY,13691
-pycodex/tools/base_tool.py,sha256=34NaExjTCyDn333MzlU4ShQ9WHocW3WREfg9ifdAqY4,5299
-pycodex/tools/close_agent_tool.py,sha256=InKhe2gFWOcqE187J3XYrCckecsyAR48VeVmGdYhKWE,1623
-pycodex/tools/code_mode_manager.py,sha256=pEczPyCq-3DpJlTtfUEpl4JAGolz8cOpI8mBc7gdrn0,18603
-pycodex/tools/exec_command_tool.py,sha256=_fWfkQLGeINb2-cniY9CWskkAPjC9hE8pfjcBKkWXAg,3459
-pycodex/tools/exec_runtime.js,sha256=ZczdhrzpSZ-qNnJDDJOe8Ap86HpzHb2FZ_vSpHszgLs,3625
-pycodex/tools/exec_tool.py,sha256=b3_HSlyA0qB9rJulSckLBXOcKS3Lw5xvsQXU-wpNpCs,1414
-pycodex/tools/grep_files_tool.py,sha256=twsx1KsvOWh8mi-lbycAtEyh6PeLxtNzl9LzdjwgAf4,4742
-pycodex/tools/list_dir_tool.py,sha256=7S0RsE-NL04G47FmFZtzo-N-O3fPCYQFF0HrjEVuv3U,4749
-pycodex/tools/read_file_tool.py,sha256=GVamhSNEZ1F1IU_og9GgSCzV12TL5t5b1fOUlzTOQBQ,8084
-pycodex/tools/request_permissions_tool.py,sha256=GzYG-mc1ifTiIM8xK8WD-vPGUKpYgMX9zyqq9O6K-EE,3036
-pycodex/tools/request_user_input_tool.py,sha256=hVqCYGPLA29uxBblIjUIoIrzXVg5KZ8PcxJ84obgNro,5715
-pycodex/tools/resume_agent_tool.py,sha256=vF-vLtx90bOuSjLFvn9vgqrKiznIbwpmZ3HVJlCP1LE,1640
-pycodex/tools/send_input_tool.py,sha256=z9PR5VoFd9SF4A-ol04Op8AXQF_3YLE74C6coiTXsZ0,3546
-pycodex/tools/shell_command_tool.py,sha256=Bbah_5HirG1BJOIiqzuMa8kNHNYVPCUvxCFa09eRU6A,3500
-pycodex/tools/shell_tool.py,sha256=BWSaEJZwfQg9Ta-ld2wqeXqavrZC7Y8qgF_vBEOxfYA,3678
-pycodex/tools/spawn_agent_tool.py,sha256=LfJlGI0Ecp9HWNLlTubyybFq-xeRNChILq9ozT7piA8,3556
-pycodex/tools/unified_exec_manager.py,sha256=dyuGfaljXTuV4_Bf5Y6OwFGj5_Kb1LW-sh9ni5mMF1Y,12602
-pycodex/tools/update_plan_tool.py,sha256=l_EG39bEw5K9BIUKoSUsXYDb0W7aLn8SviKSb-bs7Os,2887
-pycodex/tools/view_image_tool.py,sha256=yB915Jd3he4RjPANdm-dYdvio24OXKhBkAsp-9WVPBg,3924
-pycodex/tools/wait_agent_tool.py,sha256=1tJ5spBtpZ_MjoMv5xmZz5WWKl7UwMqHIJ3SYKXEPZw,2596
-pycodex/tools/wait_tool.py,sha256=G4YhaYeWAvUedzxTDAxbczVmXXUp7H2OKWO3qZlEyyk,2324
-pycodex/tools/web_search_tool.py,sha256=hq78XF6MRvmNyPFSIp5eI0eYn9ryKdKvvoIOFNU3tuY,987
-pycodex/tools/write_stdin_tool.py,sha256=DghlwPJnAqDoRBYyh1zeXRsfTXoQUdLJ8JQfrdE4RLs,2542
-pycodex/utils/__init__.py,sha256=Hj_0a7RhkAblWkaHyFhpi0cs2nSjJ1NdavbkBgEHieY,1024
-pycodex/utils/dotenv.py,sha256=sOpu6PA1VrsPZK13ynh3nZg3-u9pdiCXkW648v3pwZQ,1789
-pycodex/utils/get_env.py,sha256=3l_KA8JCWW9mrKE9FiV2mTx10-e5MUbxaU8jbn3JaRs,6265
-pycodex/utils/random_ids.py,sha256=vOEVgkwKeQXaHoEVU7IfsPPjKUABkGIeQ7lu9MZctU8,413
-pycodex/utils/visualize.py,sha256=fK79pTfOwMmRrQujAosGt0nGyyJjpz0GfpWY8BkK91c,35369
-python_codex-0.1.1.dist-info/METADATA,sha256=3w9Sv_prpkT9BQ7zYh4NUCDV3eVlcoaq2Pv6yAkacOc,13969
-python_codex-0.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-python_codex-0.1.1.dist-info/entry_points.txt,sha256=sNUVakoVuTrzJH505ZgRTQxmtRRPUHV_EH0i6EbYTyM,45
-python_codex-0.1.1.dist-info/licenses/LICENSE,sha256=0X8ifk312hYAORM4hlzg8wVSEXYKNmiPgWlB1YIy2Nw,10926
-python_codex-0.1.1.dist-info/RECORD,,