beamlit 0.0.55rc103__tar.gz → 0.0.56rc104__tar.gz

{beamlit-0.0.55rc103 → beamlit-0.0.56rc104}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: beamlit
-Version: 0.0.55rc103
+Version: 0.0.56rc104
 Summary: Add your description here
 Author-email: cploujoux <ch.ploujoux@gmail.com>
 License-File: LICENSE

{beamlit-0.0.55rc103 → beamlit-0.0.56rc104}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "beamlit"
-version = "0.0.55.pre-103"
+version = "0.0.56.pre-104"
 description = "Add your description here"
 readme = "README.md"
 authors = [

{beamlit-0.0.55rc103 → beamlit-0.0.56rc104}/src/beamlit/agents/chain.py

@@ -2,7 +2,7 @@ import asyncio
 import warnings
 from dataclasses import dataclass
 from typing import Callable
-
+import os
 import pydantic
 import typing_extensions as t
 from langchain_core.tools.base import BaseTool, ToolException
@@ -21,6 +21,8 @@ class ChainTool(BaseTool):
 
     client: RunClient
     handle_tool_error: bool | str | Callable[[ToolException], str] | None = True
+    _cloud: bool = False
+    _service_name: str | None = None
 
     @t.override
     def _run(self, *args: t.Any, **kwargs: t.Any) -> t.Any:
@@ -58,6 +60,8 @@ class ChainTool(BaseTool):
             self.name,
             settings.environment,
             "POST",
+            cloud=self._cloud,
+            service_name=self._service_name,
             json=kwargs,
         )
         return result.text
@@ -91,6 +95,8 @@ class ChainToolkit:
 
     client: AuthenticatedClient
     chain: list[AgentChain]
+    _cloud: bool = False
+    _service_name: str | None = None
     _chain: list[Agent] | None = None
 
     model_config = pydantic.ConfigDict(arbitrary_types_allowed=True)
@@ -103,6 +109,8 @@ class ChainToolkit:
             RuntimeError: If initialization fails due to missing agents.
         """
         """Initialize the session and retrieve tools list"""
+        settings = get_settings()
+        self._cloud = settings.cloud
         if self._chain is None:
             agents = list_agents.sync_detailed(
                 client=self.client,
@@ -111,6 +119,9 @@ class ChainToolkit:
             agents_chain = []
             for chain in chain_enabled:
                 agent = [agent for agent in agents if agent.metadata.name == chain.name]
+                agent_name = agent[0].metadata.name.upper().replace("-", "_")
+                if os.getenv(f"BL_AGENT_{agent_name}_SERVICE_NAME"):
+                    self._service_name = os.getenv(f"BL_AGENT_{agent_name}_SERVICE_NAME")
                 if agent:
                     agent[0].spec.prompt = chain.prompt or agent[0].spec.prompt
                     agent[0].spec.description = chain.description or agent[0].spec.description
@@ -136,6 +147,8 @@ class ChainToolkit:
                 name=agent.metadata.name,
                 description=agent.spec.description or agent.spec.prompt or "",
                 args_schema=ChainInput,
+                cloud=self._cloud,
+                service_name=self._service_name,
             )
             for agent in self._chain
         ]

{beamlit-0.0.55rc103 → beamlit-0.0.56rc104}/src/beamlit/agents/decorator.py

@@ -29,6 +29,7 @@ def agent(
     override_agent=None,
     override_functions=None,
     remote_functions=None,
+    local_functions=None,
 ) -> Callable:
     """
     A decorator factory that configures and wraps functions to integrate with Beamlit agents.
@@ -40,6 +41,7 @@ def agent(
         override_agent (Any, optional): An optional agent instance to override the default agent.
         mcp_hub (Any, optional): An optional MCP hub configuration.
         remote_functions (Any, optional): An optional list of remote functions to be integrated.
+        local_functions (Any, optional): An optional list of local functions to be integrated.
 
     Returns:
         Callable: A decorator that wraps the target function, injecting agent-related configurations and dependencies.
@@ -130,9 +132,10 @@ def agent(
                 dir=settings.agent.functions_directory,
                 remote_functions=remote_functions,
                 chain=agent.spec.agent_chain,
-            remote_functions_empty=not remote_functions,
-            warning=chat_model is not None,
-        )
+                local_functions=local_functions,
+                remote_functions_empty=not remote_functions,
+                warning=chat_model is not None,
+            )
 
         settings.agent.functions = functions
 

