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

responses_server/stream_router.py

@@ -1,4 +1,3 @@
-from __future__ import annotations
 
 import json
 import ssl
@@ -21,6 +20,7 @@ from .tools.web_search import (
     hydrate_tool_call_names,
     partition_tool_calls,
 )
+import typing
 
 
 class UnsupportedIncommingFeature(ValueError):
@@ -32,15 +32,15 @@ class OutcommingChatError(RuntimeError):
 
 
 class StreamRouter:
-    def __init__(self, config: CompatServerConfig) -> None:
+    def __init__(self, config: 'CompatServerConfig') -> 'None':
         self._config = config
         self._mock_web_search = WebSearchTool()
 
     def _provider_capability(
         self,
-        explicit_support: dict[str, bool],
-        default: bool | None = None,
-    ) -> bool:
+        explicit_support: 'typing.Dict[str, bool]',
+        default: 'typing.Union[bool, None]' = None,
+    ) -> 'bool':
         provider_name = str(self._config.model_provider or "").strip().lower()
         if provider_name in explicit_support:
             return explicit_support[provider_name]
@@ -50,7 +50,7 @@ class StreamRouter:
             return default
         raise KeyError("provider capability map is missing `vllm` fallback")
 
-    def _supports_chat_reasoning(self) -> bool:
+    def _supports_chat_reasoning(self) -> 'bool':
         # Unknown providers inherit the vLLM compatibility behavior unless a
         # provider is explicitly declared otherwise.
         return self._provider_capability(
@@ -60,7 +60,7 @@ class StreamRouter:
             }
         )
 
-    def _supports_stream_usage(self) -> bool:
+    def _supports_stream_usage(self) -> 'bool':
         return self._provider_capability(
             {
                 "vllm": True,
@@ -70,8 +70,8 @@ class StreamRouter:
 
     def validate_incomming_request(
         self,
-        incomming_request: dict[str, object],
-    ) -> None:
+        incomming_request: 'typing.Dict[str, object]',
+    ) -> 'None':
         model = str(incomming_request.get("model", "")).strip()
         if not model:
             raise UnsupportedIncommingFeature("incomming request is missing `model`")
@@ -90,11 +90,11 @@ class StreamRouter:
 
     def collect_custom_tool_names(
         self,
-        incomming_request: dict[str, object],
-    ) -> set[str]:
+        incomming_request: 'typing.Dict[str, object]',
+    ) -> 'typing.Set[str]':
         return collect_custom_tool_names(incomming_request.get("tools") or [])
 
-    def list_models(self) -> dict[str, object]:
+    def list_models(self) -> 'typing.Dict[str, object]':
         request = urllib.request.Request(
             self._config.outcomming_models_url(),
             headers=self._build_headers(accept="application/json"),
@@ -104,8 +104,8 @@ class StreamRouter:
 
     def build_outcomming_request(
         self,
-        incomming_request: dict[str, object],
-    ) -> dict[str, object]:
+        incomming_request: 'typing.Dict[str, object]',
+    ) -> 'typing.Dict[str, object]':
         model = str(incomming_request.get("model", "")).strip()
         if not model:
             raise UnsupportedIncommingFeature("incomming request is missing `model`")
@@ -121,7 +121,7 @@ class StreamRouter:
         if not isinstance(input_items, list):
             raise UnsupportedIncommingFeature("incomming `input` must be a list")
 
