blaxel 0.1.9rc36__py3-none-any.whl → 0.1.9rc37__py3-none-any.whl

blaxel/agents/__init__.py

@@ -1,4 +1,3 @@
-
 import json
 from logging import getLogger
 from typing import Any, Awaitable
@@ -8,6 +7,7 @@ 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
 
@@ -17,6 +17,19 @@ 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):
@@ -30,11 +43,10 @@ class BlAgent:
 
     @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}"
+        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 = {}):
@@ -52,14 +64,14 @@ class BlAgent:
             params=params
         )
 
-    async def acall(self, input_data, headers: dict = {}, params: dict = {}):
+    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(
-            self.url,
+            url,
             headers={
                 'Content-Type': 'application/json',
                 **headers
@@ -69,19 +81,44 @@ class BlAgent:
         )
 
     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)}):
+        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:
-                raise Exception(f"Agent {self.name} returned status code {response.status_code} with body {response.text}")
+                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]:
-        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
+        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}"

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/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/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/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/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.dist-info → blaxel-0.1.9rc37.dist-info}/METADATA

@@ -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.dist-info → blaxel-0.1.9rc37.dist-info}/RECORD

@@ -1,5 +1,5 @@
 blaxel/__init__.py,sha256=qmuJKjl5oGnjj4TbqHcJqUkKoxk4PvCsMb6-8rp67pE,159
-blaxel/agents/__init__.py,sha256=HCyqYdDHr0GkET2BBhoVpR2ZRFq824LqrYK4zf2C0dk,3369
+blaxel/agents/__init__.py,sha256=RDWkvfICIXXaQxJuuSu63jsFj_F8NBAL4U752hfN4AE,5262
 blaxel/authentication/__init__.py,sha256=WInBOiziLiEbBcrE0QXF10Ue2HJkL8aCIXjNcF5OvTA,2942
 blaxel/authentication/apikey.py,sha256=nOgLVba7EfVk3V-qm7cj-30LAL-BT7NOMIlGL9Ni1jY,1249
 blaxel/authentication/clientcredentials.py,sha256=SfWNuZVHZw6jjMqoBMMB4ZawmpyKbVPbOpv-JDFqzw8,3080
@@ -236,10 +236,11 @@ blaxel/client/models/workspace.py,sha256=K_xs5Z6qFVgw6ShzaSBtTLIdltcpfu1Op422IA2
 blaxel/client/models/workspace_labels.py,sha256=WbnUY6eCTkUNdY7hhhSF-KQCl8fWFfkCf7hzCTiNp4A,1246
 blaxel/client/models/workspace_runtime.py,sha256=dxEpmwCFPOCRKHRKhY-iW7j6TbtL5qUsbjzSn00uTXU,1665
 blaxel/client/models/workspace_user.py,sha256=70CcifQWYbeWG7TDui4pblTzUe5sVK0AS19vNCzKE8g,3423
-blaxel/common/autoload.py,sha256=SXlmPBcXUFSgqPCE4PKLYoIceloVUeDYRRI1QvDpvQA,265
+blaxel/common/autoload.py,sha256=gPDNZrVzh28iYUwUbwKudf5y0SvcJ9zBgWibVXEN3fM,262
 blaxel/common/env.py,sha256=wTbzPDdNgz4HMJiS2NCZmQlN0qpxy1PQEYBaZgtvhoc,1247
+blaxel/common/internal.py,sha256=3jIr8wDbi5ErR_N8jebaqize6SEnImq0XcGXnc7EPN8,2406
 blaxel/common/logger.py,sha256=emqgonfZMBIaQPowpngWOOZxWQieKP-yj_OzGZT8Oe8,1918
-blaxel/common/settings.py,sha256=cTPeFQ4fie23dLJUqnxqkVWbT1i1tsATDhEFE1vf74s,1959
+blaxel/common/settings.py,sha256=X0g0_hIR19qfjSeWNf8qraxb_UTSbYukVHJeRHKLTn8,2138
 blaxel/instrumentation/exporters.py,sha256=EoX3uaBVku1Rg49pSNXKFyHhgY5OV3Ih6UlqgjF5epw,1670
 blaxel/instrumentation/log.py,sha256=4tGyvLg6r4DbjqJfajYbbZ1toUzF4Q4H7kHVqYWFAEA,2537
 blaxel/instrumentation/manager.py,sha256=jVwVasyMI6tu0zv27DVYOaN57nXYuHFJ8QzJQKaNoK4,8880
