spawnllm 0.6.0__tar.gz → 0.6.2__tar.gz

{spawnllm-0.6.0 → spawnllm-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spawnllm
-Version: 0.6.0
+Version: 0.6.2
 Summary: Delete your subprocess wrappers around claude, codex, and gemini.
 Keywords: 
 Author: Yasyf Mohamedali
@@ -14,6 +14,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Typing :: Typed
 Requires-Dist: click>=8
+Requires-Dist: httpx>=0.27
 Requires-Dist: loguru>=0.7
 Requires-Dist: pydantic>=2
 Requires-Dist: openai>=2.43

{spawnllm-0.6.0 → spawnllm-0.6.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.6.0"
+version = "0.6.2"
 description = "Delete your subprocess wrappers around claude, codex, and gemini."
 readme = "README.md"
 license = "MIT"
@@ -19,6 +19,7 @@ classifiers = [
 requires-python = ">=3.13"
 dependencies = [
     "click>=8",
+    "httpx>=0.27",
     "loguru>=0.7",
     "pydantic>=2",
     # Per-backend strict-schema transforms: openai.lib._pydantic.to_strict_json_schema

{spawnllm-0.6.0 → spawnllm-0.6.2}/spawnllm/__init__.py

@@ -24,6 +24,7 @@ from spawnllm.backends import (
     LlmBackend,
     LlmBackends,
     MlxBackend,
+    OpenAiEndpointBackend,
     select_backend,
 )
 from spawnllm.call import call, call_sync
@@ -53,6 +54,7 @@ __all__ = [
     "LlmBackend",
     "LlmBackends",
     "MlxBackend",
+    "OpenAiEndpointBackend",
     "Output",
     "ProviderName",
     "Response",

{spawnllm-0.6.0 → spawnllm-0.6.2}/spawnllm/backends/__init__.py

@@ -16,6 +16,7 @@ from spawnllm.backends.claude import ClaudeCliBackend
 from spawnllm.backends.codex import CodexCliBackend
 from spawnllm.backends.gemini import AntigravityCliBackend, GeminiCliBackend
 from spawnllm.backends.mlx import MlxBackend
+from spawnllm.backends.openai_endpoint import OpenAiEndpointBackend
 from spawnllm.backends.registry import LlmBackends, select_backend
 
 __all__ = [
@@ -33,5 +34,6 @@ __all__ = [
     "LlmBackend",
     "LlmBackends",
     "MlxBackend",
+    "OpenAiEndpointBackend",
     "select_backend",
 ]

{spawnllm-0.6.0 → spawnllm-0.6.2}/spawnllm/backends/codex.py

@@ -25,8 +25,13 @@ class CodexCliBackend(CliBackend):
     ephemeral session in a read-only sandbox; `invocation` resolves the schema to
     a temp file and captures the final message to an `-o` file. The argv carries
     `--skip-git-repo-check` so a run in an untrusted or non-git `cwd` is not refused —
-    the sandbox already confines it, so the trust gate adds nothing here. An optional
-    `CodexConfig` overrides the sandbox and re-enables Codex hooks or MCP servers.
+    the sandbox already confines it, so the trust gate adds nothing here. The argv pins
+    `service_tier=fast` by default — `--ignore-user-config` discards a user-level tier pin,
+    and the standard tier turns long prompts into multi-minute runs;
+    `CodexConfig(service_tier=None)` drops the flag (an isolated run still ignores the
+    user-level config, so a `config.toml` tier pin needs `isolated=False` too).
+    `--color never` keeps ANSI codes out of the streamed log. An optional `CodexConfig`
+    overrides the sandbox and re-enables Codex hooks or MCP servers.
 
     Attributes:
         models: Mapping from abstract model size to an OpenAI model name.
@@ -73,9 +78,19 @@ class CodexCliBackend(CliBackend):
             "--sandbox",
             cfg.sandbox or "read-only",
             "--skip-git-repo-check",
+            "--color",
+            "never",
             "--model",
             model,
             *(["-c", f"model_reasoning_effort={effort}"] if effort else []),
+            *(["-c", f"service_tier={cfg.service_tier}"] if cfg.service_tier is not None else []),
+            # codex parses -c values as TOML with a raw-string fallback; a JSON string is a
+            # valid TOML basic string, so words like `true` don't coerce to booleans.
+            *(
+                ["-c", f"developer_instructions={json.dumps(cfg.developer_instructions, ensure_ascii=False)}"]
+                if cfg.developer_instructions is not None
+                else []
+            ),
             *(["--ignore-user-config"] if spec.isolated else []),
             *(
                 []

spawnllm-0.6.2/spawnllm/backends/openai_endpoint.py

@@ -0,0 +1,137 @@
+"""HTTP backend for any OpenAI-compatible `/chat/completions` endpoint."""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, ClassVar
+
+import httpx
+
+from spawnllm.backends.base import BackendReady, LlmBackend
+from spawnllm.structured import extract_json_block
+
+if TYPE_CHECKING:
+    from pydantic import BaseModel
+
+    from spawnllm.backends.base import BackendStatus
+    from spawnllm.response import Response
+    from spawnllm.spec import RunSpec
+    from spawnllm.types import ProviderName, TModel
+
+
+class OpenAiEndpointBackend(LlmBackend):
+    """`LlmBackend` that POSTs to an OpenAI-compatible `/chat/completions` endpoint.
+
+    Unlike the CLI backends this drives a raw `httpx` request rather than a
+    subprocess, and it is never auto-selected; the consumer constructs it
+    explicitly with a `base_url` and a literal `model`. Every abstract tier maps
+    to that one pinned `model`, and `RunSpec.model` is ignored at request time —
+    the endpoint always serves the constructor's `model`. Structured output rides
+    on `response_format` with a strict `json_schema`; text output reads
+    `choices[0].message.content`.
+
+    Args:
+        base_url: Root URL of the server; `/chat/completions` is appended.
+        model: The literal model id sent in every request body.
+        api_key: Bearer token for the `Authorization` header; defaults to
+            `"local"` for self-hosted servers that ignore it.
+        transport: Async transport injected into the `httpx.AsyncClient` used by
+            `aexecute` — e.g. a record/replay caching transport; `None` uses
+            httpx's default transport. The synchronous `execute` path always uses
+            the default transport.
+
+    Example:
+        >>> backend = OpenAiEndpointBackend("http://localhost:8000/v1", "qwen3")
+        >>> backend.execute(RunSpec(prompt="ping", model="qwen3"))
+    """
+
+    provider: ClassVar[ProviderName] = "openai_endpoint"
+
+    def __init__(
+        self, base_url: str, model: str, *, api_key: str = "local", transport: httpx.AsyncBaseTransport | None = None
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.model = model
+        self.api_key = api_key
+        self.transport = transport
+        self.models: dict[TModel, str] = {"small": model, "medium": model, "large": model}
+
+    @property
+    def url(self) -> str:
+        return f"{self.base_url}/chat/completions"
+
+    def headers(self) -> dict[str, str]:
+        return {"Authorization": f"Bearer {self.api_key}"}
+
+    def payload(self, spec: RunSpec) -> dict[str, object]:
+        base: dict[str, object] = {"model": self.model, "messages": [{"role": "user", "content": spec.prompt}]}
+        if (schema := self.schema_arg(spec)) is None:
+            return base
+        json_schema = {"name": "response", "strict": True, "schema": json.loads(schema)}
+        return base | {"response_format": {"type": "json_schema", "json_schema": json_schema}}
+
+    def resolve(self, resp: httpx.Response, spec: RunSpec) -> Response:
+        return self.to_response(
+            resp.text,
+            returncode=0 if resp.is_success else resp.status_code,
+            stderr="" if resp.is_success else resp.text,
+            spec=spec,
+        )
+
+    async def aexecute(self, spec: RunSpec) -> Response:
+        async with httpx.AsyncClient(timeout=spec.timeout, transport=self.transport) as client:
+            resp = await client.post(self.url, headers=self.headers(), json=self.payload(spec))
+        return self.resolve(resp, spec)
+
+    def execute(self, spec: RunSpec) -> Response:
+        with httpx.Client(timeout=spec.timeout) as client:
+            resp = client.post(self.url, headers=self.headers(), json=self.payload(spec))
+        return self.resolve(resp, spec)
+
+    def schema_for(self, model: type[BaseModel]) -> str:
+        """Serialize a Pydantic model into an OpenAI strict JSON schema for `response_format`.
+
+        Uses the OpenAI SDK's `to_strict_json_schema`, which recursively sets
+        `additionalProperties: false` and forces every property into `required`
+        across `$defs`, `anyOf`, and array items — the form a `json_schema`
+        `response_format` requires.
+
+        Args:
+            model: The Pydantic model describing the structured output.
+
+        Returns:
+            A strict JSON-schema string embedded in the request body.
+        """
+        from openai.lib._pydantic import to_strict_json_schema
+
+        return json.dumps(to_strict_json_schema(model))
+
+    def result_text(self, raw: str) -> str:
+        """Return `choices[0].message.content` from the chat-completion response body."""
+        return json.loads(raw)["choices"][0]["message"]["content"]
+
+    def result_value(self, raw: str) -> object:
+        """Return the JSON value parsed from the message content, tolerating fences or surrounding prose."""
+        return json.loads(extract_json_block(self.result_text(raw)))
+
+    def envelope_error(self, raw: str) -> str | None:
+        """Return the message from an OpenAI `{"error": {...}}` body carried on a 2xx response, else `None`."""
+        match json.loads(raw):
+            case {"error": {"message": str(msg)}}:
+                return msg
+            case {"error": str(msg)}:
+                return msg
+            case _:
+                return None
+
+    def env(self, _spec: RunSpec) -> dict[str, str]:
+        """Return no extra environment variables; the endpoint is reached over HTTP with nothing to isolate."""
+        return {}
+
+    def is_authenticated(self, *, timeout: int) -> bool:
+        """Report `True`; credentials travel inline as the `Authorization` bearer token on every request."""
+        return True
+
+    def check_status(self, *, timeout: int = 10) -> BackendStatus:
+        """Report `BackendReady`; the endpoint is reached per-request and carries its own auth."""
+        return BackendReady(binary="openai_endpoint")

{spawnllm-0.6.0 → spawnllm-0.6.2}/spawnllm/spec.py

@@ -44,6 +44,16 @@ class ClaudeConfig:
 class CodexConfig:
     """Codex CLI knobs applied only by the Codex backend.
 
+    `service_tier` (default `"fast"`) is emitted as `-c service_tier=<value>` on
+    every invocation, isolated or not: isolated runs pass `--ignore-user-config`,
+    which drops a `service_tier` pin in the user's `~/.codex/config.toml`, and the
+    standard tier turns long prompts into multi-minute runs. Set it to `None` to
+    drop the flag; an isolated run still passes `--ignore-user-config`, so a
+    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.
+
     Example:
         >>> CodexConfig(sandbox="read-only", enable_mcp=True)
     """
@@ -51,6 +61,8 @@ class CodexConfig:
     sandbox: str | None = None
     enable_hooks: bool = False
     enable_mcp: bool = False
+    service_tier: str | None = "fast"
+    developer_instructions: str | None = None
 
 
 @dataclass(frozen=True, slots=True)

{spawnllm-0.6.0 → spawnllm-0.6.2}/spawnllm/types.py

@@ -12,5 +12,5 @@ TSpecialty = Literal["debugging", "review", "general"]
 TModel = Literal["small", "medium", "large"]
 """Abstract model tier; each backend maps it to a provider-specific model name."""
 
-ProviderName = Literal["claude", "codex", "gemini", "antigravity", "mlx"]
+ProviderName = Literal["claude", "codex", "gemini", "antigravity", "mlx", "openai_endpoint"]
 """Backend provider identifier; keys the per-backend `provider_configs` on a `RunSpec`."""