blaxel 0.1.21rc69__py3-none-any.whl → 0.2.0rc1__py3-none-any.whl

blaxel/models/__init__.py

@@ -1,104 +0,0 @@
-
-from ..cache import find_from_cache
-from ..client import client
-from ..client.api.models import get_model
-from ..client.models import Model
-from ..common.settings import settings
-
-
-class BLModel:
-    models = {}
-
-    def __init__(self, model_name, **kwargs):
-        self.model_name = model_name
-        self.kwargs = kwargs
-
-    async def to_langchain(self):
-        from .langchain import get_langchain_model
-        url, type, model = await self._get_parameters()
-        model = await get_langchain_model(url, type, model, **self.kwargs)
-        BLModel.models[f"langchain_{self.model_name}"] = model
-        return model
-
-    async def to_llamaindex(self):
-        from .llamaindex import get_llamaindex_model
-        url, type, model = await self._get_parameters()
-        model = await get_llamaindex_model(url, type, model, **self.kwargs)
-        BLModel.models[f"llamaindex_{self.model_name}"] = model
-        return model
-
-    async def to_crewai(self):
-        from .crewai import get_crewai_model
-
-        url, type, model = await self._get_parameters()
-        model = await get_crewai_model(url, type, model, **self.kwargs)
-        BLModel.models[f"crewai_{self.model_name}"] = model
-        return model
-
-    async def to_openai(self):
-        from .openai import get_openai_model
-        url, type, model = await self._get_parameters()
-        model = await get_openai_model(url, type, model, **self.kwargs)
-        BLModel.models[f"openai_{self.model_name}"] = model
-        return model
-
-    async def to_pydantic(self):
-        from .pydantic import get_pydantic_model
-        url, type, model = await self._get_parameters()
-        model = await get_pydantic_model(url, type, model, **self.kwargs)
-        BLModel.models[f"pydantic_{self.model_name}"] = model
-        return model
-
-    async def to_google_adk(self):
-        from .googleadk import get_google_adk_model
-        url, type, model = await self._get_parameters()
-        model = await get_google_adk_model(url, type, model, **self.kwargs)
-        BLModel.models[f"googleadk_{self.model_name}"] = model
-        return model
-
-    async def to_livekit(self):
-        # This has to be here because livekit plugins must be registered on the main thread
-        from .livekit import get_livekit_model
-
-        url, type, model = await self._get_parameters()
-        model = await get_livekit_model(url, type, model, **self.kwargs)
-        BLModel.models[f"livekit_{self.model_name}"] = model
-        return model
-
-    async def _get_parameters(self) -> tuple[str, str, str]:
-        if self.model_name in self.models:
-            # We get the headers in case we need to refresh the token
-            settings.auth.get_headers()
-            model = self.models[self.model_name]
-            return model["url"], model["type"], model["model"]
-        url = f"{settings.run_url}/{settings.auth.workspace_name}/models/{self.model_name}"
-        model_data = await self._get_model_metadata()
-        if not model_data:
-            raise Exception(f"Model {self.model_name} not found")
-        runtime = (model_data.spec and model_data.spec.runtime)
-        if not runtime:
-            raise Exception(f"Model {self.model_name} has no runtime")
-
-        type = runtime.type_ or 'openai'
-        model = runtime.model
-        self.models[self.model_name] = {
-            "url": url,
-            "type": type,
-            "model": model
-        }
-        return url, type, model
-
-    async def _get_model_metadata(self) -> Model | None:
-        cache_data = await find_from_cache('Model', self.model_name)
-        if cache_data:
-            return Model.from_dict(cache_data)
-
-        try:
-            return await get_model.asyncio(client=client, model_name=self.model_name)
-        except Exception:
-            return None
-
-def bl_model(model_name, **kwargs):
-    return BLModel(model_name, **kwargs)
-
-__all__ = ["bl_model"]

blaxel/sandbox/base.py

