spawnllm 0.14.0__tar.gz → 0.16.0__tar.gz

{spawnllm-0.14.0 → spawnllm-0.16.0}/PKG-INFO

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

{spawnllm-0.14.0 → spawnllm-0.16.0}/pyproject.toml

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

{spawnllm-0.14.0 → spawnllm-0.16.0}/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.14.0"
+version = "0.16.0"
 description = "Delete your subprocess wrappers around claude, codex, and gemini."
 readme = "README.md"
 license = "MIT"

{spawnllm-0.14.0 → spawnllm-0.16.0}/spawnllm/backends/base.py

@@ -396,7 +396,7 @@ class CliBackend(LlmBackend):
         """
         return self.binary
 
-    def claude_isolation(self) -> ClaudeIsolation:
+    def claude_isolation(self, api_auth: bool) -> ClaudeIsolation:
         """Return the config home a claude run substitutes into `${isolated_config_dir}` and the env it adds."""
         raise NotImplementedError
 
@@ -436,7 +436,7 @@ class CliBackend(LlmBackend):
             argv = [tokens.get(arg, arg) for arg in plan["argv"]]
             env = plan["env"]
             if plan["needs_claude_isolation"]:
-                isolation = self.claude_isolation()
+                isolation = self.claude_isolation(spec.api_auth)
                 argv = [arg.replace("${isolated_config_dir}", isolation.config_dir) for arg in argv]
                 env = {
                     key: value.replace("${isolated_config_dir}", isolation.config_dir) for key, value in env.items()
@@ -468,7 +468,7 @@ class CliBackend(LlmBackend):
         plan = self.core_plan(spec)
         if not plan["needs_claude_isolation"]:
             return plan["env"]
-        isolation = self.claude_isolation()
+        isolation = self.claude_isolation(spec.api_auth)
         return {
             key: value.replace("${isolated_config_dir}", isolation.config_dir) for key, value in plan["env"].items()
         } | isolation.env

{spawnllm-0.14.0 → spawnllm-0.16.0}/spawnllm/backends/claude.py

@@ -63,8 +63,9 @@ class ClaudeCliBackend(CliBackend):
     schema_dialect: ClassVar[str | None] = "anthropic"
 
     _isolated_config_dir: str | None = None
+    _api_config_dir: str | None = None
 
-    def claude_isolation(self) -> ClaudeIsolation:
+    def claude_isolation(self, api_auth: bool) -> ClaudeIsolation:
         """Return the isolation for one run: the process-lifetime config home and the env resolved now.
 
         The core's `claude_isolation_sources` op resolves the account pointer,
@@ -76,7 +77,9 @@ class ClaudeCliBackend(CliBackend):
         to set. The files land in a fresh temp dir removed at interpreter exit,
         created on the first call and cached on the backend; the env is resolved
         on every call so a renewed Keychain token reaches the next run, and it
-        only ever lives in memory.
+        only ever lives in memory. An `api_auth` run names no source at all, so it
+        reads no account, credentials file, or Keychain item and gets an empty home
+        of its own.
         """
         sources = _core.dispatch(
             "claude_isolation_sources",
@@ -88,22 +91,28 @@ class ClaudeCliBackend(CliBackend):
                     "claude_securestorage_config_dir_env": os.environ.get("CLAUDE_SECURESTORAGE_CONFIG_DIR"),
                     "claude_code_custom_oauth_url_env": os.environ.get("CLAUDE_CODE_CUSTOM_OAUTH_URL"),
                     "claude_code_oauth_token_env": os.environ.get("CLAUDE_CODE_OAUTH_TOKEN"),
-                }
+                },
+                "api_auth": api_auth,
             },
         )
-        account_json = read_file_opt(sources["account_path"])
+        account_json = read_file_opt(sources["account_path"]) if sources["account_path"] else None
         credentials_json = read_file_opt(sources["credentials_path"]) if sources["credentials_path"] else None
         if credentials_json is None and sources["keychain_service"] is not None:
             credentials_json = keychain_credentials(sources["keychain_service"])
         seed = _core.dispatch(
             "claude_isolation_seed", {"account_json": account_json, "credentials_json": credentials_json}
         )
-        if self._isolated_config_dir is None:
+        cached = self._api_config_dir if api_auth else self._isolated_config_dir
+        if cached is None:
             config_dir = Path(tempfile.mkdtemp(prefix="spawnllm-claude-config-"))
             for file in seed["files"]:
                 fd = os.open(config_dir / file["name"], os.O_WRONLY | os.O_CREAT | os.O_EXCL, int(file["mode"], 8))
                 with os.fdopen(fd, "w") as handle:
                     handle.write(file["content"])
             atexit.register(shutil.rmtree, config_dir, ignore_errors=True)
-            self._isolated_config_dir = str(config_dir)
-        return ClaudeIsolation(self._isolated_config_dir, seed["env"])
+            cached = str(config_dir)
+            if api_auth:
+                self._api_config_dir = cached
+            else:
+                self._isolated_config_dir = cached
+        return ClaudeIsolation(cached, seed["env"])

{spawnllm-0.14.0 → spawnllm-0.16.0}/spawnllm/backends/codex.py

@@ -29,8 +29,8 @@ class CodexCliBackend(CliBackend):
     """
 
     models: ClassVar[dict[TModel, str]] = {
-        "small": "gpt-5.6-luna:low",
-        "medium": "gpt-5.6-luna:medium",
+        "small": "gpt-6-luna:low",
+        "medium": "gpt-6-luna:medium",
         "large": "gpt-5.5:medium",
     }
     provider: ClassVar[ProviderName] = "codex"

{spawnllm-0.14.0 → spawnllm-0.16.0}/spawnllm/spec.py

@@ -105,10 +105,16 @@ class CodexConfig:
     user-level tier pin applies only with `isolated=False`. `developer_instructions` injects
     the system-prompt layer via `-c developer_instructions=<value>`, serialized as
     a TOML string so any text — multi-line, or TOML-ambiguous words like `true` —
-    arrives as a string.
+    arrives as a string. `bypass_approvals_and_sandbox` replaces `--sandbox` with
+    `--dangerously-bypass-approvals-and-sandbox` for a host that is already
+    externally sandboxed; it cannot be combined with `sandbox`.
 
     Example:
         >>> CodexConfig(sandbox="read-only", enable_mcp=True)
+
+    Raises:
+        ValueError: When `bypass_approvals_and_sandbox` is set together with a
+            `sandbox`, two policies the CLI cannot apply at once.
     """
 
     sandbox: str | None = None
@@ -116,6 +122,11 @@ class CodexConfig:
     enable_mcp: bool = False
     service_tier: str | None = "fast"
     developer_instructions: str | None = None
+    bypass_approvals_and_sandbox: bool = False
+
+    def __post_init__(self) -> None:
+        if self.bypass_approvals_and_sandbox and self.sandbox is not None:
+            raise ValueError("CodexConfig accepts either sandbox or bypass_approvals_and_sandbox, not both")
 
 
 @dataclass(frozen=True, slots=True)