beamlit 0.0.20rc6__tar.gz → 0.0.20rc7__tar.gz

{beamlit-0.0.20rc6 → beamlit-0.0.20rc7}/PKG-INFO

@@ -1,15 +1,17 @@
 Metadata-Version: 2.3
 Name: beamlit
-Version: 0.0.20rc6
+Version: 0.0.20rc7
 Summary: Add your description here
 Author-email: cploujoux <ch.ploujoux@gmail.com>
 Requires-Python: >=3.12
-Requires-Dist: asgi-correlation-id==4.3.4
+Requires-Dist: asgi-correlation-id<5.0.0,>=4.3.4
 Requires-Dist: attrs>=21.3.0
-Requires-Dist: fastapi[standard]==0.115.4
+Requires-Dist: fastapi[standard]<0.116.0,>=0.115.4
 Requires-Dist: httpx<0.28.0,>=0.20.0
-Requires-Dist: langchain-core==0.3.13
-Requires-Dist: langgraph==0.2.40
+Requires-Dist: langchain-community<0.4.0,>=0.3.3
+Requires-Dist: langchain-core<0.4.0,>=0.3.13
+Requires-Dist: langchain-openai<0.3.0,>=0.2.4
+Requires-Dist: langgraph<0.3.0,>=0.2.40
 Requires-Dist: pydantic-settings<2.7.0,>=2.6.1
 Requires-Dist: pydantic<2.11.0,>=2.10.3
 Requires-Dist: python-dateutil>=2.8.0

beamlit-0.0.20rc7/beamlit.yaml

@@ -0,0 +1,5 @@
+agent:
+  functions_directory: src/integrationtest/functions
+server:
+  module: integrationtest.agent.main
+  port: 1338