@@ -1,68 +0,0 @@
-import os
-
-from httpx import Response
-
-from ..client.models import Sandbox
-from ..common.internal import get_global_unique_hash, get_forced_url
-from ..common.settings import settings
-from .client.client import client
-from .client.models import ErrorResponse
-
-
-class ResponseError(Exception):
-    def __init__(self, response: Response):
-        self.status_code = response.status_code
-        self.status_text = response.content
-        self.error = None
-        data_error = {
-            "status": response.status_code,
-            "statusText": response.content,
-        }
-        if hasattr(response, "parsed") and isinstance(response.parsed, ErrorResponse):
-            data_error["error"] = response.parsed.error
-            self.error = response.parsed.error
-        super().__init__(str(data_error))
-
-
-class SandboxHandleBase:
-    def __init__(self, sandbox: Sandbox):
-        self.sandbox = sandbox
-        self.client = client.with_base_url(self.url).with_headers(settings.headers)
-
-    @property
-    def name(self):
-        return self.sandbox.metadata and self.sandbox.metadata.name
-
-    @property
-    def fallback_url(self):
-        if self.external_url != self.url:
-            return self.external_url
-        return None
-
-    @property
-    def external_url(self):
-        return f"{settings.run_url}/{settings.workspace}/sandboxes/{self.name}"
-
-    @property
-    def internal_url(self):
-        hash_ = get_global_unique_hash(settings.workspace, "sandbox", self.name)
-        return f"{settings.run_internal_protocol}://bl-{settings.env}-{hash_}.{settings.run_internal_hostname}"
-
-    @property
-    def forced_url(self):
-        return get_forced_url("sandbox", self.name)
-
-    @property
-    def url(self):
-        if self.forced_url:
-            return self.forced_url
-        # Uncomment and use this when agent and mcp are available in mk3
-        # Update all requests made in this package to use fallbackUrl when internalUrl is not working
-        # if settings.run_internal_hostname:
-        #     return self.internal_url
-        return self.external_url
-
-    def handle_response(self, response: Response):
-        if response.status_code >= 400:
-            raise ResponseError(response)
-

blaxel/sandbox/client/models/process_kill_request.py

