synth-ai 0.2.4.dev7__py3-none-any.whl → 0.2.4.dev8__py3-none-any.whl

synth_ai/lm/vendors/synth_client.py

@@ -6,7 +6,8 @@ Provides async and sync interfaces matching OpenAI's API.
 import asyncio
 import json
 import logging
-from typing import Any
+import os
+from typing import Any, Optional
 
 import httpx
 
@@ -15,14 +16,152 @@ from ..config import SynthConfig
 logger = logging.getLogger(__name__)
 
 
+class ChatInterface:
+    """Nested interface to match OpenAI client structure."""
+
+    def __init__(self, client):
+        self._client = client
+        self.completions = self
+
+    async def create(self, **kwargs):
+        """Create chat completion - matches OpenAI interface."""
+        result = await self._client.chat_completions_create(**kwargs)
+        # If streaming was requested and the result is an async-iterable, return it directly
+        if kwargs.get("stream") and hasattr(result, "__aiter__"):
+            return result
+        # Convert dict response to object-like structure for OpenAI compatibility
+        return OpenAIResponse(result)
+
+
+class OpenAIResponse:
+    """Wrapper to make dict response behave like OpenAI response object."""
+
+    def __init__(self, data: dict):
+        self._data = data
+
+    @property
+    def choices(self):
+        return [OpenAIChoice(choice) for choice in self._data.get("choices", [])]
+
+    @property
+    def usage(self):
+        return self._data.get("usage")
+
+    @property
+    def id(self):
+        return self._data.get("id")
+
+    @property
+    def model(self):
+        return self._data.get("model")
+
+    @property
+    def object(self):
+        return self._data.get("object")
+
+
+class OpenAIChoice:
+    """Wrapper for choice objects."""
+
+    def __init__(self, data: dict):
+        self._data = data
+
+    @property
+    def message(self):
+        return OpenAIMessage(self._data.get("message", {}))
+
+    @property
+    def finish_reason(self):
+        return self._data.get("finish_reason")
+
+
+class OpenAIMessage:
+    """Wrapper for message objects."""
+
+    def __init__(self, data: dict):
+        self._data = data
+
+    @property
+    def role(self):
+        return self._data.get("role")
+
+    @property
+    def content(self):
+        return self._data.get("content")
+
+    @property
+    def tool_calls(self):
+        return self._data.get("tool_calls")
+
+
+class StreamDelta:
+    """Wrapper for stream delta objects."""
+
+    def __init__(self, data: dict):
+        self._data = data or {}
+
+    @property
+    def content(self) -> Optional[str]:
+        return self._data.get("content")
+
+
+class StreamChoice:
+    """Wrapper for stream choice objects."""
+
+    def __init__(self, data: dict):
+        self._data = data or {}
+
+    @property
+    def delta(self) -> StreamDelta:
+        return StreamDelta(self._data.get("delta", {}))
+
+
+class StreamChunk:
+    """Wrapper for stream chunk to expose .choices[0].delta.content."""
+
+    def __init__(self, data: dict):
+        self._data = data or {}
+
+    @property
+    def choices(self):
+        return [StreamChoice(c) for c in self._data.get("choices", [])]
+
+
+def _wrap_stream_chunk(data: dict) -> StreamChunk:
+    return StreamChunk(data)
+
+
 class AsyncSynthClient:
     """Async client with OpenAI-compatible interface."""
 
-    def __init__(self, config: SynthConfig | None = None):
-        """Initialize with config from environment if not provided."""
+    def __init__(
+        self,
+        config: SynthConfig | None = None,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        **_: Any,
+    ):
+        """Initialize with config or OpenAI-style parameters/env.
+
+        Precedence: explicit args -> OPENAI_* env -> SYNTH_* env -> SynthConfig.from_env().
+        """
+        if config is None and (api_key or base_url):
+            config = SynthConfig(
+                base_url=base_url or os.getenv("OPENAI_API_BASE") or os.getenv("SYNTH_BASE_URL"),
+                api_key=api_key or os.getenv("OPENAI_API_KEY") or os.getenv("SYNTH_API_KEY"),
+            )
+        elif config is None and (os.getenv("OPENAI_API_BASE") and os.getenv("OPENAI_API_KEY")):
+            config = SynthConfig(
+                base_url=os.getenv("OPENAI_API_BASE"),
+                api_key=os.getenv("OPENAI_API_KEY"),
+            )
         self.config = config or SynthConfig.from_env()
         self._client = None
 
