synth-ai 0.2.0__py3-none-any.whl → 0.2.1.dev0__py3-none-any.whl

synth_ai/environments/service/external_registry.py

@@ -0,0 +1,57 @@
+"""
+External environment registry support.
+
+This module provides functionality to register environments from external packages.
+"""
+
+import importlib
+import logging
+from typing import List, Dict
+
+logger = logging.getLogger(__name__)
+
+
+class ExternalRegistryConfig:
+    """Configuration for external environment registries."""
+
+    def __init__(self, external_environments: List[Dict[str, str]] = None):
+        self.external_environments = external_environments or []
+
+
+def load_external_environments(config: ExternalRegistryConfig):
+    """
+    Load and register environments from external packages.
+
+    Args:
+        config: Configuration specifying external environment sources
+    """
+    for env_config in config.external_environments:
+        module_name = env_config.get("module")
+        function_name = env_config.get("function", "integrate_with_environments_service")
+
+        if not module_name:
+            logger.warning("External environment config missing 'module' field")
+            continue
+
+        try:
+            # Import the module
+            module = importlib.import_module(module_name)
+
+            # Get the registration function
+            if hasattr(module, function_name):
+                register_func = getattr(module, function_name)
+                register_func()
+                logger.info(f"Successfully loaded environments from {module_name}")
+            else:
+                logger.warning(f"Module {module_name} does not have function {function_name}")
+
+        except ImportError as e:
+            logger.error(f"Failed to import module {module_name}: {e}")
+        except Exception as e:
+            logger.error(f"Error loading environments from {module_name}: {e}")
+
+
+__all__ = [
+    "ExternalRegistryConfig",
+    "load_external_environments",
+]

synth_ai/environments/service/registry.py

@@ -0,0 +1,9 @@
+# This file re-exports the actual registry functions from synth_ai.environments.environment.registry
+# to be used by the service layer, maintaining a clean separation if needed.
+from synth_ai.environments.environment.registry import (
+    register_environment,
+    get_environment_cls,
+    list_supported_env_types,
+)
+
+__all__ = ["register_environment", "get_environment_cls", "list_supported_env_types"]

synth_ai/environments/stateful/__init__.py

@@ -0,0 +1 @@
+"""Stateful environment components."""

synth_ai/environments/stateful/core.py

@@ -0,0 +1,28 @@
+from abc import abstractmethod
+from typing import List
+
+from synth_ai.environments.environment.shared_engine import Engine, InternalObservation
+from synth_ai.environments.environment.tools import EnvToolCall
+
+
+class StatefulEnvironment(Engine):
+    @abstractmethod
+    async def initialize(self) -> InternalObservation:
+        pass
+
+    @abstractmethod
+    async def terminate(self) -> InternalObservation:
+        pass
+
+    # main external api
+    @abstractmethod
+    def validate_tool_calls(self, tool_calls: EnvToolCall):
+        pass
+
+    @abstractmethod
+    async def step(self, tool_calls: List[EnvToolCall]) -> InternalObservation:
+        pass
+
+    @abstractmethod
+    async def checkpoint(self) -> InternalObservation:
+        pass

synth_ai/environments/stateful/engine.py

@@ -0,0 +1,21 @@
+from synth_ai.environments.environment.shared_engine import Engine
+from typing import TypeVar
+
+
+SnapshotType = TypeVar("SnapshotType", bound="StatefulEngineSnapshot")
+
+
+class StatefulEngineSnapshot:
+    pass
+
+
+class StatefulEngine(Engine):
+    async def serialize(self):
+        pass
+
+    @classmethod
+    async def deserialize(self, engine_snapshot: StatefulEngineSnapshot):
+        pass
+
+    async def _step_engine(self):
+        pass

synth_ai/environments/stateful/state.py

@@ -0,0 +1,7 @@
+from synth_ai.environments.v0_observability.log import EnvironmentStepRecord
+
+
+class State:
+    async def get_environment_step_record(self) -> EnvironmentStepRecord:
+        """Return the latest environment step record."""
+        raise NotImplementedError

synth_ai/environments/tasks/api.py