@@ -1,60 +0,0 @@
-from typing import Any, TypeVar, Union
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-from ..types import UNSET, Unset
-
-T = TypeVar("T", bound="ProcessKillRequest")
-
-
-@_attrs_define
-class ProcessKillRequest:
-    """
-    Attributes:
-        signal (Union[Unset, str]):  Example: SIGTERM.
-    """
-
-    signal: Union[Unset, str] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        signal = self.signal
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if signal is not UNSET:
-            field_dict["signal"] = signal
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        signal = d.pop("signal", UNSET)
-
-        process_kill_request = cls(
-            signal=signal,
-        )
-
-        process_kill_request.additional_properties = d
-        return process_kill_request
-
-    @property
-    def additional_keys(self) -> list[str]:
-        return list(self.additional_properties.keys())
-
-    def __getitem__(self, key: str) -> Any:
-        return self.additional_properties[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.additional_properties[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self.additional_properties[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.additional_properties

blaxel/sandbox/filesystem.py

@@ -1,104 +0,0 @@
-import asyncio
-from typing import Dict
-
-from ..common.settings import settings
-from .base import SandboxHandleBase
-from .client.api.filesystem.delete_filesystem_path import (
-    asyncio_detailed as delete_filesystem_by_path,
-)
-from .client.api.filesystem.get_filesystem_path import asyncio_detailed as get_filesystem_by_path
-from .client.api.filesystem.put_filesystem_path import asyncio_detailed as put_filesystem_by_path
-from .client.client import client
-from .client.models import Directory, FileRequest, SuccessResponse
-
-
-class SandboxFileSystem(SandboxHandleBase):
-    def __init__(self, sandbox):
-        super().__init__(sandbox)
-        self.client = client.with_base_url(self.url).with_headers(settings.headers)
-
-    async def mkdir(self, path: str, permissions: str = "0755") -> SuccessResponse:
-        path = self.format_path(path)
-        body = FileRequest(is_directory=True, permissions=permissions)
-        response = await put_filesystem_by_path(path=path, client=self.client, body=body)
-        self.handle_response(response)
-        return response.parsed
-
-    async def write(self, path: str, content: str) -> SuccessResponse:
-        path = self.format_path(path)
-        body = FileRequest(content=content)
-        response = await put_filesystem_by_path(path=path, client=self.client, body=body)
-        self.handle_response(response)
-        return response.parsed
-
-    async def read(self, path: str) -> str:
-        path = self.format_path(path)
-        response = await get_filesystem_by_path(path=path, client=self.client)
-        self.handle_response(response)
-        if "content" not in response.parsed.additional_properties:
-            raise Exception('{"error": "File not found"}')
-        return response.parsed.additional_properties["content"]
-
-    async def rm(self, path: str, recursive: bool = False) -> SuccessResponse:
-        path = self.format_path(path)
-        response = await delete_filesystem_by_path(path=path, client=self.client, recursive=recursive)
-        self.handle_response(response)
-        return response.parsed
-
-    async def ls(self, path: str) -> Directory:
-        path = self.format_path(path)
-        response = await get_filesystem_by_path(path=path, client=self.client)
-        self.handle_response(response)
-        if not hasattr(response.parsed, "files") and not hasattr(response.parsed, "subdirectories"):
-            raise Exception('{"error": "Directory not found"}')
-        return response.parsed
-
-    async def cp(self, source: str, destination: str) -> Dict[str, str]:
-        source = self.format_path(source)
-        destination = self.format_path(destination)
-        response = await get_filesystem_by_path(path=source, client=self.client)
-        self.handle_response(response)
-        data = response.parsed
-        if "content" in data.additional_properties:
-            await self.write(destination, data.additional_properties["content"])
-            return {
-                "message": "File copied successfully",
-                "source": source,
-                "destination": destination,
-            }
-        elif hasattr(data, "subdirectories") or hasattr(data, "files"):
-            # Create destination directory
-            await self.mkdir(destination)
-            # Process subdirectories in batches of 5
-            subdirectories = getattr(data, "subdirectories", []) or []
-            for i in range(0, len(subdirectories), 5):
-                batch = subdirectories[i:i+5]
-                await asyncio.gather(*[
-                    self.cp(
-                        getattr(subdir, "path", f"{source}/{getattr(subdir, 'path', '')}"),
-                        f"{destination}/{getattr(subdir, 'path', '')}"
-                    ) for subdir in batch
-                ])
-            # Process files in batches of 10
-            files = getattr(data, "files", []) or []
-            for i in range(0, len(files), 10):
-                batch = files[i:i+10]
-                await asyncio.gather(*[
-                    self.write(
-                        f"{destination}/{getattr(file, 'path', '')}",
-                        await self.read(getattr(file, "path", f"{source}/{getattr(file, 'path', '')}"))
-                    ) for file in batch
-                ])
-            return {
-                "message": "Directory copied successfully",
-                "source": source,
-                "destination": destination,
-            }
-        raise Exception("Unsupported file type")
-
-    def format_path(self, path: str) -> str:
-        if path == "/":
-            return "%2F"
-        if path.startswith("/"):
-            path = path[1:]
-        return path

blaxel/sandbox/process.py

@@ -1,56 +0,0 @@
-from blaxel.sandbox.client.models.process_request import ProcessRequest
-
-from .base import SandboxHandleBase
-from .client.api.process.delete_process_identifier import (
-    asyncio_detailed as delete_process_by_identifier,
-)
-from .client.api.process.delete_process_identifier_kill import (
-    asyncio_detailed as delete_process_by_identifier_kill,
-)
-from .client.api.process.get_process import asyncio_detailed as get_process
-from .client.api.process.get_process_identifier import asyncio_detailed as get_process_by_identifier
-from .client.api.process.get_process_identifier_logs import (
-    asyncio_detailed as get_process_by_identifier_logs,
-)
-from .client.api.process.post_process import asyncio_detailed as post_process
-from .client.models import ProcessKillRequest, ProcessLogs, ProcessResponse, SuccessResponse
-
-
-class SandboxProcess(SandboxHandleBase):
-    async def exec(self, process: ProcessRequest) -> ProcessResponse:
-        response = await post_process(client=self.client, body=process)
-        self.handle_response(response)
-        return response.parsed
-
-    async def get(self, identifier: str) -> ProcessResponse:
-        response = await get_process_by_identifier(identifier=identifier, client=self.client)
-        self.handle_response(response)
-        return response.parsed
-
-    async def list(self) -> list[ProcessResponse]:
-        response = await get_process(client=self.client)
-        self.handle_response(response)
-        return response.parsed
-
-    async def stop(self, identifier: str) -> SuccessResponse:
-        response = await delete_process_by_identifier(identifier=identifier, client=self.client)
-        self.handle_response(response)
-        return response.parsed
-
-    async def kill(self, identifier: str, signal: str = "SIGKILL") -> SuccessResponse:
-        kill_request = ProcessKillRequest(signal=signal)
-        response = await delete_process_by_identifier_kill(identifier=identifier, client=self.client, body=kill_request)
-        self.handle_response(response)
-        return response.parsed
-
-    async def logs(self, identifier: str, type_: str = "stdout") -> str:
-        response = await get_process_by_identifier_logs(identifier=identifier, client=self.client)
-        self.handle_response(response)
-        data: ProcessLogs = response.parsed
-        if type_ == "all":
-            return data.logs
-        elif type_ == "stderr":
-            return data.stderr
-        elif type_ == "stdout":
-            return data.stdout
-        raise Exception("Unsupported log type")

blaxel/tools/crewai.py

@@ -1,22 +0,0 @@
-from crewai.tools import BaseTool
-
-from .common import create_model_from_json_schema
-from .types import Tool
-
-
-def get_crewai_tools(tools: list[Tool]) -> list[BaseTool]:
-    class CrewAITool(BaseTool):
-        _tool: Tool
-
-        def __init__(self, tool: Tool):
-            super().__init__(
-                name=tool.name,
-                description=tool.description,
-                args_schema=create_model_from_json_schema(tool.input_schema),
-            )
-            self._tool = tool
-
-        def _run(self, *args, **kwargs):
-            return self._tool.sync_coroutine(**kwargs)
-
-    return [CrewAITool(tool) for tool in tools]

blaxel/tools/googleadk.py

@@ -1,66 +0,0 @@
-import inspect
-from typing import Any, Optional, override
-
-from google.adk.tools import BaseTool, ToolContext
-from google.genai import types
-
-from .types import Tool
-
-
-def get_google_adk_tools(tools: list[Tool]) -> list[BaseTool]:
-    class GoogleADKTool(BaseTool):
-        _tool: Tool
-
-        def __init__(self, tool: Tool):
-            super().__init__(
-                name=tool.name,
-                description=tool.description,
-            )
-            self._tool = tool
-
-        def _clean_schema(self, schema: dict) -> dict:
-            if not isinstance(schema, dict):
-                return schema
-
-            # Create a copy of the schema
-            cleaned_schema = schema.copy()
-
-            # Remove $schema and additionalProperties at current level
-            if "$schema" in cleaned_schema:
-                del cleaned_schema["$schema"]
-            if "additionalProperties" in cleaned_schema:
-                del cleaned_schema["additionalProperties"]
-
-            # Recursively clean properties if they exist
-            if "properties" in cleaned_schema:
-                cleaned_schema["properties"] = {
-                    k: self._clean_schema(v) for k, v in cleaned_schema["properties"].items()
-                }
-
-            return cleaned_schema
-
-        @override
-        def _get_declaration(self) -> Optional[types.FunctionDeclaration]:
-            # Clean the schema recursively
-            schema = self._clean_schema(self._tool.input_schema)
-
-            function_decl = types.FunctionDeclaration.model_validate(
-                types.FunctionDeclaration(
-                    name=self._tool.name,
-                    description=self._tool.description,
-                    parameters=schema,
-                )
-            )
-
-            return function_decl
-
-        @override
-        async def run_async(
-            self, *, args: dict[str, Any], tool_context: ToolContext
-        ) -> Any:
-            args_to_call = args.copy()
-            signature = inspect.signature(self._tool.coroutine)
-            if 'tool_context' in signature.parameters:
-                args_to_call['tool_context'] = tool_context
-            return await self._tool.coroutine(**args_to_call) or {}
-    return [GoogleADKTool(tool) for tool in tools]

blaxel-0.1.21rc69.dist-info/METADATA

@@ -1,169 +0,0 @@
-Metadata-Version: 2.4
-Name: blaxel
-Version: 0.1.21rc69
-Summary: Add your description here
-Project-URL: Homepage, https://blaxel.ai
-Project-URL: Documentation, https://docs.blaxel.ai
-Project-URL: Repository, https://github.com/blaxel-ai/sdk-python
-Project-URL: Changelog, https://docs.blaxel.ai/changelog
-Author-email: cploujoux <cploujoux@blaxel.ai>
-License-File: LICENSE
-Requires-Python: >=3.10
-Requires-Dist: attrs>=21.3.0
-Requires-Dist: httpx>=0.27.0
-Requires-Dist: mcp<=1.7.1
-Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: opentelemetry-exporter-otlp>=1.28.0
-Requires-Dist: opentelemetry-instrumentation-anthropic==0.40.6
-Requires-Dist: opentelemetry-instrumentation-cohere==0.40.6
-Requires-Dist: opentelemetry-instrumentation-fastapi==0.54b1
-Requires-Dist: opentelemetry-instrumentation-ollama==0.40.6
-Requires-Dist: opentelemetry-instrumentation-openai==0.40.6
-Requires-Dist: opentelemetry-instrumentation-system-metrics
-Requires-Dist: opentelemetry-sdk>=1.28.0
-Requires-Dist: pydantic<2.11.0,>=2.10.3
-Requires-Dist: pyjwt>=2.10.1
-Requires-Dist: python-dateutil>=2.8.0
-Requires-Dist: pyyaml<6.1.0,>=6.0.2
-Requires-Dist: requests<2.33.0,>=2.32.3
-Requires-Dist: tomli>=2.2.1
-Requires-Dist: websockets<15.0.0
-Provides-Extra: crewai
-Requires-Dist: crewai>=0.120.1; extra == 'crewai'
-Requires-Dist: opentelemetry-instrumentation-crewai>=0.40.6; extra == 'crewai'
-Provides-Extra: google-adk
-Requires-Dist: google-adk>=1.1.1; extra == 'google-adk'
-Requires-Dist: litellm>=1.63.11; extra == 'google-adk'
-Provides-Extra: langchain
-Requires-Dist: langchain-anthropic>=0.3.10; extra == 'langchain'
-Requires-Dist: langchain-cerebras>=0.5.0; extra == 'langchain'
-Requires-Dist: langchain-cohere>=0.4.3; extra == 'langchain'
-Requires-Dist: langchain-community<0.4.0,>=0.3.3; extra == 'langchain'
-Requires-Dist: langchain-core<0.4.0,>=0.3.13; extra == 'langchain'
-Requires-Dist: langchain-deepseek-official>=0.1.0.post1; extra == 'langchain'
-Requires-Dist: langchain-openai>=0.3.10; extra == 'langchain'
-Requires-Dist: langchain-xai>=0.2.2; extra == 'langchain'
-Requires-Dist: langgraph<0.3.0,>=0.2.40; extra == 'langchain'
-Requires-Dist: opentelemetry-instrumentation-langchain>=0.35.0; extra == 'langchain'
-Requires-Dist: pillow>=10.0.0; extra == 'langchain'
-Provides-Extra: livekit
-Requires-Dist: livekit-agents[anthropic,cartesia,deepgram,elevenlabs,groq,openai,silero,turn-detector]~=1.0; extra == 'livekit'
-Requires-Dist: livekit-plugins-noise-cancellation~=0.2; extra == 'livekit'
-Provides-Extra: llamaindex
-Requires-Dist: llama-index-llms-anthropic>=0.6.10; extra == 'llamaindex'
-Requires-Dist: llama-index-llms-cerebras>=0.2.2; extra == 'llamaindex'
-Requires-Dist: llama-index-llms-cohere>=0.4.0; extra == 'llamaindex'
-Requires-Dist: llama-index-llms-deepseek>=0.1.1; extra == 'llamaindex'
-Requires-Dist: llama-index-llms-google-genai>=0.1.7; 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.28; extra == 'llamaindex'
-Requires-Dist: llama-index>=0.12.26; extra == 'llamaindex'
-Requires-Dist: opentelemetry-instrumentation-llamaindex>=0.35.0; extra == 'llamaindex'
-Provides-Extra: openai-agents
-Requires-Dist: openai-agents>=0.0.7; extra == 'openai-agents'
-Provides-Extra: pydantic-ai
-Requires-Dist: pydantic-ai>=0.0.48; extra == 'pydantic-ai'
-Description-Content-Type: text/markdown
-
-# Blaxel Python SDK
-
-<p align="center">
-  <img src="https://blaxel.ai/logo-bg.png" alt="Blaxel"/>
-</p>
-
-**Blaxel is a computing platform for AI agent builders, with all the services and infrastructure to build and deploy agents efficiently.** This repository contains the Python SDK to create and manage resources on Blaxel.
-
-## Table of Contents
-
-- [Installation](#installation)
-  - [Authentication](#authentication)
-- [Features](#features)
-- [Quickstart](#quickstart)
-- [Contributing](#contributing)
-- [License](#license)
-
-
-
-## Installation
-
-Install Blaxel SDK which lets you manage Blaxel resources.
-
-```bash
-## Using pip
-pip install blaxel
-
-## Using uv
-uv pip install blaxel
-
-## Using uv add
-uv add blaxel
-``` 
-
-
-
-### Authentication
-
-The Blaxel SDK authenticates with your workspace using credentials from these sources, in priority order:
-1. When running on Blaxel, authentication is handled automatically
-2. Variables in your .env file (`BL_WORKSPACE` and `BL_API_KEY`, or see [this page](https://docs.blaxel.ai/Agents/Variables-and-secrets) for other authentication options).
-3. Environment variables from your machine
-4. Configuration file created locally when you log in through Blaxel CLI (or deploy on Blaxel)
-
-When developing locally, the recommended method is to just log in to your workspace with Blaxel CLI. This allows you to run Blaxel SDK functions that will automatically connect to your workspace without additional setup. When you deploy on Blaxel, this connection persists automatically.
-
-When running Blaxel SDK from a remote server that is not Blaxel-hosted, we recommend using environment variables as described in the third option above.
-
-
-
-## Features
-- Agents & MCP servers
-  - [Create MCP servers](https://docs.blaxel.ai/Functions/Create-MCP-server)
-  - [Connect to MCP servers and model APIs hosted on Blaxel](https://docs.blaxel.ai/Agents/Develop-an-agent-ts)
-  - [Call agents from another agent](https://docs.blaxel.ai/Agents/Develop-an-agent-ts#connect-to-another-agent-multi-agent-chaining)
-  - [Deploy on Blaxel](https://docs.blaxel.ai/Agents/Deploy-an-agent)
-- Sandboxes
-  - [Create and update sandboxes and sandbox previews](https://docs.blaxel.ai/Sandboxes/Overview)
-  - [Run filesystem operations and processes on a sandbox](https://docs.blaxel.ai/Sandboxes/Processes)
-- [Use environment variables or secrets](https://docs.blaxel.ai/Agents/Variables-and-secrets)
-
-
-
-## Quickstart
-
-Blaxel CLI gives you a quick way to create new applications: agents, MCP servers, jobs, etc - and deploy them to Blaxel.
-
-**Prerequisites**:
-- **Node.js:** v18 or later.
-- **Blaxel CLI:** Make sure you have Blaxel CLI installed. If not, [install it](https://docs.blaxel.ai/cli-reference/introduction):
-  ```bash
-  curl -fsSL \
-  https://raw.githubusercontent.com/blaxel-ai/toolkit/main/install.sh \
-  | BINDIR=/usr/local/bin sudo -E sh
-  ```
-- **Blaxel login:** Login to Blaxel:
-  ```bash
-    bl login YOUR-WORKSPACE
-  ```
-
-```bash
-bl create-agent-app myfolder
-cd myfolder
-bl deploy
-```
-
-Also available:
--  `bl create-mcp-server`
--  `bl create-job`
-
-
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit a Pull Request.
-
-
-
-## License
-
-This project is licensed under the MIT License - see the LICENSE file for details.