{beamlit-0.0.55rc103 → beamlit-0.0.56rc104}/src/beamlit/common/settings.py

@@ -83,9 +83,11 @@ class Settings(BaseSettings):
     base_url: str = Field(default="https://api.beamlit.com/v0")
     app_url: str = Field(default="https://app.beamlit.com")
     run_url: str = Field(default="https://run.beamlit.com")
+    run_internal_hostname: str = Field(default="internal.run.beamlit.com")
     registry_url: str = Field(default="https://us.registry.beamlit.com")
     log_level: str = Field(default="INFO")
     enable_opentelemetry: bool = Field(default=False)
+    cloud: bool = Field(default=False)
     agent: SettingsAgent = SettingsAgent()
     server: SettingsServer = SettingsServer()
     authentication: SettingsAuthentication = SettingsAuthentication()

{beamlit-0.0.55rc103 → beamlit-0.0.56rc104}/src/beamlit/functions/common.py

@@ -28,6 +28,7 @@ from beamlit.authentication import new_client
 from beamlit.client import AuthenticatedClient
 from beamlit.common import slugify
 from beamlit.common.settings import get_settings
+from beamlit.functions.local.local import LocalToolKit
 from beamlit.functions.remote.remote import RemoteToolkit
 from beamlit.models import AgentChain
 
@@ -35,10 +36,12 @@ logger = getLogger(__name__)
 
 def get_functions(
     remote_functions: Union[list[str], None] = None,
+    local_functions: Union[list[dict], None] = None,
     client: Union[AuthenticatedClient, None] = None,
     dir: Union[str, None] = None,
     chain: Union[list[AgentChain], None] = None,
     remote_functions_empty: bool = True,
+    local_functions_empty: bool = True,
     from_decorator: str = "function",
     warning: bool = True,
 ):
@@ -140,6 +143,7 @@ def get_functions(
                                             client=client,
                                             dir=os.path.join(root),
                                             remote_functions_empty=remote_functions_empty,
+                                            local_functions_empty=local_functions_empty,
                                             from_decorator="kit",
                                         )
                                         functions.extend(kit_functions)
@@ -187,6 +191,18 @@ def get_functions(
                     f"Traceback:\n{traceback.format_exc()}"
                 )
                 logger.warn(f"Failed to initialize remote function {function}: {e!s}")
+    if local_functions:
+        for function in local_functions:
+            try:
+                toolkit = LocalToolKit(client, function)
+                toolkit.initialize()
+                functions.extend(toolkit.get_tools())
+            except Exception as e:
+                logger.debug(
+                    f"Failed to initialize local function {function}: {e!s}\n"
+                    f"Traceback:\n{traceback.format_exc()}"
+                )
+                logger.warn(f"Failed to initialize local function {function}: {e!s}")
 
     if chain:
         toolkit = ChainToolkit(client, chain)

beamlit-0.0.56rc104/src/beamlit/functions/local/local.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass
+
+import pydantic
+from langchain_core.tools.base import BaseTool
+
+from beamlit.authentication.authentication import AuthenticatedClient
+from beamlit.functions.mcp.mcp import MCPClient, MCPToolkit
+from beamlit.models import Function
+
+
+@dataclass
+class LocalToolKit:
+    """
+    Toolkit for managing local tools.
+
+    Attributes:
+        client (AuthenticatedClient): The authenticated client instance.
+        function (str): The name of the local function to integrate.
+        _function (Function | None): Cached Function object after initialization.
+    """
+    client: AuthenticatedClient
+    local_function: dict
+    _function: Function | None = None
+    model_config = pydantic.ConfigDict(arbitrary_types_allowed=True)
+
+    def initialize(self) -> None:
+        """Initialize the session and retrieve the local function details."""
+        if self._function is None:
+            try:
+                # For local functions, we directly create the Function object
+                # based on the local function name
+                self._function = Function(
+                    metadata={"name": self.local_function['name']},
+                    spec={
+                        "configurations": {
+                            "url": self.local_function['url'],
+                            "sse": self.local_function['sse'],
+                        },
+                        "description": self.local_function['description'] or "",
+                    }
+                )
+            except Exception as e:
+                raise RuntimeError(f"Failed to initialize local function: {e}")
+
+    def get_tools(self) -> list[BaseTool]:
+        mcp_client = MCPClient(self.client, self._function.spec["configurations"]["url"], sse=self._function.spec["configurations"]["sse"])
+        mcp_toolkit = MCPToolkit(client=mcp_client)
+        mcp_toolkit.initialize()
+        return mcp_toolkit.get_tools()

