subactor-shell 0.2.2__py3-none-any.whl

subactor_shell/providers/__init__.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from ..models import ProviderProfile
+from ..secret_refs import SecretResolver
+from .anthropic import AnthropicProvider
+from .base import ChatProvider, ProviderBundle, ProviderError, StructuredCompletion
+from .mock import MockProvider
+from .openai_compat import OpenAICompatProvider
+from .subactor_control import SubactorControlProvider
+
+
+def build_provider(profile: ProviderProfile, resolver: SecretResolver) -> ProviderBundle:
+    kind = profile.kind.lower().strip()
+    if kind == "mock":
+        return ProviderBundle(provider=MockProvider(), sensitive_values=[])
+
+    api_key = resolver.resolve(profile.api_key_ref) if profile.api_key_ref else ""
+    if profile.auth_required and not api_key:
+        raise ProviderError(f"Provider '{profile.name}' nie ma dostępnego klucza API")
+
+    if kind == "openai_compat":
+        provider: ChatProvider = OpenAICompatProvider(
+            base_url=profile.base_url,
+            endpoint=profile.endpoint,
+            api_key=api_key,
+            timeout_seconds=profile.timeout_seconds,
+            extra_headers=profile.extra_headers,
+            structured_mode=profile.structured_mode,
+        )
+    elif kind == "subactor_control":
+        provider = SubactorControlProvider(
+            base_url=profile.base_url,
+            endpoint=profile.endpoint,
+            api_key=api_key,
+            timeout_seconds=profile.timeout_seconds,
+        )
+    elif kind == "anthropic":
+        if not api_key:
+            raise ProviderError(f"Provider '{profile.name}' wymaga klucza API")
+        provider = AnthropicProvider(
+            base_url=profile.base_url,
+            api_key=api_key,
+            max_tokens=profile.max_tokens,
+            anthropic_version=profile.anthropic_version,
+            timeout_seconds=profile.timeout_seconds,
+            extra_headers=profile.extra_headers,
+        )
+    else:
+        raise ProviderError(f"Nieobsługiwany kind providera: {profile.kind}")
+    return ProviderBundle(provider=provider, sensitive_values=[api_key] if api_key else [])
+
+
+__all__ = [
+    "AnthropicProvider",
+    "ChatProvider",
+    "MockProvider",
+    "OpenAICompatProvider",
+    "SubactorControlProvider",
+    "ProviderBundle",
+    "ProviderError",
+    "StructuredCompletion",
+    "build_provider",
+]

