blaxel 0.2.2rc79__py3-none-any.whl → 0.2.4__py3-none-any.whl

blaxel/core/client/models/job_spec.py

@@ -11,6 +11,7 @@ if TYPE_CHECKING:
     from ..models.model_private_cluster import ModelPrivateCluster
     from ..models.revision_configuration import RevisionConfiguration
     from ..models.runtime import Runtime
+    from ..models.trigger import Trigger
 
 
 T = TypeVar("T", bound="JobSpec")
@@ -30,6 +31,7 @@ class JobSpec:
         revision (Union[Unset, RevisionConfiguration]): Revision configuration
         runtime (Union[Unset, Runtime]): Set of configurations for a deployment
         sandbox (Union[Unset, bool]): Sandbox mode
+        triggers (Union[Unset, list['Trigger']]): Triggers to use your agent
     """
 
     configurations: Union[Unset, "CoreSpecConfigurations"] = UNSET
@@ -41,6 +43,7 @@ class JobSpec:
     revision: Union[Unset, "RevisionConfiguration"] = UNSET
     runtime: Union[Unset, "Runtime"] = UNSET
     sandbox: Union[Unset, bool] = UNSET
+    triggers: Union[Unset, list["Trigger"]] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -98,6 +101,16 @@ class JobSpec:
 
         sandbox = self.sandbox
 
+        triggers: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.triggers, Unset):
+            triggers = []
+            for componentsschemas_triggers_item_data in self.triggers:
+                if type(componentsschemas_triggers_item_data) is dict:
+                    componentsschemas_triggers_item = componentsschemas_triggers_item_data
+                else:
+                    componentsschemas_triggers_item = componentsschemas_triggers_item_data.to_dict()
+                triggers.append(componentsschemas_triggers_item)
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
@@ -119,6 +132,8 @@ class JobSpec:
             field_dict["runtime"] = runtime
         if sandbox is not UNSET:
             field_dict["sandbox"] = sandbox
+        if triggers is not UNSET:
+            field_dict["triggers"] = triggers
 
         return field_dict
 
@@ -129,6 +144,7 @@ class JobSpec:
         from ..models.model_private_cluster import ModelPrivateCluster
         from ..models.revision_configuration import RevisionConfiguration
         from ..models.runtime import Runtime
+        from ..models.trigger import Trigger
 
         if not src_dict:
             return None
@@ -176,6 +192,13 @@ class JobSpec:
 
         sandbox = d.pop("sandbox", UNSET)
 
+        triggers = []
+        _triggers = d.pop("triggers", UNSET)
+        for componentsschemas_triggers_item_data in _triggers or []:
+            componentsschemas_triggers_item = Trigger.from_dict(componentsschemas_triggers_item_data)
+
+            triggers.append(componentsschemas_triggers_item)
+
         job_spec = cls(
             configurations=configurations,
             enabled=enabled,
@@ -186,6 +209,7 @@ class JobSpec:
             revision=revision,
             runtime=runtime,
             sandbox=sandbox,
+            triggers=triggers,
         )
 
         job_spec.additional_properties = d

blaxel/core/client/models/trigger.py

@@ -17,7 +17,7 @@ class Trigger:
     """Trigger configuration
 
     Attributes:
-        configuration (Union[Unset, TriggerConfiguration]): The configuration of the trigger
+        configuration (Union[Unset, TriggerConfiguration]): Trigger configuration
         id (Union[Unset, str]): The id of the trigger
         type_ (Union[Unset, str]): The type of trigger, can be http or http-async
     """

blaxel/core/client/models/trigger_configuration.py

@@ -1,20 +1,50 @@
-from typing import Any, TypeVar
+from typing import Any, TypeVar, Union
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
+from ..types import UNSET, Unset
+
 T = TypeVar("T", bound="TriggerConfiguration")
 
 
 @_attrs_define
 class TriggerConfiguration:
-    """The configuration of the trigger"""
+    """Trigger configuration
+
+    Attributes:
+        authentication_type (Union[Unset, str]): The authentication type of the trigger
+        path (Union[Unset, str]): The path of the trigger
+        retry (Union[Unset, int]): The retry of the trigger
+        schedule (Union[Unset, str]): The schedule of the trigger, cron expression * * * * *
+    """
 
+    authentication_type: Union[Unset, str] = UNSET
+    path: Union[Unset, str] = UNSET
+    retry: Union[Unset, int] = UNSET
+    schedule: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+        authentication_type = self.authentication_type
+
+        path = self.path
+
+        retry = self.retry
+
+        schedule = self.schedule
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if authentication_type is not UNSET:
+            field_dict["authenticationType"] = authentication_type
+        if path is not UNSET:
+            field_dict["path"] = path
+        if retry is not UNSET:
+            field_dict["retry"] = retry
+        if schedule is not UNSET:
+            field_dict["schedule"] = schedule
 
         return field_dict
 
@@ -23,7 +53,20 @@ class TriggerConfiguration:
         if not src_dict:
             return None
         d = src_dict.copy()
-        trigger_configuration = cls()
+        authentication_type = d.pop("authenticationType", UNSET)
+
+        path = d.pop("path", UNSET)
+
+        retry = d.pop("retry", UNSET)
+
+        schedule = d.pop("schedule", UNSET)
+
+        trigger_configuration = cls(
+            authentication_type=authentication_type,
+            path=path,
+            retry=retry,
+            schedule=schedule,
+        )
 
         trigger_configuration.additional_properties = d
         return trigger_configuration

blaxel/core/sandbox/client/models/success_response.py

@@ -1,8 +1,10 @@
-from typing import Any, TypeVar
+from typing import Any, TypeVar, Union
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
+from ..types import UNSET, Unset
+
 T = TypeVar("T", bound="SuccessResponse")
 
 
@@ -11,11 +13,11 @@ class SuccessResponse:
     """
     Attributes:
         message (str):  Example: File created successfully.
