anywhere-cli 0.1.2__tar.gz → 0.1.3__tar.gz

{anywhere_cli-0.1.2 → anywhere_cli-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anywhere-cli
-Version: 0.1.2
+Version: 0.1.3
 Summary: Local runtime connector for Agents Anywhere
 Requires-Python: >=3.12
 Requires-Dist: claude-agent-sdk

{anywhere_cli-0.1.2 → anywhere_cli-0.1.3}/connector/codex/adapter.py

@@ -92,6 +92,7 @@ class CodexAdapter:
     _history_sync_tasks: dict[str, asyncio.Task[None]] = field(default_factory=dict)
     _existing_thread_sync_markers: dict[str, str] = field(default_factory=dict)
     _existing_thread_names: dict[str, str | None] = field(default_factory=dict)
+    _start_lock: asyncio.Lock = field(default_factory=asyncio.Lock, init=False, repr=False)
 
     def __post_init__(self) -> None:
         if self.rpc is None:
@@ -117,12 +118,13 @@ class CodexAdapter:
             self.sync_state_store.delete_runtime("codex", connector_id)
 
     async def start(self) -> None:
-        assert self.rpc is not None
-        await self.rpc.start(self.handle_notification)
-        if self._started:
-            return
-        await self._best_effort_bootstrap_reads()
-        self._started = True
+        async with self._start_lock:
+            assert self.rpc is not None
+            await self.rpc.start(self.handle_notification)
+            if self._started:
+                return
+            await self._best_effort_bootstrap_reads()
+            self._started = True
 
     async def create_session(self, params: dict[str, Any]) -> dict[str, Any]:
         await self.start()
@@ -929,6 +931,10 @@ def _unresumable_thread_failure_reason(error_text: str) -> str | None:
         return "archived"
     if "cannot resume" in normalized or "not resumable" in normalized or "unresumable" in normalized:
         return "unresumable"
+    if "failed to load configuration" in normalized and "model provider" in normalized:
+        return "missing_model_provider"
+    if "model provider" in normalized and "not found" in normalized:
+        return "missing_model_provider"
     return None
 
 

{anywhere_cli-0.1.2 → anywhere_cli-0.1.3}/connector/codex/rpc.py

@@ -25,6 +25,7 @@ class JsonRpcStdioClient:
     def __init__(self, command: list[str] | None = None) -> None:
         self.command = command or _resolve_codex_command()
         self.process: asyncio.subprocess.Process | None = None
+        self._start_lock = asyncio.Lock()
         self._next_id = 1
         self._pending: dict[int | str, asyncio.Future[dict[str, Any]]] = {}
         self._server_request_ids: set[int | str] = set()
@@ -32,39 +33,40 @@ class JsonRpcStdioClient:
         self._initialized = False
 
     async def start(self, handler: NotificationHandler) -> None:
-        if self.process and self._initialized:
-            self._notification_handler = handler
-            return
+        async with self._start_lock:
+            if self.process and self._initialized:
+                self._notification_handler = handler
+                return
 
-        self._notification_handler = handler
-        if self.process is None:
-            logger.info("starting codex app-server command={}", self.command)
-            self.process = await asyncio.create_subprocess_exec(
-                *self.command,
-                stdin=asyncio.subprocess.PIPE,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE,
-                limit=APP_SERVER_STREAM_LIMIT,
-            )
-            self._track_reader(asyncio.create_task(self._read_stdout()), "stdout")
-            self._track_reader(asyncio.create_task(self._read_stderr()), "stderr")
-
-        await self.request(
-            "initialize",
-            {
-                "clientInfo": {
-                    "name": "agent-server-connector",
-                    "title": "Agent Server Connector",
-                    "version": "0.1.0",
-                },
-                "capabilities": {
-                    "experimentalApi": True,
-                    "requestAttestation": False,
+            self._notification_handler = handler
+            if self.process is None:
+                logger.info("starting codex app-server command={}", self.command)
+                self.process = await asyncio.create_subprocess_exec(
+                    *self.command,
+                    stdin=asyncio.subprocess.PIPE,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                    limit=APP_SERVER_STREAM_LIMIT,
+                )
+                self._track_reader(asyncio.create_task(self._read_stdout(self.process)), "stdout")
+                self._track_reader(asyncio.create_task(self._read_stderr(self.process)), "stderr")
+
+            await self.request(
+                "initialize",
+                {
+                    "clientInfo": {
+                        "name": "agent-server-connector",
+                        "title": "Agent Server Connector",
+                        "version": "0.1.0",
+                    },
+                    "capabilities": {
+                        "experimentalApi": True,
+                        "requestAttestation": False,
+                    },
                 },
-            },
-        )
-        await self.notify("initialized")
-        self._initialized = True
+            )
+            await self.notify("initialized")
+            self._initialized = True
 
     async def request(self, method: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
         if not self.process or not self.process.stdin:
@@ -121,9 +123,9 @@ class JsonRpcStdioClient:
             self.process = None
             self._initialized = False
 
-    async def _read_stdout(self) -> None:
-        assert self.process and self.process.stdout
-        while line := await self.process.stdout.readline():
+    async def _read_stdout(self, process: asyncio.subprocess.Process) -> None:
+        assert process.stdout
+        while line := await process.stdout.readline():
             try:
                 payload = json.loads(line)
             except json.JSONDecodeError:
@@ -142,9 +144,9 @@ class JsonRpcStdioClient:
             if self._notification_handler is not None:
                 await self._notification_handler(payload)
 
-    async def _read_stderr(self) -> None:
-        assert self.process and self.process.stderr
-        while line := await self.process.stderr.readline():
+    async def _read_stderr(self, process: asyncio.subprocess.Process) -> None:
+        assert process.stderr
+        while line := await process.stderr.readline():
             logger.trace("codex app-server stderr: {}", line.decode(errors="replace").rstrip())
 
     def _track_reader(self, task: asyncio.Task[None], name: str) -> None:

{anywhere_cli-0.1.2 → anywhere_cli-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "anywhere-cli"
-version = "0.1.2"
+version = "0.1.3"
 description = "Local runtime connector for Agents Anywhere"
 readme = "README.md"
 requires-python = ">=3.12"

{anywhere_cli-0.1.2 → anywhere_cli-0.1.3}/tests/test_codex_adapter.py

@@ -130,6 +130,21 @@ class MissingRolloutResumeRpc(FakeCodexRpc):
         return {}
 
 
+class MissingModelProviderResumeRpc(FakeCodexRpc):
+    async def request(self, method: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        self.requests.append((method, params))
+        if method == "thread/resume":
+            raise RuntimeError(
+                json.dumps(
+                    {
+                        "code": -32600,
+                        "message": "failed to load configuration: Model provider `codex` not found",
+                    }
+                )
+            )
+        return await super().request(method, params)
+
+
 def test_stdio_client_stream_limit_is_large_enough_for_codex_jsonl() -> None:
     assert APP_SERVER_STREAM_LIMIT >= 64 * 1024 * 1024
 
@@ -179,6 +194,54 @@ def test_stdio_client_includes_empty_params_for_no_arg_messages() -> None:
     asyncio.run(_exercise_stdio_client_includes_empty_params())
 
 
+class EmptyAsyncReader:
+    async def readline(self) -> bytes:
+        return b""
+
+
+class StartableFakeProcess:
+    def __init__(self) -> None:
+        self.stdin = FakeStdin()
+        self.stdout = EmptyAsyncReader()
+        self.stderr = EmptyAsyncReader()
+
+
+async def _exercise_stdio_client_start_is_serialized(monkeypatch) -> None:
+    created: list[StartableFakeProcess] = []
+    initialize_seen = asyncio.Event()
+
+    async def fake_create_subprocess_exec(*_args: str, **_kwargs: Any) -> StartableFakeProcess:
+        await asyncio.sleep(0)
+        process = StartableFakeProcess()
+        created.append(process)
+        return process
+
+    async def complete_initialize_when_written() -> None:
+        client = task_client
+        while 1 not in client._pending:  # noqa: SLF001
+            await asyncio.sleep(0)
+        client._pending[1].set_result({})  # noqa: SLF001
+        initialize_seen.set()
+
+    monkeypatch.setattr(asyncio, "create_subprocess_exec", fake_create_subprocess_exec)
+    task_client = JsonRpcStdioClient(command=["codex"])
+
+    async def handler(_payload: dict[str, Any]) -> None:
+        return None
+
+    helper = asyncio.create_task(complete_initialize_when_written())
+    await asyncio.gather(task_client.start(handler), task_client.start(handler))
+    await helper
+
+    assert initialize_seen.is_set()
+    assert len(created) == 1
+    assert task_client._initialized is True  # noqa: SLF001
+
+
+def test_stdio_client_start_is_serialized(monkeypatch) -> None:
+    asyncio.run(_exercise_stdio_client_start_is_serialized(monkeypatch))
+
+
 def test_stdio_client_ignores_response_for_cancelled_request() -> None:
     client = JsonRpcStdioClient(command=["codex"])
     loop = asyncio.new_event_loop()
@@ -992,6 +1055,10 @@ def test_adapter_treats_archived_resume_failure_as_skipped() -> None:
     asyncio.run(_exercise_archived_resume_failure_sync())
 
 
+def test_adapter_treats_missing_model_provider_as_skipped_once() -> None:
+    asyncio.run(_exercise_missing_model_provider_thread_sync())
+
+
 async def _exercise_existing_thread_sync() -> None:
     rpc = FakeCodexRpc()
     adapter = CodexAdapter(rpc=rpc)  # type: ignore[arg-type]
@@ -1071,6 +1138,21 @@ async def _exercise_archived_resume_failure_sync() -> None:
     assert result["backendNotifications"] == []
 
 
+async def _exercise_missing_model_provider_thread_sync() -> None:
+    rpc = MissingModelProviderResumeRpc()
+    adapter = CodexAdapter(rpc=rpc)  # type: ignore[arg-type]
+
+    result = await adapter.sync_existing_sessions("conn_1")
+    replay = await adapter.sync_existing_sessions("conn_1")
+
+    assert result["threads"] == []
+    assert result["skippedThreads"] == ["thr_existing"]
+    assert result["backendNotifications"] == []
+    assert replay["threads"] == []
+    assert replay["skippedThreads"] == ["thr_existing"]
+    assert rpc.requests.count(("thread/resume", {"threadId": "thr_existing"})) == 1
+
+
 async def _exercise_existing_thread_sync_timeouts(monkeypatch) -> None:
     rpc = FakeCodexRpc()
     adapter = CodexAdapter(rpc=rpc)  # type: ignore[arg-type]

{anywhere_cli-0.1.2 → anywhere_cli-0.1.3}/uv.lock

@@ -26,7 +26,7 @@ wheels = [
 
 [[package]]
 name = "anywhere-cli"
-version = "0.1.2"
+version = "0.1.3"
 source = { editable = "." }
 dependencies = [
     { name = "claude-agent-sdk" },