subactor_shell/providers/anthropic.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import json
+from collections.abc import AsyncIterator
+from typing import Any
+
+import httpx
+
+from .base import ChatProvider, ProviderError
+
+
+class AnthropicProvider(ChatProvider):
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        api_key: str,
+        max_tokens: int,
+        anthropic_version: str,
+        timeout_seconds: float,
+        extra_headers: dict[str, str] | None = None,
+        transport: httpx.AsyncBaseTransport | None = None,
+    ):
+        if not base_url.startswith(("http://", "https://")):
+            raise ValueError("base_url providera musi być adresem http:// lub https://")
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.max_tokens = max_tokens
+        self.anthropic_version = anthropic_version
+        self.timeout_seconds = timeout_seconds
+        self.extra_headers = extra_headers or {}
+        self.transport = transport
+
+    async def stream(
+        self,
+        messages: list[dict[str, Any]],
+        *,
+        model: str,
+        cancel_event=None,
+    ) -> AsyncIterator[str]:
+        system_parts: list[str] = []
+        api_messages: list[dict[str, str]] = []
+        for item in messages:
+            role = str(item.get("role", "user"))
+            content = str(item.get("content", ""))
+            if role == "system":
+                system_parts.append(content)
+            elif role in {"user", "assistant"}:
+                api_messages.append({"role": role, "content": content})
+        payload: dict[str, Any] = {
+            "model": model,
+            "max_tokens": self.max_tokens,
+            "messages": api_messages,
+            "stream": True,
+        }
+        if system_parts:
+            payload["system"] = "\n\n".join(system_parts)
+        headers = {
+            **self.extra_headers,
+            "x-api-key": self.api_key,
+            "anthropic-version": self.anthropic_version,
+            "Content-Type": "application/json",
+            "Accept": "text/event-stream",
+        }
+        try:
+            async with httpx.AsyncClient(
+                base_url=self.base_url,
+                timeout=self.timeout_seconds,
+                transport=self.transport,
+            ) as client:
+                async with client.stream("POST", "/messages", headers=headers, json=payload) as response:
+                    if response.status_code >= 400:
+                        request_id = response.headers.get("request-id", "")
+                        suffix = f", request_id={request_id}" if request_id else ""
+                        raise ProviderError(
+                            f"Provider anthropic zwrócił HTTP {response.status_code}{suffix}"
+                        )
+                    async for line in response.aiter_lines():
+                        if cancel_event is not None and cancel_event.is_set():
+                            return
+                        line = line.strip()
+                        if not line or line.startswith(":") or not line.startswith("data:"):
+                            continue
+                        data = line[5:].strip()
+                        try:
+                            event = json.loads(data)
+                        except json.JSONDecodeError:
+                            continue
+                        if event.get("type") == "content_block_delta":
+                            delta = event.get("delta", {})
+                            text = delta.get("text", "") if isinstance(delta, dict) else ""
+                            if isinstance(text, str) and text:
+                                yield text
+                        elif event.get("type") == "error":
+                            raise ProviderError("Provider anthropic przerwał strumień błędem")
+        except ProviderError:
+            raise
+        except httpx.HTTPError as exc:
+            raise ProviderError(
+                f"Błąd połączenia z providerem anthropic ({type(exc).__name__})"
+            ) from exc

subactor_shell/providers/base.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import AsyncIterator
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..token_budget import TokenUsage, estimate_messages_tokens, estimate_text_tokens
+
+
+class ProviderError(RuntimeError):
+    """Sanitized provider error; never include request payloads or credentials."""
+
+
+@dataclass(slots=True)
+class StructuredCompletion:
+    data: dict[str, Any]
+    raw_text: str
+    usage: TokenUsage = field(default_factory=TokenUsage)
+    request_id: str = ""
+
+
+class ChatProvider(ABC):
+    @abstractmethod
+    async def stream(
+        self,
+        messages: list[dict[str, Any]],
+        *,
+        model: str,
+        cancel_event=None,
+    ) -> AsyncIterator[str]:
+        raise NotImplementedError
+
+    async def complete_structured(
+        self,
+        messages: list[dict[str, Any]],
+        *,
+        model: str,
+        json_schema: dict[str, Any],
+        schema_name: str,
+        max_output_tokens: int,
+        reasoning_effort: str | None = None,
+    ) -> StructuredCompletion:
+        """Portable fallback for providers without native structured output.
+
+        Native provider implementations should override this method. The fallback
+        still validates JSON locally; it does not trust a model's prose.
+        """
+
+        import json
+
+        from ..intent_ir import parse_json_object
+
+        instruction = {
+            "task": "Return exactly one JSON object matching the schema. No Markdown.",
+            "schema_name": schema_name,
+            "json_schema": json_schema,
+        }
+        prompted = [
+            {
+                "role": "system",
+                "content": json.dumps(instruction, ensure_ascii=False, separators=(",", ":")),
+            },
+            *messages,
+        ]
+        raw = "".join([chunk async for chunk in self.stream(prompted, model=model)])
+        return StructuredCompletion(
+            data=parse_json_object(raw),
+            raw_text=raw,
+            usage=TokenUsage(
+                input_tokens=estimate_messages_tokens(prompted),
+                output_tokens=estimate_text_tokens(raw),
+                estimated=True,
+            ),
+        )
+
+
+@dataclass(slots=True)
+class ProviderBundle:
+    provider: ChatProvider
+    sensitive_values: list[str]