{beamlit-0.0.55rc103 → beamlit-0.0.56rc104}/src/beamlit/functions/mcp/mcp.py

@@ -4,91 +4,87 @@ It includes classes for managing MCP clients, creating dynamic schemas, and inte
 """
 
 import asyncio
+import logging
 import warnings
-from typing import Any, Callable
+from typing import Any, AsyncIterator, Callable
 
 import pydantic
 import pydantic_core
 import requests
 import typing_extensions as t
 from langchain_core.tools.base import BaseTool, BaseToolkit, ToolException
+from mcp import ClientSession
+from mcp.client.sse import sse_client
 from mcp.types import CallToolResult, ListToolsResult
-from pydantic.json_schema import JsonSchemaValue
-from pydantic_core import core_schema as cs
 
 from beamlit.authentication.authentication import AuthenticatedClient
 from beamlit.common.settings import get_settings
 
-settings = get_settings()
+from .utils import create_schema_model
 
-TYPE_MAP = {
-    "integer": int,
-    "number": float,
-    "array": list,
-    "object": dict,
-    "boolean": bool,
-    "string": str,
-    "null": type(None),
-}
-
-FIELD_DEFAULTS = {
-    int: 0,
-    float: 0.0,
-    list: [],
-    bool: False,
-    str: "",
-    type(None): None,
-}
-
-def configure_field(name: str, type_: dict[str, t.Any], required: list[str]) -> tuple[type, t.Any]:
-    field_type = TYPE_MAP[type_["type"]]
-    default_ = FIELD_DEFAULTS.get(field_type) if name not in required else ...
-    return field_type, default_
-
-def create_schema_model(name: str, schema: dict[str, t.Any]) -> type[pydantic.BaseModel]:
-    # Create a new model class that returns our JSON schema.
-    # LangChain requires a BaseModel class.
-    class SchemaBase(pydantic.BaseModel):
-        model_config = pydantic.ConfigDict(extra="allow")
-
-        @t.override
-        @classmethod
-        def __get_pydantic_json_schema__(
-            cls, core_schema: cs.CoreSchema, handler: pydantic.GetJsonSchemaHandler
-        ) -> JsonSchemaValue:
-            return schema
-
-    # Since this langchain patch, we need to synthesize pydantic fields from the schema
-    # https://github.com/langchain-ai/langchain/commit/033ac417609297369eb0525794d8b48a425b8b33
-    required = schema.get("required", [])
-    fields: dict[str, t.Any] = {
-        name: configure_field(name, type_, required) for name, type_ in schema["properties"].items()
-    }
-
-    return pydantic.create_model(f"{name}Schema", __base__=SchemaBase, **fields)
+settings = get_settings()
 
+logger = logging.getLogger(__name__)
 
 
 class MCPClient:
     def __init__(self, client: AuthenticatedClient, url: str):
         self.client = client
         self.url = url
-
-    def list_tools(self) -> requests.Response:
-        client = self.client.get_httpx_client()
-        response = client.request("GET", f"{self.url}/tools/list")
-        response.raise_for_status()
-        return response
-
-    def call_tool(self, tool_name: str, arguments: dict[str, Any] = None) -> requests.Response:
-        client = self.client.get_httpx_client()
-        response = client.request(
-            "POST",
-            f"{self.url}/tools/call",
-            json={"name": tool_name, "arguments": arguments},
-        )
-        response.raise_for_status()
-        return response
+        self._sse = False
+
+    async def list_sse_tools(self) -> ListToolsResult:
+        # Create a new context for each SSE connection
+        try:
+            async with sse_client(f"{self.url}/sse") as (read_stream, write_stream):
+                async with ClientSession(read_stream, write_stream) as session:
+                    await session.initialize()
+                    response = await session.list_tools()
+                    return response
+        except Exception:
+            self._sse = False
+            logger.info("SSE not available, trying HTTP")
+            return None  # Signal to list_tools() to try HTTP instead
+
+    def list_tools(self) -> ListToolsResult:
+        try:
+            loop = asyncio.get_event_loop()
+            result = loop.run_until_complete(self.list_sse_tools())
+            if result is None:  # SSE failed, try HTTP
+                raise Exception("SSE failed")
+            self._sse = True
+            return result
+        except Exception:  # Fallback to HTTP
+            client = self.client.get_httpx_client()
+            response = client.request("GET", f"{self.url}/tools/list")
+            response.raise_for_status()
+            return ListToolsResult(**response.json())
+
+    async def call_tool(
+        self,
+        tool_name: str,
+        arguments: dict[str, Any] = None,
+    ) -> requests.Response | AsyncIterator[CallToolResult]:
+        if self._sse:
+            async with sse_client(f"{self.url}/sse") as (read_stream, write_stream):
+                async with ClientSession(read_stream, write_stream) as session:
+                    await session.initialize()
+                    response = await session.call_tool(tool_name, arguments or {})
+                    content = pydantic_core.to_json(response).decode()
+                    return content
+        else: # Fallback to HTTP
+            client = self.client.get_httpx_client()
+            response = client.request(
+                "POST",
+                f"{self.url}/tools/call",
+                json={"name": tool_name, "arguments": arguments},
+            )
+            response.raise_for_status()
+            result = CallToolResult(response.json())
+            if result.isError:
+                raise ToolException(result.content)
+            content = pydantic_core.to_json(result.content).decode()
+            return content
 
 class MCPTool(BaseTool):
     """