@@ -0,0 +1,19 @@
+from synth_ai.environments.tasks.core import (
+    Task,
+    TaskInstance,
+    TaskInstanceSet,
+    TaskInstanceMetadata,
+    SplitInfo,
+    Impetus,
+    Intent,
+)
+
+__all__ = [
+    "Task",
+    "TaskInstance",
+    "TaskInstanceSet",
+    "TaskInstanceMetadata",
+    "SplitInfo",
+    "Impetus",
+    "Intent",
+]

synth_ai/environments/tasks/core.py

@@ -0,0 +1,78 @@
+from typing import Optional, Dict, List, Callable, Set, Any
+from synth_ai.environments.v0_observability.history import SynthGlobalTrajectory
+from uuid import UUID
+from abc import abstractmethod
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Task:
+    global_premises: str
+    global_constraints: str
+    global_objectives: str
+
+    shared_env_params: Optional[Dict]
+
+
+@dataclass
+class TaskInstanceMetadata:
+    pass
+
+
+@dataclass
+class Intent:
+    rubric: Dict[str, Any]
+    gold_trajectories: Optional[SynthGlobalTrajectory]
+    gold_state_diff: Dict
+    deterministic_eval_functions: List[Callable] = field(default_factory=list)
+
+
+@dataclass
+class Impetus:
+    instructions: str
+
+    # ?
+
+
+@dataclass
+class TaskInstance:
+    id: UUID
+    impetus: Impetus
+    intent: Intent
+    metadata: TaskInstanceMetadata
+    is_reproducible: bool
+    initial_engine_snapshot: Optional["StatefulEngineSnapshot"]
+
+    @abstractmethod
+    async def serialize(self) -> Dict:
+        pass
+
+    @abstractmethod
+    async def deserialize(self) -> "TaskInstance":
+        pass
+
+
+@dataclass
+class TaskInstanceMetadataFilter:
+    @abstractmethod
+    def __call__(
+        self, instance: TaskInstance
+    ) -> bool:  # Use Any temporarily for broader compatibility
+        # Using Any avoids strict dependency on AgentStatefulTaskInstance here
+        # Subclasses like MetadataFilter in helpers.py can specify the type.
+        """Return True if the instance passes the filter."""
+
+
+@dataclass
+class SplitInfo:
+    val_instance_ids: Set[str]
+    test_instance_ids: Set[str]
+    _is_split_defined: bool
+
+
+@dataclass
+class TaskInstanceSet:
+    name: str
+    description: str
+    instances: List[TaskInstance]
+    split_info: SplitInfo

synth_ai/environments/tasks/filters.py

@@ -0,0 +1,39 @@
+from typing import Any, Collection, Optional
+from dataclasses import dataclass
+from synth_ai.environments.tasks.core import TaskInstanceMetadataFilter, TaskInstance
+
+
+@dataclass
+class ValueFilter(TaskInstanceMetadataFilter):
+    key: str
+    values: Collection[Any]
+
+    def __call__(self, instance: TaskInstance) -> bool:
+        instance_value = getattr(instance.metadata, self.key, None)
+        if instance_value is None:
+            return False
+        return instance_value in self.values
+
+
+@dataclass
+class RangeFilter(TaskInstanceMetadataFilter):
+    key: str
+    min_val: Optional[float] = None
+    max_val: Optional[float] = None
+
+    def __call__(self, instance: TaskInstance) -> bool:
+        instance_value = getattr(instance.metadata, self.key, None)
+        if instance_value is None:
+            # If the attribute doesn't exist on the metadata, it can't be in range.
+            return False
+
+        if not isinstance(instance_value, (int, float)):
+            # If the attribute is not a number, it can't be in a numerical range.
+            # Or, we could raise an error, depending on desired strictness.
+            return False
+
+        if self.min_val is not None and instance_value < self.min_val:
+            return False
+        if self.max_val is not None and instance_value > self.max_val:
+            return False
+        return True

synth_ai/environments/tasks/utils.py