-        payload: dict[str, object] = {
+        payload: 'typing.Dict[str, object]' = {
             "model": model,
             "messages": self._responses_input_to_chat_messages(
                 instructions,
@@ -148,7 +148,7 @@ class StreamRouter:
 
         return payload
 
-    def open_outcomming_stream(self, outcomming_request: dict[str, object]):
+    def open_outcomming_stream(self, outcomming_request: 'typing.Dict[str, object]'):
         request = urllib.request.Request(
             self._config.outcomming_chat_completions_url(),
             data=json.dumps(outcomming_request).encode("utf-8"),
@@ -180,9 +180,9 @@ class StreamRouter:
     def route_stream(
         self,
         incomming_stream,
-        stored_response: StoredResponse,
-        outcomming_request: dict[str, object],
-        custom_tool_names: set[str] | None = None,
+        stored_response: 'StoredResponse',
+        outcomming_request: 'typing.Dict[str, object]',
+        custom_tool_names: 'typing.Union[typing.Set[str], None]' = None,
     ):
         yield (
             "response.created",
@@ -197,15 +197,15 @@ class StreamRouter:
             },
         )
 
-        text_parts: list[str] = []
-        reasoning_parts: list[str] = []
-        latest_usage: dict[str, object] = {}
+        text_parts: 'typing.List[str]' = []
+        reasoning_parts: 'typing.List[str]' = []
+        latest_usage: 'typing.Dict[str, object]' = {}
         current_request = json.loads(json.dumps(outcomming_request))
         current_stream = incomming_stream
 
         while True:
-            tool_calls: dict[int, dict[str, object]] = {}
-            current_usage: dict[str, object] = {}
+            tool_calls: 'typing.Dict[int, typing.Dict[str, object]]' = {}
+            current_usage: 'typing.Dict[str, object]' = {}
             for chunk in current_stream:
                 for event_name, payload in self._consume_chat_chunk(
                     chunk,
@@ -290,16 +290,16 @@ class StreamRouter:
 
     def _responses_input_to_chat_messages(
         self,
-        instructions: str,
-        input_items: list[object],
-    ) -> list[dict[str, object]]:
-        messages: list[dict[str, object]] = []
+        instructions: 'str',
+        input_items: 'typing.List[object]',
+    ) -> 'typing.List[typing.Dict[str, object]]':
+        messages: 'typing.List[typing.Dict[str, object]]' = []
         if instructions:
             messages.append({"role": "developer", "content": instructions})
 
-        pending_assistant: dict[str, object] | None = None
+        pending_assistant: 'typing.Union[typing.Dict[str, object], None]' = None
 
-        def flush_pending_assistant() -> None:
+        def flush_pending_assistant() -> 'None':
             nonlocal pending_assistant
             if pending_assistant is None:
                 return
@@ -420,7 +420,7 @@ class StreamRouter:
         flush_pending_assistant()
         return messages
 
-    def _coalesce_content_text(self, raw_content: object) -> str:
+    def _coalesce_content_text(self, raw_content: 'object') -> 'str':
         if raw_content is None:
             return ""
         if isinstance(raw_content, str):
@@ -430,7 +430,7 @@ class StreamRouter:
                 "message `content` must be a list or string"
             )
 
-        text_parts: list[str] = []
+        text_parts: 'typing.List[str]' = []
         for part in raw_content:
             if not isinstance(part, dict):
                 raise UnsupportedIncommingFeature(
@@ -445,17 +445,17 @@ class StreamRouter:
             )
         return "".join(text_parts)
 
-    def _coalesce_tool_output_text(self, raw_output: object) -> str:
+    def _coalesce_tool_output_text(self, raw_output: 'object') -> 'str':
         if isinstance(raw_output, str):
             return raw_output
         if isinstance(raw_output, list):
             return self._coalesce_content_text(raw_output)
         return json.dumps(raw_output, ensure_ascii=False)
 
-    def _coalesce_reasoning_text(self, raw_item: dict[str, object]) -> str:
+    def _coalesce_reasoning_text(self, raw_item: 'typing.Dict[str, object]') -> 'str':
         content = raw_item.get("content")
         if isinstance(content, list):
-            text_parts: list[str] = []
+            text_parts: 'typing.List[str]' = []
             for part in content:
                 if not isinstance(part, dict):
                     continue
@@ -482,8 +482,8 @@ class StreamRouter:
                 return value
         return ""
 
-    def _translate_tools(self, incomming_tools: list[object]) -> list[dict[str, object]]:
-        translated: list[dict[str, object]] = []
+    def _translate_tools(self, incomming_tools: 'typing.List[object]') -> 'typing.List[typing.Dict[str, object]]':
+        translated: 'typing.List[typing.Dict[str, object]]' = []
         for raw_tool in incomming_tools:
             if not isinstance(raw_tool, dict):
                 raise UnsupportedIncommingFeature("tool definitions must be objects")
@@ -518,7 +518,7 @@ class StreamRouter:
             )
         return translated
 
-    def _translate_tool_choice(self, raw_tool_choice: object) -> object:
+    def _translate_tool_choice(self, raw_tool_choice: 'object') -> 'object':
         if isinstance(raw_tool_choice, str):
             return raw_tool_choice
         if not isinstance(raw_tool_choice, dict):
@@ -541,13 +541,13 @@ class StreamRouter:
 
     def _consume_chat_chunk(
         self,
-        payload: dict[str, object],
-        reasoning_parts: list[str],
-        text_parts: list[str],
-        tool_calls: dict[int, dict[str, object]],
-        current_usage: dict[str, object],
-    ) -> list[tuple[str, dict[str, object]]]:
-        events: list[tuple[str, dict[str, object]]] = []
+        payload: 'typing.Dict[str, object]',
+        reasoning_parts: 'typing.List[str]',
+        text_parts: 'typing.List[str]',
+        tool_calls: 'typing.Dict[int, typing.Dict[str, object]]',
+        current_usage: 'typing.Dict[str, object]',
+    ) -> 'typing.List[typing.Tuple[str, typing.Dict[str, object]]]':
+        events: 'typing.List[typing.Tuple[str, typing.Dict[str, object]]]' = []
         usage = payload.get("usage")
         if isinstance(usage, dict):
             self._capture_usage_snapshot(current_usage, usage)
