blaxel 0.2.38rc122__py3-none-any.whl → 0.2.39__py3-none-any.whl

blaxel/__init__.py

@@ -4,8 +4,8 @@ from .core.common.autoload import autoload
 from .core.common.env import env
 from .core.common.settings import settings
 
-__version__ = "0.2.38.pre-122"
-__commit__ = "e7e19d2c82b2b0c2a44914245734597adcc00f49"
+__version__ = "0.2.39"
+__commit__ = "48d4000d429ce3ce1d6d5b4858cf15115b380f96"
 __sentry_dsn__ = "https://9711de13cd02b285ca4378c01de8dc30@o4508714045276160.ingest.us.sentry.io/4510461121462272"
 __all__ = ["autoload", "settings", "env"]
 

blaxel/core/authentication/clientcredentials.py

@@ -115,6 +115,5 @@ class ClientCredentials(BlaxelAuth):
 
     @property
     def token(self):
-        if not self.credentials.access_token:
-            self.get_token()
+        self.get_token()
         return self.credentials.access_token

blaxel/core/tools/__init__.py

@@ -254,6 +254,10 @@ class PersistentMcpClient:
                 await self.client_exit_stack.aclose()
             except Exception as e:
                 logger.debug(f"Error closing client exit stack: {e}")
+            # Create fresh exit stacks so that future initialize() calls
+            # don't reuse stacks tainted by old cancel scopes
+            self.session_exit_stack = AsyncExitStack()
+            self.client_exit_stack = AsyncExitStack()
             logger.debug("WebSocket connection closed due to inactivity.")
 
 

blaxel/core/volume/volume.py

@@ -137,6 +137,8 @@ class VolumeCreateConfiguration:
 
 
 class VolumeInstance:
+    delete: "_AsyncDeleteDescriptor"
+
     def __init__(self, volume: Volume):
         self.volume = volume
 
@@ -275,6 +277,8 @@ class VolumeInstance:
 
 
 class SyncVolumeInstance:
+    delete: "_SyncDeleteDescriptor"
+
     """Synchronous volume instance for managing persistent storage."""
 
     def __init__(self, volume: Volume):

blaxel/crewai/model.py

@@ -1,6 +1,8 @@
 from logging import getLogger
 
-from crewai import LLM
+import httpx
+from crewai import LLM  # type: ignore[import-not-found]
+from crewai.llms.hooks.base import BaseInterceptor  # type: ignore[import-not-found]
 
 from blaxel.core import bl_model as bl_model_core
 from blaxel.core import settings
@@ -8,62 +10,97 @@ from blaxel.core import settings
 logger = getLogger(__name__)
 
 
-class AuthenticatedLLM(LLM):
-    def call(self, *args, **kwargs):
-        self.additional_params["extra_headers"] = settings.auth.get_headers()
-        return super().call(*args, **kwargs)
+class AuthInterceptor(BaseInterceptor[httpx.Request, httpx.Response]):
+    """Interceptor that injects dynamic auth headers into every HTTP request.
+
+    Used for crewai native providers (OpenAI, Anthropic, Gemini, etc.)
+    where the LLM.__new__ factory returns a provider-specific instance
+    and subclass overrides are not possible.
+    """
+
+    def on_outbound(self, message: httpx.Request) -> httpx.Request:
+        auth_headers = settings.auth.get_headers()
+        # Remove the SDK's default "Authorization: Bearer replaced" header
+        # when our auth uses a different header (e.g. X-Blaxel-Authorization with API keys)
+        if "Authorization" not in auth_headers:
+            message.headers.pop("Authorization", None)
+            message.headers.pop("authorization", None)
+        for key, value in auth_headers.items():
+            message.headers[key] = value
+        return message
+
+    def on_inbound(self, message: httpx.Response) -> httpx.Response:
+        return message
+
+    async def aon_outbound(self, message: httpx.Request) -> httpx.Request:
+        return self.on_outbound(message)
+
+    async def aon_inbound(self, message: httpx.Response) -> httpx.Response:
+        return message
+
+
+# Provider types that crewai routes to native SDK implementations.
+# These support the interceptor mechanism for auth.
+_NATIVE_PROVIDER_PREFIXES = {"openai", "anthropic", "gemini", "azure", "bedrock"}
+
+
+def _is_native_route(provider_prefix: str) -> bool:
+    """Check if a provider prefix will be routed to a native SDK by crewai."""
+    return provider_prefix.lower() in _NATIVE_PROVIDER_PREFIXES
 
 
 async def bl_model(name: str, **kwargs):
     url, type, model = await bl_model_core(name).get_parameters()
+
+    # Map blaxel model types to crewai provider prefixes and base URLs
     if type == "mistral":
-        return AuthenticatedLLM(
-            model=f"mistral/{model}",
-            api_key="replaced",
-            base_url=f"{url}/v1",
-            **kwargs,
-        )
+        provider_prefix = "mistral"
+        base_url = f"{url}/v1"
     elif type == "xai":
-        return AuthenticatedLLM(
-            model=f"groq/{model}",
-            api_key="replaced",
-            base_url=f"{url}/v1",
-            **kwargs,
-        )
+        provider_prefix = "groq"
+        base_url = f"{url}/v1"
     elif type == "deepseek":
-        return AuthenticatedLLM(
-            model=f"openai/{model}",
-            api_key="replaced",
-            base_url=f"{url}/v1",
-            **kwargs,
-        )
+        provider_prefix = "openai"
+        base_url = f"{url}/v1"
     elif type == "anthropic":
-        return AuthenticatedLLM(
-            model=f"anthropic/{model}",
-            api_key="replaced",
-            base_url=url,
-            **kwargs,
-        )
+        provider_prefix = "anthropic"
+        base_url = url
     elif type == "gemini":
-        return AuthenticatedLLM(
-            model=f"gemini/{model}",
-            api_key="replaced",
-            base_url=f"{url}/v1beta/models/{model}",
-            **kwargs,
-        )
+        provider_prefix = "gemini"
+        base_url = f"{url}/v1beta/models/{model}"
     elif type == "cerebras":
-        return AuthenticatedLLM(
-            model=f"cerebras/{model}",
-            api_key="replaced",
-            base_url=f"{url}/v1",
-            **kwargs,
-        )
+        provider_prefix = "cerebras"
+        base_url = f"{url}/v1"
     else:
         if type != "openai":
             logger.warning(f"Model {model} is not supported by CrewAI, defaulting to OpenAI")
