blaxel 0.2.33__py3-none-any.whl → 0.2.35__py3-none-any.whl

blaxel/core/sandbox/types.py

@@ -155,6 +155,7 @@ class SandboxCreateConfiguration:
         region: str | None = None,
         lifecycle: Union[SandboxLifecycle, Dict[str, Any]] | None = None,
         snapshot_enabled: bool | None = None,
+        labels: Dict[str, str] | None = None,
     ):
         self.name = name
         self.image = image
@@ -167,6 +168,7 @@ class SandboxCreateConfiguration:
         self.region = region
         self.lifecycle = lifecycle
         self.snapshot_enabled = snapshot_enabled
+        self.labels = labels
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "SandboxCreateConfiguration":
@@ -190,6 +192,7 @@ class SandboxCreateConfiguration:
             region=data.get("region"),
             lifecycle=lifecycle,
             snapshot_enabled=data.get("snapshot_enabled"),
+            labels=data.get("labels"),
         )
 
     def _normalize_ports(self) -> List[Port] | None:

blaxel/core/tools/common.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Type
+from typing import Any, Dict, List, Type, Union
 
 from pydantic import BaseModel, Field, create_model
 
@@ -13,6 +13,20 @@ json_type_mapping: Dict[str, Type] = {
 }
 
 
+def _get_python_type_from_json_type(json_type: Union[str, List[str]]) -> Type:
+    """Convert JSON Schema type to Python type.
+
+    Handles both simple types ("string") and nullable types (["string", "null"]).
+    """
+    if isinstance(json_type, list):
+        # Filter out "null" and get the primary type
+        non_null_types = [t for t in json_type if t != "null"]
+        if non_null_types:
+            return json_type_mapping.get(non_null_types[0], str)
+        return type(None)
+    return json_type_mapping.get(json_type, str)
+
+
 def create_model_from_json_schema(
     schema: Dict[str, Any], model_name: str = "DynamicModel"
 ) -> Type[BaseModel]:
@@ -32,7 +46,7 @@ def create_model_from_json_schema(
 
     for field_name, field_schema in properties.items():
         json_type = field_schema.get("type", "string")
-        field_type = json_type_mapping.get(json_type, str)
+        field_type = _get_python_type_from_json_type(json_type)
         if field_name in required_fields:
             default_value = ...
         else:

blaxel/core/volume/__init__.py

@@ -1,5 +1,5 @@
 """Volume module for persistent storage management."""
 
-from .volume import VolumeCreateConfiguration, VolumeInstance
+from .volume import SyncVolumeInstance, VolumeAPIError, VolumeCreateConfiguration, VolumeInstance
 
-__all__ = ["VolumeInstance", "VolumeCreateConfiguration"]
+__all__ = ["VolumeInstance", "SyncVolumeInstance", "VolumeCreateConfiguration", "VolumeAPIError"]

blaxel/core/volume/volume.py

@@ -1,15 +1,65 @@
 import uuid
-from typing import Dict, Union
+from typing import Callable, Dict, List, Union
 
 from ..client.api.volumes.create_volume import asyncio as create_volume
+from ..client.api.volumes.create_volume import sync as create_volume_sync
 from ..client.api.volumes.delete_volume import asyncio as delete_volume
+from ..client.api.volumes.delete_volume import sync as delete_volume_sync
 from ..client.api.volumes.get_volume import asyncio as get_volume
+from ..client.api.volumes.get_volume import sync as get_volume_sync
 from ..client.api.volumes.list_volumes import asyncio as list_volumes
+from ..client.api.volumes.list_volumes import sync as list_volumes_sync
 from ..client.client import client
 from ..client.models import Metadata, Volume, VolumeSpec
+from ..client.models.error import Error
 from ..client.types import UNSET
 
 
+class VolumeAPIError(Exception):
+    """Exception raised when volume API returns an error."""
+
+    def __init__(self, message: str, status_code: int | None = None, code: str | None = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.code = code
+
+
+class _AsyncDeleteDescriptor:
+    """Descriptor that provides both class-level and instance-level delete functionality."""
+
+    def __init__(self, delete_func: Callable):
+        self._delete_func = delete_func
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            # Called on the class: VolumeInstance.delete("name")
+            return self._delete_func
+        else:
+            # Called on an instance: instance.delete()
+            async def instance_delete() -> Volume:
+                return await self._delete_func(instance.metadata.name or "")
+
+            return instance_delete
+
+
+class _SyncDeleteDescriptor:
+    """Descriptor that provides both class-level and instance-level delete functionality (sync)."""
+
+    def __init__(self, delete_func: Callable):
+        self._delete_func = delete_func
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            # Called on the class: SyncVolumeInstance.delete("name")
+            return self._delete_func
+        else:
+            # Called on an instance: instance.delete()
+            def instance_delete() -> Volume:
+                return self._delete_func(instance.metadata.name or "")
+
+            return instance_delete
+
+
 class VolumeCreateConfiguration:
     """Simplified configuration for creating volumes with default values."""
 
@@ -17,12 +67,14 @@ class VolumeCreateConfiguration:
         self,
         name: str | None = None,
         display_name: str | None = None,
+        labels: Dict[str, str] | None = None,
         size: int | None = None,  # Size in MB
         region: str | None = None,  # AWS region
         template: str | None = None,  # Template
     ):
         self.name = name
         self.display_name = display_name
+        self.labels = labels
         self.size = size
         self.region = region
         self.template = template
@@ -32,6 +84,7 @@ class VolumeCreateConfiguration:
         return cls(
             name=data.get("name"),
             display_name=data.get("display_name"),
+            labels=data.get("labels"),
             size=data.get("size"),
             region=data.get("region"),
             template=data.get("template"),
@@ -90,6 +143,7 @@ class VolumeInstance:
                 metadata=Metadata(
                     name=config.name or default_name,
                     display_name=config.display_name or config.name or default_name,
+                    labels=config.labels,
                 ),
                 spec=VolumeSpec(
                     size=config.size or default_size,
@@ -103,6 +157,7 @@ class VolumeInstance:
                 metadata=Metadata(
                     name=volume_config.name or default_name,
                     display_name=volume_config.display_name or volume_config.name or default_name,
+                    labels=volume_config.labels,
                 ),
                 spec=VolumeSpec(
                     size=volume_config.size or default_size,
@@ -126,11 +181,19 @@ class VolumeInstance:
             volume.spec.size = default_size
 
         response = await create_volume(client=client, body=volume)
+        if isinstance(response, Error):
+            status_code = int(response.code) if response.code is not UNSET else None
+            message = response.message if response.message is not UNSET else response.error
+            raise VolumeAPIError(message, status_code=status_code, code=response.error)
         return cls(response)
 
     @classmethod
     async def get(cls, volume_name: str) -> "VolumeInstance":
         response = await get_volume(volume_name=volume_name, client=client)
+        if isinstance(response, Error):
+            status_code = int(response.code) if response.code is not UNSET else None
+            message = response.message if response.message is not UNSET else response.error
+            raise VolumeAPIError(message, status_code=status_code, code=response.error)
         return cls(response)
 
     @classmethod
@@ -138,11 +201,6 @@ class VolumeInstance:
         response = await list_volumes(client=client)
         return [cls(volume) for volume in response or []]
 
-    @classmethod
-    async def delete(cls, volume_name: str) -> Volume:
-        response = await delete_volume(volume_name=volume_name, client=client)
-        return response
-
     @classmethod
     async def create_if_not_exists(
         cls, config: Union[VolumeCreateConfiguration, Volume, Dict[str, any]]
@@ -150,11 +208,9 @@ class VolumeInstance:
         """Create a volume if it doesn't exist, otherwise return existing."""
         try:
             return await cls.create(config)
-        except Exception as e:
+        except VolumeAPIError as e:
             # Check if it's a 409 conflict error (volume already exists)
-            if (hasattr(e, "status_code") and e.status_code == 409) or (
-                hasattr(e, "code") and e.code in [409, "VOLUME_ALREADY_EXISTS"]
-            ):
+            if e.status_code == 409 or e.code in ["409", "VOLUME_ALREADY_EXISTS"]:
                 # Extract name from different configuration types
                 if isinstance(config, VolumeCreateConfiguration):
                     name = config.name
@@ -170,4 +226,164 @@ class VolumeInstance:
 
                 volume_instance = await cls.get(name)
                 return volume_instance
-            raise e
+            raise
+
+
+class SyncVolumeInstance:
+    """Synchronous volume instance for managing persistent storage."""
+
+    def __init__(self, volume: Volume):
+        self.volume = volume
+
+    @property
+    def metadata(self):
+        return self.volume.metadata
+
+    @property
+    def spec(self):
+        return self.volume.spec
+
+    @property
+    def status(self):
+        return self.volume.status
+
+    @property
+    def name(self):
+        return self.volume.metadata.name if self.volume.metadata else None
+
+    @property
+    def display_name(self):
+        return self.volume.metadata.display_name if self.volume.metadata else None
+
+    @property
+    def size(self):
+        return self.volume.spec.size if self.volume.spec else None
+
+    @property
+    def region(self):
+        return self.volume.spec.region if self.volume.spec else None
+
+    @property
+    def template(self):
+        return self.volume.spec.template if self.volume.spec else None
+
+    @classmethod
+    def create(
+        cls, config: Union[VolumeCreateConfiguration, Volume, Dict[str, any]]
+    ) -> "SyncVolumeInstance":
+        """Create a new volume synchronously."""
+        # Generate default values
+        default_name = f"volume-{uuid.uuid4().hex[:8]}"
+        default_size = 1024  # 1GB in MB
+
+        # Handle different configuration types
+        if isinstance(config, Volume):
+            volume = config
+        elif isinstance(config, VolumeCreateConfiguration):
+            volume = Volume(
+                metadata=Metadata(
+                    name=config.name or default_name,
+                    display_name=config.display_name or config.name or default_name,
+                    labels=config.labels,
+                ),
+                spec=VolumeSpec(
+                    size=config.size or default_size,
+                    region=config.region or UNSET,
+                    template=config.template or UNSET,
+                ),
+            )
+        elif isinstance(config, dict):
+            volume_config = VolumeCreateConfiguration.from_dict(config)
+            volume = Volume(
+                metadata=Metadata(
+                    name=volume_config.name or default_name,
+                    display_name=volume_config.display_name or volume_config.name or default_name,
+                    labels=volume_config.labels,
+                ),
+                spec=VolumeSpec(
+                    size=volume_config.size or default_size,
+                    region=volume_config.region or UNSET,
+                    template=volume_config.template or UNSET,
+                ),
+            )
+        else:
+            raise ValueError(
+                f"Invalid config type: {type(config)}. Expected VolumeCreateConfiguration, Volume, or dict."
+            )
+
+        # Ensure required fields have defaults
+        if not volume.metadata:
+            volume.metadata = Metadata(name=default_name)
+        if not volume.metadata.name:
+            volume.metadata.name = default_name
+        if not volume.spec:
+            volume.spec = VolumeSpec(size=default_size)
+        if not volume.spec.size:
+            volume.spec.size = default_size
+
+        response = create_volume_sync(client=client, body=volume)
+        if isinstance(response, Error):
+            status_code = int(response.code) if response.code is not UNSET else None
+            message = response.message if response.message is not UNSET else response.error
+            raise VolumeAPIError(message, status_code=status_code, code=response.error)
+        return cls(response)
+
+    @classmethod
+    def get(cls, volume_name: str) -> "SyncVolumeInstance":
+        """Get a volume by name synchronously."""
+        response = get_volume_sync(volume_name=volume_name, client=client)
+        if isinstance(response, Error):
+            status_code = int(response.code) if response.code is not UNSET else None
+            message = response.message if response.message is not UNSET else response.error
+            raise VolumeAPIError(message, status_code=status_code, code=response.error)
+        return cls(response)
+
+    @classmethod
+    def list(cls) -> List["SyncVolumeInstance"]:
+        """List all volumes synchronously."""
+        response = list_volumes_sync(client=client)
+        return [cls(volume) for volume in response or []]
+
+    @classmethod
+    def create_if_not_exists(
+        cls, config: Union[VolumeCreateConfiguration, Volume, Dict[str, any]]
+    ) -> "SyncVolumeInstance":
+        """Create a volume if it doesn't exist, otherwise return existing."""
+        try:
+            return cls.create(config)
+        except VolumeAPIError as e:
+            # Check if it's a 409 conflict error (volume already exists)
+            if e.status_code == 409 or e.code in ["409", "VOLUME_ALREADY_EXISTS"]:
+                # Extract name from different configuration types
+                if isinstance(config, VolumeCreateConfiguration):
+                    name = config.name
+                elif isinstance(config, dict):
+                    name = config.get("name")
+                elif isinstance(config, Volume):
+                    name = config.metadata.name if config.metadata else None
+                else:
+                    name = None
+
+                if not name:
+                    raise ValueError("Volume name is required")
+
+                volume_instance = cls.get(name)
+                return volume_instance
+            raise
+
+
+async def _delete_volume_by_name(volume_name: str) -> Volume:
+    """Delete a volume by name (async)."""
+    response = await delete_volume(volume_name=volume_name, client=client)
+    return response
+
+
+def _delete_volume_by_name_sync(volume_name: str) -> Volume:
+    """Delete a volume by name (sync)."""
+    response = delete_volume_sync(volume_name=volume_name, client=client)
+    return response
+
+
+# Assign the delete descriptors to support both class-level and instance-level calls
+VolumeInstance.delete = _AsyncDeleteDescriptor(_delete_volume_by_name)
+SyncVolumeInstance.delete = _SyncDeleteDescriptor(_delete_volume_by_name_sync)

blaxel/langgraph/tools.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Dict
 
 from langchain_core.tools import StructuredTool
 from mcp.types import (
@@ -14,6 +14,35 @@ from blaxel.core.tools.types import Tool, ToolException
 NonTextContent = ImageContent | EmbeddedResource
 
 
+def _clean_schema_for_openai(schema: Dict[str, Any]) -> Dict[str, Any]:
+    """Clean JSON schema to be compatible with OpenAI function calling.
+
+    OpenAI requires object schemas to have a 'properties' field, even if empty.
+    This function ensures the schema is properly formatted.
+    """
+    if not isinstance(schema, dict):
+        return schema
+
+    cleaned = schema.copy()
+
+    # Ensure object type schemas have properties
+    if cleaned.get("type") == "object":
+        if "properties" not in cleaned:
+            cleaned["properties"] = {}
+        if "required" not in cleaned:
+            cleaned["required"] = []
+
+    # Recursively clean nested schemas
+    if "properties" in cleaned:
+        cleaned["properties"] = {
+            k: _clean_schema_for_openai(v) for k, v in cleaned["properties"].items()
+        }
+    if "items" in cleaned and isinstance(cleaned["items"], dict):
+        cleaned["items"] = _clean_schema_for_openai(cleaned["items"])
+
+    return cleaned
+
+
 def get_langchain_tool(tool: Tool) -> StructuredTool:
     async def langchain_coroutine(
         **arguments: dict[str, Any],
@@ -36,10 +65,13 @@ def get_langchain_tool(tool: Tool) -> StructuredTool:
 
         return tool_content, non_text_contents or None
 
+    # Clean the schema to ensure OpenAI compatibility
+    cleaned_schema = _clean_schema_for_openai(tool.input_schema)
+
     return StructuredTool(
         name=tool.name,
         description=tool.description,
-        args_schema=tool.input_schema,
+        args_schema=cleaned_schema,
         coroutine=langchain_coroutine,
         sync_coroutine=tool.sync_coroutine,
     )

blaxel/openai/tools.py

@@ -7,6 +7,36 @@ from blaxel.core.tools import bl_tools as bl_tools_core
 from blaxel.core.tools.types import Tool
 
 
+def _clean_schema_for_openai(schema: dict) -> dict:
+    """Clean JSON schema to be compatible with OpenAI agents SDK.
+
+    OpenAI agents SDK doesn't allow additionalProperties on object types.
+    This function recursively removes additionalProperties and $schema fields.
+    """
+    if not isinstance(schema, dict):
+        return schema
+
+    cleaned_schema = schema.copy()
+
+    # Remove $schema and additionalProperties at current level
+    if "$schema" in cleaned_schema:
+        del cleaned_schema["$schema"]
+    if "additionalProperties" in cleaned_schema:
+        del cleaned_schema["additionalProperties"]
+
+    # Recursively clean properties if they exist
+    if "properties" in cleaned_schema:
+        cleaned_schema["properties"] = {
+            k: _clean_schema_for_openai(v) for k, v in cleaned_schema["properties"].items()
+        }
+
+    # Recursively clean items for array types
+    if "items" in cleaned_schema:
+        cleaned_schema["items"] = _clean_schema_for_openai(cleaned_schema["items"])
+
+    return cleaned_schema
+
+
 def get_openai_tool(tool: Tool) -> FunctionTool:
     async def openai_coroutine(
         _: RunContextWrapper,
@@ -15,10 +45,12 @@ def get_openai_tool(tool: Tool) -> FunctionTool:
         result = await tool.coroutine(**json.loads(arguments))
         return result
 
+    cleaned_schema = _clean_schema_for_openai(tool.input_schema)
+
     return FunctionTool(
         name=tool.name,
         description=tool.description,
-        params_json_schema=tool.input_schema,
+        params_json_schema=cleaned_schema,
         on_invoke_tool=openai_coroutine,
     )
 

{blaxel-0.2.33.dist-info → blaxel-0.2.35.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blaxel
-Version: 0.2.33
+Version: 0.2.35
 Summary: Blaxel - AI development platform SDK
 Project-URL: Homepage, https://blaxel.ai
 Project-URL: Documentation, https://docs.blaxel.ai
@@ -23,7 +23,7 @@ Provides-Extra: all
 Requires-Dist: crewai==0.159.0; extra == 'all'
 Requires-Dist: google-adk>=1.4.0; extra == 'all'
 Requires-Dist: langchain-anthropic>=0.3.10; extra == 'all'
-Requires-Dist: langchain-cerebras>=0.5.0; extra == 'all'
+Requires-Dist: langchain-cerebras<0.6.0,>=0.5.0; extra == 'all'
 Requires-Dist: langchain-cohere>=0.4.3; extra == 'all'
 Requires-Dist: langchain-community<0.4.0,>=0.3.3; extra == 'all'
 Requires-Dist: langchain-core<0.4.0,>=0.3.13; extra == 'all'
@@ -74,7 +74,7 @@ Requires-Dist: google-adk>=1.4.0; extra == 'googleadk'
 Requires-Dist: litellm>=1.63.11; extra == 'googleadk'
 Provides-Extra: langgraph
 Requires-Dist: langchain-anthropic>=0.3.10; extra == 'langgraph'
-Requires-Dist: langchain-cerebras>=0.5.0; extra == 'langgraph'
+Requires-Dist: langchain-cerebras<0.6.0,>=0.5.0; extra == 'langgraph'
 Requires-Dist: langchain-cohere>=0.4.3; extra == 'langgraph'
 Requires-Dist: langchain-community<0.4.0,>=0.3.3; extra == 'langgraph'
 Requires-Dist: langchain-core<0.4.0,>=0.3.13; extra == 'langgraph'