@@ -627,9 +627,9 @@ class StreamRouter:
 
     def _capture_usage_snapshot(
         self,
-        current_usage: dict[str, object],
-        usage: dict[str, object],
-    ) -> None:
+        current_usage: 'typing.Dict[str, object]',
+        usage: 'typing.Dict[str, object]',
+    ) -> 'None':
         scalar_mappings = (
             ("input_tokens", usage.get("input_tokens", usage.get("prompt_tokens"))),
             (
@@ -661,12 +661,12 @@ class StreamRouter:
 
     def _build_output_items(
         self,
-        reasoning_parts: list[str],
-        text_parts: list[str],
-        tool_calls: dict[int, dict[str, object]],
-        custom_tool_names: set[str],
-    ) -> list[dict[str, object]]:
-        items: list[dict[str, object]] = []
+        reasoning_parts: 'typing.List[str]',
+        text_parts: 'typing.List[str]',
+        tool_calls: 'typing.Dict[int, typing.Dict[str, object]]',
+        custom_tool_names: 'typing.Set[str]',
+    ) -> 'typing.List[typing.Dict[str, object]]':
+        items: 'typing.List[typing.Dict[str, object]]' = []
         reasoning_text = "".join(reasoning_parts)
         if reasoning_text:
             items.append(
@@ -731,7 +731,7 @@ class StreamRouter:
 
         return items
 
-    def _request_json(self, request: urllib.request.Request) -> dict[str, object]:
+    def _request_json(self, request: 'urllib.request.Request') -> 'typing.Dict[str, object]':
         try:
             with urllib.request.urlopen(
                 request,
@@ -749,7 +749,7 @@ class StreamRouter:
                 f"outcomming request failed: {exc.reason}"
             ) from exc
 
-    def _build_headers(self, accept: str) -> dict[str, str]:
+    def _build_headers(self, accept: 'str') -> 'typing.Dict[str, str]':
         headers = {
             "Accept": accept,
             "Content-Type": "application/json",
@@ -760,8 +760,8 @@ class StreamRouter:
         return headers
 
     def _iter_sse_events(self, response):
-        event_name: str | None = None
-        data_lines: list[str] = []
+        event_name: 'typing.Union[str, None]' = None
+        data_lines: 'typing.List[str]' = []
 
         for raw_line in response:
             line = raw_line.decode("utf-8", errors="replace").rstrip("\r\n")

responses_server/tools/custom_adapter.py

@@ -1,7 +1,7 @@
-from __future__ import annotations
 
 from copy import deepcopy
 import json
+import typing
 
 
 class CustomToolAdapterError(ValueError):
@@ -82,8 +82,8 @@ It is important to remember:
 """
 
 
-def collect_custom_tool_names(raw_tools: object) -> set[str]:
-    names: set[str] = set()
+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:
@@ -95,7 +95,7 @@ def collect_custom_tool_names(raw_tools: object) -> set[str]:
     return names
 
 
-def build_tool_definition(raw_tool: dict[str, object]) -> dict[str, object]:
+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 = (
@@ -125,7 +125,7 @@ def build_tool_definition(raw_tool: dict[str, object]) -> dict[str, object]:
     }
 
 
-def build_tool_call(raw_item: dict[str, object]) -> dict[str, object]:
+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,
@@ -141,7 +141,7 @@ def build_tool_call(raw_item: dict[str, object]) -> dict[str, object]:
     }
 
 
-def build_output_item(tool_call: dict[str, object], index: int) -> dict[str, object]:
+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(
@@ -160,7 +160,7 @@ def build_output_item(tool_call: dict[str, object], index: int) -> dict[str, obj
     }
 
 
-def extract_input_text(raw_arguments: object) -> str:
+def extract_input_text(raw_arguments: 'object') -> 'str':
     if isinstance(raw_arguments, dict):
         parsed = deepcopy(raw_arguments)
     else:
@@ -186,7 +186,7 @@ def extract_input_text(raw_arguments: object) -> str:
     return str(raw_arguments or "")
 
 
-def _build_description(raw_tool: dict[str, object]) -> str:
+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
@@ -200,7 +200,7 @@ def _build_description(raw_tool: dict[str, object]) -> str:
 
     raw_format = raw_tool.get("format")
     if isinstance(raw_format, dict):
-        format_lines: list[str] = []
+        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()
@@ -217,18 +217,18 @@ def _build_description(raw_tool: dict[str, object]) -> str:
     return "\n\n".join(parts)
 
 
-def _tool_name(raw_tool: dict[str, object]) -> str:
+def _tool_name(raw_tool: 'typing.Dict[str, object]') -> 'str':
     return str(raw_tool.get("name", "")).strip()
 
 
-def _required_tool_name(raw_tool: dict[str, object]) -> str:
+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: dict[str, object]) -> str:
+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`")

responses_server/tools/web_search.py

@@ -1,10 +1,10 @@
-from __future__ import annotations
 
 from copy import deepcopy
 import json
 
 from pycodex.protocol import JSONValue
 from pycodex.tools.base_tool import BaseTool, ToolContext
+import typing
 
 
 class WebSearchTool(BaseTool):
@@ -29,10 +29,10 @@ class WebSearchTool(BaseTool):
     }
     supports_parallel = False
 
-    async def run(self, context: ToolContext, args: JSONValue) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONValue') -> 'JSONValue':
         del context
         query, queries = extract_queries(args)
-        output_payload: dict[str, object] = {
+        output_payload: 'typing.Dict[str, object]' = {
             "results": [],
             "mock": True,
         }
@@ -43,7 +43,7 @@ class WebSearchTool(BaseTool):
         return output_payload
 
 
-def build_tool_definition(tool: WebSearchTool) -> dict[str, object]:
+def build_tool_definition(tool: 'WebSearchTool') -> 'typing.Dict[str, object]':
     return {
         "type": "function",
         "name": tool.name,
@@ -57,13 +57,13 @@ def build_tool_definition(tool: WebSearchTool) -> dict[str, object]:
 
 
 def partition_tool_calls(
-    tool: WebSearchTool,
-    tool_calls: dict[int, dict[str, object]],
-    outcomming_request: dict[str, object],
-) -> tuple[list[dict[str, object]], dict[int, dict[str, object]]]:
+    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: list[dict[str, object]] = []
-    ordinary_tool_calls: dict[int, dict[str, object]] = {}
+    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 {}
@@ -78,9 +78,9 @@ def partition_tool_calls(
 
 
 def hydrate_tool_call_names(
-    tool_calls: dict[int, dict[str, object]],
-    outcomming_request: dict[str, object],
-) -> None:
+    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
@@ -104,15 +104,15 @@ def hydrate_tool_call_names(
 
 
 def build_output_items(
-    mock_search_calls: list[dict[str, object]],
-) -> list[dict[str, object]]:
-    items: list[dict[str, object]] = []
+    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: dict[str, object] = {"type": "search"}
+        action: 'typing.Dict[str, object]' = {"type": "search"}
         if query:
             action["query"] = query
         if queries:
@@ -128,17 +128,17 @@ def build_output_items(
 
 
 def build_followup_request(
-    tool: WebSearchTool,
-    outcomming_request: dict[str, object],
-    mock_search_calls: list[dict[str, object]],
-    reasoning_text: str | None = None,
-) -> dict[str, object]:
+    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: list[dict[str, object]] = []
+    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):
@@ -154,7 +154,7 @@ def build_followup_request(
             }
         )
     if assistant_tool_calls:
-        assistant_message: dict[str, object] = {
+        assistant_message: 'typing.Dict[str, object]' = {
             "role": "assistant",
             "tool_calls": assistant_tool_calls,
         }
@@ -187,7 +187,7 @@ def build_followup_request(
     return followup_request
 
 
-def extract_queries(raw_arguments: JSONValue) -> tuple[str, list[str]]:
+def extract_queries(raw_arguments: 'JSONValue') -> 'typing.Tuple[str, typing.List[str]]':
     if isinstance(raw_arguments, dict):
         parsed = raw_arguments
     else:
@@ -211,7 +211,7 @@ def extract_queries(raw_arguments: JSONValue) -> tuple[str, list[str]]:
 
     query = str(parsed.get("query", "")).strip()
     queries_value = parsed.get("queries") or []
-    queries: list[str] = []
+    queries: 'typing.List[str]' = []
     if isinstance(queries_value, list):
         for value in queries_value:
             normalized = str(value).strip()
@@ -224,7 +224,7 @@ def extract_queries(raw_arguments: JSONValue) -> tuple[str, list[str]]:
     return query, queries
 
 
-def is_mock_tool(tool: WebSearchTool, raw_tool: object) -> bool:
+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 {}
@@ -237,10 +237,10 @@ def is_mock_tool(tool: WebSearchTool, raw_tool: object) -> bool:
 
 
 def _collect_mock_tool_names(
-    tool: WebSearchTool,
-    outcomming_request: dict[str, object],
-) -> set[str]:
-    names: set[str] = set()
+    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
@@ -250,9 +250,9 @@ def _collect_mock_tool_names(
     return names
 
 
-def _build_mock_output(raw_arguments: JSONValue) -> dict[str, object]:
+def _build_mock_output(raw_arguments: 'JSONValue') -> 'typing.Dict[str, object]':
     query, queries = extract_queries(raw_arguments)
-    output_payload: dict[str, object] = {
+    output_payload: 'typing.Dict[str, object]' = {
         "results": [],
         "mock": True,
     }

python_codex-0.1.2.dist-info/RECORD

@@ -1,73 +0,0 @@
-pycodex/__init__.py,sha256=T11JU1QHEk81TchhrTAOqVkvUUiQGlesk9PNaivjPrU,3052
-pycodex/agent.py,sha256=ApIneWSqDxryf9hdmTRFL65AH4e-sn0MWuuR80951Ec,10069
-pycodex/cli.py,sha256=ju4aF_kwbraqZ-NfoymzB6CjvvMX22afeXDvse2ykf8,24676
-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=hmdwFiOZ1DPEJ5T8vfDSLfujgGQBPrzPQkn6uX_9vZ8,12503
-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=xJfEpcQXpL3OX-ZzKxQ2sI781OuEqpeyPvVkkwhgZ1c,1415
-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=ZEaMXmO83Iu20V4dwxAuUjy4EF5IHqHmwnTvFJh8zGc,13330
-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=Ehh0mVPhkDlPMd1WXhrz1UqjPCePg8YfZH7zrtu1EOQ,6894
-pycodex/utils/random_ids.py,sha256=vOEVgkwKeQXaHoEVU7IfsPPjKUABkGIeQ7lu9MZctU8,413
-pycodex/utils/visualize.py,sha256=fK79pTfOwMmRrQujAosGt0nGyyJjpz0GfpWY8BkK91c,35369
-responses_server/__init__.py,sha256=3yPv_zeGT7P11tTnmj5kXktISLNsNW-02MUnnbiZcb0,394
-responses_server/__main__.py,sha256=9SRp-Yw7ShGxc6DhSIXcDLKgGEdAVm3oBZ59rBOPjT0,62
-responses_server/app.py,sha256=VJSceVaXxbPLu9KGafLIt5fiGvxrqVTkWeOg81O5-FQ,7016
-responses_server/config.py,sha256=XAJmvvLiCYN5jCUcP_6uZyoW79OzxigMbik8X-ZTdKE,2174
-responses_server/payload_processors.py,sha256=_3Sl7HLG00BgN_TKcvT3_3drCDAq1MAeK1HxbRXNta4,3019
-responses_server/server.py,sha256=Q-gjtHzb7K1Guex10G38PgH9hxqJgdzYnBV7Ycy9L7Y,2049
-responses_server/session_store.py,sha256=oP3aFHsGmEMoXuUcxNh6B4vzp6KwaeRdLzM-3AOwM98,1078
-responses_server/stream_router.py,sha256=uYPjrlBUnNqiuQQ91eKmwDfNF6e5NYDtf5C8BdPRPRc,29536
-responses_server/tools/__init__.py,sha256=ivsBSEy0SBUhY-Uea5v1XMLXShkwHdCVl0id-1FwdZg,150
-responses_server/tools/custom_adapter.py,sha256=ivROeI8D9B1saS7skGLXnwF7fbsjAmEVSbeMceYno4E,8238
-responses_server/tools/web_search.py,sha256=HR9E5uMxWU07khsaIO9zvdg1GCCrWNy73263zfMaxsw,8565
-python_codex-0.1.2.dist-info/METADATA,sha256=wy8bEToZxyf9Cio-upoAS8XmC3MscN8wiKTVXp9MW9g,13969
-python_codex-0.1.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-python_codex-0.1.2.dist-info/entry_points.txt,sha256=sNUVakoVuTrzJH505ZgRTQxmtRRPUHV_EH0i6EbYTyM,45
-python_codex-0.1.2.dist-info/licenses/LICENSE,sha256=0X8ifk312hYAORM4hlzg8wVSEXYKNmiPgWlB1YIy2Nw,10926
-python_codex-0.1.2.dist-info/RECORD,,