blaxel 0.1.9rc36__tar.gz → 0.1.9rc37__tar.gz

{blaxel-0.1.9rc36 → blaxel-0.1.9rc37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blaxel
-Version: 0.1.9rc36
+Version: 0.1.9rc37
 Summary: Add your description here
 Author-email: cploujoux <cploujoux@blaxel.ai>
 License-File: LICENSE

{blaxel-0.1.9rc36 → blaxel-0.1.9rc37}/integrationtest/bl_agents.py

@@ -4,7 +4,7 @@ from blaxel.agents import bl_agent
 
 
 async def main():
-    agent = bl_agent("vercel-first")
+    agent = bl_agent("template-google-adk-py")
     print(await agent.arun({"inputs": "Hello, world!"}))
     print(agent.run({"inputs": "Hello, world!"}))
 

blaxel-0.1.9rc37/integrationtest/global_hash.py

@@ -0,0 +1,3 @@
+from blaxel.common.internal import get_alphanumeric_limited_hash
+
+print(get_alphanumeric_limited_hash("dawa-function-pym", 48))

{blaxel-0.1.9rc36 → blaxel-0.1.9rc37}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "blaxel"
-version = "0.1.9.pre-36"
+version = "0.1.9.pre-37"
 description = "Add your description here"
 readme = "README.md"
 authors = [{ name = "cploujoux", email = "cploujoux@blaxel.ai" }]

blaxel-0.1.9rc37/src/blaxel/agents/__init__.py

@@ -0,0 +1,139 @@
+import json
+from logging import getLogger
+from typing import Any, Awaitable
+
+from ..cache import find_from_cache
+from ..client import client
+from ..client.api.agents import get_agent
+from ..client.models import Agent
+from ..common.env import env
+from ..common.internal import get_global_unique_hash
+from ..common.settings import settings
+from ..instrumentation.span import SpanManager
+
+logger = getLogger(__name__)
+
+class BlAgent:
+    def __init__(self, name: str):
+        self.name = name
+
+    @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, "agent", 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."""
+        env_var = self.name.replace("-", "_").upper()
+        if env[f"BL_AGENT_{env_var}_URL"]:
+            return env[f"BL_AGENT_{env_var}_URL"]
+        return None
+
+    @property
+    def external_url(self):
+        return f"{settings.run_url}/{settings.workspace}/agents/{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.forced_url:
+            return self.forced_url
+        if settings.run_internal_hostname:
+            return self.internal_url
+        return self.external_url
+
+    def call(self, url, input_data, headers: dict = {}, params: dict = {}):
+        body = input_data
+        if not isinstance(body, str):
+            body = json.dumps(body)
+
+        return client.get_httpx_client().post(
+            url,
+            headers={
+                'Content-Type': 'application/json',
+                **headers
+            },
+            data=body,
+            params=params
+        )
+
+    async def acall(self, url, input_data, headers: dict = {}, params: dict = {}):
+        logger.debug(f"Agent Calling: {self.name}")
+        body = input_data
+        if not isinstance(body, str):
+            body = json.dumps(body)
+
+        return await client.get_async_httpx_client().post(
+            url,
+            headers={
+                'Content-Type': 'application/json',
+                **headers
+            },
+            data=body,
+            params=params
+        )
+
+    def run(self, input: Any, headers: dict = {}, params: dict = {}) -> str:
+        attributes = {
+            "agent.name": self.name,
+            "agent.args": json.dumps(input),
+            "span.type": "agent.run",
+        }
+        with SpanManager("blaxel-tracer").create_active_span(self.name, attributes) as span:
+            logger.debug(f"Agent Calling: {self.name}")
+            response = self.call(self.url, input, headers, params)
+            if response.status_code >= 400:
+                if not self.fallback_url:
+                    span.set_attribute("agent.run.error", response.text)
+                    raise Exception(f"Agent {self.name} returned status code {response.status_code} with body {response.text}")
+                response = self.call(self.fallback_url, input, headers, params)
+                if response.status_code >= 400:
+                    span.set_attribute("agent.run.error", response.text)
+                    raise Exception(f"Agent {self.name} returned status code {response.status_code} with body {response.text}")
+            span.set_attribute("agent.run.result", response.text)
+            return response.text
+
+    async def arun(self, input: Any, headers: dict = {}, params: dict = {}) -> Awaitable[str]:
+        attributes = {
+            "agent.name": self.name,
+            "agent.args": json.dumps(input),
+            "span.type": "agent.run",
+        }
+        with SpanManager("blaxel-tracer").create_active_span(self.name, attributes) as span:
+            logger.debug(f"Agent Calling: {self.name}")
+            response = await self.acall(self.url, input, headers, params)
+            if response.status_code >= 400:
+                if not self.fallback_url:
+                    span.set_attribute("agent.run.error", response.text)
+                    raise Exception(f"Agent {self.name} returned status code {response.status_code} with body {response.text}")
+                response = await self.acall(self.fallback_url, input, headers, params)
+                if response.status_code >= 400:
+                    span.set_attribute("agent.run.error", response.text)
+                    raise Exception(f"Agent {self.name} returned status code {response.status_code} with body {response.text}")
+            span.set_attribute("agent.run.result", response.text)
+            return response.text
+
+    def __str__(self):
+        return f"Agent {self.name}"
+
+    def __repr__(self):
+        return self.__str__()
+
+def bl_agent(name: str):
+    return BlAgent(name)
+
+async def get_agent_metadata(name):
+    cache_data = await find_from_cache('Agent', name)
+    if cache_data:
+        return Agent.from_dict(cache_data)
+    try:
+        return await get_agent.asyncio(client=client, agent_name=name)
+    except Exception:
+        return None

{blaxel-0.1.9rc36 → blaxel-0.1.9rc37}/src/blaxel/common/autoload.py

@@ -1,10 +1,7 @@
-
-
 from ..client import client
 from ..instrumentation.manager import telemetry_manager
 from .settings import settings
 
-
 def autoload() -> None:
     client.with_base_url(settings.base_url)
     client.with_auth(settings.auth)

blaxel-0.1.9rc37/src/blaxel/common/internal.py

@@ -0,0 +1,75 @@
+import base64
+import hashlib
+import os
+import re
+from typing import Optional
+from logging import getLogger
+
+logger = getLogger(__name__)
+
+def get_alphanumeric_limited_hash(input_str, max_size):
+    # Create SHA-256 hash of the input string
+    hash_obj = hashlib.sha256(input_str.encode('utf-8'))
+    
+    # Get the hash digest in base64 format
+    hash_base64 = base64.b64encode(hash_obj.digest()).decode('utf-8')
+    
+    # Remove non-alphanumeric characters and convert to lowercase
+    alphanumeric = re.sub(r'[^a-zA-Z0-9]', '', hash_base64).lower()
+    
+    # Skip the first character to match the Node.js crypto output
+    alphanumeric = alphanumeric[1:]
+    
+    # Limit to max_size characters
+    return alphanumeric[:max_size] if len(alphanumeric) > max_size else alphanumeric
+
+
+def get_global_unique_hash(workspace: str, type: str, name: str) -> str:
+    """
+    Generate a unique hash for a combination of workspace, type, and name.
+
+    Args:
+        workspace: The workspace identifier
+        type: The type identifier
+        name: The name identifier
+
+    Returns:
+        A unique alphanumeric hash string of maximum length 48
+    """
+    global_unique_name = f"{workspace}-{type}-{name}"
+    hash = get_alphanumeric_limited_hash(global_unique_name, 48)
+    return hash
+
+class Agent:
+    def __init__(self, agent_name: str, workspace: str, run_internal_protocol: str, run_internal_hostname: str):
+        self.agent_name = agent_name
+        self.workspace = workspace
+        self.run_internal_protocol = run_internal_protocol
+        self.run_internal_hostname = run_internal_hostname
+
+    @property
+    def internal_url(self) -> str:
+        """
+        Generate the internal URL for the agent using a unique hash.
+
+        Returns:
+            The internal URL as a string
+        """
+        hash_value = get_global_unique_hash(
+            self.workspace,
+            "agent",
+            self.agent_name
+        )
+        return f"{self.run_internal_protocol}://{hash_value}.{self.run_internal_hostname}"
+
+    @property
+    def forced_url(self) -> Optional[str]:
+        """
+        Check for a forced URL in environment variables.
+
+        Returns:
+            The forced URL if found in environment variables, None otherwise
+        """
+        env_var = self.agent_name.replace("-", "_").upper()
+        env_key = f"BL_AGENT_{env_var}_URL"
+        return os.environ.get(env_key)

{blaxel-0.1.9rc36 → blaxel-0.1.9rc37}/src/blaxel/common/settings.py

@@ -21,7 +21,7 @@ class Settings:
     @property
     def log_level(self) -> str:
         """Get the log level."""
-        return os.environ.get("LOG_LEVEL", "INFO")
+        return os.environ.get("LOG_LEVEL", "INFO").upper()
 
     @property
     def base_url(self) -> str:
@@ -69,6 +69,11 @@ class Settings:
         """Is running on bl cloud."""
         return os.environ.get("BL_CLOUD", "") == "true"
 
+    @property
+    def run_internal_protocol(self) -> str:
+        """Get the run internal protocol."""
+        return os.environ.get("BL_RUN_INTERNAL_PROTOCOL", "https")
+
     @property
     def enable_opentelemetry(self) -> bool:
         """Get the enable opentelemetry."""

{blaxel-0.1.9rc36 → blaxel-0.1.9rc37}/src/blaxel/mcp/server.py

@@ -65,7 +65,8 @@ class BlaxelMcpServerTransport:
                                 "mcp.message.parsed": True,
                                 "mcp.method": getattr(msg, "method", None),
                                 "mcp.messageId": getattr(msg, "id", None),
-                                "mcp.toolName": getattr(getattr(msg, "params", None), "name", None)
+                                "mcp.toolName": getattr(getattr(msg, "params", None), "name", None),
+                                "span.type": "mcp.message",
                             })
                             self.spans[client_id+":"+msg.id] =  span
                         await read_stream_writer.send(msg)

{blaxel-0.1.9rc36 → blaxel-0.1.9rc37}/src/blaxel/tools/__init__.py

@@ -4,12 +4,14 @@ import os
 from contextlib import AsyncExitStack
 from logging import getLogger
 from typing import Any, cast
+import traceback
 
 from mcp import ClientSession
 from mcp.types import CallToolResult
 from mcp.types import Tool as MCPTool
 
 from ..common.env import env
+from ..common.internal import get_global_unique_hash
 from ..common.settings import settings
 from ..instrumentation.span import SpanManager
 from ..mcp.client import websocket_client
@@ -22,15 +24,19 @@ if os.getenv("BL_SERVER_PORT"):
     DEFAULT_TIMEOUT = 5
 
 class PersistentWebSocket:
-    def __init__(self, url: str, timeout: int = DEFAULT_TIMEOUT, timeout_enabled: bool = True):
+    def __init__(self, url: str, name: str, timeout: int = DEFAULT_TIMEOUT, timeout_enabled: bool = True):
         self.url = url
+        self.name = name
         self.timeout = timeout
-        self.timeout_enabled = timeout_enabled
         self.session_exit_stack = AsyncExitStack()
         self.client_exit_stack = AsyncExitStack()
         self.session: ClientSession = None
         self.timer_task = None
         self.tools_cache = []
+        if settings.bl_cloud:
+            self.timeout_enabled = False
+        else:
+            self.timeout_enabled = timeout_enabled
 
     def with_metas(self, metas: dict[str, Any]):
         self.metas = metas
@@ -46,19 +52,32 @@ class PersistentWebSocket:
         logger.debug(f"Tool {tool_name} returned {call_tool_result}")
         if self.timeout_enabled:
             self._reset_timer()
+        else:
+            await self._close()
         return call_tool_result
 
     async def list_tools(self):
-        await self._initialize()
-        if self.timeout_enabled:
-            self._remove_timer()
-        logger.debug("Listing tools")
-        list_tools_result = await self.session.list_tools()
-        self.tools_cache = list_tools_result.tools
-        logger.debug(f"Tools listed: {list_tools_result}")
-        if self.timeout_enabled:
-            self._reset_timer()
-        return list_tools_result
+        logger.debug(f"Listing tools for {self.name}")
+        span_attributes = {
+            "tool.server": self.url,
+            "tool.server_name": self.name,
+            "span.type": "tool.list",
+        }
+        with SpanManager("blaxel-tracer").create_active_span(self.name, span_attributes) as span:
+            await self._initialize()
+            logger.debug(f"Initialized websocket for {self.name}")
+            if self.timeout_enabled:
+                self._remove_timer()
+            logger.debug("Listing tools")
+            list_tools_result = await self.session.list_tools()
+            self.tools_cache = list_tools_result.tools
+            logger.debug(f"Tools listed: {list_tools_result}")
+            if self.timeout_enabled:
+                self._reset_timer()
+            else:
+                await self._close()
+            span.set_attribute("tool.list.result", list_tools_result.model_dump_json())
+            return list_tools_result
 
     def get_tools(self):
         return self.tools_cache
@@ -125,6 +144,7 @@ def convert_mcp_tool_to_blaxel_tool(
             "tool.args": json.dumps(arguments),
             "tool.server": url,
             "tool.server_name": name,
+            "span.type": "tool.call",
         }
         with SpanManager("blaxel-tracer").create_active_span("blaxel-tool-call", span_attributes):
             logger.debug(f"Calling tool {tool.name} with arguments {arguments}")
@@ -163,22 +183,37 @@ class BlTools:
         self.timeout = timeout
         self.timeout_enabled = timeout_enabled
 
-    def _external_url(self, name: str) -> str:
-        return f"{settings.run_url}/{settings.auth.workspace_name}/functions/{name}"
+    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 _url(self, name: str) -> str:
+    def _forced_url(self, name: str):
+        """Get the forced URL from environment variables if set."""
         env_var = name.replace("-", "_").upper()
         if env[f"BL_FUNCTION_{env_var}_URL"]:
             return env[f"BL_FUNCTION_{env_var}_URL"]
-        elif env[f"BL_FUNCTION_{env_var}_SERVICE_NAME"]:
-            return f"https://{env[f'BL_FUNCTION_{env_var}_SERVICE_NAME']}.{settings.run_internal_hostname}"
-        return self._external_url(name)
+        return None
+
+    def _external_url(self, name: str):
+        return f"{settings.run_url}/{settings.workspace}/functions/{name}"
 
-    def _fallback_url(self, name: str) -> str | None:
+    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] = []
@@ -240,8 +275,13 @@ class BlTools:
         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)
-            await self.connect_with_url(name, url)
+            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
@@ -255,7 +295,8 @@ class BlTools:
         logger.debug(f"Initializing session and loading tools from {url}")
 
         if not toolPersistances.get(name):
-            toolPersistances[name] = PersistentWebSocket(url, timeout=self.timeout, timeout_enabled=self.timeout_enabled)
+            logger.debug(f"Creating new persistent websocket for {name}")
+            toolPersistances[name] = PersistentWebSocket(url, 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}")
         return toolPersistances[name].with_metas(self.metas)

blaxel-0.1.9rc36/src/blaxel/agents/__init__.py

@@ -1,102 +0,0 @@
-
-import json
-from logging import getLogger
-from typing import Any, Awaitable
-
-from ..cache import find_from_cache
-from ..client import client
-from ..client.api.agents import get_agent
-from ..client.models import Agent
-from ..common.env import env
-from ..common.settings import settings
-from ..instrumentation.span import SpanManager
-
-logger = getLogger(__name__)
-
-class BlAgent:
-    def __init__(self, name: str):
-        self.name = name
-
-
-    @property
-    def external_url(self):
-        return f"{settings.run_url}/{settings.workspace}/agents/{self.name}"
-
-    @property
-    def fallback_url(self):
-        if self.external_url != self.url:
-            return self.external_url
-        return None
-
-    @property
-    def url(self):
-        env_var = self.name.replace("-", "_").upper()
-        if env[f"BL_AGENT_{env_var}_URL"]:
-            return env[f"BL_AGENT_{env_var}_URL"]
-        if f"BL_AGENT_{env_var}_SERVICE_NAME" in settings.env:
-            return f"https://{settings.env[f'BL_AGENT_{env_var}_SERVICE_NAME']}.{settings.run_internal_hostname}"
-        return self.external_url
-
-    def call(self, url, input_data, headers: dict = {}, params: dict = {}):
-        body = input_data
-        if not isinstance(body, str):
-            body = json.dumps(body)
-
-        return client.get_httpx_client().post(
-            url,
-            headers={
-                'Content-Type': 'application/json',
-                **headers
-            },
-            data=body,
-            params=params
-        )
-
-    async def acall(self, input_data, headers: dict = {}, params: dict = {}):
-        logger.debug(f"Agent Calling: {self.name}")
-        body = input_data
-        if not isinstance(body, str):
-            body = json.dumps(body)
-
-        return await client.get_async_httpx_client().post(
-            self.url,
-            headers={
-                'Content-Type': 'application/json',
-                **headers
-            },
-            data=body,
-            params=params
-        )
-
-    def run(self, input: Any, headers: dict = {}, params: dict = {}) -> str:
-        with SpanManager("blaxel-tracer").create_active_span(self.name, {"agent.name": self.name, "agent.args": json.dumps(input)}):
-            logger.debug(f"Agent Calling: {self.name}")
-            response = self.call(self.url, input, headers, params)
-            if response.status_code >= 400:
-                raise Exception(f"Agent {self.name} returned status code {response.status_code} with body {response.text}")
-            return response.text
-
-    async def arun(self, input: Any, headers: dict = {}, params: dict = {}) -> Awaitable[str]:
-        logger.debug(f"Agent Calling: {self.name}")
-        response = await self.acall(input, headers, params)
-        if response.status_code >= 400:
-            raise Exception(f"Agent {self.name} returned status code {response.status_code} with body {response.text}")
-        return response.text
-
-    def __str__(self):
-        return f"Agent {self.name}"
-
-    def __repr__(self):
-        return self.__str__()
-
-def bl_agent(name: str):
-    return BlAgent(name)
-
-async def get_agent_metadata(name):
-    cache_data = await find_from_cache('Agent', name)
-    if cache_data:
-        return Agent.from_dict(cache_data)
-    try:
-        return await get_agent.asyncio(client=client, agent_name=name)
-    except Exception:
-        return None