spawnllm 0.5.0__tar.gz → 0.5.2__tar.gz

{spawnllm-0.5.0 → spawnllm-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spawnllm
-Version: 0.5.0
+Version: 0.5.2
 Summary: Subshell + MLX LLM-calling backends (Claude/Codex CLI, local MLX) shared across tools.
 Keywords: 
 Author: Yasyf Mohamedali

{spawnllm-0.5.0 → spawnllm-0.5.2}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "spawnllm"
 # Inert sentinel: the real version is set from the release tag (uv version --frozen).
-version = "0.5.0"
+version = "0.5.2"
 description = "Subshell + MLX LLM-calling backends (Claude/Codex CLI, local MLX) shared across tools."
 readme = "README.md"
 license = "MIT"

{spawnllm-0.5.0 → spawnllm-0.5.2}/spawnllm/__init__.py

@@ -28,7 +28,7 @@ from spawnllm.backends import (
 )
 from spawnllm.call import call, call_sync
 from spawnllm.extract import extract, extract_sync
-from spawnllm.response import Response
+from spawnllm.response import Error, Output, Response, Result
 from spawnllm.run import run, run_sync
 from spawnllm.spec import ClaudeConfig, CodexConfig, GeminiConfig, RunSpec
 from spawnllm.types import ProviderName, TModel, TSpecialty
@@ -46,13 +46,16 @@ __all__ = [
     "CliBackend",
     "CodexCliBackend",
     "CodexConfig",
+    "Error",
     "GeminiCliBackend",
     "GeminiConfig",
     "LlmBackend",
     "LlmBackends",
     "MlxBackend",
+    "Output",
     "ProviderName",
     "Response",
+    "Result",
     "RunSpec",
     "TModel",
     "TSpecialty",

{spawnllm-0.5.0 → spawnllm-0.5.2}/spawnllm/backends/base.py

@@ -5,13 +5,14 @@ from __future__ import annotations
 import json
 import os
 import shutil
+import subprocess
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING, ClassVar
 
 from spawnllm.proc import acapture_cli, capture_cli
-from spawnllm.response import Response
+from spawnllm.response import Error, Output, Response, Result
 
 if TYPE_CHECKING:
     from pydantic import BaseModel
@@ -66,14 +67,9 @@ class BackendUnavailable(RuntimeError):
 class BackendCallError(RuntimeError):
     """Raised by `call`/`extract` when a backend returns a provider error.
 
-    Carries the backend's error string (a nonzero exit with stderr, or an error
-    envelope), attached both as the message and as a note for tracebacks.
+    Carries the backend's error string: a nonzero exit with stderr, or an error envelope.
     """
 
-    def __init__(self, error: str) -> None:
-        super().__init__(error)
-        self.add_note(error)
-
 
 @dataclass(frozen=True)
 class Invocation:
@@ -133,8 +129,13 @@ class LlmBackend(ABC):
         """
 
     @abstractmethod
-    def env(self) -> dict[str, str]:
-        """Return extra environment variables for the invocation, merged over the inherited environment."""
+    def env(self, spec: RunSpec) -> dict[str, str]:
+        """Return extra environment variables for the invocation, merged over the inherited environment.
+
+        Args:
+            spec: The configured run, so a backend can scope env overrides to
+                `spec.isolated` (e.g. a fresh config home only when isolating).
+        """
 
     @abstractmethod
     def is_authenticated(self, *, timeout: int) -> bool:
@@ -177,35 +178,59 @@ class LlmBackend(ABC):
         return json.dumps(model.model_json_schema())
 
     def schema_arg(self, spec: RunSpec) -> str | None:
-        """Return the JSON-schema string for `spec`'s `response_model`, or `None` when absent."""
-        return self.schema_for(spec.response_model) if spec.response_model is not None else None
+        """Return the JSON-schema string for `spec`, from a `response_model` or a raw `schema`.
+
+        A `response_model` is run through `schema_for` (the provider's
+        strict-schema transform); a raw `schema` passes verbatim — a dict is
+        `json.dumps`'d, a string is returned unchanged. Returns `None` when
+        neither is set.
+
+        Args:
+            spec: The configured run, carrying the optional `response_model` or `schema`.
+
+        Returns:
+            The JSON-schema string for this backend's structured-output argument, or `None`.
+        """
+        if spec.response_model is not None:
+            return self.schema_for(spec.response_model)
+        if spec.schema is not None:
+            return json.dumps(spec.schema) if isinstance(spec.schema, dict) else spec.schema
+        return None
 
     def to_response(self, raw: str, *, returncode: int, stderr: str, spec: RunSpec) -> Response:
-        """Resolve a raw capture into a `Response`: detect failure, extract text, validate.
+        """Resolve a raw capture into a structured `Response`: detect failure, extract text, validate.
 
-        A nonzero exit or an error envelope becomes `Response.error`; otherwise
-        the text comes from `result_text` and, when `spec.response_model` is set,
-        the validated model from `result_value`. A `pydantic.ValidationError`
-        from a non-conforming model propagates.
+        `output` always carries the full raw stream. A nonzero exit, an error
+        envelope, or a `pydantic.ValidationError` from a non-conforming model all
+        route through `error` (with the underlying exception preserved in
+        `error.ex`) and leave `result` as `None`; a success yields `result` (text
+        from `result_text`, plus the validated model from `result_value` when
+        `spec.response_model` is set) and `error` as `None`.
 
         Args:
             raw: The raw output read wherever the provider wrote it.
             returncode: The process exit code.
             stderr: The captured stderr.
-            spec: The configured run, carrying the optional `response_model`.
+            spec: The configured run, carrying the optional `response_model` or `schema`.
 
         Returns:
             The resolved `Response`.
         """
+        import pydantic
+
+        output = Output(raw)
         if returncode != 0:
-            return Response(error=f"{self.provider} exited {returncode}: {stderr.strip()[-2000:]}", result=None)
+            msg = f"{self.provider} exited {returncode}: {stderr.strip()[-2000:]}"
+            return Response(spec=spec, output=output, error=Error(msg, BackendCallError(msg)))
         if (err := self.envelope_error(raw)) is not None:
-            return Response(error=err, result=None)
+            return Response(spec=spec, output=output, error=Error(err, BackendCallError(err)))
         if spec.response_model is None:
-            return Response(error=None, result=self.result_text(raw))
-        return Response(
-            error=None, result=self.result_text(raw), parsed=spec.response_model.model_validate(self.result_value(raw))
-        )
+            return Response(spec=spec, output=output, result=Result(raw=self.result_text(raw)))
+        try:
+            parsed = spec.response_model.model_validate(self.result_value(raw))
+        except pydantic.ValidationError as e:
+            return Response(spec=spec, output=output, error=Error(str(e), e))
+        return Response(spec=spec, output=output, result=Result(raw=self.result_text(raw), parsed=parsed))
 
     def result_text(self, raw: str) -> str:
         """Return the final text output from a raw capture; the default is `raw` unchanged."""
@@ -261,16 +286,23 @@ class CliBackend(LlmBackend):
         """
         return Invocation(self.build_command(spec), spec.prompt)
 
+    def timed_out(self, spec: RunSpec) -> Response:
+        msg = f"{self.provider} timed out after {spec.timeout}s"
+        return Response(spec=spec, output=Output(""), error=Error(msg, TimeoutError(msg)))
+
     async def aexecute(self, spec: RunSpec) -> Response:
         inv = self.invocation(spec)
         try:
-            rr = await acapture_cli(
-                inv.argv,
-                input=inv.stdin,
-                env=os.environ | self.env() | (spec.env or {}),
-                cwd=spec.cwd,
-                timeout=spec.timeout,
-            )
+            try:
+                rr = await acapture_cli(
+                    inv.argv,
+                    input=inv.stdin,
+                    env=os.environ | self.env(spec) | (spec.env or {}),
+                    cwd=spec.cwd,
+                    timeout=spec.timeout,
+                )
+            except TimeoutError:
+                return self.timed_out(spec)
             raw = Path(inv.result_path).read_text() if inv.result_path else rr.stdout
         finally:
             for path in inv.cleanup_paths:
@@ -280,13 +312,16 @@ class CliBackend(LlmBackend):
     def execute(self, spec: RunSpec) -> Response:
         inv = self.invocation(spec)
         try:
-            rr = capture_cli(
-                inv.argv,
-                input=inv.stdin,
-                env=os.environ | self.env() | (spec.env or {}),
-                cwd=spec.cwd,
-                timeout=spec.timeout,
-            )
+            try:
+                rr = capture_cli(
+                    inv.argv,
+                    input=inv.stdin,
+                    env=os.environ | self.env(spec) | (spec.env or {}),
+                    cwd=spec.cwd,
+                    timeout=spec.timeout,
+                )
+            except subprocess.TimeoutExpired:
+                return self.timed_out(spec)
             raw = Path(inv.result_path).read_text() if inv.result_path else rr.stdout
         finally:
             for path in inv.cleanup_paths:

{spawnllm-0.5.0 → spawnllm-0.5.2}/spawnllm/backends/claude.py

@@ -2,8 +2,12 @@
 
 from __future__ import annotations
 
+import atexit
 import json
+import shutil
 import subprocess
+import tempfile
+from pathlib import Path
 from typing import TYPE_CHECKING, ClassVar
 
 from spawnllm.backends.base import CliBackend
@@ -58,6 +62,8 @@ class ClaudeCliBackend(CliBackend):
     binary: ClassVar[str] = "claude"
     install_hint: ClassVar[str] = "curl -fsSL https://claude.ai/install.sh | bash"
 
+    _isolated_config_dir: str | None = None
+
     def build_command(self, spec: RunSpec) -> list[str]:
         """Build the `claude -p` argv for one stdin-prompted invocation.
 
@@ -84,11 +90,12 @@ class ClaudeCliBackend(CliBackend):
             "--no-session-persistence",
             "--model",
             spec.model,
+            *(["--setting-sources", ""] if spec.isolated else []),
+            *(["--strict-mcp-config"] if spec.isolated or cfg.strict_mcp else []),
             *(
                 [
                     *(["--permission-mode", cfg.permission_mode] if cfg.permission_mode is not None else []),
                     *(["--mcp-config", cfg.mcp_config] if cfg.mcp_config is not None else []),
-                    *(["--strict-mcp-config"] if cfg.strict_mcp else []),
                     *(["--disallowedTools", *cfg.disallowed_tools] if cfg.disallowed_tools else []),
                     *(
                         ["--append-system-prompt", cfg.append_system_prompt]
@@ -101,7 +108,7 @@ class ClaudeCliBackend(CliBackend):
                 if explicit
                 else ["--permission-mode", "auto", "--max-budget-usd", "1"]
                 if spec.agent
-                else ["--system-prompt", "", "--setting-sources", "", "--strict-mcp-config"]
+                else ["--system-prompt", ""]
             ),
             *(["--system-prompt", cfg.system_prompt] if cfg.system_prompt is not None else []),
             *(["--max-turns", str(cfg.max_turns)] if cfg.max_turns is not None else []),
@@ -150,11 +157,50 @@ class ClaudeCliBackend(CliBackend):
             return event["result"] if isinstance(event.get("result"), str) else "claude reported an error"
         return None
 
-    def env(self) -> dict[str, str]:
-        """Return no extra environment variables; the `claude` CLI runs with the inherited environment."""
-        # CLAUDE_CODE_SIMPLE=1 breaks claude.ai keychain auth ("Not logged in")
-        # on current CLIs; --setting-sources ""/--strict-mcp-config already trim startup.
-        return {}
+    def env(self, spec: RunSpec) -> dict[str, str]:
+        """Point an isolated run at a fresh, host-free `CLAUDE_CONFIG_DIR`; otherwise add nothing.
+
+        Defense in depth behind the argv flags: a config home seeded with nothing
+        but the account pointer and OAuth token means plugin and
+        `~/.claude.json`-driven loading finds no host settings, plugins, or hooks
+        even if a flag is ever dropped.
+
+        Args:
+            spec: The configured run; `spec.isolated` gates the override.
+
+        Returns:
+            `{"CLAUDE_CONFIG_DIR": <isolated dir>}` for an isolated run, else `{}`.
+        """
+        if not spec.isolated:
+            return {}
+        return {"CLAUDE_CONFIG_DIR": self._isolated_dir()}
+
+    def _isolated_dir(self) -> str:
+        """Return the process-lifetime isolated config home, creating and seeding it once.
+
+        The home is a fresh temp dir seeded with only the two auth-bearing files:
+        `~/.claude.json` minus its `mcpServers` block (the active-account pointer,
+        with no host MCP servers leaking even absent `--strict-mcp-config`) and
+        `~/.claude/.credentials.json` (the claude.ai OAuth token, which lives in
+        the config home — relocating it without this copy logs the run out). Host
+        `settings.json`, plugins, and hooks are never copied. The dir is cached on
+        the backend and removed at interpreter exit.
+        """
+        if self._isolated_config_dir is not None:
+            return self._isolated_config_dir
+        config_dir = Path(tempfile.mkdtemp(prefix="spawnllm-claude-config-"))
+        home = Path.home()
+        account_path = home / ".claude.json"
+        if account_path.exists():
+            account = json.loads(account_path.read_text())
+            account.pop("mcpServers", None)
+            (config_dir / ".claude.json").write_text(json.dumps(account))
+        credentials_path = home / ".claude" / ".credentials.json"
+        if credentials_path.exists():
+            shutil.copyfile(credentials_path, config_dir / ".credentials.json")
+        atexit.register(shutil.rmtree, config_dir, ignore_errors=True)
+        self._isolated_config_dir = str(config_dir)
+        return self._isolated_config_dir
 
     def is_authenticated(self, *, timeout: int) -> bool:
         """Report whether `claude auth status` exits cleanly, i.e. a claude.ai login is stored.

{spawnllm-0.5.0 → spawnllm-0.5.2}/spawnllm/backends/codex.py

@@ -36,9 +36,9 @@ class CodexCliBackend(CliBackend):
     """
 
     models: ClassVar[dict[TModel, str]] = {
-        "small": "gpt-5.3-codex-spark",
-        "medium": "gpt-5.4-mini",
-        "large": "gpt-5.5",
+        "small": "gpt-5.4-mini:low",
+        "medium": "gpt-5.4-mini:medium",
+        "large": "gpt-5.5:medium",
     }
     provider: ClassVar[ProviderName] = "codex"
     binary: ClassVar[str] = "codex"
@@ -63,6 +63,7 @@ class CodexCliBackend(CliBackend):
 
     def command_for(self, spec: RunSpec, schema_path: str | None) -> list[str]:
         cfg = spec.config_for(CodexConfig) or CodexConfig()
+        model, _, effort = spec.model.partition(":")
         return [
             "codex",
             "exec",
@@ -70,12 +71,14 @@ class CodexCliBackend(CliBackend):
             "--sandbox",
             cfg.sandbox or "read-only",
             "--model",
-            spec.model,
+            model,
+            *(["-c", f"model_reasoning_effort={effort}"] if effort else []),
+            *(["--ignore-user-config"] if spec.isolated else []),
             *(
                 []
                 if spec.agent
                 else [
-                    *([] if cfg.enable_hooks else ["-c", "features.codex_hooks=false"]),
+                    *([] if cfg.enable_hooks else ["-c", "features.hooks=false"]),
                     *([] if cfg.enable_mcp else ["-c", "features.mcp_servers=false"]),
                 ]
             ),
@@ -125,8 +128,13 @@ class CodexCliBackend(CliBackend):
 
         return json.dumps(to_strict_json_schema(model))
 
-    def env(self) -> dict[str, str]:
-        """Return no extra environment variables; the `codex` CLI runs with the inherited environment."""
+    def env(self, _spec: RunSpec) -> dict[str, str]:
+        """Return no extra environment variables; `--ignore-user-config` isolates config while `CODEX_HOME` keeps auth.
+
+        `codex` keeps `auth.json` in `CODEX_HOME`, so relocating it would strand a
+        single-use OAuth refresh token; the `--ignore-user-config` flag isolates
+        `config.toml` without touching auth.
+        """
         return {}
 
     def is_authenticated(self, *, timeout: int) -> bool:

{spawnllm-0.5.0 → spawnllm-0.5.2}/spawnllm/backends/gemini.py

@@ -30,8 +30,13 @@ class GeminiFamilyBackend(CliBackend, ABC):
 
     api_key_envs: ClassVar[tuple[str, ...]]
 
-    def env(self) -> dict[str, str]:
-        """Return no extra environment variables; Gemini-family CLIs authenticate via OAuth, not an injected key."""
+    def env(self, _spec: RunSpec) -> dict[str, str]:
+        """Return no extra environment variables.
+
+        Gemini-family CLIs read settings and OAuth from the same config home (`~/.gemini`,
+        `~/.gemini/antigravity-cli`), with no isolation flag and no way to relocate config
+        without stranding auth, so isolated runs read the real config — the no-flag exception.
+        """
         return {}
 
     def is_authenticated(self, *, timeout: int) -> bool:

{spawnllm-0.5.0 → spawnllm-0.5.2}/spawnllm/backends/mlx.py

@@ -52,8 +52,8 @@ class MlxBackend(LlmBackend):
         """Return the `structured_output` from a stream-json result event, else `raw` parsed as JSON."""
         return structured_value(raw)
 
-    def env(self) -> dict[str, str]:
-        """Return no extra environment variables; MLX runs in-process."""
+    def env(self, _spec: RunSpec) -> dict[str, str]:
+        """Return no extra environment variables; MLX runs in-process with nothing to isolate."""
         return {}
 
     def is_authenticated(self, *, timeout: int) -> bool:

{spawnllm-0.5.0 → spawnllm-0.5.2}/spawnllm/backends/registry.py

@@ -55,7 +55,9 @@ def select_backend(*, specialty: TSpecialty | None = None, timeout: int = 10) ->
     """Return the first installed, authenticated backend in priority order.
 
     A `specialty`, when given, promotes its registered backend to the front of
-    the chain; the chain otherwise follows `PRIORITY`. The first backend whose
+    the chain; the chain otherwise follows `PRIORITY`, minus `GeminiCliBackend`
+    (its Code Assist OAuth tier is retired, so it reports ready yet fails at call
+    time — reach it only via an explicit `backend=`). The first backend whose
     `check_status` reports `BackendReady` wins, short-circuiting the rest;
     backends that time out are skipped.
 
@@ -71,7 +73,8 @@ def select_backend(*, specialty: TSpecialty | None = None, timeout: int = 10) ->
     """
     preferred = [LlmBackends.LLM_BACKENDS[specialty]] if specialty else []
     seen = {type(b) for b in preferred}
-    for backend in (*preferred, *(b for b in PRIORITY if type(b) not in seen)):
+    auto = (b for b in PRIORITY if type(b) not in seen and not isinstance(b, GeminiCliBackend))
+    for backend in (*preferred, *auto):
         try:
             if isinstance(backend.check_status(timeout=timeout), BackendReady):
                 return backend

{spawnllm-0.5.0 → spawnllm-0.5.2}/spawnllm/call.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from spawnllm.backends.base import BackendCallError
 from spawnllm.backends.registry import select_backend
 from spawnllm.run import run, run_sync
 from spawnllm.spec import RunSpec
@@ -54,8 +53,8 @@ async def call(
         RunSpec(prompt=prompt, model=backend.models[model], agent=agent, cwd=cwd, timeout=timeout), backend=backend
     )
     if resp.error is not None:
-        raise BackendCallError(resp.error)
-    return resp.result
+        raise resp.error.ex
+    return resp.result.raw
 
 
 def call_sync(
@@ -96,5 +95,5 @@ def call_sync(
         RunSpec(prompt=prompt, model=backend.models[model], agent=agent, cwd=cwd, timeout=timeout), backend=backend
     )
     if resp.error is not None:
-        raise BackendCallError(resp.error)
-    return resp.result
+        raise resp.error.ex
+    return resp.result.raw

{spawnllm-0.5.0 → spawnllm-0.5.2}/spawnllm/extract.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, cast
 
-from spawnllm.backends.base import BackendCallError
 from spawnllm.backends.registry import select_backend
 from spawnllm.run import run, run_sync
 from spawnllm.spec import RunSpec
@@ -66,8 +65,8 @@ async def extract[T: BaseModel](
     )
     resp = await run(spec, backend=backend)
     if resp.error is not None:
-        raise BackendCallError(resp.error)
-    return cast(T, resp.parsed)
+        raise resp.error.ex
+    return cast(T, resp.result.parsed)
 
 
 def extract_sync[T: BaseModel](
@@ -118,5 +117,5 @@ def extract_sync[T: BaseModel](
     )
     resp = run_sync(spec, backend=backend)
     if resp.error is not None:
-        raise BackendCallError(resp.error)
-    return cast(T, resp.parsed)
+        raise resp.error.ex
+    return cast(T, resp.result.parsed)

spawnllm-0.5.2/spawnllm/response.py

@@ -0,0 +1,78 @@
+"""The structured object every backend hands back: spec, raw output, result, and error."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pydantic import BaseModel
+
+    from spawnllm.spec import RunSpec
+
+
+@dataclass(frozen=True, slots=True)
+class Error:
+    """A failed run: a human-readable message plus the underlying exception.
+
+    `ex` preserves the real exception so a caller can re-raise it unchanged —
+    a `BackendCallError` for a nonzero exit or error envelope, a normalized
+    timeout error, or a `pydantic.ValidationError` for a non-conforming model.
+
+    Example:
+        >>> Error(msg="codex exited 127: codex: not found", ex=RuntimeError("..."))
+    """
+
+    msg: str
+    ex: Exception
+
+
+@dataclass(frozen=True, slots=True)
+class Result:
+    """A successful run: the extracted final text and the optional validated model.
+
+    `raw` is the extracted final text; `parsed` is the validated model, set only
+    when the `RunSpec` carried a `response_model`.
+
+    Example:
+        >>> Result(raw="hello", parsed=None)
+    """
+
+    raw: str
+    parsed: BaseModel | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class Output:
+    """The full unparsed transport stream, present on success and failure alike.
+
+    `raw` is the complete output the provider wrote — the `claude
+    --output-format json` event stream, the `codex -o` file, or plain stdout —
+    before any extraction.
+
+    Example:
+        >>> Output(raw='[{"type": "system"}, {"type": "result", "result": "hi"}]')
+    """
+
+    raw: str
+
+
+@dataclass(frozen=True, slots=True)
+class Response:
+    """A backend's fully-resolved outcome: the spec, the raw output, and exactly one of result/error.
+
+    A backend runs the process, reads its output wherever the provider writes it,
+    detects failure, and validates — then hands back one `Response`. `spec` and
+    `output` are always present (the raw bytes live in `output.raw` even on
+    failure); exactly one of `result`/`error` is set. Every failure — a nonzero
+    exit, an error envelope, a timeout, or a validation error — routes through
+    `error`, never a raise from `run`.
+
+    Example:
+        >>> Response(spec=spec, output=Output(raw="hi"), result=Result(raw="hi"))
+    """
+
+    spec: RunSpec
+    output: Output
+    result: Result | None = None
+    error: Error | None = None

{spawnllm-0.5.0 → spawnllm-0.5.2}/spawnllm/run.py

@@ -23,8 +23,9 @@ async def run(spec: RunSpec, *, backend: LlmBackend | None = None) -> Response:
     Each attempt runs through `backend.aexecute`; a transient `Response.error`
     (a 529, overloaded, rate-limit, or `5xx`) triggers a capped exponential
     backoff and another attempt, up to `spec.max_attempts`. The final `Response`
-    — success or last transient failure — is returned without raising. A
-    `pydantic.ValidationError` from the backend's validate propagates.
+    — success or last failure — is returned without raising; every operational
+    failure (nonzero exit, error envelope, timeout, validation) lives in
+    `resp.error`.
 
     Args:
         spec: The configured run to execute.

{spawnllm-0.5.0 → spawnllm-0.5.2}/spawnllm/spec.py

@@ -75,7 +75,12 @@ class RunSpec:
     Common fields are interpreted by every backend; `provider_configs` carries
     optional per-provider flag passthrough that only the matching backend reads.
     `model` is a literal provider model id (`opus`, `sonnet`, …) passed straight
-    through with no tier mapping.
+    through with no tier mapping. `isolated` (default `True`) runs the backend
+    against a fresh, host-free config home so a spawned CLI ignores ambient
+    settings, MCP servers, and hooks. Structured output comes from either a
+    `response_model` (validated to a model) or a raw `schema` (a JSON-Schema dict
+    or pre-serialized string, passed to the provider verbatim, with nothing to
+    validate); setting both raises `ValueError`.
 
     Example:
         >>> RunSpec(prompt="ping", model="opus")
@@ -84,13 +89,19 @@ class RunSpec:
     prompt: str
     model: str
     response_model: type[BaseModel] | None = None
+    schema: dict[str, object] | str | None = None
     agent: bool = False
+    isolated: bool = True
     cwd: str | None = None
     env: dict[str, str] | None = None
     timeout: int = 180
     max_attempts: int = 5
     provider_configs: dict[ProviderName, ProviderConfig] = field(default_factory=dict)
 
+    def __post_init__(self) -> None:
+        if self.response_model is not None and self.schema is not None:
+            raise ValueError("RunSpec accepts either response_model or schema, not both")
+
     def config_for[T: ProviderConfig](self, kind: type[T]) -> T | None:
         """Return the first provider config that is an instance of `kind`, or None."""
         return next((c for c in self.provider_configs.values() if isinstance(c, kind)), None)

{spawnllm-0.5.0 → spawnllm-0.5.2}/spawnllm/structured.py

@@ -92,7 +92,7 @@ def structured_value(raw: str) -> object:
 def is_transient(resp: Response) -> bool:
     """Report whether a response failed with a retryable transient error.
 
-    A response is transient iff it carries an `error` whose text matches the
+    A response is transient iff it carries an `error` whose message matches the
     `TRANSIENT` pattern (529, overloaded, rate-limit, or any `5xx`).
 
     Args:
@@ -101,7 +101,7 @@ def is_transient(resp: Response) -> bool:
     Returns:
         `True` when the response should be retried.
     """
-    return resp.error is not None and bool(TRANSIENT.search(resp.error))
+    return resp.error is not None and bool(TRANSIENT.search(resp.error.msg))
 
 
 def backoff(attempt: int) -> float:

spawnllm-0.5.0/spawnllm/response.py

@@ -1,29 +0,0 @@
-"""The single object every backend hands back: error, text, and validated model."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from pydantic import BaseModel
-
-
-@dataclass(frozen=True, slots=True)
-class Response:
-    """A backend's fully-resolved outcome: the provider error, the text, and the model.
-
-    A backend runs the process, reads its output wherever the provider writes it,
-    detects failure, and validates — then hands back one `Response`. No
-    subprocess plumbing escapes: `error` carries the provider failure (a nonzero
-    exit with stderr, or an error envelope) and is `None` on success; `result`
-    is the final text output; `parsed` is the validated model, set only when the
-    `RunSpec` carried a `response_model`.
-
-    Example:
-        >>> Response(error=None, result="hello", parsed=None)
-    """
-
-    error: str | None
-    result: str | None
-    parsed: BaseModel | None = None