{beamlit-0.0.20rc6 → beamlit-0.0.20rc7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "beamlit"
-version = "0.0.20.pre-6"
+version = "0.0.20.pre-7"
 description = "Add your description here"
 readme = "README.md"
 authors = [
@@ -19,10 +19,12 @@ dependencies = [
     "pydantic-settings>=2.6.1,<2.7.0",
     "pydantic>=2.10.3,<2.11.0",
     "requests>=2.32.3,<2.33.0",
-    "langchain-core==0.3.13",
-    "langgraph==0.2.40",
-    "fastapi[standard]==0.115.4",
-    "asgi-correlation-id==4.3.4",
+    "langchain-core>=0.3.13,<0.4.0",
+    "langchain-community>=0.3.3,<0.4.0",
+    "langchain-openai>=0.2.4,<0.3.0",
+    "langgraph>=0.2.40,<0.3.0",
+    "fastapi[standard]>=0.115.4,<0.116.0",
+    "asgi-correlation-id>=4.3.4,<5.0.0",
 ]
 [dependency-groups]
 dev = [
@@ -34,7 +36,7 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [tool.ruff]
-line-length = 120
+line-length = 100
 
 [tool.ruff.lint]
 select = ["F", "I", "UP"]

{beamlit-0.0.20rc6 → beamlit-0.0.20rc7}/src/beamlit/agents/chat.py

@@ -62,12 +62,12 @@ def get_chat_model(agent_model: AgentDeployment):
         raise ValueError("agent_model not found in configuration")
     if agent_model.runtime is None:
         raise ValueError("runtime not found in agent model")
-    if agent_model.runtime.type is None:
+    if agent_model.runtime.type_ is None:
         raise ValueError("type not found in runtime")
     if agent_model.runtime.model is None:
         raise ValueError("model not found in runtime")
 
-    provider = agent_model.runtime.type
+    provider = agent_model.runtime.type_
     model = agent_model.runtime.model
 
     kwargs = {

{beamlit-0.0.20rc6 → beamlit-0.0.20rc7}/src/beamlit/agents/decorator.py

@@ -34,7 +34,10 @@ def get_functions(dir="src/functions", from_decorator="function"):
 
                         # Look for function definitions with decorators
                         for node in ast.walk(tree):
-                            if not isinstance(node, ast.FunctionDef) or len(node.decorator_list) == 0:
+                            if (
+                                not isinstance(node, ast.FunctionDef)
+                                or len(node.decorator_list) == 0
+                            ):
                                 continue
                             decorator = node.decorator_list[0]
 
@@ -56,7 +59,9 @@ def get_functions(dir="src/functions", from_decorator="function"):
                                 is_kit = False
                                 if isinstance(decorator, ast.Call):
                                     for keyword in decorator.keywords:
-                                        if keyword.arg == "kit" and isinstance(keyword.value, ast.Constant):
+                                        if keyword.arg == "kit" and isinstance(
+                                            keyword.value, ast.Constant
+                                        ):
                                             is_kit = keyword.value.value
                                 if is_kit:
                                     kit_functions = get_functions(
@@ -87,9 +92,9 @@ def agent(
 
         def wrapped(*args, **kwargs):
             return func(
-                settings.agent,
-                settings.agent_chat_model,
-                settings.agent_functions,
+                settings.agent.agent,
+                settings.agent.chat_model,
+                settings.agent.functions,
                 *args,
                 **kwargs,
             )
@@ -97,33 +102,46 @@ def agent(
         return wrapped
 
     # Initialize functions array to store decorated functions
-    functions = get_functions()
-    settings.agent_functions = functions
+    functions = get_functions(dir=settings.agent.functions_directory)
+    settings.agent.functions = functions
 
     if bl_agent.model and chat_model is None:
         client = new_client()
         try:
-            response = get_model_deployment.sync_detailed(bl_agent.model, settings.environment, client=client)
-            settings.agent_model = response.parsed
+            response = get_model_deployment.sync_detailed(
+                bl_agent.model, settings.environment, client=client
+            )
+            settings.agent.model = response.parsed
         except UnexpectedStatus as e:
             if e.status_code == 404 and settings.environment != "production":
                 try:
-                    response = get_model_deployment.sync_detailed(bl_agent.model, "production", client=client)
-                    settings.agent_model = response.parsed
+                    response = get_model_deployment.sync_detailed(
+                        bl_agent.model, "production", client=client
+                    )
+                    settings.agent.model = response.parsed
                 except UnexpectedStatus as e:
                     if e.status_code == 404:
                         raise ValueError(f"Model {bl_agent.model} not found")
             else:
                 raise e
-
-        chat_model = get_chat_model(settings.agent_model)
-        settings.agent_chat_model = chat_model
-        runtime = settings.agent_model.runtime
-        logger.info(f"Chat model configured, using: {runtime.type}:{runtime.model}")
+        chat_model = get_chat_model(settings.agent.model)
+        settings.agent.chat_model = chat_model
+        runtime = settings.agent.model.runtime
+        logger.info(f"Chat model configured, using: {runtime.type_}:{runtime.model}")
+
+    if len(functions) == 0:
+        raise ValueError(
+            "You must define at least one function, you can define this function in directory "
+            f'"{settings.agent.functions_directory}". Here is a sample function you can use:\n\n'
+            "from beamlit.functions import function\n\n"
+            "@function()\n"
+            "def hello_world(query: str):\n"
+            "    return 'Hello, world!'\n"
+        )
 
     if agent is None and chat_model is not None:
         memory = MemorySaver()
         agent = create_react_agent(chat_model, functions, checkpointer=memory)
-        settings.agent = agent
+        settings.agent.agent = agent
 
     return wrapper

{beamlit-0.0.20rc6 → beamlit-0.0.20rc7}/src/beamlit/authentication/authentication.py

@@ -66,9 +66,7 @@ def new_client_with_credentials(config: RunClientWithCredentials):
     elif config.credentials.access_token:
         provider = BearerToken(config.credentials, config.workspace, config.api_url)
     elif config.credentials.client_credentials:
-        provider = ClientCredentials(
-            config.credentials, config.workspace, config.api_url
-        )
+        provider = ClientCredentials(config.credentials, config.workspace, config.api_url)
     else:
         provider = PublicProvider()
 
@@ -76,7 +74,13 @@ def new_client_with_credentials(config: RunClientWithCredentials):
 
 
 def get_authentication_headers(settings: Settings) -> Dict[str, str]:
-    credentials = load_credentials_from_settings(settings)
+    context = current_context()
+    if context.workspace:
+        credentials = load_credentials(context.workspace)
+    else:
+        settings = get_settings()
+        credentials = load_credentials_from_settings(settings)
+
     config = RunClientWithCredentials(
         credentials=credentials,
         workspace=settings.workspace,
@@ -87,9 +91,7 @@ def get_authentication_headers(settings: Settings) -> Dict[str, str]:
     elif config.credentials.access_token:
         provider = BearerToken(config.credentials, config.workspace, config.api_url)
     elif config.credentials.client_credentials:
-        provider = ClientCredentials(
-            config.credentials, config.workspace, config.api_url
-        )
+        provider = ClientCredentials(config.credentials, config.workspace, config.api_url)
 
     if provider is None:
         return None

{beamlit-0.0.20rc6 → beamlit-0.0.20rc7}/src/beamlit/authentication/credentials.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from logging import getLogger
 from pathlib import Path
 from typing import List
 
@@ -6,6 +7,8 @@ import yaml
 
 from beamlit.common.settings import Settings
 
+logger = getLogger(__name__)
+
 
 @dataclass
 class Credentials:
@@ -120,32 +123,35 @@ def load_credentials(workspace_name: str) -> Credentials:
     return Credentials()
 
 
-def load_credentials_from_settings(config: Settings) -> Credentials:
-    return Credentials(api_key=config.api_key, client_credentials=config.client_credentials)
+def load_credentials_from_settings(settings: Settings) -> Credentials:
+    return Credentials(
+        api_key=settings.authentication.api_key,
+        client_credentials=settings.authentication.client_credentials,
+    )
 
 
 def create_home_dir_if_missing():
     home_dir = Path.home()
     if not home_dir:
-        print("Error getting home directory")
+        logger.error("Error getting home directory")
         return
 
     credentials_dir = home_dir / ".beamlit"
     credentials_file = credentials_dir / "credentials.json"
 
     if credentials_file.exists():
-        print("You are already logged in. Enter a new API key to overwrite it.")
+        logger.warning("You are already logged in. Enter a new API key to overwrite it.")
     else:
         try:
             credentials_dir.mkdir(mode=0o700, parents=True, exist_ok=True)
         except Exception as e:
-            print(f"Error creating credentials directory: {e}")
+            logger.error(f"Error creating credentials directory: {e}")
 
 
 def save_credentials(workspace_name: str, credentials: Credentials):
     create_home_dir_if_missing()
     if not credentials.access_token and not credentials.api_key:
-        print("No credentials to save, error")
+        logger.info("No credentials to save, error")
         return
 
     config = load_config()

{beamlit-0.0.20rc6 → beamlit-0.0.20rc7}/src/beamlit/common/generate.py

@@ -155,8 +155,8 @@ run_client = RunClient(client=client)
     export_code = "\n\nfunctions = ["
     export_chain = "\n\nchains = ["
     code = imports
-    if settings.agent_functions and len(settings.agent_functions) > 0:
-        for function_config in settings.agent_functions:
+    if settings.agent.functions and len(settings.agent.functions) > 0:
+        for function_config in settings.agent.functions:
             if function_config.kit and len(function_config.kit) > 0:
                 new_code, export = generate_kit_function_code(settings, function_config, function_config.kit)
                 code += new_code
@@ -165,15 +165,15 @@ run_client = RunClient(client=client)
                 new_code, export = generate_function_code(settings, function_config)
                 code += new_code
                 export_code += export
-    if settings.agent_chain and len(settings.agent_chain) > 0:
-        for agent in settings.agent_chain:
+    if settings.agent.chain and len(settings.agent.chain) > 0:
+        for agent in settings.agent.chain:
             new_code, export = generate_chain_code(settings, agent)
             code += new_code
             export_chain += export
-    if settings.agent_functions and len(settings.agent_functions) > 0:
+    if settings.agent.functions and len(settings.agent.functions) > 0:
         export_code = export_code[:-1]
     export_code += "]"
-    if settings.agent_chain and len(settings.agent_chain) > 0:
+    if settings.agent.chain and len(settings.agent.chain) > 0:
         export_chain = export_chain[:-1]
     export_chain += "]"
     content = code + export_code + export_chain

{beamlit-0.0.20rc6 → beamlit-0.0.20rc7}/src/beamlit/common/settings.py

@@ -1,11 +1,16 @@
 import os
 from logging import getLogger
-from typing import Any, List, Tuple, Type, Union
+from typing import List, Tuple, Type, Union
 
 from langchain_core.language_models.chat_models import BaseChatModel
 from langgraph.graph.graph import CompiledGraph
 from pydantic import Field
-from pydantic_settings import BaseSettings, PydanticBaseSettingsSource, SettingsConfigDict, YamlConfigSettingsSource
+from pydantic_settings import (
+    BaseSettings,
+    PydanticBaseSettingsSource,
+    SettingsConfigDict,
+    YamlConfigSettingsSource,
+)
 
 from beamlit.api.functions import get_function_deployment
 from beamlit.api.models import get_model_deployment
@@ -24,6 +29,28 @@ def get_settings():
     return SETTINGS
 
 
+class SettingsAgent(BaseSettings):
+    agent: Union[None, CompiledGraph, BaseChatModel] = None
+    chain: Union[Unset, List[AgentDeployment]] = UNSET
+    model: Union[Unset, ModelDeployment] = UNSET
+    functions: Union[Unset, List[FunctionDeployment]] = UNSET
+    functions_directory: str = Field(default="src/functions")
+    chat_model: Union[None, BaseChatModel] = None
+    module: str = Field(default="main.main")
+
+
+class SettingsAuthentication(BaseSettings):
+    api_key: Union[None, str] = None
+    jwt: Union[None, str] = None
+    client_credentials: Union[None, str] = None
+
+
+class SettingsServer(BaseSettings):
+    module: str = Field(default="main.main")
+    port: int = Field(default=80)
+    host: str = Field(default="0.0.0.0")
+
+
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(
         yaml_file="beamlit.yaml",
@@ -31,24 +58,15 @@ class Settings(BaseSettings):
     )
 
     workspace: str
-    type: str
-    name: str
-    environment: str = Field(default="production")
+    environment: str
+    type: str = Field(default="agent")
+    name: str = Field(default="beamlit-agent")
     base_url: str = Field(default="https://api.beamlit.dev/v0")
     run_url: str = Field(default="https://run.beamlit.dev")
-    port: int = Field(default=80)
-    host: str = Field(default="0.0.0.0")
     log_level: str = Field(default="INFO")
-    api_key: Union[None, str] = None
-    jwt: Union[None, str] = None
-    client_credentials: Union[None, str] = None
-    agent_module: str = Field(default="main.main")
-    agent_chain: Union[Unset, List[AgentDeployment]] = UNSET
-    agent_functions: Union[Unset, List[FunctionDeployment]] = UNSET
-    agent_model: Union[Unset, ModelDeployment] = UNSET
-    agent: Union[None, CompiledGraph, BaseChatModel] = None
-    agent_chat_model: Union[None, BaseChatModel] = None
-    agent_functions: Union[None, List[Any]] = None
+    agent: SettingsAgent = SettingsAgent()
+    server: SettingsServer = SettingsServer()
+    authentication: SettingsAuthentication = SettingsAuthentication()
 
     @classmethod
     def settings_customise_sources(
@@ -76,14 +94,14 @@ def init_agent(
     from beamlit.common.generate import generate
 
     logger = getLogger(__name__)
-
+    settings = get_settings()
     # Init configuration from environment variables
-    if SETTINGS.agent_functions or SETTINGS.agent_chain:
+    if settings.agent.functions or settings.agent.chain:
         return
 
     # Init configuration from beamlit control plane
-    name = SETTINGS.name
-    env = SETTINGS.environment
+    name = settings.name
+    env = settings.environment
 
     agent_deployment = get_agent_deployment.sync(name, env, client=client)
     function_deployments = []
@@ -92,7 +110,7 @@ def init_agent(
         for function in agent_deployment.functions:
             function_deployment = get_function_deployment.sync(function, env, client=client)
             function_deployments.append(function_deployment)
-        SETTINGS.agent_functions = function_deployments
+        settings.agent.functions = function_deployments
 
     if agent_deployment.agent_chain:
         for chain in agent_deployment.agent_chain:
@@ -101,25 +119,37 @@ def init_agent(
                 if chain.description:
                     agent_deployment.description = chain.description
                 agent_chain_deployments.append(agent_deployment)
-        SETTINGS.agent_chain = agent_chain_deployments
+        settings.agent.chain = agent_chain_deployments
     if agent_deployment.model:
         model_deployment = get_model_deployment.sync(agent_deployment.model, env, client=client)
-        SETTINGS.agent_model = model_deployment
+        settings.agent.model = model_deployment
 
     content_generate = generate(destination, dry_run=True)
     compared_content = None
     if os.path.exists(destination):
         compared_content = open(destination).read()
 
-    if not os.path.exists(destination) or (compared_content and content_generate != compared_content):
+    if not os.path.exists(destination) or (
+        compared_content and content_generate != compared_content
+    ):
         logger.info("Generating agent code")
         generate(destination)
 
 
 def init() -> Settings:
     """Parse the beamlit.yaml file to get configurations."""
+    from beamlit.authentication.credentials import current_context
+
     global SETTINGS
 
-    SETTINGS = Settings()
+    context = current_context()
+    kwargs = {}
+    if context.workspace:
+        kwargs["workspace"] = context.workspace
+    if context.environment:
+        kwargs["environment"] = context.environment
+
+    SETTINGS = Settings(**kwargs)
     init_logger(SETTINGS.log_level)
+
     return SETTINGS

beamlit-0.0.20rc7/src/beamlit/serve/app.py

@@ -0,0 +1,73 @@
+import importlib
+import traceback
+from logging import getLogger
+from uuid import uuid4
+
+from asgi_correlation_id import CorrelationIdMiddleware
+from fastapi import FastAPI, Request, Response
+from fastapi.responses import JSONResponse
+
+from beamlit.common.settings import get_settings, init
+
+from .middlewares import AccessLogMiddleware, AddProcessTimeHeader
+
+
+def import_module():
+    settings = get_settings()
+    main_module = importlib.import_module(".".join(settings.server.module.split(".")[0:-1]))
+    func = getattr(main_module, settings.server.module.split(".")[-1])
+    return func
+
+
+settings = init()
+logger = getLogger(__name__)
+logger.info(f"Importing server module: {settings.server.module}")
+func = import_module()
+logger.info(
+    f"Running server with environment {settings.environment}"
+    f" on {settings.server.host}:{settings.server.port}"
+)
+
+app = FastAPI(docs_url=None, redoc_url=None)
+app.add_middleware(
+    CorrelationIdMiddleware,
+    header_name="x-beamlit-request-id",
+    generator=lambda: str(uuid4()),
+)
+app.add_middleware(AddProcessTimeHeader)
+app.add_middleware(AccessLogMiddleware)
+
+
+@app.get("/health")
+async def health():
+    return {"status": "ok"}
+
+
+@app.post("/")
+async def root(request: Request):
+    settings = get_settings()
+    logger = getLogger(__name__)
+    try:
+        body = await request.json()
+        response = await func(body)
+        if isinstance(response, Response):
+            return response
+        if type(response) is str:
+            return Response(
+                content=response,
+                headers={"Content-Type": "text/plain"},
+                media_type="text/plain",
+                status_code=200,
+            )
+        return JSONResponse(status_code=200, content=response)
+    except ValueError as e:
+        content = {"error": str(e)}
+        if settings.environment == "development":
+            content["traceback"] = str(traceback.format_exc())
+        logger.error(f"{content}")
+        return JSONResponse(status_code=400, content=content)
+    except Exception as e:
+        content = {"error": f"Internal server error, {e}"}
+        if settings.environment == "development":
+            content["traceback"] = str(traceback.format_exc())
+        return JSONResponse(status_code=500, content=content)

beamlit-0.0.20rc7/src/beamlit/serve/middlewares/__init__.py

@@ -0,0 +1,4 @@
+from .accesslog import AccessLogMiddleware
+from .processtime import AddProcessTimeHeader
+
+__all__ = ["AccessLogMiddleware", "AddProcessTimeHeader"]

beamlit-0.0.20rc7/src/beamlit/serve/middlewares/accesslog.py

@@ -0,0 +1,14 @@
+from logging import getLogger
+
+from starlette.middleware.base import BaseHTTPMiddleware
+
+
+class AccessLogMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request, call_next):
+        logger = getLogger(__name__)
+        response = await call_next(request)
+        process_time = response.headers.get("X-Process-Time")
+        rid_header = response.headers.get("X-Request-Id")
+        request_id = rid_header or response.headers.get("X-Beamlit-Request-Id")
+        logger.info(f"{request.method} {request.url.path} {response.status_code} {process_time}ms rid={request_id}")
+        return response

beamlit-0.0.20rc7/src/beamlit/serve/middlewares/processtime.py

@@ -0,0 +1,12 @@
+import time
+
+from starlette.middleware.base import BaseHTTPMiddleware
+
+
+class AddProcessTimeHeader(BaseHTTPMiddleware):
+    async def dispatch(self, request, call_next):
+        start_time = time.perf_counter()
+        response = await call_next(request)
+        process_time = (time.perf_counter() - start_time) * 1000
+        response.headers["X-Process-Time"] = f"{process_time:.2f}"
+        return response

beamlit-0.0.20rc7/src/integrationtest/agent.py

@@ -0,0 +1,39 @@
+import asyncio
+import uuid
+
+from beamlit.agents import agent
+from beamlit.models import AgentDeployment
+
+
+@agent(
+    AgentDeployment(
+        agent="agent-custom",
+        description="A chat agent using Beamlit to handle your tasks.",
+        model="gpt-4o-mini",
+    ),
+)
+async def main(agent, chat_model, tools, body, headers=None, query_params=None, **_):
+    agent_config = {"configurable": {"thread_id": str(uuid.uuid4())}}
+    if body.get("inputs"):
+        body["input"] = body["inputs"]
+
+    agent_body = {"messages": [("user", body["input"])]}
+    responses = []
+
+    for chunk in agent.stream(agent_body, config=agent_config):
+        responses.append(chunk)
+    content = responses[-1]
+    return content["agent"]["messages"][-1].content
+
+
+if __name__ == "__main__":
+
+    async def check():
+        response = await main(
+            {"input": "What does 4+2 ?"},
+            headers={"X-Beamlit-Sub": "123"},
+            query_params={"debug": "false"},
+        )
+        print(response)
+
+    asyncio.run(check())

beamlit-0.0.20rc7/src/integrationtest/functions/helloworld.py

@@ -0,0 +1,7 @@
+from beamlit.functions import function
+
+
+@function()
+def helloworld(query: str):
+    """A function for saying hello to the world."""
+    return "Hello, world!"

{beamlit-0.0.20rc6/src → beamlit-0.0.20rc7/src/integrationtest}/main.py

@@ -1,11 +1,11 @@
 from beamlit.api.models import get_model_deployment
-from beamlit.authentication import get_authentication_headers, new_client_from_settings
+from beamlit.authentication import get_authentication_headers, new_client
 from beamlit.common.settings import init
 from beamlit.models.model_deployment import ModelDeployment
 from beamlit.run import RunClient
 
 settings = init()
-client = new_client_from_settings(settings)
+client = new_client()
 model_deployment: ModelDeployment = get_model_deployment.sync("gpt-4o-mini", "production", client=client)
 # init_agent(client=client)
 run_client = RunClient(client=client)