-        return AuthenticatedLLM(
-            model=f"openai/{model}",
+        provider_prefix = "openai"
+        base_url = f"{url}/v1"
+
+    model_string = f"{provider_prefix}/{model}"
+    auth_headers = settings.auth.get_headers()
+
+    if _is_native_route(provider_prefix):
+        # Native providers: use interceptor for dynamic auth headers.
+        # Always pass api_key="replaced" because crewai's native providers
+        # require a non-None api_key. The AuthInterceptor handles stripping
+        # the dummy Authorization header and injecting the real auth.
+        return LLM(
+            model=model_string,
             api_key="replaced",
-            base_url=f"{url}/v1",
+            base_url=base_url,
+            interceptor=AuthInterceptor(),
+            **kwargs,
+        )
+    else:
+        # LiteLLM fallback: pass auth headers via extra_headers param.
+        # Omit api_key when auth uses X-Blaxel-Authorization to prevent
+        # litellm from adding "Authorization: Bearer replaced".
+        llm_api_key = "replaced" if "Authorization" in auth_headers else None
+        return LLM(
+            model=model_string,
+            api_key=llm_api_key,
+            base_url=base_url,
+            extra_headers=auth_headers,
             **kwargs,
         )

blaxel/crewai/tools.py

@@ -1,10 +1,86 @@
+from typing import Any
+
 from crewai.tools import BaseTool
+from pydantic import BaseModel
 
 from blaxel.core.tools import bl_tools as bl_tools_core
-from blaxel.core.tools.common import create_model_from_json_schema
 from blaxel.core.tools.types import Tool
 
 
+def _clean_schema_for_openai(schema: dict) -> dict:
+    """Clean JSON schema to be compatible with OpenAI strict mode.
+
+    Recursively resolves anyOf patterns, ensures all schemas have type keys,
+    removes additionalProperties and $schema, and ensures object types have
+    properties and required fields.
+    """
+    if not isinstance(schema, dict):
+        return schema
+
+    cleaned = schema.copy()
+
+    # Remove unsupported keys
+    cleaned.pop("$schema", None)
+    cleaned.pop("additionalProperties", None)
+
+    # Resolve anyOf: pick the non-null type
+    if "anyOf" in cleaned:
+        any_of = cleaned.pop("anyOf")
+        non_null = [s for s in any_of if s.get("type") != "null"]
+        if non_null:
+            # Merge the first non-null variant into current schema
+            resolved = _clean_schema_for_openai(non_null[0])
+            cleaned.update(resolved)
+        else:
+            cleaned["type"] = "string"
+
+    # Ensure type exists
+    if "type" not in cleaned and "properties" in cleaned:
+        cleaned["type"] = "object"
+
+    # Handle object types
+    if cleaned.get("type") == "object":
+        if "properties" not in cleaned:
+            cleaned["properties"] = {}
+        if "required" not in cleaned:
+            cleaned["required"] = list(cleaned["properties"].keys())
+
+    # Recursively clean properties
+    if "properties" in cleaned:
+        cleaned["properties"] = {
+            k: _clean_schema_for_openai(v) for k, v in cleaned["properties"].items()
+        }
+
+    # Recursively clean array items
+    if "items" in cleaned:
+        cleaned["items"] = _clean_schema_for_openai(cleaned["items"])
+        # Ensure items has a type
+        if "type" not in cleaned["items"]:
+            cleaned["items"]["type"] = "string"
+
+    return cleaned
+
+
+def _make_clean_args_schema(tool: Tool) -> type[BaseModel]:
+    """Create a Pydantic model whose JSON schema returns the pre-cleaned schema.
+
+    CrewAI calls model_json_schema() on args_schema to build the OpenAI tool
+    parameters. By overriding model_json_schema we ensure the cleaned schema
+    is used directly, avoiding issues with Pydantic re-introducing anyOf or
+    dropping type keys on array items.
+    """
+    clean = _clean_schema_for_openai(tool.input_schema)
+
+    class CleanArgsSchema(BaseModel):
+        @classmethod
+        def model_json_schema(cls, *args: Any, **kwargs: Any) -> dict[str, Any]:
+            return clean
+
+    CleanArgsSchema.__name__ = f"{tool.name}Schema"
+    CleanArgsSchema.__qualname__ = f"{tool.name}Schema"
+    return CleanArgsSchema
+
+
 class CrewAITool(BaseTool):
     _tool: Tool
 
@@ -12,13 +88,20 @@ class CrewAITool(BaseTool):
         super().__init__(
             name=tool.name,
             description=tool.description,
-            args_schema=create_model_from_json_schema(tool.input_schema),
+            args_schema=_make_clean_args_schema(tool),
         )
         self._tool = tool
 
     def _run(self, *args, **kwargs):
+        if not self._tool.sync_coroutine:
+            raise ValueError(f"Tool {self._tool.name} does not have a sync_coroutine defined")
         return self._tool.sync_coroutine(**kwargs)
 
+    async def _arun(self, *args, **kwargs):
+        if not self._tool.coroutine:
+            raise ValueError(f"Tool {self._tool.name} does not have a coroutine defined")
+        return await self._tool.coroutine(**kwargs)
+
 
 async def bl_tools(tools_names: list[str], **kwargs) -> list[BaseTool]:
     tools = bl_tools_core(tools_names, **kwargs)

blaxel/googleadk/model.py

@@ -1,6 +1,9 @@
 from logging import getLogger
 
-from google.adk.models.lite_llm import LiteLlm, LiteLLMClient
+from google.adk.models.lite_llm import (  # type: ignore[import-not-found]
+    LiteLlm,
+    LiteLLMClient,
+)
 
 from blaxel.core import bl_model as bl_model_core
 from blaxel.core import settings
@@ -23,7 +26,15 @@ class AuthenticatedLiteLLMClient(LiteLLMClient):
         Returns:
           The model response as a message.
         """
-        kwargs["extra_headers"] = settings.auth.get_headers()
+        auth_headers = settings.auth.get_headers()
+        extra = dict(auth_headers)
+        # When auth uses X-Blaxel-Authorization (API keys), override the
+        # Authorization header that litellm sets from api_key or OPENAI_API_KEY
+        # env var. Without this, the server sees an invalid Authorization header
+        # and rejects the request.
+        if "Authorization" not in auth_headers:
+            extra["Authorization"] = ""
+        kwargs["extra_headers"] = extra
         return await super().acompletion(
             model=model,
             messages=messages,
@@ -44,7 +55,15 @@ class AuthenticatedLiteLLMClient(LiteLLMClient):
         Returns:
           The response from the model.
         """
-        kwargs["extra_headers"] = settings.auth.get_headers()
+        auth_headers = settings.auth.get_headers()
+        extra = dict(auth_headers)
+        # When auth uses X-Blaxel-Authorization (API keys), override the
+        # Authorization header that litellm sets from api_key or OPENAI_API_KEY
+        # env var. Without this, the server sees an invalid Authorization header
+        # and rejects the request.
+        if "Authorization" not in auth_headers:
+            extra["Authorization"] = ""
+        kwargs["extra_headers"] = extra
         return super().completion(
             model=model,
             messages=messages,

blaxel/googleadk/tools.py

@@ -1,8 +1,8 @@
 import inspect
-from typing import Any, override
+from typing import Any
 
-from google.adk.tools import BaseTool, ToolContext
-from google.genai import types
+from google.adk.tools import BaseTool, ToolContext  # type: ignore[import-not-found]
+from google.genai import types  # type: ignore[import-not-found]
 
 from blaxel.core.tools import bl_tools as bl_tools_core
 from blaxel.core.tools.types import Tool
@@ -31,15 +31,33 @@ class GoogleADKTool(BaseTool):
         if "additionalProperties" in cleaned_schema:
             del cleaned_schema["additionalProperties"]
 
+        # Google genai Schema expects type as a single enum string (e.g. "STRING"),
+        # not a JSON Schema union list like ["null", "string"].
+        if "type" in cleaned_schema and isinstance(cleaned_schema["type"], list):
+            type_list = [t for t in cleaned_schema["type"] if t != "null"]
+            cleaned_schema["type"] = type_list[0].upper() if type_list else "STRING"
+            # Mark as nullable if "null" was in the original list
+            if "null" in schema["type"]:
+                cleaned_schema["nullable"] = True
+        elif "type" in cleaned_schema and isinstance(cleaned_schema["type"], str):
+            cleaned_schema["type"] = cleaned_schema["type"].upper()
+
+        # Ensure object types have properties
+        if cleaned_schema.get("type") == "OBJECT" and "properties" not in cleaned_schema:
+            cleaned_schema["properties"] = {}
+
         # Recursively clean properties if they exist
         if "properties" in cleaned_schema:
             cleaned_schema["properties"] = {
                 k: self._clean_schema(v) for k, v in cleaned_schema["properties"].items()
             }
 
+        # Recursively clean items for array types
+        if "items" in cleaned_schema and isinstance(cleaned_schema["items"], dict):
+            cleaned_schema["items"] = self._clean_schema(cleaned_schema["items"])
+
         return cleaned_schema
 
-    @override
     def _get_declaration(self) -> types.FunctionDeclaration | None:
         # Clean the schema recursively
         schema = self._clean_schema(self._tool.input_schema)
@@ -48,14 +66,15 @@ class GoogleADKTool(BaseTool):
             types.FunctionDeclaration(
                 name=self._tool.name,
                 description=self._tool.description,
-                parameters=schema,
+                parameters=types.Schema(**schema),
             )
         )
 
         return function_decl
 
-    @override
     async def run_async(self, *, args: dict[str, Any], tool_context: ToolContext) -> Any:
+        if not self._tool.coroutine:
+            raise ValueError(f"Tool {self._tool.name} does not have a coroutine defined")
         args_to_call = args.copy()
         signature = inspect.signature(self._tool.coroutine)
         if "tool_context" in signature.parameters:

blaxel/langgraph/custom/gemini.py

@@ -23,16 +23,18 @@ from typing import (
 
 import httpx
 import requests
-from langchain_core.callbacks.manager import (
+from langchain_core.callbacks.manager import (  # type: ignore[import-not-found]
     AsyncCallbackManagerForLLMRun,
     CallbackManagerForLLMRun,
 )
-from langchain_core.language_models import LanguageModelInput
-from langchain_core.language_models.chat_models import (
+from langchain_core.language_models import (  # type: ignore[import-not-found]
+    LanguageModelInput,
+)
+from langchain_core.language_models.chat_models import (  # type: ignore[import-not-found]
     BaseChatModel,
     LangSmithParams,
 )
-from langchain_core.messages import (
+from langchain_core.messages import (  # type: ignore[import-not-found]
     AIMessage,
     AIMessageChunk,
     BaseMessage,
@@ -41,25 +43,30 @@ from langchain_core.messages import (
     SystemMessage,
     ToolMessage,
 )
-from langchain_core.messages.ai import UsageMetadata
-from langchain_core.messages.tool import (
+from langchain_core.messages.ai import UsageMetadata  # type: ignore[import-not-found]
+from langchain_core.messages.tool import (  # type: ignore[import-not-found]
     invalid_tool_call,
     tool_call,
     tool_call_chunk,
 )
-from langchain_core.output_parsers.openai_tools import (
+from langchain_core.output_parsers.openai_tools import (  # type: ignore[import-not-found]
     JsonOutputKeyToolsParser,
     PydanticToolsParser,
     parse_tool_calls,
 )
-from langchain_core.outputs import (
+from langchain_core.outputs import (  # type: ignore[import-not-found]
     ChatGeneration,
     ChatGenerationChunk,
     ChatResult,
 )
-from langchain_core.runnables import Runnable, RunnablePassthrough
-from langchain_core.tools import BaseTool
-from langchain_core.utils.function_calling import convert_to_openai_tool
+from langchain_core.runnables import (  # type: ignore[import-not-found]
+    Runnable,
+    RunnablePassthrough,
+)
+from langchain_core.tools import BaseTool  # type: ignore[import-not-found]
+from langchain_core.utils.function_calling import (  # type: ignore[import-not-found]
+    convert_to_openai_tool,
+)
 from PIL import Image
 from pydantic import BaseModel, ConfigDict, Field, SecretStr, model_validator
 from tenacity import (
@@ -1467,4 +1474,4 @@ def image_bytes_to_b64_string(image_bytes: bytes, image_format: str = "jpeg") ->
     """Convert image bytes to base64 string."""
     import base64
 
-    return f"data:image/{image_format};base64,{base64.b64encode(image_bytes).decode('utf-8')}"
+    return f"data:image/{image_format};base64,{base64.b64encode(image_bytes).decode('utf-8')}"

blaxel/langgraph/model.py

@@ -7,11 +7,15 @@ from blaxel.core import bl_model as bl_model_core
 from blaxel.core import settings
 
 if TYPE_CHECKING:
-    from langchain_core.callbacks import Callbacks
-    from langchain_core.language_models import LanguageModelInput
-    from langchain_core.messages import BaseMessage
-    from langchain_core.outputs import LLMResult
-    from langchain_core.runnables import RunnableConfig
+    from langchain_core.callbacks import Callbacks  # type: ignore[import-not-found]
+    from langchain_core.language_models import (  # type: ignore[import-not-found]
+        LanguageModelInput,
+    )
+    from langchain_core.messages import BaseMessage  # type: ignore[import-not-found]
+    from langchain_core.outputs import LLMResult  # type: ignore[import-not-found]
+    from langchain_core.runnables import (  # type: ignore[import-not-found]
+        RunnableConfig,
+    )
 
 logger = getLogger(__name__)
 
@@ -32,7 +36,7 @@ class TokenRefreshingWrapper:
         kwargs = config.get("kwargs", {})
 
         if model_type == "mistral":
-            from langchain_openai import ChatOpenAI
+            from langchain_openai import ChatOpenAI  # type: ignore[import-not-found]
 
             return ChatOpenAI(
                 api_key=settings.auth.token,
@@ -41,7 +45,7 @@ class TokenRefreshingWrapper:
                 **kwargs,
             )
         elif model_type == "cohere":
-            from langchain_cohere import ChatCohere
+            from langchain_cohere import ChatCohere  # type: ignore[import-not-found]
 
             return ChatCohere(
                 cohere_api_key=settings.auth.token,
@@ -50,7 +54,7 @@ class TokenRefreshingWrapper:
                 **kwargs,
             )
         elif model_type == "xai":
-            from langchain_xai import ChatXAI
+            from langchain_xai import ChatXAI  # type: ignore[import-not-found]
 
             return ChatXAI(
                 model=model,
@@ -59,7 +63,9 @@ class TokenRefreshingWrapper:
                 **kwargs,
             )
         elif model_type == "deepseek":
-            from langchain_deepseek import ChatDeepSeek
+            from langchain_deepseek import (  # type: ignore[import-not-found]
+                ChatDeepSeek,
+            )
 
             return ChatDeepSeek(
                 api_key=settings.auth.token,
@@ -68,7 +74,9 @@ class TokenRefreshingWrapper:
                 **kwargs,
             )
         elif model_type == "anthropic":
-            from langchain_anthropic import ChatAnthropic
+            from langchain_anthropic import (  # type: ignore[import-not-found]
+                ChatAnthropic,
+            )
 
             return ChatAnthropic(
                 api_key=settings.auth.token,
@@ -78,7 +86,9 @@ class TokenRefreshingWrapper:
                 **kwargs,
             )
         elif model_type == "gemini":
-            from .custom.gemini import ChatGoogleGenerativeAI
+            from .custom.gemini import (
+                ChatGoogleGenerativeAI,  # type: ignore[import-not-found]
+            )
 
             return ChatGoogleGenerativeAI(
                 model=model,
@@ -88,7 +98,9 @@ class TokenRefreshingWrapper:
                 **kwargs,
             )
         elif model_type == "cerebras":
-            from langchain_cerebras import ChatCerebras
+            from langchain_cerebras import (  # type: ignore[import-not-found]
+                ChatCerebras,
+            )
 
             return ChatCerebras(
                 api_key=settings.auth.token,
@@ -97,7 +109,7 @@ class TokenRefreshingWrapper:
                 **kwargs,
             )
         else:
-            from langchain_openai import ChatOpenAI
+            from langchain_openai import ChatOpenAI  # type: ignore[import-not-found]
 
             if model_type != "openai":
                 logger.warning(f"Model {model} is not supported by Langchain, defaulting to OpenAI")
@@ -113,10 +125,6 @@ class TokenRefreshingWrapper:
         # Only refresh if using ClientCredentials (which has get_token method)
         current_token = settings.auth.token
 
-        if hasattr(settings.auth, "get_token"):
-            # This will trigger token refresh if needed
-            settings.auth.get_token()
-
         new_token = settings.auth.token
 
         # If token changed, recreate the model
@@ -251,4 +259,4 @@ async def bl_model(name: str, **kwargs):
     model_config = {"type": type, "model": model, "url": url, "kwargs": kwargs}
 
     # Create and return the wrapper
-    return TokenRefreshingChatModel(model_config)
+    return TokenRefreshingChatModel(model_config)

blaxel/langgraph/tools.py

@@ -4,7 +4,7 @@ from blaxel.core.tools import bl_tools as bl_tools_core
 from blaxel.core.tools.types import Tool, ToolException
 
 if TYPE_CHECKING:
-    from langchain_core.tools import StructuredTool
+    from langchain_core.tools import StructuredTool  # type: ignore[import-not-found]
 
 
 def _clean_schema_for_openai(schema: Dict[str, Any]) -> Dict[str, Any]:
@@ -37,19 +37,14 @@ def _clean_schema_for_openai(schema: Dict[str, Any]) -> Dict[str, Any]:
 
 
 def get_langchain_tool(tool: Tool) -> "StructuredTool":
-    from langchain_core.tools import StructuredTool
-    from mcp.types import (
-        CallToolResult,
-        EmbeddedResource,
-        ImageContent,
-        TextContent,
-    )
-
-    NonTextContent = ImageContent | EmbeddedResource
+    from langchain_core.tools import StructuredTool  # type: ignore[import-not-found]
+    from mcp.types import CallToolResult, EmbeddedResource, ImageContent, TextContent
 
     async def langchain_coroutine(
         **arguments: dict[str, Any],
-    ) -> tuple[str | list[str], list[NonTextContent] | None]:
+    ) -> tuple[str | list[str], list[ImageContent | EmbeddedResource] | None]:
+        if not tool.coroutine:
+            raise ValueError(f"Tool {tool.name} does not have a coroutine defined")
         result: CallToolResult = await tool.coroutine(**arguments)
         text_contents: list[TextContent] = []
         non_text_contents = []

blaxel/livekit/model.py

@@ -1,8 +1,8 @@
 from logging import getLogger
 
 import httpx
-from livekit.plugins import openai
-from openai import AsyncOpenAI
+from livekit.plugins import openai  # type: ignore[import-not-found]
+from openai import AsyncOpenAI  # type: ignore[import-not-found]
 
 from blaxel.core import bl_model as bl_model_core
 from blaxel.core import settings
@@ -20,6 +20,11 @@ class DynamicHeadersHTTPClient(httpx.AsyncClient):
     async def send(self, request, *args, **kwargs):
         # Update headers with the latest auth headers before each request
         auth_headers = settings.auth.get_headers()
+        # Remove the SDK's default "Authorization: Bearer replaced" header
+        # when our auth uses a different header (e.g. X-Blaxel-Authorization with API keys)
+        if "Authorization" not in auth_headers:
+            request.headers.pop("Authorization", None)
+            request.headers.pop("authorization", None)
         for key, value in auth_headers.items():
             request.headers[key] = value
         return await super().send(request, *args, **kwargs)

blaxel/livekit/tools.py

@@ -1,4 +1,4 @@
-from livekit.agents import function_tool, llm
+from livekit.agents import function_tool, llm  # type: ignore[import-not-found]
 
 from blaxel.core.tools import bl_tools as bl_tools_core
 from blaxel.core.tools.types import Tool
@@ -6,6 +6,8 @@ from blaxel.core.tools.types import Tool
 
 def livekit_coroutine(tool: Tool):
     async def livekit_coroutine_wrapper(raw_arguments: dict[str, object]):
+        if not tool.coroutine:
+            raise ValueError(f"Tool {tool.name} does not have a coroutine defined")
         result = await tool.coroutine(**raw_arguments)
         return result.model_dump_json()
 

blaxel/llamaindex/model.py

@@ -11,7 +11,7 @@ from blaxel.core import settings
 os.environ["TRANSFORMERS_NO_ADVISORY_WARNINGS"] = "1"
 
 if TYPE_CHECKING:
-    from llama_index.core.base.llms.types import (
+    from llama_index.core.base.llms.types import (  # type: ignore[import-not-found]
         ChatMessage,
         ChatResponse,
         ChatResponseAsyncGen,
@@ -20,13 +20,19 @@ if TYPE_CHECKING:
         CompletionResponseAsyncGen,
         CompletionResponseGen,
     )
-    from llama_index.core.llms.llm import ToolSelection
-    from llama_index.core.tools.types import BaseTool
+    from llama_index.core.llms.llm import (  # type: ignore[import-not-found]
+        ToolSelection,
+    )
+    from llama_index.core.tools.types import BaseTool  # type: ignore[import-not-found]
 
 # Runtime imports needed for class inheritance and construction
-from llama_index.core.base.llms.types import LLMMetadata  # noqa: E402
-from llama_index.core.llms.function_calling import FunctionCallingLLM  # noqa: E402
-from pydantic import PrivateAttr  # noqa: E402
+from llama_index.core.base.llms.types import (  # type: ignore[import-not-found]
+    LLMMetadata,
+)
+from llama_index.core.llms.function_calling import (  # type: ignore[import-not-found]
+    FunctionCallingLLM,
+)
+from pydantic import PrivateAttr  # type: ignore[import-not-found]
 
 logger = getLogger(__name__)
 
@@ -81,7 +87,9 @@ class TokenRefreshingLLM(FunctionCallingLLM):
         kwargs = config.get("kwargs", {})
 
         if model_type == "anthropic":
-            from llama_index.llms.anthropic import Anthropic
+            from llama_index.llms.anthropic import (  # type: ignore[import-not-found]
+                Anthropic,
+            )
 
             return Anthropic(
                 model=model,
@@ -91,7 +99,7 @@ class TokenRefreshingLLM(FunctionCallingLLM):
                 **kwargs,
             )
         elif model_type == "xai":
-            from llama_index.llms.groq import Groq
+            from llama_index.llms.groq import Groq  # type: ignore[import-not-found]
 
             return Groq(
                 model=model,
@@ -101,7 +109,9 @@ class TokenRefreshingLLM(FunctionCallingLLM):
             )
         elif model_type == "gemini":
             from google.genai.types import HttpOptions
-            from llama_index.llms.google_genai import GoogleGenAI
+            from llama_index.llms.google_genai import (  # type: ignore[import-not-found]
+                GoogleGenAI,
+            )
 
             return GoogleGenAI(
                 api_key=settings.auth.token,
@@ -114,11 +124,13 @@ class TokenRefreshingLLM(FunctionCallingLLM):
                 **kwargs,
             )
         elif model_type == "cohere":
-            from .custom.cohere import Cohere
+            from .custom.cohere import Cohere  # type: ignore[import-not-found]
 
             return Cohere(model=model, api_key=settings.auth.token, api_base=url, **kwargs)
         elif model_type == "deepseek":
-            from llama_index.llms.deepseek import DeepSeek
+            from llama_index.llms.deepseek import (  # type: ignore[import-not-found]
+                DeepSeek,
+            )
 
             return DeepSeek(
                 model=model,
@@ -127,11 +139,15 @@ class TokenRefreshingLLM(FunctionCallingLLM):
                 **kwargs,
             )
         elif model_type == "mistral":
-            from llama_index.llms.mistralai import MistralAI
+            from llama_index.llms.mistralai import (  # type: ignore[import-not-found]
+                MistralAI,
+            )
 
             return MistralAI(model=model, api_key=settings.auth.token, endpoint=url, **kwargs)
         elif model_type == "cerebras":
-            from llama_index.llms.cerebras import Cerebras
+            from llama_index.llms.cerebras import (  # type: ignore[import-not-found]
+                Cerebras,
+            )
 
             return Cerebras(
                 model=model,
@@ -140,7 +156,7 @@ class TokenRefreshingLLM(FunctionCallingLLM):
                 **kwargs,
             )
         else:
-            from llama_index.llms.openai import OpenAI
+            from llama_index.llms.openai import OpenAI  # type: ignore[import-not-found]
 
             if model_type != "openai":
                 logger.warning(
@@ -265,4 +281,4 @@ async def bl_model(name, **kwargs):
     model_config = {"type": type, "model": model, "url": url, "kwargs": kwargs}
 
     # Create and return the wrapper
-    return TokenRefreshingLLM(model_config)
+    return TokenRefreshingLLM(model_config)

blaxel/llamaindex/tools.py

@@ -5,12 +5,14 @@ from blaxel.core.tools.common import create_model_from_json_schema
 from blaxel.core.tools.types import Tool
 
 if TYPE_CHECKING:
-    from llama_index.core.tools import FunctionTool
+    from llama_index.core.tools import FunctionTool  # type: ignore[import-not-found]
 
 
 def get_llamaindex_tool(tool: Tool) -> "FunctionTool":
-    from llama_index.core.tools import FunctionTool
-    from llama_index.core.tools.types import ToolMetadata
+    from llama_index.core.tools import FunctionTool  # type: ignore[import-not-found]
+    from llama_index.core.tools.types import (  # type: ignore[import-not-found]
+        ToolMetadata,
+    )
 
     model_schema = create_model_from_json_schema(
         tool.input_schema, model_name=f"{tool.name}_Schema"
@@ -29,4 +31,4 @@ def get_llamaindex_tool(tool: Tool) -> "FunctionTool":
 async def bl_tools(tools_names: list[str], **kwargs) -> list["FunctionTool"]:
     tools = bl_tools_core(tools_names, **kwargs)
     await tools.initialize()
-    return [get_llamaindex_tool(tool) for tool in tools.get_tools()]
+    return [get_llamaindex_tool(tool) for tool in tools.get_tools()]

blaxel/openai/model.py

@@ -1,5 +1,6 @@
 import httpx
-from agents import AsyncOpenAI, OpenAIChatCompletionsModel
+from agents import OpenAIChatCompletionsModel
+from openai import AsyncOpenAI
 
 from blaxel.core import bl_model as bl_model_core
 from blaxel.core import settings
@@ -14,6 +15,11 @@ class DynamicHeadersHTTPClient(httpx.AsyncClient):
     async def send(self, request, *args, **kwargs):
         # Update headers with the latest auth headers before each request
         auth_headers = settings.auth.get_headers()
+        # Remove the SDK's default "Authorization: Bearer replaced" header
+        # when our auth uses a different header (e.g. X-Blaxel-Authorization with API keys)
+        if "Authorization" not in auth_headers:
+            request.headers.pop("Authorization", None)
+            request.headers.pop("authorization", None)
         for key, value in auth_headers.items():
             request.headers[key] = value
         return await super().send(request, *args, **kwargs)

blaxel/openai/tools.py

@@ -1,7 +1,8 @@
 import json
 from typing import Any
 
-from agents import FunctionTool, RunContextWrapper
+from agents import FunctionTool  # type: ignore[import-not-found]
+from agents.tool_context import ToolContext  # type: ignore[import-not-found]
 
 from blaxel.core.tools import bl_tools as bl_tools_core
 from blaxel.core.tools.types import Tool
@@ -24,6 +25,13 @@ def _clean_schema_for_openai(schema: dict) -> dict:
     if "additionalProperties" in cleaned_schema:
         del cleaned_schema["additionalProperties"]
 
+    # Ensure object type schemas have properties
+    if cleaned_schema.get("type") == "object":
+        if "properties" not in cleaned_schema:
+            cleaned_schema["properties"] = {}
+        if "required" not in cleaned_schema:
+            cleaned_schema["required"] = []
+
     # Recursively clean properties if they exist
     if "properties" in cleaned_schema:
         cleaned_schema["properties"] = {
@@ -39,9 +47,11 @@ def _clean_schema_for_openai(schema: dict) -> dict:
 
 def get_openai_tool(tool: Tool) -> FunctionTool:
     async def openai_coroutine(
-        _: RunContextWrapper,
-        arguments: dict[str, Any],
+        _: ToolContext[Any],
+        arguments: str,
     ) -> Any:
+        if not tool.coroutine:
+            raise ValueError(f"Tool {tool.name} does not have a coroutine defined")
         result = await tool.coroutine(**json.loads(arguments))
         return result
 

blaxel/pydantic/model.py

@@ -1,7 +1,7 @@
 import logging
 from typing import Any
 
-from pydantic_ai.models import Model
+from pydantic_ai.models import Model  # type: ignore[import-not-found]
 
 from blaxel.core import bl_model as bl_model_core
 from blaxel.core import settings
@@ -30,8 +30,12 @@ class TokenRefreshingModel(Model):
 
         if type == "mistral":
             from mistralai.sdk import Mistral
-            from pydantic_ai.models.mistral import MistralModel
-            from pydantic_ai.providers.mistral import MistralProvider
+            from pydantic_ai.models.mistral import (  # type: ignore[import-not-found]
+                MistralModel,
+            )
+            from pydantic_ai.providers.mistral import (  # type: ignore[import-not-found]
+                MistralProvider,
+            )
 
             return MistralModel(
                 model_name=model,
@@ -45,8 +49,12 @@ class TokenRefreshingModel(Model):
             )
         elif type == "cohere":
             from cohere import AsyncClientV2
-            from pydantic_ai.models.cohere import CohereModel
-            from pydantic_ai.providers.cohere import CohereProvider
+            from pydantic_ai.models.cohere import (  # type: ignore[import-not-found]
+                CohereModel,
+            )
+            from pydantic_ai.providers.cohere import (  # type: ignore[import-not-found]
+                CohereProvider,
+            )
 
             return CohereModel(
                 model_name=model,
@@ -58,30 +66,42 @@ class TokenRefreshingModel(Model):
                 ),
             )
         elif type == "xai":
-            from pydantic_ai.models.openai import OpenAIModel
-            from pydantic_ai.providers.openai import OpenAIProvider
+            from pydantic_ai.models.openai import (  # type: ignore[import-not-found]
+                OpenAIChatModel,
+            )
+            from pydantic_ai.providers.openai import (  # type: ignore[import-not-found]
+                OpenAIProvider,
+            )
 
-            return OpenAIModel(
+            return OpenAIChatModel(
                 model_name=model,
                 provider=OpenAIProvider(
                     base_url=f"{url}/v1", api_key=settings.auth.token, **kwargs
                 ),
             )
         elif type == "deepseek":
-            from pydantic_ai.models.openai import OpenAIModel
-            from pydantic_ai.providers.openai import OpenAIProvider
+            from pydantic_ai.models.openai import (  # type: ignore[import-not-found]
+                OpenAIChatModel,
+            )
+            from pydantic_ai.providers.openai import (  # type: ignore[import-not-found]
+                OpenAIProvider,
+            )
 
-            return OpenAIModel(
+            return OpenAIChatModel(
                 model_name=model,
                 provider=OpenAIProvider(
                     base_url=f"{url}/v1", api_key=settings.auth.token, **kwargs
                 ),
             )
         elif type == "cerebras":
-            from pydantic_ai.models.openai import OpenAIModel
-            from pydantic_ai.providers.openai import OpenAIProvider
+            from pydantic_ai.models.openai import (  # type: ignore[import-not-found]
+                OpenAIChatModel,
+            )
+            from pydantic_ai.providers.openai import (  # type: ignore[import-not-found]
+                OpenAIProvider,
+            )
 
-            return OpenAIModel(
+            return OpenAIChatModel(
                 model_name=model,
                 provider=OpenAIProvider(
                     base_url=f"{url}/v1", api_key=settings.auth.token, **kwargs
@@ -116,12 +136,12 @@ class TokenRefreshingModel(Model):
                 ),
             )
         else:
-            from pydantic_ai.models.openai import OpenAIModel
+            from pydantic_ai.models.openai import OpenAIChatModel
             from pydantic_ai.providers.openai import OpenAIProvider
 
             if type != "openai":
                 logger.warning(f"Model {model} is not supported by Pydantic, defaulting to OpenAI")
-            return OpenAIModel(
+            return OpenAIChatModel(
                 model_name=model,
                 provider=OpenAIProvider(
                     base_url=f"{url}/v1", api_key=settings.auth.token, **kwargs
@@ -130,12 +150,6 @@ class TokenRefreshingModel(Model):
 
     def _get_fresh_model(self) -> Model:
         """Get or create a model with fresh token if needed."""
-        # Only refresh if using ClientCredentials (which has get_token method)
-        if hasattr(settings.auth, "get_token"):
-            # This will trigger token refresh if needed
-            logger.debug(f"Calling get_token for {self.model_config['type']} model")
-            settings.auth.get_token()
-
         new_token = settings.auth.token
 
         # If token changed or no cached model, create new one
@@ -152,10 +166,10 @@ class TokenRefreshingModel(Model):
         return model.model_name
 
     @property
-    def system(self) -> Any | None:
+    def system(self) -> str:
         """Return the system property from the wrapped model."""
         model = self._get_fresh_model()
-        return model.system if hasattr(model, "system") else None
+        return model.system if hasattr(model, "system") else ""
 
     async def request(self, *args, **kwargs):
         """Make a request to the model with token refresh."""

blaxel/pydantic/tools.py

@@ -1,11 +1,44 @@
-from pydantic_ai import RunContext
-from pydantic_ai.tools import Tool as PydanticTool
-from pydantic_ai.tools import ToolDefinition
+from typing import Any
+
+from pydantic_ai import RunContext  # type: ignore[import-not-found]
+from pydantic_ai.tools import Tool as PydanticTool  # type: ignore[import-not-found]
+from pydantic_ai.tools import ToolDefinition  # type: ignore[import-not-found]
 
 from blaxel.core.tools import Tool
 from blaxel.core.tools import bl_tools as bl_tools_core
 
 
+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.
+    """
+    if not isinstance(schema, dict):
+        return schema
+
+    cleaned = schema.copy()
+
+    if cleaned.get("type") == "object":
+        if "properties" not in cleaned:
+            cleaned["properties"] = {}
+        if "required" not in cleaned:
+            cleaned["required"] = []
+
+    if "additionalProperties" in cleaned:
+        del cleaned["additionalProperties"]
+    if "$schema" in cleaned:
+        del cleaned["$schema"]
+
+    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_pydantic_tool(tool: Tool) -> PydanticTool:
     """
     Converts a custom Tool object into a Pydantic AI Tool object.
@@ -27,7 +60,7 @@ def get_pydantic_tool(tool: Tool) -> PydanticTool:
         """Dynamically prepares the ToolDefinition using the custom Tool's attributes."""
         tool_def.name = tool.name  # Override inferred name
         tool_def.description = tool.description  # Override inferred description
-        tool_def.parameters_json_schema = tool.input_schema
+        tool_def.parameters_json_schema = _clean_schema_for_openai(tool.input_schema)
         return tool_def
 
     async def pydantic_function(**kwargs):

{blaxel-0.2.38rc122.dist-info → blaxel-0.2.39.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blaxel
-Version: 0.2.38rc122
+Version: 0.2.39
 Summary: Blaxel - AI development platform SDK
 Project-URL: Homepage, https://blaxel.ai
 Project-URL: Documentation, https://docs.blaxel.ai
@@ -17,52 +17,11 @@ Requires-Dist: pyjwt>=2.0.0
 Requires-Dist: python-dateutil>=2.8.0
 Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: requests>=2.32.3
-Requires-Dist: tomli>=2.2.1
+Requires-Dist: tomli>=2.0.2
 Requires-Dist: websockets<16.0.0
-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.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'
-Requires-Dist: langchain-deepseek-official>=0.1.0.post1; extra == 'all'
-Requires-Dist: langchain-openai>=0.3.10; extra == 'all'
-Requires-Dist: langchain-xai>=0.2.2; extra == 'all'
-Requires-Dist: langgraph<0.3.0,>=0.2.40; extra == 'all'
-Requires-Dist: litellm==1.74.9; extra == 'all'
-Requires-Dist: litellm>=1.63.11; extra == 'all'
-Requires-Dist: livekit-agents[anthropic,cartesia,deepgram,elevenlabs,groq,openai,silero,turn-detector]~=1.0; extra == 'all'
-Requires-Dist: livekit-plugins-noise-cancellation~=0.2; extra == 'all'
-Requires-Dist: llama-index-llms-anthropic>=0.6.14; extra == 'all'
-Requires-Dist: llama-index-llms-cerebras>=0.2.2; extra == 'all'
-Requires-Dist: llama-index-llms-cohere>=0.4.1; extra == 'all'
-Requires-Dist: llama-index-llms-deepseek>=0.1.1; extra == 'all'
-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.46; extra == 'all'
-Requires-Dist: openai-agents>=0.0.19; extra == 'all'
-Requires-Dist: openai==1.99.9; extra == 'all'
-Requires-Dist: opentelemetry-exporter-otlp>=1.28.0; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-anthropic==0.41.0; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-cohere==0.41.0; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-crewai==0.41.0; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-fastapi==0.56b0; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-google-generativeai==0.41.0; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-langchain>=0.35.0; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-llamaindex>=0.40.7; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-ollama==0.41.0; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-openai==0.41.0; extra == 'all'
-Requires-Dist: pillow>=10.0.0; extra == 'all'
-Requires-Dist: pydantic-ai>=0.0.48; extra == 'all'
 Provides-Extra: core
 Provides-Extra: crewai
-Requires-Dist: crewai==0.159.0; extra == 'crewai'
-Requires-Dist: litellm==1.74.9; extra == 'crewai'
-Requires-Dist: openai==1.99.9; extra == 'crewai'
+Requires-Dist: crewai[litellm]==1.9.3; extra == 'crewai'
 Requires-Dist: opentelemetry-instrumentation-crewai==0.41.0; extra == 'crewai'
 Provides-Extra: dev
 Requires-Dist: pyright; extra == 'dev'
@@ -96,17 +55,17 @@ 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.46; extra == 'llamaindex'
+Requires-Dist: llama-index>=0.14.13; extra == 'llamaindex'
 Requires-Dist: opentelemetry-instrumentation-llamaindex>=0.40.7; extra == 'llamaindex'
 Provides-Extra: openai
 Requires-Dist: openai-agents>=0.0.19; extra == 'openai'
 Provides-Extra: pydantic
-Requires-Dist: pydantic-ai>=0.0.48; extra == 'pydantic'
+Requires-Dist: pydantic-ai>=1.0.8; extra == 'pydantic'
 Provides-Extra: telemetry
 Requires-Dist: opentelemetry-exporter-otlp>=1.28.0; extra == 'telemetry'
 Requires-Dist: opentelemetry-instrumentation-anthropic==0.41.0; extra == 'telemetry'
 Requires-Dist: opentelemetry-instrumentation-cohere==0.41.0; extra == 'telemetry'
-Requires-Dist: opentelemetry-instrumentation-fastapi==0.56b0; extra == 'telemetry'
+Requires-Dist: opentelemetry-instrumentation-fastapi==0.55b0; extra == 'telemetry'
 Requires-Dist: opentelemetry-instrumentation-google-generativeai==0.41.0; extra == 'telemetry'
 Requires-Dist: opentelemetry-instrumentation-ollama==0.41.0; extra == 'telemetry'
 Requires-Dist: opentelemetry-instrumentation-openai==0.41.0; extra == 'telemetry'

{blaxel-0.2.38rc122.dist-info → blaxel-0.2.39.dist-info}/RECORD

@@ -1,10 +1,10 @@
-blaxel/__init__.py,sha256=CJtHkLCfIuSmNEqG5afzbxuceMG5h0ve2VADXBGizWs,421
+blaxel/__init__.py,sha256=QTfkxywUPHoSPf0P4W1ZlvAXblBsMkxtuduqXT78Lgo,413
 blaxel/core/__init__.py,sha256=CU0gXpVRbuQZNWoCJuuhZS0ZhXPEu0cg-3XzoYMrBm4,1756
 blaxel/core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 blaxel/core/agents/__init__.py,sha256=MJZga99lU8JWUUPHd4rmUfdo7ALwWgF7CQq95SfT2OI,4456
 blaxel/core/authentication/__init__.py,sha256=5uHv73xZ2aZRXzGHc1sP-XWqZUryfXxfC9dMX7-gd6o,3241
 blaxel/core/authentication/apikey.py,sha256=k56FGvjoniW2BzdFqNNKzsfnu8Jvh8fvNZlwDq_78Y4,1286
-blaxel/core/authentication/clientcredentials.py,sha256=Ph-S_LQCoHrYgUfrcnw-TI5x5wL-lbgNzPTmholuKk0,3903
+blaxel/core/authentication/clientcredentials.py,sha256=tXY-PKOMyZzqx4D-T20PJNJekUBGiEamEv8Q6W36h-g,3853
 blaxel/core/authentication/devicemode.py,sha256=SVCBEZzL0d74JPln9lJFsngA2RsNW1RqgbORSpVbEIg,6064
 blaxel/core/authentication/oauth.py,sha256=01yaAXytxqgsXUsSXhJzfI5-WpeU9RtrruZiimmMKf4,1453
 blaxel/core/authentication/types.py,sha256=0AmkmiPq9THT8a9bDC645rLE8mnEKb_BHUsYmYn0JAQ,1573
@@ -423,41 +423,41 @@ blaxel/core/sandbox/sync/process.py,sha256=0sDCTBp7lANzBkzB560pJnRvRz4yopnsLYj_g
 blaxel/core/sandbox/sync/sandbox.py,sha256=pbACjLaWy69imTZ2wtPA6eQeGFt5JpVuT4Fi4GPBbdU,15476
 blaxel/core/sandbox/sync/session.py,sha256=e0CVbW2LBRYTwm4RL52S0UdNvhNfuFLo6AYE5hk9DH0,4931
 blaxel/core/sandbox/sync/system.py,sha256=VDmO32qFVkURNZySvncYT2KBqu5Rj8cxT6qT2nMn0-k,2713
-blaxel/core/tools/__init__.py,sha256=OK2TFqeXAIi6CC7xtL8fFl-4DvCB7jjihkhx6RTld_c,13147
+blaxel/core/tools/__init__.py,sha256=v9Ef8MjPElJiSkq2BlS9yo0mYzyHpJCzNgW7352pcns,13391
 blaxel/core/tools/common.py,sha256=dAjDRaI2psAoHPqKeUzyqab3N6blgkD-HO0gPMpIzCE,1878
 blaxel/core/tools/types.py,sha256=EXa-10iOOXvd8zB2IsTS0gWrgoC2hqbIv6iK5m6E5t8,693
 blaxel/core/volume/__init__.py,sha256=jZgddogAPJGQnD2OoTcDb9zLqxeT6yYpfC-i1yKUVUM,253
-blaxel/core/volume/volume.py,sha256=exCPH3llsjQDRH9MWsGwp-JXqJfumZAFD8APhmsY6oI,22653
+blaxel/core/volume/volume.py,sha256=jY_BrSEw063TjpX8aLIhfhKpw07NdgMMGYZIa4LhXIc,22728
 blaxel/crewai/__init__.py,sha256=HdAZxRDgC2zW-O5xYzb_Xuysb66_fMykNJVPxlTmFnY,123
-blaxel/crewai/model.py,sha256=iR-40o8pGBFrktYNKcTaMdqbF_F1SFVavNOhhi2fW3w,1957
+blaxel/crewai/model.py,sha256=mH8iKTwALRDT3IrDbiHW5zyDv9vFl0u4OX3hXPmC7mI,3973
 blaxel/crewai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-blaxel/crewai/tools.py,sha256=HVMSRTVrc0ygiCCNkL6xa3i31IWwFlGKB6oC-6iWrK8,789
+blaxel/crewai/tools.py,sha256=Slcy1BDwzdOSa8ZHia1gSkKoQuuTHtq4nK9BLpMdlDE,3678
 blaxel/googleadk/__init__.py,sha256=3rOLe32eQt2-YN4ktHdhDWc3TK_OW0FgidTIhZ8Nnm8,225
-blaxel/googleadk/model.py,sha256=iW2VqUnTZjGo4d9keiHVQbzs5B5KngvYYruskYfMTWk,3758
+blaxel/googleadk/model.py,sha256=vhSX7vqFtgLgwnb8dgseCmR57gZel5PwHD7WBS3Na9Y,4647
 blaxel/googleadk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-blaxel/googleadk/tools.py,sha256=S9yDK5EPR_FrXhPwgd3CBR2FjoHOuKbYzax4X2v_LBo,2238
+blaxel/googleadk/tools.py,sha256=rAdFi3nH49Onss4RFFZz4uBuq1Mx4vlywsr04a5nSF4,3510
 blaxel/langgraph/__init__.py,sha256=lw9d7bl5TsYbemToCtus5P6XnhzR4SAcBWM-1Pffc_U,126
-blaxel/langgraph/model.py,sha256=XxzD9GAglsAZCRb2zN23ApjHxJDeItGetqnGcwPDi-A,8114
+blaxel/langgraph/model.py,sha256=SdWwhfFeYNauRIbqzb_zGgjE4oCKoUKKuZbDq-RcoOs,8578
 blaxel/langgraph/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-blaxel/langgraph/tools.py,sha256=sutGgsbU5ptpHrf_fjYJi1LgYe0QuW6WpfpdBlRbP_U,2841
-blaxel/langgraph/custom/gemini.py,sha256=ui_nnfA5eqz-_F_bI3Nc8RkL4644Tx_NlnVM5aTGyxM,54572
+blaxel/langgraph/tools.py,sha256=_Gw77ilq9Rhq1pmNmrFr0JItcKhvkCV4yfymW5L_lWc,2946
+blaxel/langgraph/custom/gemini.py,sha256=Dd5GiaCDNKFxMJqd1nR54SmXf7IkSe0gu5OszE7blvk,54976
 blaxel/livekit/__init__.py,sha256=byUwOJ6MHeSXOYXmaVoHnC3ZUmpkqJ55u5mQglXX-SQ,124
-blaxel/livekit/model.py,sha256=Qhl3EVa4Uum1IsT3nyMxJwXrZn2eDvCyj6V8RHOaJsQ,1687
+blaxel/livekit/model.py,sha256=ciBLX92X9SIgDcebWguO-1P4cCHMDzRXCQWesv30hmg,2080
 blaxel/livekit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-blaxel/livekit/tools.py,sha256=QipxGDnKqma_ktzTUpKgzdp5x4bvpQnxEVoqSTBesu8,1053
+blaxel/livekit/tools.py,sha256=2TkCkqWI1FyKR638T-B9TVWE8wNwLC0NNf4ecUERr3U,1202
 blaxel/llamaindex/__init__.py,sha256=iZ3QbZhlwKvP91ChcqSXVkpRrzurMxJoQfKdZFzE2AA,127
-blaxel/llamaindex/model.py,sha256=wDWEXn2oLCjdsJ9aBN6po6-LuiSuYa3-V6SRxBMTKG0,9405
+blaxel/llamaindex/model.py,sha256=j0Im7BiIpu_DQes0xAIYZyiGUIsL9irsBiP88epeXBU,10038
 blaxel/llamaindex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-blaxel/llamaindex/tools.py,sha256=5wnPX45sgLduk9fPkhQ0rHRGK3Ekrye0MJNtMdw3GII,1024
+blaxel/llamaindex/tools.py,sha256=RhAox8XT6o9FpDgXcK8Cq1hjJo-TFlgioCoVOlz_iK4,1142
 blaxel/llamaindex/custom/cohere.py,sha256=8Kfo5BjrND6EFDZXosHNrgrg98ktvxhYG48ztaWptps,18707
 blaxel/openai/__init__.py,sha256=YkizVtcYL2m9v-z5B1EReYVu9n9V-DCxJhSB2mvqOs0,123
-blaxel/openai/model.py,sha256=OalejbWJHlHhx_LUClP3FRwhiNyeyqME9RzEE41s8zs,1244
+blaxel/openai/model.py,sha256=jauDHyKzAWmgjOv569F6pRGmUjxL1G9E2xGhjZhQeyQ,1587
 blaxel/openai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-blaxel/openai/tools.py,sha256=NFiqs1S8Uz2PGtPzAAYjNz2RGCTu3zANndmRE8IsCXo,1936
+blaxel/openai/tools.py,sha256=NWCrOpuJVulGegj8WI4dW48ScycPgfa6W2zrJtzZxI0,2411
 blaxel/pydantic/__init__.py,sha256=-UDZ5VSrlgfqErJuiuphcAFwesijzXxYLeyC7yHEDrE,128
-blaxel/pydantic/model.py,sha256=fa26oGzgT6ZxWK-cXG_c5urkMVxjE1patco2N4K4S04,6581
+blaxel/pydantic/model.py,sha256=q_FRVZ047hOolckxyp0n5pCeneWu7HvfaFF5XmA5BC0,7001
 blaxel/pydantic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-blaxel/pydantic/tools.py,sha256=5ua0Cr98-Hgkyhc92Tc6hzJrDRiNGSbAphmZQtgA5j0,1956
+blaxel/pydantic/tools.py,sha256=thrSIBXeWVF3ogyfDRqK504rv2DHnK37GHI7Ze9TrM0,3091
 blaxel/pydantic/custom/gemini.py,sha256=DddpfkP75hPPHokXWCpdk6NZiqObK5KJFxL3TXRN8Kg,1051
 blaxel/telemetry/__init__.py,sha256=g5wNqaXAVdRmUe0cX7qKHN1cftF2MaHo_QCS4D-u8CQ,257
 blaxel/telemetry/exporters.py,sha256=PFQ38SQYDftSmR4cGcWPhdMKo4uic6pE9qv72j6q-TE,2232
@@ -472,7 +472,7 @@ blaxel/telemetry/instrumentation/map.py,sha256=PCzZJj39yiYVYJrxLBNP-NW-tjjYyTijw
 blaxel/telemetry/instrumentation/utils.py,sha256=FGyMY5ZE4f-0JdZpm_R_BCoKLJ18hftz8vsh7ftDwMk,1889
 blaxel/telemetry/log/log.py,sha256=vtzUIFIIj4MTTKUigILDYXN8NHHPOo44OaKukpyIjQg,2407
 blaxel/telemetry/log/logger.py,sha256=IcFWCd1yyWWGAjAd2i0pDYqpZHQ61pmcaQ7Kf4bC8lg,4150
-blaxel-0.2.38rc122.dist-info/METADATA,sha256=--Hscbw_W5MLB8BsePm4W1NIyMklqQuO-jdV0EBoI1E,18689
-blaxel-0.2.38rc122.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-blaxel-0.2.38rc122.dist-info/licenses/LICENSE,sha256=p5PNQvpvyDT_0aYBDgmV1fFI_vAD2aSV0wWG7VTgRis,1069
-blaxel-0.2.38rc122.dist-info/RECORD,,
+blaxel-0.2.39.dist-info/METADATA,sha256=_mhXijtEXJloaPxYh4md_2i63SRdafVgWxYggj4s5_E,16109
+blaxel-0.2.39.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+blaxel-0.2.39.dist-info/licenses/LICENSE,sha256=p5PNQvpvyDT_0aYBDgmV1fFI_vAD2aSV0wWG7VTgRis,1069
+blaxel-0.2.39.dist-info/RECORD,,