spawnllm 0.17.2__tar.gz → 0.17.4__tar.gz

{spawnllm-0.17.2 → spawnllm-0.17.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spawnllm
-Version: 0.17.2
+Version: 0.17.4
 Summary: Delete your subprocess wrappers around claude, codex, and gemini.
 Keywords: 
 Author: Yasyf Mohamedali

{spawnllm-0.17.2 → spawnllm-0.17.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "spawnllm"
-version = "0.17.2"
+version = "0.17.4"
 description = "Delete your subprocess wrappers around claude, codex, and gemini."
 readme = "README.md"
 license = "MIT"

{spawnllm-0.17.2 → spawnllm-0.17.4}/pyproject.toml.orig

@@ -1,7 +1,7 @@
 [project]
 name = "spawnllm"
 # Inert sentinel: the real version is set from the release tag (uv version --frozen).
-version = "0.17.2"
+version = "0.17.4"
 description = "Delete your subprocess wrappers around claude, codex, and gemini."
 readme = "README.md"
 license = "MIT"

{spawnllm-0.17.2 → spawnllm-0.17.4}/spawnllm/backends/base.py

@@ -17,6 +17,10 @@ import subprocess
 import sys
 import tempfile
 from abc import ABC, abstractmethod
+from collections.abc import Iterator
+from contextlib import contextmanager
+from contextvars import ContextVar
+from copy import deepcopy
 from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar
@@ -33,6 +37,9 @@ if TYPE_CHECKING:
     from spawnllm.types import ProviderName, TModel
 
 
+INVOCATION_PLAN: ContextVar[InvocationPlanState | None] = ContextVar("spawnllm_invocation_plan", default=None)
+
+
 @dataclass(frozen=True)
 class BackendReady:
     """A backend whose CLI is installed and authenticated.
@@ -164,6 +171,14 @@ def run_probe(probe: dict[str, Any], *, binary: str, timeout: int) -> bool:
             return False
 
 
+@dataclass(slots=True)
+class InvocationPlanState:
+    backend: LlmBackend
+    spec: RunSpec
+    value: dict[str, Any] | None = None
+    active: bool = True
+
+
 class LlmBackend(ABC):
     """Abstract execution contract for an LLM backend.
 
@@ -312,6 +327,14 @@ class LlmBackend(ABC):
 
     def core_plan(self, spec: RunSpec) -> dict[str, Any]:
         """Ask the core to plan this run's invocation (an exec argv or an HTTP request)."""
+        pending = INVOCATION_PLAN.get()
+        if pending is not None and pending.active and pending.backend is self and pending.spec is spec:
+            if pending.value is None:
+                pending.value = self._core_plan(spec)
+            return deepcopy(pending.value)
+        return self._core_plan(spec)
+
+    def _core_plan(self, spec: RunSpec) -> dict[str, Any]:
         return _core.dispatch(
             "plan", {"host": {"platform": sys.platform}, "provider": self.provider, "spec": self.wire_spec(spec)}
         )
@@ -387,6 +410,16 @@ class CliBackend(LlmBackend):
     binary: ClassVar[str]
     install_hint: ClassVar[str]
 
+    @contextmanager
+    def _reuse_plan(self, spec: RunSpec) -> Iterator[None]:
+        pending = InvocationPlanState(self, spec)
+        token = INVOCATION_PLAN.set(pending)
+        try:
+            yield
+        finally:
+            pending.active = False
+            INVOCATION_PLAN.reset(token)
+
     def binary_path(self) -> str:
         """Return the command every exec of this backend runs as `argv[0]`.
 
@@ -500,7 +533,10 @@ class CliBackend(LlmBackend):
         return Response(spec=spec, output=Output(""), error=Error(msg, TimeoutError(msg)))
 
     async def aexecute(self, spec: RunSpec) -> Response:
-        return await self.aexecute_invocation(spec, self.invocation(spec), self.env(spec))
+        with self._reuse_plan(spec):
+            inv = self.invocation(spec)
+            env = self.env(spec)
+        return await self.aexecute_invocation(spec, inv, env)
 
     async def aexecute_invocation(self, spec: RunSpec, inv: Invocation, env: dict[str, str]) -> Response:
         """Run a materialized `inv` asynchronously under `env` and resolve it, removing its temp files."""
@@ -525,7 +561,10 @@ class CliBackend(LlmBackend):
         return self.to_response(raw, returncode=rr.returncode, stderr=rr.stderr, spec=spec)
 
     def execute(self, spec: RunSpec) -> Response:
-        return self.execute_invocation(spec, self.invocation(spec), self.env(spec))
+        with self._reuse_plan(spec):
+            inv = self.invocation(spec)
+            env = self.env(spec)
+        return self.execute_invocation(spec, inv, env)
 
     def execute_invocation(self, spec: RunSpec, inv: Invocation, env: dict[str, str]) -> Response:
         """Run a materialized `inv` under `env` and resolve it, removing its temp files."""

{spawnllm-0.17.2 → spawnllm-0.17.4}/spawnllm/backends/claude.py

@@ -146,17 +146,25 @@ class ClaudeCliBackend(CliBackend):
         return self.claude_isolation(spec.api_auth).env.get("CLAUDE_CODE_OAUTH_TOKEN") not in self._rejected_tokens
 
     async def aexecute(self, spec: RunSpec) -> Response:
-        env = self.env(spec)
-        response = await self.aexecute_invocation(spec, self.invocation(spec), env)
-        while self.reject_credentials(spec, env, response):
+        with self._reuse_plan(spec):
             env = self.env(spec)
-            response = await self.aexecute_invocation(spec, self.invocation(spec), env)
+            inv = self.invocation(spec)
+        response = await self.aexecute_invocation(spec, inv, env)
+        while self.reject_credentials(spec, env, response):
+            with self._reuse_plan(spec):
+                env = self.env(spec)
+                inv = self.invocation(spec)
+            response = await self.aexecute_invocation(spec, inv, env)
         return response
 
     def execute(self, spec: RunSpec) -> Response:
-        env = self.env(spec)
-        response = self.execute_invocation(spec, self.invocation(spec), env)
-        while self.reject_credentials(spec, env, response):
+        with self._reuse_plan(spec):
             env = self.env(spec)
-            response = self.execute_invocation(spec, self.invocation(spec), env)
+            inv = self.invocation(spec)
+        response = self.execute_invocation(spec, inv, env)
+        while self.reject_credentials(spec, env, response):
+            with self._reuse_plan(spec):
+                env = self.env(spec)
+                inv = self.invocation(spec)
+            response = self.execute_invocation(spec, inv, env)
         return response

{spawnllm-0.17.2 → spawnllm-0.17.4}/spawnllm/proc.py

@@ -7,6 +7,7 @@ import contextlib
 import os
 import subprocess
 import tempfile
+import time
 from collections.abc import Awaitable, Callable, Iterator, Sequence
 from dataclasses import dataclass
 from pathlib import Path
@@ -16,6 +17,7 @@ __all__ = ["RunResult", "acapture_cli", "arun_cli", "capture_cli", "collect_proc
 # Drain stderr in fixed chunks: `StreamReader.readline` (what `async for` uses) caps a
 # line at 64 KiB and raises `LimitOverrunError` on a longer newline-free blob.
 _STDERR_CHUNK = 1 << 16
+CHECKPOINT_INTERVAL = 0.05
 
 
 @dataclass(frozen=True, slots=True)
@@ -40,6 +42,7 @@ def run_cli(
     timeout: int = 30,
     env: dict[str, str] | None = None,
     cwd: str | None = None,
+    checkpoint: Callable[[], None] | None = None,
 ) -> str:
     """Run a CLI command to completion and return its stdout.
 
@@ -49,6 +52,8 @@ def run_cli(
         timeout: Seconds to wait before the process is killed.
         env: Environment for the process; `None` inherits the current environment.
         cwd: Working directory for the process.
+        checkpoint: POSIX-only check before spawning, while waiting, and before returning.
+            An exception stops and reaps the direct child, then propagates unchanged.
 
     Returns:
         The decoded stdout.
@@ -57,16 +62,20 @@ def run_cli(
         subprocess.CalledProcessError: On a nonzero exit code, with the argv,
             exit code, and stdout/stderr tails attached as notes.
         subprocess.TimeoutExpired: When the process outlives `timeout`.
+        NotImplementedError: When a checkpoint is requested on a non-POSIX platform.
     """
-    result = subprocess.run(
-        argv,
-        input=input,
-        capture_output=True,
-        text=True,
-        timeout=timeout,
-        env=env,
-        cwd=cwd,
-    )
+    if checkpoint is None:
+        result = subprocess.run(
+            argv,
+            input=input,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            env=env,
+            cwd=cwd,
+        )
+    else:
+        result = cancellable_cli(argv, input=input, timeout=timeout, env=env, cwd=cwd, checkpoint=checkpoint)
     if result.returncode != 0:
         err = subprocess.CalledProcessError(result.returncode, argv, output=result.stdout, stderr=result.stderr)
         err.add_note(f"argv: {argv}")
@@ -77,6 +86,49 @@ def run_cli(
     return result.stdout
 
 
+def cancellable_cli(
+    argv: list[str],
+    *,
+    input: str | None,
+    timeout: int,
+    env: dict[str, str] | None,
+    cwd: str | None,
+    checkpoint: Callable[[], None],
+) -> subprocess.CompletedProcess[str]:
+    if os.name != "posix":
+        raise NotImplementedError("CLI cancellation checkpoints require POSIX")
+    checkpoint()
+    with subprocess.Popen(
+        argv,
+        stdin=subprocess.PIPE if input is not None else None,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        env=env,
+        cwd=cwd,
+    ) as child:
+        deadline = time.monotonic() + timeout
+        partial = subprocess.TimeoutExpired(argv, timeout)
+        payload = input
+        try:
+            while True:
+                checkpoint()
+                if (remaining := deadline - time.monotonic()) <= 0:
+                    raise subprocess.TimeoutExpired(argv, timeout, output=partial.output, stderr=partial.stderr)
+                try:
+                    stdout, stderr = child.communicate(input=payload, timeout=min(CHECKPOINT_INTERVAL, remaining))
+                except subprocess.TimeoutExpired as expired:
+                    partial = expired
+                else:
+                    checkpoint()
+                    return subprocess.CompletedProcess(argv, child.wait(), stdout, stderr)
+                payload = None
+        except BaseException:
+            child.kill()
+            child.wait()
+            raise
+
+
 def capture_cli(
     argv: list[str],
     *,