@@ -0,0 +1,89 @@
+"""
+Utility functions and generic filters for taskset creation.
+"""
+
+from typing import Any, Collection, Optional, List, Set
+from uuid import UUID, uuid4
+from synth_ai.environments.tasks.core import (
+    TaskInstanceMetadataFilter,
+    TaskInstanceSet,
+    SplitInfo,
+    TaskInstance,
+)
+
+
+def parse_or_new_uuid(raw_id: Optional[str]) -> UUID:
+    """
+    Parse a raw ID string into a UUID, or generate a new one if invalid or missing.
+    """
+    try:
+        return UUID(raw_id)  # type: ignore[arg-type]
+    except Exception:
+        return uuid4()
+
+
+class ValueFilter(TaskInstanceMetadataFilter):
+    """
+    Filter TaskInstances by exact match of a metadata attribute.
+    """
+
+    def __init__(self, key: str, values: Collection[Any]):
+        self.key = key
+        self.values = set(values)
+
+    def __call__(self, instance: TaskInstance) -> bool:
+        return getattr(instance.metadata, self.key, None) in self.values
+
+
+class RangeFilter(TaskInstanceMetadataFilter):
+    """
+    Filter TaskInstances where a numeric metadata attribute falls within [min_value, max_value].
+    """
+
+    def __init__(
+        self,
+        key: str,
+        min_value: Optional[float] = None,
+        max_value: Optional[float] = None,
+    ):
+        self.key = key
+        self.min_value = min_value
+        self.max_value = max_value
+
+    def __call__(self, instance: TaskInstance) -> bool:
+        value = getattr(instance.metadata, self.key, None)
+        if self.min_value is not None and (value is None or value < self.min_value):
+            return False
+        if self.max_value is not None and (value is None or value > self.max_value):
+            return False
+        return True
+
+
+def make_taskset(
+    name: str,
+    description: str,
+    instances: List[TaskInstance],
+    val_filter: Optional[TaskInstanceMetadataFilter] = None,
+    test_filter: Optional[TaskInstanceMetadataFilter] = None,
+) -> TaskInstanceSet:
+    """
+    Assemble a TaskInstanceSet by applying optional validation and test filters.
+    """
+    val_ids: Set[Any] = set()
+    test_ids: Set[Any] = set()
+    if val_filter:
+        val_ids = {inst.id for inst in instances if val_filter(inst)}
+    if test_filter:
+        test_ids = {inst.id for inst in instances if test_filter(inst)}
+    is_defined = val_filter is not None or test_filter is not None
+    split_info = SplitInfo(
+        val_instance_ids=val_ids,
+        test_instance_ids=test_ids,
+        _is_split_defined=is_defined,
+    )
+    return TaskInstanceSet(
+        name=name,
+        description=description,
+        instances=instances,
+        split_info=split_info,
+    )

synth_ai/environments/v0_observability/history.py

@@ -0,0 +1,3 @@
+# Env and Graph
+class SynthGlobalTrajectory:
+    pass

synth_ai/environments/v0_observability/log.py

@@ -0,0 +1,2 @@
+class EnvironmentStepRecord:
+    pass

synth_ai/lm/caching/constants.py

@@ -0,0 +1 @@
+DISKCACHE_SIZE_LIMIT = 10 * 1024 * 1024 * 1024  # 10GB

synth_ai/{zyk/lms → lm}/caching/ephemeral.py

@@ -5,8 +5,8 @@ from typing import Optional, Union
 from diskcache import Cache
 from pydantic import BaseModel
 
-from synth_ai.zyk.lms.caching.constants import DISKCACHE_SIZE_LIMIT
-from synth_ai.zyk.lms.vendors.base import BaseLMResponse
+from synth_ai.lm.caching.constants import DISKCACHE_SIZE_LIMIT
+from synth_ai.lm.vendors.base import BaseLMResponse
 
 
 @dataclass
@@ -27,9 +27,7 @@ class EphemeralCache:
             return None
 
         if not isinstance(cache_data, dict):
-            return BaseLMResponse(
-                raw_response=cache_data, structured_output=None, tool_calls=None
-            )
+            return BaseLMResponse(raw_response=cache_data, structured_output=None, tool_calls=None)
 
         raw_response = cache_data.get("raw_response")
         tool_calls = cache_data.get("tool_calls")
@@ -54,9 +52,7 @@ class EphemeralCache:
                 "raw_response": response.raw_response
                 if response.raw_response is not None
                 else None,