@@ -97,6 +93,7 @@ class MCPTool(BaseTool):
     Attributes:
         client (MCPClient): The MCP client instance.
         handle_tool_error (bool | str | Callable[[ToolException], str] | None): Error handling strategy.
+        sse (bool): Whether to use SSE streaming for responses.
     """
 
     client: MCPClient
@@ -112,13 +109,7 @@ class MCPTool(BaseTool):
 
     @t.override
     async def _arun(self, *args: t.Any, **kwargs: t.Any) -> t.Any:
-        result = self.client.call_tool(self.name, arguments=kwargs)
-        response = result.json()
-        result = CallToolResult(**response)
-        if result.isError:
-            raise ToolException(result.content)
-        content = pydantic_core.to_json(result.content).decode()
-        return content
+        return await self.client.call_tool(self.name, arguments=kwargs)
 
     @t.override
     @property
@@ -139,14 +130,13 @@ class MCPToolkit(BaseToolkit):
     """The MCP session used to obtain the tools"""
 
     _tools: ListToolsResult | None = None
-
     model_config = pydantic.ConfigDict(arbitrary_types_allowed=True)
 
     def initialize(self) -> None:
         """Initialize the session and retrieve tools list"""
         if self._tools is None:
             response = self.client.list_tools()
-            self._tools = ListToolsResult(**response.json())
+            self._tools = response
 
     @t.override
     def get_tools(self) -> list[BaseTool]:

beamlit-0.0.56rc104/src/beamlit/functions/mcp/utils.py

@@ -0,0 +1,56 @@
+"""
+This module provides functionalities to interact with MCP (Multi-Client Platform) servers.
+It includes classes for managing MCP clients, creating dynamic schemas, and integrating MCP tools into Beamlit.
+"""
+import pydantic
+import typing_extensions as t
+from pydantic.json_schema import JsonSchemaValue
+from pydantic_core import core_schema as cs
+
+TYPE_MAP = {
+    "integer": int,
+    "number": float,
+    "array": list,
+    "object": dict,
+    "boolean": bool,
+    "string": str,
+    "null": type(None),
+}
+
+FIELD_DEFAULTS = {
+    int: 0,
+    float: 0.0,
+    list: [],
+    bool: False,
+    str: "",
+    type(None): None,
+}
+
+def configure_field(name: str, type_: dict[str, t.Any], required: list[str]) -> tuple[type, t.Any]:
+    field_type = TYPE_MAP[type_["type"]]
+    default_ = FIELD_DEFAULTS.get(field_type) if name not in required else ...
+    return field_type, default_
+
+def create_schema_model(name: str, schema: dict[str, t.Any]) -> type[pydantic.BaseModel]:
+    # Create a new model class that returns our JSON schema.
+    # LangChain requires a BaseModel class.
+    class SchemaBase(pydantic.BaseModel):
+        model_config = pydantic.ConfigDict(extra="allow")
+
+        @t.override
+        @classmethod
+        def __get_pydantic_json_schema__(
+            cls, core_schema: cs.CoreSchema, handler: pydantic.GetJsonSchemaHandler
+        ) -> JsonSchemaValue:
+            return schema
+
+    # Since this langchain patch, we need to synthesize pydantic fields from the schema
+    # https://github.com/langchain-ai/langchain/commit/033ac417609297369eb0525794d8b48a425b8b33
+    required = schema.get("required", [])
+    fields: dict[str, t.Any] = {
+        name: configure_field(name, type_, required) for name, type_ in schema["properties"].items()
+    }
+
+    return pydantic.create_model(f"{name}Schema", __base__=SchemaBase, **fields)
+
+

{beamlit-0.0.55rc103 → beamlit-0.0.56rc104}/src/beamlit/functions/remote/remote.py

@@ -7,11 +7,10 @@ import asyncio
 import warnings
 from dataclasses import dataclass
 from typing import Callable
+import os
 
 import pydantic
 import typing_extensions as t
-from langchain_core.tools.base import BaseTool, ToolException
-
 from beamlit.api.functions import get_function, list_functions
 from beamlit.authentication.authentication import AuthenticatedClient
 from beamlit.common.settings import get_settings
@@ -19,6 +18,7 @@ from beamlit.errors import UnexpectedStatus
 from beamlit.functions.mcp.mcp import MCPClient, MCPToolkit
 from beamlit.models import Function, StoreFunctionParameter
 from beamlit.run import RunClient
+from langchain_core.tools.base import BaseTool, ToolException
 
 
 def create_dynamic_schema(name: str, parameters: list[StoreFunctionParameter]) -> type[pydantic.BaseModel]:
@@ -67,7 +67,8 @@ class RemoteTool(BaseTool):
     resource_name: str
     kit: bool = False
     handle_tool_error: bool | str | Callable[[ToolException], str] | None = True
-
+    service_name: str | None = None
+    cloud: bool = False
     @t.override
     def _run(self, *args: t.Any, **kwargs: t.Any) -> t.Any:
         warnings.warn(
@@ -87,7 +88,9 @@ class RemoteTool(BaseTool):
             self.resource_name,
             settings.environment,
             "POST",
-            json=body
+            cloud=self.cloud,
+            service_name=self.service_name,
+            json=body,
         )
         return result.text
 
@@ -110,6 +113,7 @@ class RemoteToolkit:
     client: AuthenticatedClient
     function: str
     _function: Function | None = None
+    _service_name: str | None = None
     model_config = pydantic.ConfigDict(arbitrary_types_allowed=True)
 
     def initialize(self) -> None:
@@ -117,6 +121,9 @@ class RemoteToolkit:
         if self._function is None:
             try:
                 response = get_function.sync_detailed(self.function, client=self.client)
+                function_name = self.function.upper().replace("-", "_")
+                if os.getenv(f"BL_FUNCTION_{function_name}_SERVICE_NAME"):
+                    self._service_name = os.getenv(f"BL_FUNCTION_{function_name}_SERVICE_NAME")
                 self._function = response.parsed
             except UnexpectedStatus as e:
                 settings = get_settings()
@@ -139,6 +146,8 @@ class RemoteToolkit:
 
         if self._function.spec.integration_connections:
             url = f"{settings.run_url}/{settings.workspace}/functions/{self._function.metadata.name}"
+            if self._service_name:
+                url = f"https://{self._service_name}.{settings.run_internal_hostname}"
             mcp_client = MCPClient(self.client, url)
             mcp_toolkit = MCPToolkit(client=mcp_client)
             mcp_toolkit.initialize()
@@ -153,6 +162,8 @@ class RemoteToolkit:
                     kit=True,
                     description=func.description or "",
                     args_schema=create_dynamic_schema(func.name, func.parameters),
+                    cloud=settings.cloud,
+                    service_name=self._service_name,
                 )
                 for func in self._function.spec.kit
             ]
@@ -167,5 +178,7 @@ class RemoteToolkit:
                     self._function.metadata.name,
                     self._function.spec.parameters
                 ),
+                cloud=settings.cloud,
+                service_name=self._service_name,
             )
         ]

{beamlit-0.0.55rc103 → beamlit-0.0.56rc104}/src/beamlit/run.py

@@ -48,6 +48,8 @@ class RunClient:
         json: dict[str, Any] | None = None,
         data: str | None = None,
         params: dict[str, str] | None = None,
+        cloud: bool = False,
+        service_name: str | None = None,
     ) -> requests.Response:
         """Execute an HTTP request against a Beamlit resource.
 