subactor_shell/providers/mock.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncIterator
+from typing import Any
+
+from .base import ChatProvider
+
+
+class MockProvider(ChatProvider):
+    """Offline provider useful for installation checks and tests."""
+
+    async def stream(
+        self,
+        messages: list[dict[str, Any]],
+        *,
+        model: str,
+        cancel_event=None,
+    ) -> AsyncIterator[str]:
+        last_user = next(
+            (str(item.get("content", "")) for item in reversed(messages) if item.get("role") == "user"),
+            "",
+        )
+        response = (
+            "[mock] Odebrałem wiadomość w bezpiecznej sesji Subactor. "
+            f"Model: {model}. Znaki wejścia: {len(last_user)}.\n\n{last_user}"
+        )
+        for index in range(0, len(response), 24):
+            if cancel_event is not None and cancel_event.is_set():
+                return
+            await asyncio.sleep(0)
+            yield response[index : index + 24]

subactor_shell/providers/openai_compat.py

@@ -0,0 +1,303 @@
+from __future__ import annotations
+
+import json
+from collections.abc import AsyncIterator
+from typing import Any
+
+import httpx
+
+from ..intent_ir import parse_json_object
+from ..token_budget import TokenUsage, estimate_messages_tokens, estimate_text_tokens
+from .base import ChatProvider, ProviderError, StructuredCompletion
+
+
+class OpenAICompatProvider(ChatProvider):
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        endpoint: str,
+        api_key: str,
+        timeout_seconds: float,
+        extra_headers: dict[str, str] | None = None,
+        structured_mode: str = "auto",
+        transport: httpx.AsyncBaseTransport | None = None,
+    ):
+        if not base_url.startswith(("http://", "https://")):
+            raise ValueError("base_url providera musi być adresem http:// lub https://")
+        self.base_url = base_url.rstrip("/")
+        self.endpoint = endpoint or "/chat/completions"
+        if not self.endpoint.startswith("/"):
+            self.endpoint = "/" + self.endpoint
+        self.api_key = api_key
+        self.timeout_seconds = timeout_seconds
+        self.extra_headers = extra_headers or {}
+        self.structured_mode = structured_mode.strip().lower() or "auto"
+        self.transport = transport
+        self.last_usage = TokenUsage()
+
+    def _headers(self, *, stream: bool) -> dict[str, str]:
+        headers = {
+            **self.extra_headers,
+            "Content-Type": "application/json",
+            "Accept": "text/event-stream" if stream else "application/json",
+        }
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        return headers
+
+    async def stream(
+        self,
+        messages: list[dict[str, Any]],
+        *,
+        model: str,
+        cancel_event=None,
+    ) -> AsyncIterator[str]:
+        is_responses = self.endpoint.rstrip("/").endswith("/responses")
+        if is_responses:
+            payload: dict[str, Any] = {"model": model, "input": messages, "stream": True}
+        else:
+            payload = {
+                "model": model,
+                "messages": messages,
+                "stream": True,
+                "stream_options": {"include_usage": True},
+            }
+        output_parts: list[str] = []
+        usage = TokenUsage(
+            input_tokens=estimate_messages_tokens(messages),
+            estimated=True,
+        )
+        try:
+            async with httpx.AsyncClient(
+                base_url=self.base_url,
+                timeout=self.timeout_seconds,
+                transport=self.transport,
+            ) as client:
+                async with client.stream(
+                    "POST", self.endpoint, headers=self._headers(stream=True), json=payload
+                ) as response:
+                    if response.status_code >= 400:
+                        request_id = response.headers.get("x-request-id", "")
+                        suffix = f", request_id={request_id}" if request_id else ""
+                        raise ProviderError(
+                            f"Provider openai_compat zwrócił HTTP {response.status_code}{suffix}"
+                        )
+                    async for line in response.aiter_lines():
+                        if cancel_event is not None and cancel_event.is_set():
+                            break
+                        line = line.strip()
+                        if not line or line.startswith(":") or not line.startswith("data:"):
+                            continue
+                        data = line[5:].strip()
+                        if data == "[DONE]":
+                            break
+                        try:
+                            event = json.loads(data)
+                        except json.JSONDecodeError:
+                            continue
+                        event_usage = self._extract_usage(event, is_responses=is_responses)
+                        if event_usage.input_tokens or event_usage.output_tokens:
+                            usage = event_usage
+                        text = self._extract_text(event, is_responses=is_responses)
+                        if text:
+                            output_parts.append(text)
+                            yield text
+        except ProviderError:
+            raise
+        except httpx.HTTPError as exc:
+            raise ProviderError(
+                f"Błąd połączenia z providerem openai_compat ({type(exc).__name__})"
+            ) from exc
+        if usage.output_tokens <= 0:
+            usage.output_tokens = estimate_text_tokens("".join(output_parts))
+            usage.estimated = True
+        self.last_usage = usage
+
+    async def complete_structured(
+        self,
+        messages: list[dict[str, Any]],
+        *,
+        model: str,
+        json_schema: dict[str, Any],
+        schema_name: str,
+        max_output_tokens: int,
+        reasoning_effort: str | None = None,
+    ) -> StructuredCompletion:
+        is_responses = self.endpoint.rstrip("/").endswith("/responses")
+        mode = self.structured_mode
+        if mode == "auto":
+            mode = "responses_json_schema" if is_responses else "json_schema"
+
+        if is_responses:
+            payload: dict[str, Any] = {
+                "model": model,
+                "input": messages,
+                "stream": False,
+                "max_output_tokens": max_output_tokens,
+            }
+            if reasoning_effort:
+                payload["reasoning"] = {"effort": reasoning_effort}
+            if mode in {"responses_json_schema", "json_schema"}:
+                payload["text"] = {
+                    "format": {
+                        "type": "json_schema",
+                        "name": schema_name,
+                        "strict": True,
+                        "schema": json_schema,
+                    }
+                }
+            elif mode == "json_object":
+                payload["text"] = {"format": {"type": "json_object"}}
+            else:
+                payload["instructions"] = (
+                    "Return exactly one JSON object matching this schema and no Markdown: "
+                    + json.dumps(json_schema, ensure_ascii=False, separators=(",", ":"))
+                )
+        else:
+            payload = {
+                "model": model,
+                "messages": messages,
+                "stream": False,
+                "max_tokens": max_output_tokens,
+            }
+            if reasoning_effort:
+                payload["reasoning_effort"] = reasoning_effort
+            if mode == "json_schema":
+                payload["response_format"] = {
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": schema_name,
+                        "strict": True,
+                        "schema": json_schema,
+                    },
+                }
+            elif mode == "json_object":
+                payload["response_format"] = {"type": "json_object"}
+            else:
+                payload["messages"] = [
+                    {
+                        "role": "system",
+                        "content": (
+                            "Return exactly one JSON object and no Markdown. JSON Schema: "
+                            + json.dumps(json_schema, ensure_ascii=False, separators=(",", ":"))
+                        ),
+                    },
+                    *messages,
+                ]
+
+        try:
+            async with httpx.AsyncClient(
+                base_url=self.base_url,
+                timeout=self.timeout_seconds,
+                transport=self.transport,
+            ) as client:
+                response = await client.post(
+                    self.endpoint,
+                    headers=self._headers(stream=False),
+                    json=payload,
+                )
+            if response.status_code >= 400:
+                request_id = response.headers.get("x-request-id", "")
+                suffix = f", request_id={request_id}" if request_id else ""
+                raise ProviderError(
+                    f"Provider openai_compat zwrócił HTTP {response.status_code}{suffix}"
+                )
+            body = response.json()
+            raw_text = self._extract_complete_text(body, is_responses=is_responses)
+            usage = self._extract_usage(body, is_responses=is_responses)
+            if usage.input_tokens <= 0:
+                usage.input_tokens = estimate_messages_tokens(messages)
+                usage.estimated = True
+            if usage.output_tokens <= 0:
+                usage.output_tokens = estimate_text_tokens(raw_text)
+                usage.estimated = True
+            self.last_usage = usage
+            return StructuredCompletion(
+                data=parse_json_object(raw_text),
+                raw_text=raw_text,
+                usage=usage,
+                request_id=response.headers.get("x-request-id", "") or str(body.get("id", "")),
+            )
+        except ProviderError:
+            raise
+        except (httpx.HTTPError, ValueError, KeyError, TypeError) as exc:
+            raise ProviderError(
+                f"Błąd structured output providera openai_compat ({type(exc).__name__})"
+            ) from exc
+
+    @staticmethod
+    def _extract_text(event: dict[str, Any], *, is_responses: bool) -> str:
+        if is_responses:
+            if event.get("type") == "response.output_text.delta":
+                delta = event.get("delta", "")
+                return delta if isinstance(delta, str) else ""
+            return ""
+        try:
+            content = event["choices"][0]["delta"].get("content", "")
+        except (KeyError, IndexError, TypeError):
+            return ""
+        return OpenAICompatProvider._content_to_text(content)
+
+    @staticmethod
+    def _content_to_text(content: Any) -> str:
+        if isinstance(content, str):
+            return content
+        if isinstance(content, list):
+            parts: list[str] = []
+            for item in content:
+                if isinstance(item, dict):
+                    text = item.get("text")
+                    if isinstance(text, str):
+                        parts.append(text)
+            return "".join(parts)
+        return ""
+
+    @staticmethod
+    def _extract_complete_text(body: dict[str, Any], *, is_responses: bool) -> str:
+        if is_responses:
+            output_text = body.get("output_text")
+            if isinstance(output_text, str):
+                return output_text
+            parts: list[str] = []
+            outputs = body.get("output", [])
+            for output in outputs if isinstance(outputs, list) else []:
+                if not isinstance(output, dict):
+                    continue
+                contents = output.get("content", [])
+                for content in contents if isinstance(contents, list) else []:
+                    if not isinstance(content, dict):
+                        continue
+                    text = content.get("text")
+                    if isinstance(text, str):
+                        parts.append(text)
+            return "".join(parts)
+        choices = body.get("choices", [])
+        if not isinstance(choices, list) or not choices:
+            raise ProviderError("Provider nie zwrócił choices")
+        first = choices[0] if isinstance(choices[0], dict) else {}
+        message = first.get("message", {}) if isinstance(first, dict) else {}
+        if not isinstance(message, dict):
+            return ""
+        return OpenAICompatProvider._content_to_text(message.get("content", ""))
+
+    @staticmethod
+    def _extract_usage(body: dict[str, Any], *, is_responses: bool) -> TokenUsage:
+        usage = body.get("usage", {})
+        if not isinstance(usage, dict) or not usage:
+            return TokenUsage()
+        if is_responses:
+            details = usage.get("input_tokens_details", {})
+            cached = details.get("cached_tokens", 0) if isinstance(details, dict) else 0
+            return TokenUsage(
+                input_tokens=int(usage.get("input_tokens", 0) or 0),
+                cached_input_tokens=int(cached or 0),
+                output_tokens=int(usage.get("output_tokens", 0) or 0),
+            )
+        details = usage.get("prompt_tokens_details", {})
+        cached = details.get("cached_tokens", 0) if isinstance(details, dict) else 0
+        return TokenUsage(
+            input_tokens=int(usage.get("prompt_tokens", 0) or 0),
+            cached_input_tokens=int(cached or 0),
+            output_tokens=int(usage.get("completion_tokens", 0) or 0),
+        )