beamlit 0.0.28rc25__tar.gz → 0.0.29__tar.gz

{beamlit-0.0.28rc25 → beamlit-0.0.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: beamlit
-Version: 0.0.28rc25
+Version: 0.0.29
 Summary: Add your description here
 Author-email: cploujoux <ch.ploujoux@gmail.com>
 Requires-Python: >=3.12

{beamlit-0.0.28rc25 → beamlit-0.0.29}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "beamlit"
-version = "0.0.28.pre-25"
+version = "0.0.29"
 description = "Add your description here"
 readme = "README.md"
 authors = [

beamlit-0.0.29/src/beamlit/agents/chain.py

@@ -0,0 +1,93 @@
+import asyncio
+from dataclasses import dataclass
+import warnings
+from typing import Any, Callable
+
+import pydantic
+import typing_extensions as t
+from beamlit.api.agents import list_agents
+from beamlit.authentication.authentication import AuthenticatedClient
+from beamlit.models import Agent, AgentChain
+from beamlit.run import RunClient
+from beamlit.common.settings import get_settings
+from langchain_core.tools.base import BaseTool, ToolException
+
+
+
+class ChainTool(BaseTool):
+    """
+    Chain tool
+    """
+
+    client: RunClient
+    handle_tool_error: bool | str | Callable[[ToolException], str] | None = True
+
+    @t.override
+    def _run(self, *args: t.Any, **kwargs: t.Any) -> t.Any:
+        warnings.warn(
+            "Invoke this tool asynchronousely using `ainvoke`. This method exists only to satisfy standard tests.",
+            stacklevel=1,
+        )
+        return asyncio.run(self._arun(*args, **kwargs))
+
+    @t.override
+    async def _arun(self, *args: t.Any, **kwargs: t.Any) -> t.Any:
+        settings = get_settings()
+        result = self.client.run(
+            "agent",
+            self.name,
+            settings.environment,
+            "POST",
+            json=kwargs,
+        )
+        return result.text
+
+    @t.override
+    @property
+    def tool_call_schema(self) -> type[pydantic.BaseModel]:
+        assert self.args_schema is not None  # noqa: S101
+        return self.args_schema
+
+class ChainInput(pydantic.BaseModel):
+    inputs: str
+
+@dataclass
+class ChainToolkit:
+    """
+    Remote toolkit
+    """
+    client: AuthenticatedClient
+    chain: list[AgentChain]
+    _chain: list[Agent] | None = None
+
+    model_config = pydantic.ConfigDict(arbitrary_types_allowed=True)
+
+    def initialize(self) -> None:
+        """Initialize the session and retrieve tools list"""
+        if self._chain is None:
+            agents = list_agents.sync_detailed(
+                client=self.client,
+            ).parsed
+            chain_enabled = [chain for chain in self.chain if chain.enabled]
+            agents_chain = []
+            for chain in chain_enabled:
+                agent = [agent for agent in agents if agent.metadata.name == chain.name]
+                if agent:
+                    agent[0].spec.description = chain.description or agent[0].spec.description
+                    agents_chain.append(agent[0])
+            self._chain = agents_chain
+
+    @t.override
+    def get_tools(self) -> list[BaseTool]:
+        if self._chain is None:
+            raise RuntimeError("Must initialize the toolkit first")
+
+        return [
+            ChainTool(
+                client=RunClient(self.client),
+                name=agent.metadata.name,
+                description=agent.spec.description or "",
+                args_schema=ChainInput,
+            )
+            for agent in self._chain
+        ]

{beamlit-0.0.28rc25 → beamlit-0.0.29}/src/beamlit/agents/decorator.py

@@ -17,16 +17,18 @@ from langchain_core.tools import Tool
 from langgraph.checkpoint.memory import MemorySaver
 from langgraph.prebuilt import create_react_agent
 
+from .chain import ChainToolkit
 from .chat import get_chat_model
 
 
-def get_functions(dir="src/functions", from_decorator="function"):
+def get_functions(dir="src/functions", from_decorator="function", remote_functions_empty=True):
     functions = []
     logger = getLogger(__name__)
 
     # Walk through all Python files in functions directory and subdirectories
     if not os.path.exists(dir):
-        logger.warn(f"Functions directory {dir} not found")
+        if remote_functions_empty:
+            logger.warn(f"Functions directory {dir} not found")
         return []
     for root, _, files in os.walk(dir):
         for file in files:
@@ -74,6 +76,7 @@ def get_functions(dir="src/functions", from_decorator="function"):
                                     kit_functions = get_functions(
                                         dir=os.path.join(root),
                                         from_decorator="kit",
+                                        remote_functions_empty=remote_functions_empty,
                                     )
                                     functions.extend(kit_functions)
 
@@ -134,7 +137,10 @@ def agent(
             return wrapped
 
         # Initialize functions array to store decorated functions
-        functions = get_functions(dir=settings.agent.functions_directory)
+        functions = get_functions(
+            dir=settings.agent.functions_directory,
+            remote_functions_empty=not remote_functions,
+        )
         settings.agent.functions = functions
 
         if agent is not None:
@@ -178,7 +184,6 @@ def agent(
                     logger.warn(f"Failed to initialize MCP server {server}: {e!s}")
 
         if remote_functions:
-
             for function in remote_functions:
                 try:
                     toolkit = RemoteToolkit(client, function)
@@ -187,6 +192,11 @@ def agent(
                 except Exception as e:
                     logger.warn(f"Failed to initialize remote function {function}: {e!s}")
 
+        if agent.spec.agent_chain:
+            toolkit = ChainToolkit(client, agent.spec.agent_chain)
+            toolkit.initialize()
+            functions.extend(toolkit.get_tools())
+
         if override_agent is None and len(functions) == 0:
             raise ValueError(
                 "You must define at least one function, you can define this function in directory "

beamlit-0.0.29/src/beamlit/api/agents/get_agent_trace_ids.py

@@ -0,0 +1,171 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.trace_ids_response import TraceIdsResponse
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    agent_name: str,
+    *,
+    environment: Union[Unset, str] = UNSET,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["environment"] = environment
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/agents/{agent_name}/traces",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[TraceIdsResponse]:
+    if response.status_code == 200:
+        response_200 = TraceIdsResponse.from_dict(response.json())
+
+        return response_200
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[TraceIdsResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    agent_name: str,
+    *,
+    client: AuthenticatedClient,
+    environment: Union[Unset, str] = UNSET,
+) -> Response[TraceIdsResponse]:
+    """Get agent trace IDs
+
+    Args:
+        agent_name (str):
+        environment (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[TraceIdsResponse]
+    """
+
+    kwargs = _get_kwargs(
+        agent_name=agent_name,
+        environment=environment,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    agent_name: str,
+    *,
+    client: AuthenticatedClient,
+    environment: Union[Unset, str] = UNSET,
+) -> Optional[TraceIdsResponse]:
+    """Get agent trace IDs
+
+    Args:
+        agent_name (str):
+        environment (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        TraceIdsResponse
+    """
+
+    return sync_detailed(
+        agent_name=agent_name,
+        client=client,
+        environment=environment,
+    ).parsed
+
+
+async def asyncio_detailed(
+    agent_name: str,
+    *,
+    client: AuthenticatedClient,
+    environment: Union[Unset, str] = UNSET,
+) -> Response[TraceIdsResponse]:
+    """Get agent trace IDs
+
+    Args:
+        agent_name (str):
+        environment (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[TraceIdsResponse]
+    """
+
+    kwargs = _get_kwargs(
+        agent_name=agent_name,
+        environment=environment,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    agent_name: str,
+    *,
+    client: AuthenticatedClient,
+    environment: Union[Unset, str] = UNSET,
+) -> Optional[TraceIdsResponse]:
+    """Get agent trace IDs
+
+    Args:
+        agent_name (str):
+        environment (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        TraceIdsResponse
+    """
+
+    return (
+        await asyncio_detailed(
+            agent_name=agent_name,
+            client=client,
+            environment=environment,
+        )
+    ).parsed

beamlit-0.0.29/src/beamlit/api/functions/get_function_trace_ids.py

@@ -0,0 +1,171 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.trace_ids_response import TraceIdsResponse
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    function_name: str,
+    *,
+    environment: Union[Unset, str] = UNSET,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["environment"] = environment
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/functions/{function_name}/traces",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[TraceIdsResponse]:
+    if response.status_code == 200:
+        response_200 = TraceIdsResponse.from_dict(response.json())
+
+        return response_200
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[TraceIdsResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    function_name: str,
+    *,
+    client: AuthenticatedClient,
+    environment: Union[Unset, str] = UNSET,
+) -> Response[TraceIdsResponse]:
+    """Get function trace IDs
+
+    Args:
+        function_name (str):
+        environment (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[TraceIdsResponse]
+    """
+
+    kwargs = _get_kwargs(
+        function_name=function_name,
+        environment=environment,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    function_name: str,
+    *,
+    client: AuthenticatedClient,
+    environment: Union[Unset, str] = UNSET,
+) -> Optional[TraceIdsResponse]:
+    """Get function trace IDs
+
+    Args:
+        function_name (str):
+        environment (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        TraceIdsResponse
+    """
+
+    return sync_detailed(
+        function_name=function_name,
+        client=client,
+        environment=environment,
+    ).parsed
+
+
+async def asyncio_detailed(
+    function_name: str,
+    *,
+    client: AuthenticatedClient,
+    environment: Union[Unset, str] = UNSET,
+) -> Response[TraceIdsResponse]:
+    """Get function trace IDs
+
+    Args:
+        function_name (str):
+        environment (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[TraceIdsResponse]
+    """
+
+    kwargs = _get_kwargs(
+        function_name=function_name,
+        environment=environment,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    function_name: str,
+    *,
+    client: AuthenticatedClient,
+    environment: Union[Unset, str] = UNSET,
+) -> Optional[TraceIdsResponse]:
+    """Get function trace IDs
+
+    Args:
+        function_name (str):
+        environment (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        TraceIdsResponse
+    """
+
+    return (
+        await asyncio_detailed(
+            function_name=function_name,
+            client=client,
+            environment=environment,
+        )
+    ).parsed

beamlit-0.0.29/src/beamlit/api/models/get_model_trace_ids.py

@@ -0,0 +1,171 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.trace_ids_response import TraceIdsResponse
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    model_name: str,
+    *,
+    environment: Union[Unset, str] = UNSET,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["environment"] = environment
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/models/{model_name}/traces",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[TraceIdsResponse]:
+    if response.status_code == 200:
+        response_200 = TraceIdsResponse.from_dict(response.json())
+
+        return response_200
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[TraceIdsResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    model_name: str,
+    *,
+    client: AuthenticatedClient,
+    environment: Union[Unset, str] = UNSET,
+) -> Response[TraceIdsResponse]:
+    """Get model trace IDs
+
+    Args:
+        model_name (str):
+        environment (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[TraceIdsResponse]
+    """
+
+    kwargs = _get_kwargs(
+        model_name=model_name,
+        environment=environment,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    model_name: str,
+    *,
+    client: AuthenticatedClient,
+    environment: Union[Unset, str] = UNSET,
+) -> Optional[TraceIdsResponse]:
+    """Get model trace IDs
+
+    Args:
+        model_name (str):
+        environment (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        TraceIdsResponse
+    """
+
+    return sync_detailed(
+        model_name=model_name,
+        client=client,
+        environment=environment,
+    ).parsed
+
+
+async def asyncio_detailed(
+    model_name: str,
+    *,
+    client: AuthenticatedClient,
+    environment: Union[Unset, str] = UNSET,
+) -> Response[TraceIdsResponse]:
+    """Get model trace IDs
+
+    Args:
+        model_name (str):
+        environment (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[TraceIdsResponse]
+    """
+
+    kwargs = _get_kwargs(
+        model_name=model_name,
+        environment=environment,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    model_name: str,
+    *,
+    client: AuthenticatedClient,
+    environment: Union[Unset, str] = UNSET,
+) -> Optional[TraceIdsResponse]:
+    """Get model trace IDs
+
+    Args:
+        model_name (str):
+        environment (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        TraceIdsResponse
+    """
+
+    return (
+        await asyncio_detailed(
+            model_name=model_name,
+            client=client,
+            environment=environment,
+        )
+    ).parsed