@@ -247,7 +248,7 @@ blaxel/instrumentation/map.py,sha256=zZoiUiQHmik5WQZ4VCWNARSa6ppMi0r7D6hlb41N-Mg
 blaxel/instrumentation/span.py,sha256=X2lwfu_dyxwQTMQJT2vbXOrbVSChEhjRLc413QOxQJM,3244
 blaxel/mcp/__init__.py,sha256=KednMrtuc4Y0O3lv7u1Lla54FCk8UX9c1k0USjL3Ahk,69
 blaxel/mcp/client.py,sha256=cFFXfpKXoMu8qTUly2ejF0pX2iBQkSNAxqwvDV1V6xY,4979
-blaxel/mcp/server.py,sha256=Rqa6fXoP96-ePz0OIBlsFhwcBa6s5NfR87_3SRUj50Q,7249
+blaxel/mcp/server.py,sha256=GIldtA_NgIc2dzd7ZpPvpbhpIt_7AfKu5yS_YJ0bDGg,7310
 blaxel/models/__init__.py,sha256=BawkSR3ociBSHAXr42upBiX8AFJTXFVdvnt8F_CMdpc,3880
 blaxel/models/crewai.py,sha256=xsp8TmbtDjtqj5std5Gpg-yammhhgdTNL7Vlr1RSPa8,1705
 blaxel/models/googleadk.py,sha256=I2rH3ZpzdrLnFhNt01XqAC73rGvQ9gnwXjIEagFWBk8,1951
@@ -259,7 +260,7 @@ blaxel/models/pydantic.py,sha256=4_z2KtaeEiRMt_Zz6Ghy6il-QiaXzE3yizDJnCBcWO8,332
 blaxel/models/custom/langchain/gemini.py,sha256=AkhpuVMXnh1CyJ0zR2NMTtxQFPPHtAdHf_cyNzV3EsA,55421
 blaxel/models/custom/llamaindex/cohere.py,sha256=Igj5Y1ozf1V4feIXfBHDdaTFU7od_wuOhm0yChZNxMY,19109
 blaxel/models/custom/pydantic/gemini.py,sha256=rbsunh-M7EEKlD5ir3GlA-8a12JzPFcvsf6NISjzE5I,1052
-blaxel/tools/__init__.py,sha256=zBWKvxl0c3Oc24ZqP6ICvQ4GrCHXGTlySNWVzOGFHKY,9626
+blaxel/tools/__init__.py,sha256=Ihxy3AHgh4eUK4hbVf01w6jemjZynbZ4xxK9vTd0l-k,11520
 blaxel/tools/common.py,sha256=JGK052v_fvwWBFYnIArlBnFFViYyFrqdDn3gdVf53EU,1332
 blaxel/tools/crewai.py,sha256=rPrRGwkXejunJQ6In1IsYAxJPNbr6d9EckXrSIHQods,638
 blaxel/tools/googleadk.py,sha256=65qJysecgAMujxsyGxuCEVL0fWoR5I489DMiSA3ZaGs,2265
@@ -269,7 +270,7 @@ blaxel/tools/llamaindex.py,sha256=-gQ-C9V_h9a11J4ItsbWjXrCJOg0lRKsb98v9rVsNak,71
 blaxel/tools/openai.py,sha256=GuFXkj6bXEwldyVr89jEsRAi5ihZUVEVe327QuWiGNs,653
 blaxel/tools/pydantic.py,sha256=CvnNbAG_J4yBtA-XFI4lQrq3FYKjNd39hu841vZT004,1801
 blaxel/tools/types.py,sha256=YPCGJ4vZDhqR0X2H_TWtc5chQScsC32nGTQdRKJlO8Y,707
-blaxel-0.1.9rc36.dist-info/METADATA,sha256=SZtld07RmNMSYyFr-EiHMrmAmWk5jFINSNfGH-Hdy74,11606
-blaxel-0.1.9rc36.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-blaxel-0.1.9rc36.dist-info/licenses/LICENSE,sha256=p5PNQvpvyDT_0aYBDgmV1fFI_vAD2aSV0wWG7VTgRis,1069
-blaxel-0.1.9rc36.dist-info/RECORD,,
+blaxel-0.1.9rc37.dist-info/METADATA,sha256=CwCyqpx3AtQTXCJEFxTt4Ikuz1VSK1WMyIF1q-ye9Rs,11606
+blaxel-0.1.9rc37.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+blaxel-0.1.9rc37.dist-info/licenses/LICENSE,sha256=p5PNQvpvyDT_0aYBDgmV1fFI_vAD2aSV0wWG7VTgRis,1069
+blaxel-0.1.9rc37.dist-info/RECORD,,