-        path (str):  Example: /path/to/file.
+        path (Union[Unset, str]):  Example: /path/to/file.
     """
 
     message: str
-    path: str
+    path: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -28,9 +30,10 @@ class SuccessResponse:
         field_dict.update(
             {
                 "message": message,
-                "path": path,
             }
         )
+        if path is not UNSET:
+            field_dict["path"] = path
 
         return field_dict
 
@@ -41,7 +44,7 @@ class SuccessResponse:
         d = src_dict.copy()
         message = d.pop("message")
 
-        path = d.pop("path")
+        path = d.pop("path", UNSET)
 
         success_response = cls(
             message=message,

blaxel/core/sandbox/preview.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, Dict, List, Optional, Union
 
+from ..client import errors
 from ..client.api.compute.create_sandbox_preview import (
     asyncio as create_sandbox_preview,
 )
@@ -47,18 +48,21 @@ class SandboxPreviewToken:
 class SandboxPreviewTokens:
     """Manages preview tokens for a sandbox preview."""
 
-    def __init__(self, preview: Preview, sandbox_name: str):
+    def __init__(self, preview: Preview):
         self.preview = preview
-        self.sandbox_name = sandbox_name
 
     @property
     def preview_name(self) -> str:
         return self.preview.metadata.name if self.preview.metadata else ""
 
+    @property
+    def resource_name(self) -> str:
+        return self.preview.metadata.resource_name if self.preview.metadata else ""
+
     async def create(self, expires_at: datetime) -> SandboxPreviewToken:
         """Create a new preview token."""
         response: PreviewToken = await create_sandbox_preview_token(
-            self.sandbox_name,
+            self.resource_name,
             self.preview_name,
             body=PreviewToken(
                 spec=PreviewTokenSpec(
@@ -72,7 +76,7 @@ class SandboxPreviewTokens:
     async def list(self) -> List[SandboxPreviewToken]:
         """List all preview tokens."""
         response: List[PreviewToken] = await list_sandbox_preview_tokens(
-            self.sandbox_name,
+            self.resource_name,
             self.preview_name,
             client=client,
         )
@@ -81,7 +85,7 @@ class SandboxPreviewTokens:
     async def delete(self, token_name: str) -> dict:
         """Delete a preview token."""
         response: PreviewToken = await delete_sandbox_preview_token(
-            self.sandbox_name,
+            self.resource_name,
             self.preview_name,
             token_name,
             client=client,
@@ -92,10 +96,9 @@ class SandboxPreviewTokens:
 class SandboxPreview:
     """Represents a sandbox preview with its metadata and tokens."""
 
-    def __init__(self, preview: Preview, sandbox_name: str = ""):
+    def __init__(self, preview: Preview):
         self.preview = preview
-        self.sandbox_name = sandbox_name
-        self.tokens = SandboxPreviewTokens(preview, sandbox_name)
+        self.tokens = SandboxPreviewTokens(preview)
 
     @property
     def name(self) -> str:
@@ -140,6 +143,24 @@ class SandboxPreviews:
         )
         return SandboxPreview(response)
 
+    async def create_if_not_exists(self, preview: Union[Preview, Dict[str, Any]]) -> SandboxPreview:
+        """Create a preview if it doesn't exist, otherwise return the existing one."""
+        if isinstance(preview, dict):
+            preview = Preview.from_dict(preview)
+
+        preview_name = preview.metadata.name if preview.metadata else ""
+
+        try:
+            # Try to get existing preview
+            existing_preview = await self.get(preview_name)
+            return existing_preview
+        except errors.UnexpectedStatus as e:
+            # If 404, create the preview
+            if e.status_code == 404:
+                return await self.create(preview)
+            # For any other error, re-raise
+            raise e
+
     async def get(self, preview_name: str) -> SandboxPreview:
         """Get a specific preview by name."""
         response: Preview = await get_sandbox_preview(

blaxel/core/sandbox/sandbox.py

@@ -77,7 +77,7 @@ class SandboxInstance:
         default_image = "blaxel/prod-base:latest"
         default_memory = 4096
 
-        # Handle SandboxCreateConfiguration or simple dict with name/image/memory/ports keys
+        # Handle SandboxCreateConfiguration or simple dict with name/image/memory/ports/envs keys
         if (
             sandbox is None
             or isinstance(sandbox, SandboxCreateConfiguration | dict)
@@ -89,6 +89,7 @@ class SandboxInstance:
                     or "image" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                     or "memory" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                     or "ports" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
+                    or "envs" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                 )
             )
         ):