@@ -61,6 +63,8 @@ class RunClient:
             json (dict[str, Any] | None, optional): JSON payload to send with the request. Defaults to None.
             data (str | None, optional): Raw data to send with the request. Defaults to None.
             params (dict[str, str] | None, optional): Query parameters to include in the URL. Defaults to None.
+            cloud (bool, optional): Whether to use the cloud endpoint. Defaults to False.
+            service_name (str | None, optional): The name of the service to use. Defaults to None.
 
         Returns:
             requests.Response: The HTTP response from the server.
@@ -72,14 +76,17 @@ class RunClient:
         headers = headers or {}
         params = params or {}
 
-        # Build the path
-        if path:
-            path = f"{settings.workspace}/{resource_type}s/{resource_name}/{path}"
-        else:
-            path = f"{settings.workspace}/{resource_type}s/{resource_name}"
+        if cloud and path and service_name:
+            url = f"https://{service_name}.{settings.run_internal_hostname}/{path}"
+        
+        if cloud and not path and service_name:
+            url = f"https://{service_name}.{settings.run_internal_hostname}"
 
-        client = self.client.get_httpx_client()
-        url = urllib.parse.urljoin(settings.run_url, path)
+        if not cloud and path:
+            url = urllib.parse.urljoin(settings.run_url, f"{settings.workspace}/{resource_type}s/{resource_name}/{path}")
+
+        if not cloud and not path:
+            url = urllib.parse.urljoin(settings.run_url, f"{settings.workspace}/{resource_type}s/{resource_name}")
 
         kwargs = {
             "headers": headers,
@@ -90,7 +97,16 @@ class RunClient:
         if json:
             kwargs["json"] = json
 
-        response = client.request(method, url, **kwargs)
-        if response.status_code >= 400:
+        response = self.client.request(method, url, **kwargs)
+        if response.status_code >= 400 and not cloud:
             raise HTTPError(response.status_code, response.text)
+        if response.status_code >= 400 and cloud: # Redirect to the public endpoint if the resource is in the cloud and the request fails
+            if path:
+                url = urllib.parse.urljoin(settings.run_url, f"{settings.workspace}/{resource_type}s/{resource_name}/{path}")
+            else:
+                url = urllib.parse.urljoin(settings.run_url, f"{settings.workspace}/{resource_type}s/{resource_name}")
+            response = self.client.request(method, url, **kwargs)
+            if response.status_code >= 400:
+                raise HTTPError(response.status_code, response.text)
+            return response
         return response

{beamlit-0.0.55rc103 → beamlit-0.0.56rc104}/src/integrationtest/agent.py

@@ -18,14 +18,24 @@ settings = init()
         },
     },
     remote_functions=["brave-search"],