-                "tool_calls": response.tool_calls
-                if response.tool_calls is not None
-                else None,
+                "tool_calls": response.tool_calls if response.tool_calls is not None else None,
                 "structured_output": (
                     response.structured_output.model_dump()
                     if response.structured_output is not None

synth_ai/{zyk/lms → lm}/caching/handler.py

@@ -3,17 +3,19 @@ from typing import Any, Dict, List, Optional, Type
 
 from pydantic import BaseModel
 
-from synth_ai.zyk.lms.caching.ephemeral import EphemeralCache
-from synth_ai.zyk.lms.caching.persistent import PersistentCache
-from synth_ai.zyk.lms.tools.base import BaseTool
-from synth_ai.zyk.lms.vendors.base import BaseLMResponse
+from synth_ai.lm.caching.ephemeral import EphemeralCache
+from synth_ai.lm.caching.persistent import PersistentCache
+from synth_ai.lm.tools.base import BaseTool
+from synth_ai.lm.vendors.base import BaseLMResponse
 
 persistent_cache = PersistentCache()
 ephemeral_cache = EphemeralCache()
 
 import logging
+
 logger = logging.getLogger(__name__)
 
+
 def map_params_to_key(
     messages: List[Dict],
     model: str,
@@ -30,7 +32,7 @@ def map_params_to_key(
         normalized_messages = "".join([msg["content"] for msg in messages])
     normalized_model = model
     normalized_temperature = f"{temperature:.2f}"[:4]
-    normalized_response_model = str(response_model.schema()) if response_model else ""
+    normalized_response_model = str(response_model.model_json_schema()) if response_model else ""
     normalized_reasoning_effort = reasoning_effort if reasoning_effort else ""
 
     # Normalize tools if present
@@ -44,10 +46,10 @@ def map_params_to_key(
                 "arguments": tool.arguments.schema(),
             }
             tool_schemas.append(str(tool_schema))
-        #logger.error(f"Tool schemas: {tool_schemas}")
+        # logger.error(f"Tool schemas: {tool_schemas}")
         normalized_tools = "".join(tool_schemas)
     elif tools:
-        #logger.error(f"Tools: {tools}")
+        # logger.error(f"Tools: {tools}")
         normalized_tools = "".join([str(tool) for tool in tools])
 
     key_str = ""
@@ -57,30 +59,28 @@ def map_params_to_key(
         normalized_temperature,
         normalized_response_model,
         normalized_tools,
-        normalized_reasoning_effort
+        normalized_reasoning_effort,
     ]
     for component in components:
         if component:
             key_str += str(component)
 
-    return hashlib.sha256(key_str.encode()).hexdigest() 
+    return hashlib.sha256(key_str.encode()).hexdigest()
 
 
 class CacheHandler:
     use_persistent_store: bool = False
     use_ephemeral_store: bool = True
 
-    def __init__(
-        self, use_persistent_store: bool = False, use_ephemeral_store: bool = True
-    ):
+    def __init__(self, use_persistent_store: bool = False, use_ephemeral_store: bool = True):
         self.use_persistent_store = use_persistent_store
         self.use_ephemeral_store = use_ephemeral_store
 
     def _validate_messages(self, messages: List[Dict[str, Any]]) -> None:
         """Validate that messages are in the correct format."""
-        assert all(
-            [type(msg["content"]) == str for msg in messages]
-        ), "All message contents must be strings"
+        assert all([type(msg["content"]) == str for msg in messages]), (
+            "All message contents must be strings"
+        )
 
     def hit_managed_cache(
         self,

synth_ai/{zyk/lms → lm}/caching/initialize.py

@@ -1,9 +1,7 @@
-from synth_ai.zyk.lms.caching.handler import CacheHandler
+from synth_ai.lm.caching.handler import CacheHandler
 
 cache_handler = CacheHandler(use_ephemeral_store=True, use_persistent_store=True)
-ephemeral_cache_handler = CacheHandler(
-    use_ephemeral_store=True, use_persistent_store=False
-)
+ephemeral_cache_handler = CacheHandler(use_ephemeral_store=True, use_persistent_store=False)
 
 
 def get_cache_handler(use_ephemeral_cache_only: bool = False):

synth_ai/{zyk/lms → lm}/caching/persistent.py

@@ -6,7 +6,7 @@ from typing import Optional, Type, Union
 
 from pydantic import BaseModel
 
-from synth_ai.zyk.lms.vendors.base import BaseLMResponse
+from synth_ai.lm.vendors.base import BaseLMResponse
 
 
 @dataclass
@@ -31,14 +31,10 @@ class PersistentCache:
             cache_data = json.loads(result[0])
         except json.JSONDecodeError:
             # Handle legacy string responses
-            return BaseLMResponse(
-                raw_response=result[0], structured_output=None, tool_calls=None
-            )
+            return BaseLMResponse(raw_response=result[0], structured_output=None, tool_calls=None)
 
         if not isinstance(cache_data, dict):
-            return BaseLMResponse(
-                raw_response=cache_data, structured_output=None, tool_calls=None
-            )
+            return BaseLMResponse(raw_response=cache_data, structured_output=None, tool_calls=None)
 
         raw_response = cache_data.get("raw_response")
         tool_calls = cache_data.get("tool_calls")
@@ -61,9 +57,7 @@ class PersistentCache:
                 "raw_response": response.raw_response
                 if response.raw_response is not None
                 else None,
-                "tool_calls": response.tool_calls
-                if response.tool_calls is not None
-                else None,
+                "tool_calls": response.tool_calls if response.tool_calls is not None else None,
                 "structured_output": (
                     response.structured_output.model_dump()
                     if response.structured_output is not None

synth_ai/{zyk/lms → lm}/config.py

@@ -7,4 +7,5 @@ def should_use_cache() -> bool:
     cache_env = os.getenv("USE_ZYK_CACHE", "true").lower()
     return cache_env not in ("false", "0", "no")
 
-reasoning_models = ["o1","o3-mini", "o3", "o4-mini", "claude-3-7-sonnet-latest"]
+
+reasoning_models = ["o1", "o3-mini", "o3", "o4-mini", "claude-3-7-sonnet-latest"]

synth_ai/{zyk/lms → lm}/constants.py

@@ -1,4 +1,4 @@
-OPENAI_REASONING_MODELS = ["o4", "o4-mini", "o3","o3-mini", "o1-mini", "o1"]
+OPENAI_REASONING_MODELS = ["o4", "o4-mini", "o3", "o3-mini", "o1-mini", "o1"]
 CLAUDE_REASONING_MODELS = ["claude-3-7-sonnet-latest"]
 GEMINI_REASONING_MODELS = ["gemini-2.5-flash", "gemini-2.5-pro"]
 
@@ -19,4 +19,4 @@ SONNET_37_BUDGETS = {
 
 REASONING_MODELS = OPENAI_REASONING_MODELS + CLAUDE_REASONING_MODELS + GEMINI_REASONING_MODELS
 
-SPECIAL_BASE_TEMPS = {model: 1 for model in REASONING_MODELS}
+SPECIAL_BASE_TEMPS = {model: 1 for model in REASONING_MODELS}

synth_ai/{zyk/lms → lm}/core/all.py

@@ -1,16 +1,16 @@
-from synth_ai.zyk.lms.vendors.core.anthropic_api import AnthropicAPI
-from synth_ai.zyk.lms.vendors.core.gemini_api import GeminiAPI
-from synth_ai.zyk.lms.vendors.core.openai_api import (
+from synth_ai.lm.vendors.core.anthropic_api import AnthropicAPI
+from synth_ai.lm.vendors.core.gemini_api import GeminiAPI
+from synth_ai.lm.vendors.core.openai_api import (
     OpenAIPrivate,
     OpenAIStructuredOutputClient,
 )
-from synth_ai.zyk.lms.vendors.supported.deepseek import DeepSeekAPI
-from synth_ai.zyk.lms.vendors.supported.together import TogetherAPI
-from synth_ai.zyk.lms.vendors.supported.groq import GroqAPI
-from synth_ai.zyk.lms.vendors.supported.grok import GrokAPI
-from synth_ai.zyk.lms.vendors.core.mistral_api import MistralAPI
-from synth_ai.zyk.lms.vendors.supported.custom_endpoint import CustomEndpointAPI
-from synth_ai.zyk.lms.vendors.supported.openrouter import OpenRouterAPI
+from synth_ai.lm.vendors.supported.deepseek import DeepSeekAPI
+from synth_ai.lm.vendors.supported.together import TogetherAPI
+from synth_ai.lm.vendors.supported.groq import GroqAPI
+from synth_ai.lm.vendors.supported.grok import GrokAPI
+from synth_ai.lm.vendors.core.mistral_api import MistralAPI
+from synth_ai.lm.vendors.supported.custom_endpoint import CustomEndpointAPI
+from synth_ai.lm.vendors.supported.openrouter import OpenRouterAPI
 
 
 class OpenAIClient(OpenAIPrivate):