@@ -102,12 +103,13 @@ class SandboxInstance:
             image = sandbox.image or default_image
             memory = sandbox.memory or default_memory
             ports = sandbox._normalize_ports() or UNSET
+            envs = sandbox._normalize_envs() or UNSET
 
             # Create full Sandbox object
             sandbox = Sandbox(
                 metadata=Metadata(name=name),
                 spec=SandboxSpec(
-                    runtime=Runtime(image=image, memory=memory, ports=ports, generation="mk3")
+                    runtime=Runtime(image=image, memory=memory, ports=ports, envs=envs, generation="mk3")
                 ),
             )
         else:

blaxel/core/sandbox/session.py

@@ -46,7 +46,7 @@ class SandboxSessions:
             self.sandbox_name, client=client, body=preview_body
         )
 
-        preview = SandboxPreview(preview_response, self.sandbox_name)
+        preview = SandboxPreview(preview_response)
         token_obj = await preview.tokens.create(expires_at)
 
         return SessionWithToken(
@@ -71,8 +71,23 @@ class SandboxSessions:
         threshold = now + timedelta(seconds=delta_seconds)
 
         if all_sessions:
+            all_sessions.sort(
+                key=lambda s: datetime.fromisoformat(s.expires_at)
+                if isinstance(s.expires_at, str)
+                else s.expires_at
+            )
             session_data = all_sessions[0]
-            if session_data.expires_at < threshold:
+            expires_at = datetime.fromisoformat(session_data.expires_at)
+
+            # Make both datetimes timezone-aware or timezone-naive for comparison
+            if expires_at.tzinfo is not None and threshold.tzinfo is None:
+                # expires_at is timezone-aware, make threshold timezone-aware too
+                threshold = threshold.replace(tzinfo=expires_at.tzinfo)
+            elif expires_at.tzinfo is None and threshold.tzinfo is not None:
+                # threshold is timezone-aware, make expires_at timezone-aware too
+                expires_at = expires_at.replace(tzinfo=threshold.tzinfo)
+
+            if expires_at < threshold:
                 await self.delete(session_data.name)
                 session_data = await self.create(options)
         else:

blaxel/core/sandbox/types.py

@@ -113,11 +113,13 @@ class SandboxCreateConfiguration:
         image: Optional[str] = None,
         memory: Optional[int] = None,
         ports: Optional[Union[List[Port], List[Dict[str, Any]]]] = None,
+        envs: Optional[List[Dict[str, str]]] = None,
     ):
         self.name = name
         self.image = image
         self.memory = memory
         self.ports = ports
+        self.envs = envs
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "SandboxCreateConfiguration":
@@ -126,6 +128,7 @@ class SandboxCreateConfiguration:
             image=data.get("image"),
             memory=data.get("memory"),
             ports=data.get("ports"),
+            envs=data.get("envs"),
         )
 
     def _normalize_ports(self) -> Optional[List[Port]]:
@@ -150,3 +153,20 @@ class SandboxCreateConfiguration:
                 raise ValueError(f"Invalid port type: {type(port)}. Expected Port object or dict.")
 
         return port_objects
+
+    def _normalize_envs(self) -> Optional[List[Dict[str, str]]]:
+        """Convert envs to list of dicts with name and value keys."""
+        if not self.envs:
+            return None
+
+        env_objects = []
+        for env in self.envs:
+            if isinstance(env, dict):
+                # Validate that the dict has the required keys
+                if "name" not in env or "value" not in env:
+                    raise ValueError(f"Environment variable dict must have 'name' and 'value' keys: {env}")
+                env_objects.append({"name": env["name"], "value": env["value"]})
+            else:
+                raise ValueError(f"Invalid env type: {type(env)}. Expected dict with 'name' and 'value' keys.")
+
+        return env_objects

blaxel/core/tools/__init__.py

@@ -22,12 +22,15 @@ if os.getenv("BL_SERVER_PORT"):
 
 
 class PersistentWebSocket:
-    def __init__(
-        self, url: str, name: str, timeout: int = DEFAULT_TIMEOUT, timeout_enabled: bool = True
-    ):
-        self.url = url
+    def __init__(self, name: str, timeout: int = DEFAULT_TIMEOUT, timeout_enabled: bool = True):
         self.name = name
         self.timeout = timeout
+        self.type = "function"
+        self.pluralType = "functions"
+        if name.startswith("sandbox/") or name.startswith("sandboxes/"):
+            self.name = name.split("/")[1]
+            self.type = "sandbox"
+            self.pluralType = "sandboxes"
         self.session_exit_stack = AsyncExitStack()
         self.client_exit_stack = AsyncExitStack()
         self.session: ClientSession = None
@@ -37,6 +40,42 @@ class PersistentWebSocket:
             self.timeout_enabled = False
         else:
             self.timeout_enabled = timeout_enabled