+    # local_functions=[
+    #     {
+    #         "name": "github-search",
+    #         "description": "A tool that searches GitHub for a given query",
+    #         "url": "http://0.0.0.0:8000",
+    #         "sse": True,
+    #     }
+    # ],
 )
 async def main(
-    input, agent,
+    input, agent, functions
 ):
     agent_config = {"configurable": {"thread_id": str(uuid.uuid4())}}
+    print(functions)
 
+    body = await input.json()
 
-    agent_body = {"messages": [("user", input)]}
+    agent_body = {"messages": [("user", body["inputs"])]}
     responses = []
 
     async for chunk in agent.astream(agent_body, config=agent_config):
@@ -38,7 +48,7 @@ async def main(
 
 if __name__ == "__main__":
     async def check():
-        input = "Generate a dog picture, a golden retriever because they are the best"
+        input = "Give me the content of the README.md file for beamlit/toolkit repository"
         response = await main(input)
         print(response)
 

{beamlit-0.0.55rc103 → beamlit-0.0.56rc104}/uv.lock

@@ -174,7 +174,7 @@ dependencies = [
     { name = "websockets" },
 ]
 
-[package.dependency-groups]
+[package.dev-dependencies]
 dev = [
     { name = "pdoc3" },
     { name = "ruff" },
@@ -223,7 +223,7 @@ requires-dist = [
     { name = "websockets", specifier = ">=14.1" },
 ]
 
-[package.metadata.dependency-groups]
+[package.metadata.requires-dev]
 dev = [
     { name = "pdoc3", specifier = ">=0.11.5" },
     { name = "ruff", specifier = ">=0.8.2" },