+        # Create nested OpenAI-style interface
+        self.chat = ChatInterface(self)
+        self.completions = self.chat  # Alias for backward compatibility
+
     async def __aenter__(self):
         self._client = httpx.AsyncClient(
             timeout=self.config.timeout,
@@ -134,6 +273,32 @@ class AsyncSynthClient:
     ) -> dict[str, Any]:
         """
         Create chat completion with OpenAI-compatible API.
+        This method provides the OpenAI client interface structure.
+        """
+        return await self._chat_completions_create(
+            model, messages, temperature, max_tokens, top_p, frequency_penalty,
+            presence_penalty, stop, stream, tools, tool_choice, response_format, seed, **kwargs
+        )
+
+    async def _chat_completions_create(
+        self,
+        model: str,
+        messages: list[dict[str, Any]],
+        temperature: float = 0.7,
+        max_tokens: int | None = None,
+        top_p: float = 1.0,
+        frequency_penalty: float = 0.0,
+        presence_penalty: float = 0.0,
+        stop: str | list[str] | None = None,
+        stream: bool = False,
+        tools: list[dict[str, Any]] | None = None,
+        tool_choice: str | dict[str, Any] | None = "auto",
+        response_format: dict[str, Any] | None = None,
+        seed: int | None = None,
+        **kwargs,
+    ) -> dict[str, Any]:
+        """
+        Create chat completion with OpenAI-compatible API.
 
         Args:
             model: Model identifier
@@ -180,41 +345,92 @@ class AsyncSynthClient:
         if seed is not None:
             payload["seed"] = seed
 
-        # Add any additional kwargs
+        # Add any additional kwargs (including thinking_mode and thinking_budget)
         payload.update(kwargs)
 
+        # Apply env defaults for thinking if not set explicitly
+        try:
+            if "thinking_mode" not in payload:
+                env_mode = os.getenv("SYNTH_THINKING_MODE")
+                if env_mode in ("think", "no_think"):
+                    payload["thinking_mode"] = env_mode
+            if "thinking_budget" not in payload:
+                env_budget = os.getenv("SYNTH_THINKING_BUDGET")
+                if env_budget and str(env_budget).strip().isdigit():
+                    payload["thinking_budget"] = int(env_budget)
+        except Exception:
+            pass
+
+        # Local warn if budget exceeds max_tokens (do not mutate payload)
+        try:
+            bt = payload.get("thinking_budget")
+            mt = payload.get("max_tokens")
+            if isinstance(bt, int) and isinstance(mt, int) and bt > mt:
+                logger.warning(
+                    "thinking_budget (%s) exceeds max_tokens (%s) – forwarding as-is",
+                    str(bt), str(mt)
+                )
+        except Exception:
+            pass
+
         # Retry logic
         for attempt in range(self.config.max_retries):
             try:
                 url = f"{self.config.get_base_url_without_v1()}/v1/chat/completions"
-                print(f"🔍 SYNTH DEBUG: Making request to URL: {url}")
-                print(f"🔍 SYNTH DEBUG: Payload keys: {list(payload.keys())}")
-                if "tools" in payload:
-                    print(f"🔍 SYNTH DEBUG: Tools in payload: {len(payload['tools'])} tools")
-                    print(
-                        f"🔍 SYNTH DEBUG: First tool: {json.dumps(payload['tools'][0], indent=2)}"
-                    )
+                _debug_client = os.getenv("SYNTH_CLIENT_DEBUG") == "1"
+                if _debug_client:
+                    print(f"🔍 SYNTH DEBUG: Making request to URL: {url}")
+                    print(f"🔍 SYNTH DEBUG: Payload keys: {list(payload.keys())}")
+                    if "tools" in payload:
+                        # Only print counts, avoid dumping tool schemas unless explicitly enabled
+                        print(f"🔍 SYNTH DEBUG: Tools in payload: {len(payload['tools'])} tools")
+
+                # If streaming requested, return an async stream adapter
+                if stream:
+                    async def _astream():
+                        await self._ensure_client()
+                        async with self._client.stream("POST", url, json=payload) as r:  # type: ignore
+                            r.raise_for_status()
+                            async for line in r.aiter_lines():
+                                if not line:
+                                    continue
+                                if line.startswith("data:"):
+                                    data_line = line[len("data:") :].strip()
+                                    if data_line == "[DONE]":
+                                        return
+                                    try:
+                                        chunk = json.loads(data_line)
+                                        yield _wrap_stream_chunk(chunk)
+                                    except json.JSONDecodeError:
+                                        logger.debug("Non-JSON stream line: %s", data_line)
+
+                    class _AsyncStream:
+                        def __aiter__(self):
+                            return _astream()
+
+                        async def __aenter__(self):
+                            return self
+
+                        async def __aexit__(self, *exc):
+                            return False
+
+                    return _AsyncStream()
 
                 response = await self._client.post(url, json=payload)
 
-                print(f"🔍 SYNTH DEBUG: Response status: {response.status_code}")
+                if _debug_client:
+                    print(f"🔍 SYNTH DEBUG: Response status: {response.status_code}")
 
                 if response.status_code == 200:
                     result = response.json()
-                    print(f"🔍 SYNTH DEBUG: Response keys: {list(result.keys())}")
-                    if "choices" in result and result["choices"]:
-                        choice = result["choices"][0]
-                        print(f"🔍 SYNTH DEBUG: Choice keys: {list(choice.keys())}")
-                        if "message" in choice:
-                            message = choice["message"]
-                            print(f"🔍 SYNTH DEBUG: Message keys: {list(message.keys())}")
-                            if "tool_calls" in message:
-                                print(f"🔍 SYNTH DEBUG: Tool calls: {message['tool_calls']}")
-                            else:
-                                print("🔍 SYNTH DEBUG: No tool_calls in message")
-                                print(
-                                    f"🔍 SYNTH DEBUG: Message content: {message.get('content', 'N/A')[:200]}..."
-                                )
+                    if _debug_client:
+                        print(f"🔍 SYNTH DEBUG: Response keys: {list(result.keys())}")
+                        if "choices" in result and result["choices"]:
+                            choice = result["choices"][0]
+                            print(f"🔍 SYNTH DEBUG: Choice keys: {list(choice.keys())}")
+                            if "message" in choice:
+                                message = choice["message"]
+                                print(f"🔍 SYNTH DEBUG: Message keys: {list(message.keys())}")
                     return result
 
                 # Handle rate limits with exponential backoff
@@ -250,14 +466,48 @@ class AsyncSynthClient:
             await self._client.aclose()
 
 
+class SyncChatInterface:
+    """Nested interface to match OpenAI client structure (sync version)."""
+
+    def __init__(self, client):
+        self._client = client
+        self.completions = self
+
+    def create(self, **kwargs):
+        """Create chat completion - matches OpenAI interface."""
+        result = self._client.chat_completions_create(**kwargs)
+        # Convert dict response to object-like structure for OpenAI compatibility
+        return OpenAIResponse(result)
+
+
 class SyncSynthClient:
     """Sync client with OpenAI-compatible interface."""
 
-    def __init__(self, config: SynthConfig | None = None):
-        """Initialize with config from environment if not provided."""
+    def __init__(
+        self,
+        config: SynthConfig | None = None,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        **_: Any,
+    ):
+        """Initialize with config or OpenAI-style parameters/env."""
+        if config is None and (api_key or base_url):
+            config = SynthConfig(
+                base_url=base_url or os.getenv("OPENAI_API_BASE") or os.getenv("SYNTH_BASE_URL"),
+                api_key=api_key or os.getenv("OPENAI_API_KEY") or os.getenv("SYNTH_API_KEY"),
+            )
+        elif config is None and (os.getenv("OPENAI_API_BASE") and os.getenv("OPENAI_API_KEY")):
+            config = SynthConfig(
+                base_url=os.getenv("OPENAI_API_BASE"),
+                api_key=os.getenv("OPENAI_API_KEY"),
+            )
         self.config = config or SynthConfig.from_env()
         self._client = None
 
+        # Create nested OpenAI-style interface
+        self.chat = SyncChatInterface(self)
+        self.completions = self.chat  # Alias for backward compatibility
+
     def __enter__(self):
         self._client = httpx.Client(
             timeout=self.config.timeout,
@@ -425,6 +675,100 @@ def create_sync_client(config: SynthConfig | None = None) -> SyncSynthClient:
     return SyncSynthClient(config)
 
 
+# Drop-in replacements for OpenAI clients
+# These allow Synth to be used as a complete replacement for OpenAI
+
+class AsyncOpenAI(AsyncSynthClient):
+    """
+    Drop-in replacement for openai.AsyncOpenAI.
+
+    Use Synth backend instead of OpenAI while maintaining the same API.
+
+    Example:
+        from synth_ai.lm.vendors.synth_client import AsyncOpenAI
+
+        client = AsyncOpenAI(
+            api_key="sk_live_...",
+            base_url="https://synth-backend-dev-docker.onrender.com/api"
+        )
+
+        # Works exactly like openai.AsyncOpenAI!
+        response = await client.chat.completions.create(
+            model="Qwen/Qwen3-0.6B",
+            messages=[{"role": "user", "content": "Hello"}]
+        )
+    """
+
+    def __init__(self, api_key: str | None = None, base_url: str | None = None, **kwargs):
+        """
+        Initialize AsyncOpenAI-compatible Synth client.
+
+        Args:
+            api_key: Synth API key (if not provided, uses SYNTH_API_KEY env var)
+            base_url: Synth base URL (if not provided, uses OPENAI_API_BASE env var)
+            **kwargs: Additional arguments passed to AsyncSynthClient
+        """
+        # Handle OpenAI-style initialization
+        from ..config import SynthConfig
+        if api_key or base_url:
+            config = SynthConfig(
+                base_url=base_url or os.getenv("OPENAI_API_BASE", "https://synth-backend-dev-docker.onrender.com/api"),
+                api_key=api_key or os.getenv("OPENAI_API_KEY", "")
+            )
+        else:
+            # Fallback to environment variables (OPENAI_* first, then SYNTH_*)
+            env_base = os.getenv("OPENAI_API_BASE") or os.getenv("SYNTH_BASE_URL")
+            env_key = os.getenv("OPENAI_API_KEY") or os.getenv("SYNTH_API_KEY")
+            config = SynthConfig(base_url=env_base, api_key=env_key) if env_base and env_key else None
+
+        super().__init__(config, **kwargs)
+
+
+class OpenAI(SyncSynthClient):
+    """
+    Drop-in replacement for openai.OpenAI.
+
+    Synchronous version of AsyncOpenAI for Synth backend.
+    """
+
+    def __init__(self, api_key: str | None = None, base_url: str | None = None, **kwargs):
+        """
+        Initialize OpenAI-compatible Synth client.
+
+        Args:
+            api_key: Synth API key (if not provided, uses SYNTH_API_KEY env var)
+            base_url: Synth base URL (if not provided, uses OPENAI_API_BASE env var)
+            **kwargs: Additional arguments passed to SyncSynthClient
+        """
+        # Handle OpenAI-style initialization
+        from ..config import SynthConfig
+        if api_key or base_url:
+            config = SynthConfig(
+                base_url=base_url or os.getenv("OPENAI_API_BASE", "https://synth-backend-dev-docker.onrender.com/api"),
+                api_key=api_key or os.getenv("OPENAI_API_KEY", "")
+            )
+        else:
+            env_base = os.getenv("OPENAI_API_BASE") or os.getenv("SYNTH_BASE_URL")
+            env_key = os.getenv("OPENAI_API_KEY") or os.getenv("SYNTH_API_KEY")
+            config = SynthConfig(base_url=env_base, api_key=env_key) if env_base and env_key else None
+
+        super().__init__(config, **kwargs)
+
+
+# Convenience imports for easy usage
+__all__ = [
+    "AsyncSynthClient",
+    "SyncSynthClient",
+    "AsyncOpenAI",  # Drop-in replacement for openai.AsyncOpenAI
+    "OpenAI",       # Drop-in replacement for openai.OpenAI
+    "create_async_client",
+    "create_sync_client",
+    "create_chat_completion_async",
+    "create_chat_completion_sync",
+    "SynthConfig",
+]
+
+
 # Convenience functions for one-off requests
 async def create_chat_completion_async(
     model: str, messages: list[dict[str, Any]], config: SynthConfig | None = None, **kwargs

synth_ai/rl/__init__.py

@@ -0,0 +1,30 @@
+from .contracts import (
+    RolloutEnvSpec,
+    RolloutPolicySpec,
+    RolloutRecordConfig,
+    RolloutSafetyConfig,
+    RolloutRequest,
+    RolloutStep,
+    RolloutTrajectory,
+    RolloutMetrics,
+    RolloutResponse,
+)
+from .env_keys import MAX_ENVIRONMENT_API_KEY_BYTES, encrypt_for_backend, setup_environment_api_key
+from .secrets import mint_environment_api_key
+
+__all__ = [
+    "RolloutEnvSpec",
+    "RolloutPolicySpec",
+    "RolloutRecordConfig",
+    "RolloutSafetyConfig",
+    "RolloutRequest",
+    "RolloutStep",
+    "RolloutTrajectory",
+    "RolloutMetrics",
+    "RolloutResponse",
+    "encrypt_for_backend",
+    "setup_environment_api_key",
+    "mint_environment_api_key",
+    "MAX_ENVIRONMENT_API_KEY_BYTES",
+]
+

synth_ai/rl/contracts.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+"""
+Compatibility layer: re-export Task App rollout contracts from synth_ai.task.contracts
+so existing imports continue to work while consolidating under synth_ai.task.
+"""
+
+from synth_ai.task.contracts import (
+    RolloutEnvSpec,
+    RolloutPolicySpec,
+    RolloutRecordConfig,
+    RolloutSafetyConfig,
+    RolloutRequest,
+    RolloutStep,
+    RolloutTrajectory,
+    RolloutMetrics,
+    RolloutResponse,
+)
+
+__all__ = [
+    "RolloutEnvSpec",
+    "RolloutPolicySpec",
+    "RolloutRecordConfig",
+    "RolloutSafetyConfig",
+    "RolloutRequest",
+    "RolloutStep",
+    "RolloutTrajectory",
+    "RolloutMetrics",
+    "RolloutResponse",
+]
+
+

synth_ai/rl/env_keys.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+"""Helpers for uploading RL environment credentials to the backend."""
+
+import base64
+import binascii
+import json
+from typing import Any, Dict
+import os
+
+import requests
+from nacl.public import PublicKey, SealedBox
+
+__all__ = ["encrypt_for_backend", "setup_environment_api_key", "MAX_ENVIRONMENT_API_KEY_BYTES"]
+
+MAX_ENVIRONMENT_API_KEY_BYTES = 8 * 1024
+_ALGORITHM = "libsodium.sealedbox.v1"
+
+
+def encrypt_for_backend(pubkey_b64: str, secret: str | bytes) -> str:
+    """Encrypt ``secret`` for storage by the backend using libsodium sealed boxes."""
+
+    if not isinstance(pubkey_b64, str) or not pubkey_b64.strip():
+        raise ValueError("public key must be a non-empty base64 string")
+
+    try:
+        key_bytes = base64.b64decode(pubkey_b64, validate=True)
+    except binascii.Error as exc:  # pragma: no cover - defensive guard
+        raise ValueError("public key must be base64-encoded") from exc
+
+    if len(key_bytes) != 32:
+        raise ValueError("public key must be 32 bytes for X25519")
+
+    if isinstance(secret, str):
+        secret_bytes = secret.encode("utf-8")
+    elif isinstance(secret, bytes):
+        secret_bytes = secret
+    else:  # pragma: no cover - type guard
+        raise TypeError("secret must be str or bytes")
+
+    if not secret_bytes:
+        raise ValueError("secret must not be empty")
+
+    box = SealedBox(PublicKey(key_bytes))
+    ciphertext = box.encrypt(secret_bytes)
+    return base64.b64encode(ciphertext).decode("ascii")
+
+
+def setup_environment_api_key(
+    backend_base: str,
+    synth_api_key: str,
+    token: str | None = None,
+    *,
+    timeout: float = 15.0,
+) -> Dict[str, Any]:
+    """Upload an ENVIRONMENT_API_KEY to the backend."""
+
+    backend = backend_base.rstrip("/")
+    if not backend:
+        raise ValueError("backend_base must be provided")
+    if not synth_api_key:
+        raise ValueError("synth_api_key must be provided")
+
+    # Require caller-provided plaintext. If not provided, read from ENVIRONMENT_API_KEY.
+    plaintext = token if token is not None else os.getenv("ENVIRONMENT_API_KEY", "").strip()
+    if not plaintext:
+        raise ValueError("ENVIRONMENT_API_KEY must be set (or pass token=...) to upload")
+    if not isinstance(plaintext, str):  # pragma: no cover - defensive guard
+        raise TypeError("token must be a string")
+
+    token_bytes = plaintext.encode("utf-8")
+    if not token_bytes:
+        raise ValueError("ENVIRONMENT_API_KEY token must not be empty")
+    if len(token_bytes) > MAX_ENVIRONMENT_API_KEY_BYTES:
+        raise ValueError("ENVIRONMENT_API_KEY token exceeds 8 KiB limit")
+
+    headers = {"Authorization": f"Bearer {synth_api_key}"}
+    pub_url = f"{backend}/api/v1/crypto/public-key"
+    response = requests.get(pub_url, headers=headers, timeout=timeout)
+    _raise_with_detail(response)
+
+    try:
+        doc = response.json()
+    except ValueError as exc:  # pragma: no cover - backend invariant
+        raise RuntimeError("backend returned invalid JSON for public key") from exc
+
+    if not isinstance(doc, dict):
+        raise RuntimeError("backend public key response must be an object")
+
+    pubkey = doc.get("public_key")
+    if not isinstance(pubkey, str) or not pubkey:
+        raise RuntimeError("backend response missing public_key")
+
+    # The backend currently returns a single algorithm identifier; keep a guard in
+    # case future versions change the value and we need to surface that to callers.
+    alg = doc.get("alg")
+    if alg is not None and alg != _ALGORITHM:
+        raise RuntimeError(f"unsupported sealed box algorithm: {alg}")
+
+    ciphertext_b64 = encrypt_for_backend(pubkey, token_bytes)
+
+    body = {"name": "ENVIRONMENT_API_KEY", "ciphertext_b64": ciphertext_b64}
+    post_url = f"{backend}/api/v1/env-keys"
+    response2 = requests.post(post_url, headers={**headers, "Content-Type": "application/json"}, json=body, timeout=timeout)
+    _raise_with_detail(response2)
+
+    try:
+        upload_doc = response2.json()
+    except ValueError:
+        upload_doc = {}
+
+    if not isinstance(upload_doc, dict):
+        upload_doc = {}
+
+    return {
+        "stored": True,
+        "id": upload_doc.get("id"),
+        "name": upload_doc.get("name"),
+        "updated_at": upload_doc.get("updated_at"),
+    }
+
+
+def _raise_with_detail(response: requests.Response) -> None:
+    try:
+        response.raise_for_status()
+    except requests.HTTPError as exc:
+        detail_snippet: str | None = None
+        try:
+            detail = response.json()
+            detail_snippet = json.dumps(detail, separators=(",", ":"))[:200]
+        except Exception:
+            body = response.text if response.text is not None else ""
+            detail_snippet = body[:200] if body else None
+        message = str(exc)
+        if detail_snippet:
+            message = f"{message} | body={detail_snippet}"
+        raise requests.HTTPError(message, request=exc.request, response=exc.response) from None

synth_ai/rl/secrets.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+"""Helpers for generating RL environment credentials."""
+
+import secrets
+
+__all__ = ["mint_environment_api_key"]
+
+
+def mint_environment_api_key() -> str:
+    """Mint a random ENVIRONMENT_API_KEY value.
+
+    The current format is 64 hexadecimal characters (256 bits of entropy), which
+    matches the shell helpers used by the RL examples. This keeps the token easy
+    to copy while remaining suitably strong for authentication.
+    """
+
+    # secrets.token_hex(32) → 32 random bytes rendered as 64 hex characters.
+    return secrets.token_hex(32)