+        self.use_fallback_url = False
+
+    @property
+    def _internal_url(self):
+        """Get the internal URL for the agent using a hash of workspace and agent name."""
+        hash = get_global_unique_hash(settings.workspace, self.type, self.name)
+        return f"{settings.run_internal_protocol}://bl-{settings.env}-{hash}.{settings.run_internal_hostname}"
+
+    @property
+    def _forced_url(self):
+        """Get the forced URL from environment variables if set."""
+        return get_forced_url(self.type, self.name)
+
+    @property
+    def _external_url(self):
+        return f"{settings.run_url}/{settings.workspace}/{self.pluralType}/{self.name}"
+
+    @property
+    def _fallback_url(self):
+        if self._external_url != self._url:
+            return self._external_url
+        return None
+
+    @property
+    def _url(self):
+        if self.use_fallback_url:
+            return self._fallback_url
+        logger.debug(f"Getting URL for {self.name}")
+        if self._forced_url:
+            logger.debug(f"Forced URL found for {self.name}: {self._forced_url}")
+            return self._forced_url
+        if settings.run_internal_hostname:
+            logger.debug(f"Internal hostname found for {self.name}: {self._internal_url}")
+            return self._internal_url
+        logger.debug(f"No URL found for {self.name}, using external URL")
+        return self._external_url
 
     def with_metas(self, metas: dict[str, Any]):
         self.metas = metas
@@ -44,7 +83,7 @@ class PersistentWebSocket:
 
     async def call_tool(self, tool_name: str, arguments: dict[str, Any]) -> CallToolResult:
         try:
-            await self._initialize()
+            await self.initialize()
             if self.timeout_enabled:
                 self._remove_timer()
             logger.debug(f"Calling tool {tool_name} with arguments {arguments}")
@@ -70,7 +109,7 @@ class PersistentWebSocket:
 
     async def list_tools(self):
         logger.debug(f"Listing tools for {self.name}")
-        await self._initialize()
+        await self.initialize()
         logger.debug(f"Initialized websocket for {self.name}")
         if self.timeout_enabled:
             self._remove_timer()
@@ -87,17 +126,23 @@ class PersistentWebSocket:
     def get_tools(self):
         return self.tools_cache
 
-    async def _initialize(self):
+    async def initialize(self, fallback: bool = False):
         if not self.session:
-            logger.debug(f"Initializing websocket client for {self.url}")
-            read, write = await self.client_exit_stack.enter_async_context(
-                websocket_client(self.url, settings.headers)
-            )
-            self.session = cast(
-                ClientSession,
-                await self.session_exit_stack.enter_async_context(ClientSession(read, write)),
-            )
-            await self.session.initialize()
+            try:
+                logger.debug(f"Initializing websocket client for {self._url}")
+                read, write = await self.client_exit_stack.enter_async_context(
+                    websocket_client(self._url, settings.headers)
+                )
+                self.session = cast(
+                    ClientSession,
+                    await self.session_exit_stack.enter_async_context(ClientSession(read, write)),
+                )
+                await self.session.initialize()
+            except Exception as e:
+                if not fallback:
+                    self.use_fallback_url = True
+                    return await self.initialize(fallback=True)
+                raise e
 
     def _reset_timer(self):
         self._remove_timer()
@@ -113,7 +158,7 @@ class PersistentWebSocket:
         self.session = None
 
     async def _close(self):
-        logger.debug(f"Closing websocket client {self.url}")
+        logger.debug(f"Closing websocket client {self._url}")
         if self.session:
             self.session = None
             try:
@@ -129,8 +174,6 @@ class PersistentWebSocket:
 
 def convert_mcp_tool_to_blaxel_tool(
     websocket_client: PersistentWebSocket,
-    name: str,
-    url: str,
     tool: MCPTool,
 ) -> Tool:
     """Convert an MCP tool to a blaxel tool.
@@ -193,34 +236,6 @@ class BlTools:
         self.timeout = timeout
         self.timeout_enabled = timeout_enabled
 
-    def _internal_url(self, name: str):
-        """Get the internal URL for the agent using a hash of workspace and agent name."""
-        hash = get_global_unique_hash(settings.workspace, "function", name)
-        return f"{settings.run_internal_protocol}://bl-{settings.env}-{hash}.{settings.run_internal_hostname}"
-
-    def _forced_url(self, name: str):
-        """Get the forced URL from environment variables if set."""
-        return get_forced_url("function", name)
-
-    def _external_url(self, name: str):
-        return f"{settings.run_url}/{settings.workspace}/functions/{name}"
-
-    def _fallback_url(self, name: str):
-        if self._external_url(name) != self._url(name):
-            return self._external_url(name)
-        return None
-
-    def _url(self, name: str):
-        logger.debug(f"Getting URL for {name}")
-        if self._forced_url(name):
-            logger.debug(f"Forced URL found for {name}: {self._forced_url(name)}")
-            return self._forced_url(name)
-        if settings.run_internal_hostname:
-            logger.debug(f"Internal hostname found for {name}: {self._internal_url(name)}")
-            return self._internal_url(name)
-        logger.debug(f"No URL found for {name}, using external URL")
-        return self._external_url(name)
-
     def get_tools(self) -> list[Tool]:
         """Get a list of all tools from all connected servers."""
         all_tools: list[Tool] = []
@@ -228,47 +243,21 @@ class BlTools:
             toolPersistances.get(name).with_metas(self.metas)
             websocket = toolPersistances.get(name)
             tools = websocket.get_tools()
-            converted_tools = [
-                convert_mcp_tool_to_blaxel_tool(websocket, name, self._url(name), tool)
-                for tool in tools
-            ]
+            converted_tools = [convert_mcp_tool_to_blaxel_tool(websocket, tool) for tool in tools]
             all_tools.extend(converted_tools)
         return all_tools
 
     async def connect(self, name: str):
         # Create and store the connection
-        try:
-            url = self._url(name)
-            await self.connect_with_url(name, url)
-        except Exception as e:
-            if not self._fallback_url(name):
-                raise e
-            logger.warning(f"Error connecting to {name}: {e}\n{traceback.format_exc()}")
-            url = self._fallback_url(name)
-            try:
-                await self.connect_with_url(name, url)
-            except Exception as e:
-                logger.error(
-                    f"Error connecting to {name} with fallback URL: {e}\n{traceback.format_exc()}"
-                )
-                raise e
-
-    async def connect_with_url(self, name: str, url: str) -> None:
-        """Initialize a session and load tools from it.
-
-        Args:
-            name: Name to identify this server connection
-            url: The URL to connect to
-        """
-        logger.debug(f"Initializing session and loading tools from {url}")
+        logger.debug("Initializing session and loading tools")
 
         if not toolPersistances.get(name):
             logger.debug(f"Creating new persistent websocket for {name}")
             toolPersistances[name] = PersistentWebSocket(
-                url, name, timeout=self.timeout, timeout_enabled=self.timeout_enabled
+                name, timeout=self.timeout, timeout_enabled=self.timeout_enabled
             )
             await toolPersistances[name].list_tools()
-        logger.debug(f"Loaded {len(toolPersistances[name].get_tools())} tools from {url}")
+        logger.debug(f"Loaded {len(toolPersistances[name].get_tools())} tools")
         return toolPersistances[name].with_metas(self.metas)
 
     async def initialize(self) -> "BlTools":

blaxel/crewai/tools.py

@@ -19,8 +19,8 @@ class CrewAITool(BaseTool):
     def _run(self, *args, **kwargs):
         return self._tool.sync_coroutine(**kwargs)
 
+
 async def bl_tools(tools_names: list[str], **kwargs) -> list[BaseTool]:
     tools = bl_tools_core(tools_names, **kwargs)
     await tools.initialize()
     return [CrewAITool(tool) for tool in tools.get_tools()]
-    return [CrewAITool(tool) for tool in tools.get_tools()]

blaxel/livekit/tools.py

@@ -8,23 +8,27 @@ def livekit_coroutine(tool: Tool):
     async def livekit_coroutine_wrapper(raw_arguments: dict[str, object]):
         result = await tool.coroutine(**raw_arguments)
         return result.model_dump_json()
+
     return livekit_coroutine_wrapper
 
+
 def get_livekit_tools(tools: list[Tool]) -> list[llm.FunctionTool]:
     livekit_tools = []
     for tool in tools:
-        livekit_tools.append(function_tool(
-            livekit_coroutine(tool),
-            raw_schema={
-                "name": tool.name,
-                "description": tool.description,
-                "parameters": tool.input_schema,
-            },
-        ))
+        livekit_tools.append(
+            function_tool(
+                livekit_coroutine(tool),
+                raw_schema={
+                    "name": tool.name,
+                    "description": tool.description,
+                    "parameters": tool.input_schema,
+                },
+            )
+        )
     return livekit_tools
 
+
 async def bl_tools(tools_names: list[str], **kwargs) -> list[llm.FunctionTool]:
     tools = bl_tools_core(tools_names, **kwargs)
     await tools.initialize()
     return get_livekit_tools(tools.get_tools())
-    return get_livekit_tools(tools.get_tools())

blaxel/openai/tools.py

@@ -9,8 +9,8 @@ from blaxel.core.tools.types import Tool
 
 def get_openai_tool(tool: Tool) -> FunctionTool:
     async def openai_coroutine(
-      _: RunContextWrapper,
-      arguments: dict[str, Any],
+        _: RunContextWrapper,
+        arguments: dict[str, Any],
     ) -> Any:
         result = await tool.coroutine(**json.loads(arguments))
         return result
@@ -22,8 +22,8 @@ def get_openai_tool(tool: Tool) -> FunctionTool:
         on_invoke_tool=openai_coroutine,
     )
 
+
 async def bl_tools(tools_names: list[str], **kwargs) -> list[FunctionTool]:
     tools = bl_tools_core(tools_names, **kwargs)
     await tools.initialize()
     return [get_openai_tool(tool) for tool in tools.get_tools()]
-    return [get_openai_tool(tool) for tool in tools.get_tools()]

{blaxel-0.2.2rc79.dist-info → blaxel-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blaxel
-Version: 0.2.2rc79
+Version: 0.2.4
 Summary: Blaxel - AI development platform SDK
 Project-URL: Homepage, https://blaxel.ai
 Project-URL: Documentation, https://docs.blaxel.ai
@@ -42,7 +42,7 @@ Requires-Dist: llama-index-llms-google-genai>=0.1.13; extra == 'all'
 Requires-Dist: llama-index-llms-groq>=0.3.1; extra == 'all'
 Requires-Dist: llama-index-llms-mistralai>=0.4.0; extra == 'all'
 Requires-Dist: llama-index-llms-openai>=0.3.42; extra == 'all'
-Requires-Dist: llama-index>=0.12.37; extra == 'all'
+Requires-Dist: llama-index>=0.12.46; extra == 'all'
 Requires-Dist: openai-agents>=0.0.19; extra == 'all'
 Requires-Dist: opentelemetry-exporter-otlp>=1.28.0; extra == 'all'
 Requires-Dist: opentelemetry-instrumentation-anthropic==0.40.6; extra == 'all'
@@ -92,7 +92,7 @@ Requires-Dist: llama-index-llms-google-genai>=0.1.13; extra == 'llamaindex'
 Requires-Dist: llama-index-llms-groq>=0.3.1; extra == 'llamaindex'
 Requires-Dist: llama-index-llms-mistralai>=0.4.0; extra == 'llamaindex'
 Requires-Dist: llama-index-llms-openai>=0.3.42; extra == 'llamaindex'
-Requires-Dist: llama-index>=0.12.37; extra == 'llamaindex'
+Requires-Dist: llama-index>=0.12.46; extra == 'llamaindex'
 Requires-Dist: opentelemetry-instrumentation-llamaindex>=0.40.7; extra == 'llamaindex'
 Provides-Extra: openai
 Requires-Dist: openai-agents>=0.0.19; extra == 'openai'

{blaxel-0.2.2rc79.dist-info → blaxel-0.2.4.dist-info}/RECORD

@@ -182,7 +182,7 @@ blaxel/core/client/models/job_metrics_executions_chart.py,sha256=OGBEQu-6vvdQJfc
 blaxel/core/client/models/job_metrics_executions_total.py,sha256=YSaxHgDPP4G2y24zFKpz5AfSSZKOqsfphOaNdr0Hxzw,1302
 blaxel/core/client/models/job_metrics_tasks_chart.py,sha256=fJ-Lr76ZF6L7UIhhU8vpRzlTpJ83XnCpmCXDlvb9204,1272
 blaxel/core/client/models/job_metrics_tasks_total.py,sha256=MjCKjj81S2LHWrnbNHXLt6LUxdZY-8vmzqbEVQFVlWY,1272
-blaxel/core/client/models/job_spec.py,sha256=tMwazR18WWjoRYHvttmqRadKCkNWJoWWHXinJ3pwgqY,8245
+blaxel/core/client/models/job_spec.py,sha256=ZhQ-YlQ53Yqty3qe7qGQxkeYrWupzJx18ehzNxVCl2c,9430
 blaxel/core/client/models/jobs_chart.py,sha256=XbpoY1WLbP9yRlw7NAY8_XmeQFavP5RQ43OpmvczBdQ,2944
 blaxel/core/client/models/jobs_chart_value.py,sha256=c-n9y3uc5TC_EBGTDm3_-vzRsEKCUSo7ep5YtxZTQUY,1892
 blaxel/core/client/models/jobs_executions.py,sha256=e9ryxYNPRPlE9a4ObwdbTMBFPi3gveGbd4QFuxO5lNA,2410
@@ -282,8 +282,8 @@ blaxel/core/client/models/token_rate_metric.py,sha256=iucEWvuDrmDBQYu_Q1fyFYN9R8
 blaxel/core/client/models/token_rate_metrics.py,sha256=nvhSYuA9E2Cc73_1gogoWIjtiVzn3u7xXe8iHmKN0aY,4404
 blaxel/core/client/models/token_total_metric.py,sha256=BPitBM2P79gGL-FkUE89_SPAdhXKeL5yw6lawvdlBnA,3919
 blaxel/core/client/models/trace_ids_response.py,sha256=0JuhxhKvwEd0qMPBzf3PAGa3eNR547xZ2VveIF0Ztdw,1256
-blaxel/core/client/models/trigger.py,sha256=88Gf1cjwDGwQZzKg5wtNtQF417vTgqo65mRfDCS94IA,2975
-blaxel/core/client/models/trigger_configuration.py,sha256=2uYMWxPW1dmy-B8NaVepe-J9MgTVmP5pbPRhQSbEAPA,1287
+blaxel/core/client/models/trigger.py,sha256=15LJZP4kCIP7U1CGfd0pY9icz2yvUltTndnE0MNTizk,2964
+blaxel/core/client/models/trigger_configuration.py,sha256=4GzaxybXJ0KSPcLgKg1vIB67MntlchmVgkh-RJez86g,2635
 blaxel/core/client/models/update_workspace_service_account_body.py,sha256=fz2MGqwRfrYkMmL8PaFHQdsu3RQcRljvP6n6JIru45o,2004
 blaxel/core/client/models/update_workspace_service_account_response_200.py,sha256=nCLPHFP_iR1MIpicgQMpbiyme97ZMfTFhyQUEbhzkHI,2968
 blaxel/core/client/models/update_workspace_user_role_body.py,sha256=FyLCWy9oRgUxoFPxxtrDvwzh1kHLkoTZ1pL5w3ayexM,1572
@@ -308,11 +308,11 @@ blaxel/core/sandbox/__init__.py,sha256=oF3sX5MbwSqfwhOtF5ODYWwapHffbkp2UI78jPBn7
 blaxel/core/sandbox/action.py,sha256=9Zjkco7YkLzBThD3N2Hr5SpeEiqU_-Ktk8HlKpkpiAg,2802
 blaxel/core/sandbox/filesystem.py,sha256=dyIvDdlPZO0ijD6mXXX8Yl0t75VijQ6_uMz_9rJd-_4,11317
 blaxel/core/sandbox/network.py,sha256=P5jLd4AAg1zgyIK4qGWvZaDZ5BzIcxRx2ffz_JLsLMI,357
-blaxel/core/sandbox/preview.py,sha256=M6FulOxPghUBpb5fLxu1Rd3ekLeCbZ_dgt4s1X2Cneo,5354
+blaxel/core/sandbox/preview.py,sha256=g0uVbMsIi8gRXmmyOfSyqm1qO4Cv6rsq92fs_k884dY,6120
 blaxel/core/sandbox/process.py,sha256=7zEngDTs2XiNsMm9TZ4lEDUiRpS3af8dw60pEvRuHDY,8357
-blaxel/core/sandbox/sandbox.py,sha256=3eJSWG0Y0jJsi1B5PK8BIvAEw-p0kP03vfUruYqAP14,8484
-blaxel/core/sandbox/session.py,sha256=4SH1tyXcQ9UqJx4lMwxAlp7x9Te_anDrdSEG6AlNkvU,4496
-blaxel/core/sandbox/types.py,sha256=ylvwCnqNXMtCrGaJ-saMwi1Tz9ky_5phnpwmx4HNwOI,4775
+blaxel/core/sandbox/sandbox.py,sha256=y6mV2-i6TsSZGQsvBBGptR514OfgvhV0hXBMEsOBcsY,8648
+blaxel/core/sandbox/session.py,sha256=3PfoekfdVzLYttsmKeK3MePhuprjqv_FDyVQTQME0OE,5277
+blaxel/core/sandbox/types.py,sha256=nsbvZLUxvDZkg2oExE3HdXx2qIpPaaoa7_lGYBzQ8Xk,5638
 blaxel/core/sandbox/client/__init__.py,sha256=N26bD5o1jsTb48oExow6Rgivd8ylaU9jaWZfZsVilP8,128
 blaxel/core/sandbox/client/client.py,sha256=tcP8cJ4Q3dV9aB3yQ01dDXO-ekfsa3WGGFz4DQAEf8I,7079
 blaxel/core/sandbox/client/errors.py,sha256=gO8GBmKqmSNgAg-E5oT-oOyxztvp7V_6XG7OUTT15q0,546
@@ -354,14 +354,14 @@ blaxel/core/sandbox/client/models/process_request_env.py,sha256=hzVPY4mk4g4bKj_S
 blaxel/core/sandbox/client/models/process_response.py,sha256=vXHK6NBnuf0KYVzpkaApC29KOKwDE-7jBxy_WszApXs,3239
 blaxel/core/sandbox/client/models/process_response_status.py,sha256=hCE1gCtheV83T6PYURG3k-rPZSauvyTFhsxLEtudgYE,246
 blaxel/core/sandbox/client/models/subdirectory.py,sha256=obztIgi_XjT4pPoT1-dyOX6O8k0e4ERZUTiI9qgkhJM,1593
-blaxel/core/sandbox/client/models/success_response.py,sha256=ksioQ0qNV7yhXlySY3_3EycsJ1ec7LSxBMwIq4HnfVQ,1703
-blaxel/core/tools/__init__.py,sha256=9_pgKEU5GbPfqfGN4aZTkthnaV4AVYf63jIZw44peBQ,10167
+blaxel/core/sandbox/client/models/success_response.py,sha256=m8Bj9GJjN4yYQsPszC68izkuTRzEE9DCHjOaDdIYeGg,1825
+blaxel/core/tools/__init__.py,sha256=OCZExds99o_j_GvAywaWFIGfY12abNZHcaiGOmAyh8o,9793
 blaxel/core/tools/common.py,sha256=JGK052v_fvwWBFYnIArlBnFFViYyFrqdDn3gdVf53EU,1332
 blaxel/core/tools/types.py,sha256=YPCGJ4vZDhqR0X2H_TWtc5chQScsC32nGTQdRKJlO8Y,707
 blaxel/crewai/__init__.py,sha256=HdAZxRDgC2zW-O5xYzb_Xuysb66_fMykNJVPxlTmFnY,123
 blaxel/crewai/model.py,sha256=VOLUE5tpz9tmYl7KU9L1kNUJ5uTci2rhRfPQ8HyCfWI,1785
 blaxel/crewai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-blaxel/crewai/tools.py,sha256=wMMZvSrmhuoFRFux2j31PeSVMbElhs5e49jtvRNxZxY,848
+blaxel/crewai/tools.py,sha256=HVMSRTVrc0ygiCCNkL6xa3i31IWwFlGKB6oC-6iWrK8,789
 blaxel/googleadk/__init__.py,sha256=WfYZvtkh5IF042qWLaiWjbDarJZCX9ghHGiTrat8eps,127
 blaxel/googleadk/model.py,sha256=ZSBGapgcrhRogc1kBFKfuLS36UUkcQL6nZD22yVUEJM,2236
 blaxel/googleadk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -374,7 +374,7 @@ blaxel/langgraph/custom/gemini.py,sha256=AkhpuVMXnh1CyJ0zR2NMTtxQFPPHtAdHf_cyNzV
 blaxel/livekit/__init__.py,sha256=byUwOJ6MHeSXOYXmaVoHnC3ZUmpkqJ55u5mQglXX-SQ,124
 blaxel/livekit/model.py,sha256=4HA6Jn4_jQ5QeH5mWMeopWybQDeiJcDRyh5kX5O9LHE,961
 blaxel/livekit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-blaxel/livekit/tools.py,sha256=-TnlCRB1toKNJi6ix2HvteQ4TWMtxU_99hS8R7Xjvek,1048
+blaxel/livekit/tools.py,sha256=QipxGDnKqma_ktzTUpKgzdp5x4bvpQnxEVoqSTBesu8,1053
 blaxel/llamaindex/__init__.py,sha256=iZ3QbZhlwKvP91ChcqSXVkpRrzurMxJoQfKdZFzE2AA,127
 blaxel/llamaindex/model.py,sha256=FYUCTA80LKC4-UfESh43htoHrsoZjwwVaxXD51T0IuE,2557
 blaxel/llamaindex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -383,7 +383,7 @@ blaxel/llamaindex/custom/cohere.py,sha256=zoUv4NWwMZLZEynYTC3JuOvtinguRgtuRwS31w
 blaxel/openai/__init__.py,sha256=YkizVtcYL2m9v-z5B1EReYVu9n9V-DCxJhSB2mvqOs0,123
 blaxel/openai/model.py,sha256=lGz4zrV4sURPb6aLtroMRV5-CgfQUq15PeTgjc7QkTI,600
 blaxel/openai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-blaxel/openai/tools.py,sha256=De6Gjiu9pnX-jVUiueCWvUl8hXcnLgrqcWjAIMDEbIo,894
+blaxel/openai/tools.py,sha256=XnbQt8AvvmCHjoQIe3AhylmGi3bwTJIrdmXm--sldLg,834
 blaxel/pydantic/__init__.py,sha256=-UDZ5VSrlgfqErJuiuphcAFwesijzXxYLeyC7yHEDrE,128
 blaxel/pydantic/model.py,sha256=1oPf1EH01wvbgBS-w89L73nQrII6VNkZiRIuJYmrMms,3396
 blaxel/pydantic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -402,7 +402,7 @@ blaxel/telemetry/instrumentation/map.py,sha256=PCzZJj39yiYVYJrxLBNP-NW-tjjYyTijw
 blaxel/telemetry/instrumentation/utils.py,sha256=KInMYZH-mu9_wvetmf0EmgrfN3Sw8IWk2Y95v2u90_U,1901
 blaxel/telemetry/log/log.py,sha256=RvQByRjZMoP_dRaAZu8oK6DTegsHs-xV4W-UIqis6CA,2461
 blaxel/telemetry/log/logger.py,sha256=NPAS3g82ryROjvc_DEZaTIfrcehoLEZoP-JkLxADxc0,4113
-blaxel-0.2.2rc79.dist-info/METADATA,sha256=Riq57nznlw3GBF4YKj_dpKtKdKbYg9jXxVR07J85SXE,9879
-blaxel-0.2.2rc79.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-blaxel-0.2.2rc79.dist-info/licenses/LICENSE,sha256=p5PNQvpvyDT_0aYBDgmV1fFI_vAD2aSV0wWG7VTgRis,1069
-blaxel-0.2.2rc79.dist-info/RECORD,,
+blaxel-0.2.4.dist-info/METADATA,sha256=oh2nI5vCd2gRNp-9jWiQigKLjSeuVwz7ODk1yny-PMM,9875
+blaxel-0.2.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+blaxel-0.2.4.dist-info/licenses/LICENSE,sha256=p5PNQvpvyDT_0aYBDgmV1fFI_vAD2aSV0wWG7VTgRis,1069
+blaxel-0.2.4.dist-info/RECORD,,