beamlit 0.0.31rc42__py3-none-any.whl → 0.0.33__py3-none-any.whl

beamlit/agents/decorator.py

@@ -6,13 +6,15 @@ import importlib
 import os
 from logging import getLogger
 
-from langchain_core.tools import Tool
+from langchain_core.tools import StructuredTool
 from langgraph.checkpoint.memory import MemorySaver
 from langgraph.prebuilt import create_react_agent
+from langchain_core.tools.base import create_schema_from_function
 
 from beamlit.api.models import get_model
 from beamlit.authentication import new_client
-from beamlit.common.settings import init
+from beamlit.common import slugify
+from beamlit.common.settings import get_settings, init
 from beamlit.errors import UnexpectedStatus
 from beamlit.functions.mcp.mcp import MCPClient, MCPToolkit
 from beamlit.functions.remote.remote import RemoteToolkit
@@ -22,9 +24,10 @@ from .chain import ChainToolkit
 from .chat import get_chat_model
 
 
-def get_functions(dir="src/functions", from_decorator="function", remote_functions_empty=True):
+def get_functions(client, dir="src/functions", from_decorator="function", remote_functions_empty=True):
     functions = []
     logger = getLogger(__name__)
+    settings = get_settings()
 
     # Walk through all Python files in functions directory and subdirectories
     if not os.path.exists(dir):
@@ -73,8 +76,9 @@ def get_functions(dir="src/functions", from_decorator="function", remote_functio
                                             keyword.value, ast.Constant
                                         ):
                                             is_kit = keyword.value.value
-                                if is_kit:
+                                if is_kit and not settings.remote:
                                     kit_functions = get_functions(
+                                        client,
                                         dir=os.path.join(root),
                                         from_decorator="kit",
                                         remote_functions_empty=remote_functions_empty,
@@ -84,23 +88,30 @@ def get_functions(dir="src/functions", from_decorator="function", remote_functio
                                 # Get the decorated function
                                 if not is_kit and hasattr(module, func_name):
                                     func = getattr(module, func_name)
-                                    if asyncio.iscoroutinefunction(func):
-                                        functions.append(
-                                            Tool(
-                                                name=func.__name__,
-                                                description=func.__doc__,
-                                                func=func,
-                                                coroutine=func,
-                                            )
-                                        )
+                                    if settings.remote:
+                                        toolkit = RemoteToolkit(client, slugify(func.__name__))
+                                        toolkit.initialize()
+                                        functions.extend(toolkit.get_tools())
                                     else:
-                                        functions.append(
-                                            Tool(
-                                                name=func.__name__,
-                                                description=func.__doc__,
-                                                func=func,
+                                        if asyncio.iscoroutinefunction(func):
+                                            functions.append(
+                                                StructuredTool(
+                                                    name=func.__name__,
+                                                    description=func.__doc__,
+                                                    func=func,
+                                                    coroutine=func,
+                                                    args_schema=create_schema_from_function(func.__name__, func)
+                                                )
+                                            )
+                                        else:
+                                            functions.append(
+                                                StructuredTool(
+                                                    name=func.__name__,
+                                                    description=func.__doc__,
+                                                    func=func,
+                                                    args_schema=create_schema_from_function(func.__name__, func)
+                                                )
                                             )
-                                        )
                     except Exception as e:
                         logger.warning(f"Error processing {file_path}: {e!s}")
     return functions
@@ -139,9 +150,11 @@ def agent(
 
         # Initialize functions array to store decorated functions
         functions = get_functions(
+            client,
             dir=settings.agent.functions_directory,
             remote_functions_empty=not remote_functions,
         )
+
         settings.agent.functions = functions
 
         if agent is not None:

beamlit/common/__init__.py

@@ -1,16 +1,17 @@
 from .error import HTTPError
 from .logger import init as init_logger
 from .secrets import Secret
-from .settings import Settings, get_settings, init, init_agent
+from .settings import Settings, get_settings, init
+from .slugify import slugify
 from .utils import copy_folder
 
 __all__ = [
     "Secret",
     "Settings",
     "get_settings",
-    "init_agent",
     "init",
     "copy_folder",
     "init_logger",
     "HTTPError",
+    "slugify"
 ]

beamlit/common/settings.py

@@ -1,5 +1,4 @@
 import os
-from logging import getLogger
 from typing import Tuple, Type, Union
 
 from langchain_core.language_models.chat_models import BaseChatModel
@@ -12,22 +11,17 @@ from pydantic_settings import (
     YamlConfigSettingsSource,
 )
 
-from beamlit.api.agents import get_agent
-from beamlit.api.functions import get_function
-from beamlit.api.models import get_model
-from beamlit.client import AuthenticatedClient
 from beamlit.common.logger import init as init_logger
 from beamlit.models import Agent, Function, Model
-from beamlit.types import UNSET, Unset
 
 global SETTINGS
 SETTINGS = None
 
 class SettingsAgent(BaseSettings):
-    agent: Union[None, CompiledGraph, BaseChatModel] = None
-    chain: Union[Unset, list[Agent]] = UNSET
-    model: Union[Unset, Model] = UNSET
-    functions: Union[Unset, list[Function]] = UNSET
+    agent: Union[None, CompiledGraph] = None
+    chain: Union[None, list[Agent]] = None
+    model: Union[None, Model] = None
+    functions: Union[None, list[Function]] = None
     functions_directory: str = Field(default="src/functions")
     chat_model: Union[None, BaseChatModel] = None
     module: str = Field(default="main.main")
@@ -100,59 +94,6 @@ class Settings(BaseSettings):
 def get_settings() -> Settings:
     return SETTINGS
 
-
-def init_agent(
-    client: AuthenticatedClient,
-    destination: str = f"{os.getcwd()}/src/beamlit_generated.py",
-):
-    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:
-        return
-
-    # Init configuration from beamlit control plane
-    name = settings.name
-    env = settings.environment
-
-    agent = get_agent.sync(name, environment=env, client=client)
-    if not agent:
-        raise ValueError(f"Agent {name} not found")
-    functions: list[Function] = []
-    agents_chain: list[Agent] = []
-    if agent.spec.functions:
-        for function in agent.spec.functions:
-            function = get_function.sync(function, environment=env, client=client)
-            if function:
-                functions.append(function)
-        settings.agent.functions = functions
-
-    if agent.spec.agentChain:
-        for chain in agent.spec.agentChain:
-            if chain.enabled:
-                agentChain = get_agent.sync(chain.name, environment=env, client=client)
-                if chain.description:
-                    agentChain.spec.description = chain.description
-                agents_chain.append(agentChain)
-        settings.agent.chain = agents_chain
-    if agent.spec.model:
-        model = get_model.sync(agent.spec.model, environment=env, client=client)
-        settings.agent.model = model
-
-    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
-    ):
-        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

beamlit/common/slugify.py

@@ -0,0 +1,2 @@
+def slugify(name: str) -> str:
+    return name.lower().replace(" ", "-").replace("_", "-")

beamlit/deploy/deploy.py

@@ -6,6 +6,7 @@ import uuid
 from logging import getLogger
 from typing import Literal
 
+from beamlit.common import slugify
 from beamlit.common.settings import Settings, get_settings, init
 from beamlit.models import (
     Agent,
@@ -24,8 +25,6 @@ sys.path.insert(0, os.getcwd())
 sys.path.insert(0, os.path.join(os.getcwd(), "src"))
 
 random_id = str(uuid.uuid4())[:8]
-def slugify(name: str) -> str:
-    return name.lower().replace(" ", "-").replace("_", "-")
 
 def get_runtime_image(type: str, name: str) -> str:
     settings = get_settings()
@@ -130,7 +129,7 @@ metadata:
 spec:
   enabled: true
   policies: [{", ".join(agent.spec.policies or [])}]
-  functions: [{", ".join([f"{function.metadata.name}" for (_, function) in functions])}]
+  functions: [{", ".join([f"{slugify(function.metadata.name)}" for (_, function) in functions])}]
   agentChain: {format_agent_chain(agent.spec.agent_chain)}
   model: {agent.spec.model}
   runtime:

beamlit/functions/decorator.py

@@ -1,62 +1,15 @@
 """Decorators for creating function tools with Beamlit and LangChain integration."""
-
-import json
+import asyncio
+import functools
 from collections.abc import Callable
 from logging import getLogger
 
-from langchain_core.tools import create_schema_from_function
+from fastapi import Request
 
-from beamlit.authentication import new_client
-from beamlit.common.settings import get_settings
 from beamlit.models import Function, FunctionKit
-from beamlit.run import RunClient
 
 logger = getLogger(__name__)
 
-
-def get_remote_function(func: Callable, function: Function):
-    settings = get_settings()
-    name = (function and function.metadata and function.metadata.name) or func.__name__
-
-    def _partial(*args, **kwargs):
-        # Get function signature parameters
-        try:
-            client = new_client()
-            run_client = RunClient(client)
-            logger.debug(
-                f"Calling remote function: NAME={name}"
-                f" PARAMS={kwargs} ENVIRONMENT={settings.environment}"
-            )
-            response = run_client.run(
-                resource_type="function",
-                resource_name=name,
-                environment=settings.environment,
-                method="POST",
-                headers={"Content-Type": "application/json"},
-                data=json.dumps(kwargs),
-            )
-            content = response.text
-            if response.status_code >= 400:
-                content = f"{response.status_code}:{response.text}"
-                logger.error(f"Error calling remote function: {content}")
-                return f"Error calling remote function: {content}"
-            logger.debug(
-                f"Response from remote function: NAME={name}"
-                f" RESPONSE={content} ENVIRONMENT={settings.environment}"
-            )
-            if response.headers.get("content-type") == "application/json":
-                return response.json()
-            return content
-        except Exception as e:
-            logger.error(f"Error calling function {name}: {e}")
-            raise e
-
-    remote_func = _partial
-    remote_func.__name__ = func.__name__
-    remote_func.__doc__ = func.__doc__
-    return remote_func
-
-
 def kit(bl_kit: FunctionKit = None, **kwargs: dict) -> Callable:
     """Create function tools with Beamlit and LangChain integration."""
 
@@ -70,26 +23,23 @@ def kit(bl_kit: FunctionKit = None, **kwargs: dict) -> Callable:
 
 def function(*args, function: Function | dict = None, kit=False, **kwargs: dict) -> Callable:
     """Create function tools with Beamlit and LangChain integration."""
-    settings = get_settings()
     if function is not None and not isinstance(function, dict):
         raise Exception(
             'function must be a dictionary, example: @function(function={"metadata": {"name": "my_function"}})'
         )
     if isinstance(function, dict):
         function = Function(**function)
-        
+
     def wrapper(func: Callable) -> Callable:
         if function and not func.__doc__ and function.spec and function.spec.description:
             func.__doc__ = function.spec.description
-        if settings.remote:
-            remote_func = get_remote_function(func, function)
-            if not kwargs.get("args_schema"):
-                kwargs["args_schema"] = create_schema_from_function(
-                    func.__name__,
-                    func,
-                    parse_docstring=func.__doc__,
-                )
-            return remote_func
-        return func
+
+        @functools.wraps(func)
+        async def wrapped(*args, **kwargs):
+            if len(args) > 0 and isinstance(args[0], Request):
+                body = await args[0].json()
+                args = [body.get(param) for param in func.__code__.co_varnames[:func.__code__.co_argcount]]
+            return await func(*args, **kwargs) if asyncio.iscoroutinefunction(func) else func(*args, **kwargs)
+        return wrapped
 
     return wrapper

beamlit/serve/app.py

@@ -71,13 +71,11 @@ async def root(request: Request):
     settings = get_settings()
     logger = getLogger(__name__)
     try:
-        body = await request.json()
-
         original_func = getattr(func, "__wrapped__", func)
         if asyncio.iscoroutinefunction(func) or asyncio.iscoroutinefunction(original_func):
-            response = await func(body)
+            response = await func(request)
         else:
-            response = func(body)
+            response = func(request)
 
         if isinstance(response, Response):
             return response

{beamlit-0.0.31rc42.dist-info → beamlit-0.0.33.dist-info}/METADATA

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

{beamlit-0.0.31rc42.dist-info → beamlit-0.0.33.dist-info}/RECORD

@@ -7,7 +7,7 @@ beamlit/types.py,sha256=E1hhDh_zXfsSQ0NCt9-uw90_Mr5iIlsdfnfvxv5HarU,1005
 beamlit/agents/__init__.py,sha256=nf1iwQwGtCG6nDqyVhxfWoqR6dv6X3bvSpCeqkTCFaM,101
 beamlit/agents/chain.py,sha256=vfCjiFHuu02uTTGicxMlFzjyICQkIjpXrBGs-7uJEsg,2826
 beamlit/agents/chat.py,sha256=gVyv4FGBdQTDhdutX8l64OUNa6Fdqaw4eCfEDRH0IPQ,3558
-beamlit/agents/decorator.py,sha256=RAhe7wHKJnjMpmU7KWKcM6EZjdm3pgUBhQQUP2T6GZY,9716
+beamlit/agents/decorator.py,sha256=n3sETKu8V2g3GDJ0f17kUowyqaRJvpg3n_BGRRVuNGY,10619
 beamlit/api/__init__.py,sha256=zTSiG_ujSjAqWPyc435YXaX9XTlpMjiJWBbV-f-YtdA,45
 beamlit/api/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 beamlit/api/agents/create_agent.py,sha256=t5Pr62My2EhQlcIY71MrI73-0_q5Djr3a_Ybt9MIiQQ,3587
@@ -128,20 +128,20 @@ beamlit/authentication/authentication.py,sha256=ODQCc00RvCOZNaiGG5ctylNnE-JVCuge
 beamlit/authentication/clientcredentials.py,sha256=cxZPPu--CgizwqX0pdfFQ91gJt1EFKwyy-aBB_dXX7I,3990
 beamlit/authentication/credentials.py,sha256=p_1xenabCbQuRz7BiFk7oTK4uCxAt_zoyku5o-jcKGE,5343
 beamlit/authentication/device_mode.py,sha256=tmr22gllKOZwBRub_QjF5pYa425x-nE8tQNpZ_EGR6g,3644
-beamlit/common/__init__.py,sha256=vj4_boIBVitMsaQR8BqBqE2eupOIh6MWBAYlYyCCH98,341
+beamlit/common/__init__.py,sha256=saX5X3hRCJ9erSlXuSkZ2VGgquvpgdcofAU_9sM4bCE,354
 beamlit/common/error.py,sha256=f9oJDFxhoHK-vpjxBgEp0NwWIk0N_THPemUI7uQxVzU,270
-beamlit/common/generate.py,sha256=LtdCju_QayRS4lZrrb_0VHqWWvTcv4Mbf-iV1TB_Qko,7522
 beamlit/common/instrumentation.py,sha256=GVYeat7qCcqzDoKSYig3s8ZCC172R9JiQIr3Evv3kik,4293
 beamlit/common/logger.py,sha256=nN_dSOl4bs13QU3Rod-w3e3jYOnlSrHx3_bs-ACY6Aw,1115
 beamlit/common/secrets.py,sha256=sid81bOe3LflkMKDHwBsBs9nIju8bp5-v9qU9gkyNMc,212
-beamlit/common/settings.py,sha256=_4oCVrJZOMaTZoK2Zzo2DWqtUyBsspuOH3iAJ_nU0tw,5923
+beamlit/common/settings.py,sha256=b2rvby-ufG3M0AB1ReoWFM-1EzF1LaE-gbokO9HvQDI,3810
+beamlit/common/slugify.py,sha256=nR29r37IdWS2i44ZC6ZsXRgqKPYmvMGtFQ7BuIQUTlc,90
 beamlit/common/utils.py,sha256=jouz5igBvT37Xn_e94-foCHyQczVim-UzVcoIF6RWJ4,657
 beamlit/deploy/__init__.py,sha256=GS7l7Jtm2yKs7iNLKcfjYO-rAhUzggQ3xiYSf3oxLBY,91
-beamlit/deploy/deploy.py,sha256=xo2fAdF6jR1cG75sXMzpqsJlG_qGAKVnMwjuDa_8sk8,9936
+beamlit/deploy/deploy.py,sha256=YKY1iN0ZofQr_n9efvDJ5pK9HpyLZO9wyHmh8W9PAaE,9889
 beamlit/deploy/format.py,sha256=PJ8kU7Y1pwiS3tqqyvFaag9LO3jju-4ua574163VPk4,1820
 beamlit/deploy/parser.py,sha256=Ga0poCZkoRnuTw082QnTcNGCBJncoRAnVsn8-1FsaJE,6907
 beamlit/functions/__init__.py,sha256=_RPG1Bfg54JGdIPnViAU6n9zD7E1cDNsdXi8oYGskzE,138
-beamlit/functions/decorator.py,sha256=YNNU8MZXV2C6gIjxaYhp-FSWGLc9I_XLsIE24zQ3fr8,3541
+beamlit/functions/decorator.py,sha256=ZtSQsPLI70WKwi2jPhA7DaqREQUINpqt9BDVugeV_sg,1714
 beamlit/functions/github/__init__.py,sha256=gYnUkeegukOfbymdabuuJkScvH-_ZJygX05BoqkPn0o,49
 beamlit/functions/github/github.py,sha256=FajzLCNkpXcwfgnC0l9rOGT2eSPLCz8-qrMzK9N_ZNc,598
 beamlit/functions/github/kit/__init__.py,sha256=jBwPqZv6C23_utukohxqXZwrlicNlI7PYPUj0Den7Cw,136
@@ -252,10 +252,10 @@ beamlit/models/websocket_channel.py,sha256=jg3vN7yS_oOIwGtndtIUr1LsyEA58RXLXahqS
 beamlit/models/workspace.py,sha256=l__bIpbA4oJvxXo7UbEoCcqkvu9MiNt5aXXpZ3bgwHg,4309
 beamlit/models/workspace_labels.py,sha256=WbnUY6eCTkUNdY7hhhSF-KQCl8fWFfkCf7hzCTiNp4A,1246
 beamlit/models/workspace_user.py,sha256=70CcifQWYbeWG7TDui4pblTzUe5sVK0AS19vNCzKE8g,3423
-beamlit/serve/app.py,sha256=QzReZZjGFQWhNA1XBDq81rsn9zpEihtLZLrfZi9ThT0,3554
+beamlit/serve/app.py,sha256=DXWxQoMeuA5FYvBMyLrP94OEWQbwLf4GZk3I9fkwSPA,3523
 beamlit/serve/middlewares/__init__.py,sha256=1dVmnOmhAQWvWktqHkKSIX-YoF6fmMU8xkUQuhg_rJU,148
 beamlit/serve/middlewares/accesslog.py,sha256=Mu4T4_9OvHybjA0ApzZFpgi2C8f3X1NbUk-76v634XM,631
 beamlit/serve/middlewares/processtime.py,sha256=lDAaIasZ4bwvN-HKHvZpaD9r-yrkVNZYx4abvbjbrCg,411
-beamlit-0.0.31rc42.dist-info/METADATA,sha256=9DQPwNYvv6Q3ailPx5xQTQCxOyzOKlD8xuLp6qcBhck,2405
-beamlit-0.0.31rc42.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-beamlit-0.0.31rc42.dist-info/RECORD,,
+beamlit-0.0.33.dist-info/METADATA,sha256=4AMW5iTcsR-ZCtdCDjbHpt7mN-1OFd_Haj7dOWztBFw,2401
+beamlit-0.0.33.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+beamlit-0.0.33.dist-info/RECORD,,

beamlit/common/generate.py

@@ -1,196 +0,0 @@
-from typing import Tuple
-
-from beamlit.common.settings import Settings, get_settings
-from beamlit.models import Agent, Function, FunctionMetadata, FunctionSpec
-from beamlit.models.function_kit import FunctionKit
-
-
-def get_titles_name(name: str) -> str:
-    return name.title().replace("-", "").replace("_", "")
-
-
-def generate_kit_function_code(
-    settings: Settings, function: Function, kit: FunctionKit
-) -> Tuple[str, str]:
-    export_code = ""
-    code = ""
-    for kit in kit:
-        fn = Function(
-            metadata=FunctionMetadata(
-                name=kit.name,
-                workspace=settings.workspace,
-                environment=settings.environment,
-            ),
-            spec=FunctionSpec(
-                parameters=kit.parameters,
-                description=kit.description,
-            ),
-        )
-        new_code, export = generate_function_code(
-            settings, fn, force_name_in_endpoint=function.metadata.name, kit=True
-        )
-        code += new_code
-        export_code += export
-    return code, export_code
-
-
-def generate_function_code(
-    settings: Settings,
-    function: Function,
-    force_name_in_endpoint: str = "",
-    kit: bool = False,
-) -> Tuple[str, str]:
-    name = get_titles_name(function.metadata.name)
-    if function.spec.parameters and len(function.spec.parameters) > 0:
-        args_list = ", ".join(f"{param.name}: str" for param in function.spec.parameters)
-        args_list += ", "
-    else:
-        args_list = ""
-    args_schema = ""
-    if function.spec.parameters:
-        for param in function.spec.parameters:
-            args_schema += f'{param.name}: str = Field(description="""{param.description}""")\n    '
-    if len(args_schema) == 0:
-        args_schema = "pass"
-
-    # TODO: add return direct in function configuration
-    return_direct = False
-    endpoint_name = force_name_in_endpoint or function.metadata.name
-    body = "{}"
-    if function.spec.parameters:
-        body = f'{", ".join(f'"{param.name}": {param.name}' for param in function.spec.parameters)}'
-    if kit is True:
-        has_name = False
-        if function.spec.parameters:
-            for param in function.spec.parameters:
-                if param.name == "name":
-                    has_name = True
-                    break
-        if not has_name:
-            if len(body) > 0:
-                body += ", "
-            body += f'"name": "{function.metadata.name}"'
-    return (
-        f'''
-
-class Beamlit{name}Input(BaseModel):
-    {args_schema}
-
-class Beamlit{name}(BaseTool):
-    name: str = "beamlit_{function.metadata.name.replace("-", "_")}"
-    description: str = """{function.spec.description}"""
-    args_schema: Type[BaseModel] = Beamlit{name}Input
-
-    response_format: Literal["content_and_artifact"] = "content_and_artifact"
-    return_direct: bool = {return_direct}
-
-    def _run(self, {args_list} run_manager: Optional[CallbackManagerForToolRun] = None) -> Tuple[Union[List[Dict[str, str]], str], Dict]:
-        try:
-            params = self.metadata.get("params", {{}})
-            response = run_client.run("function", "{endpoint_name}", settings.environment, "POST", json={{{body}}})
-            if response.status_code >= 400:
-                logger.error(f"Failed to run function {name}, {{response.status_code}}::{{response.text}}")
-                raise Exception(f"Failed to run function {name}, {{response.status_code}}::{{response.text}}")
-            return response.json(), {{}}
-        except Exception as e:
-            return repr(e), {{}}
-''',
-        f"Beamlit{get_titles_name(function.metadata.name)},",
-    )
-
-
-def generate_chain_code(settings: Settings, agent: Agent) -> Tuple[str, str]:
-    name = get_titles_name(agent.metadata.name)
-    # TODO: add return direct in agent configuration
-    return_direct = False
-    return (
-        f'''
-class BeamlitChain{name}Input(BaseModel):
-    input: str = Field(description='{agent.spec.description}')
-
-class BeamlitChain{name}(BaseTool):
-    name: str = "beamlit_chain_{agent.metadata.name.replace("-", "_")}"
-    description: str = """{agent.spec.description}"""
-    args_schema: Type[BaseModel] = BeamlitChain{name}Input
-
-    response_format: Literal["content_and_artifact"] = "content_and_artifact"
-    return_direct: bool = {return_direct}
-
-    def _run(
-        self,
-        input: str,
-        run_manager: Optional[CallbackManagerForToolRun] = None,
-    ) -> Tuple[Union[List[Dict[str, str]], str], Dict]:
-        try:
-            params = self.metadata.get("params", {{}})
-            response = run_client.run("agent", "{agent.metadata.name}", settings.environment, "POST", json={{"input": input}})
-            if response.status_code >= 400:
-                logger.error(f"Failed to run tool {agent.metadata.name}, {{response.status_code}}::{{response.text}}")
-                raise Exception(f"Failed to run tool {agent.metadata.name}, {{response.status_code}}::{{response.text}}")
-            if response.headers.get("Content-Type") == "application/json":
-                return response.json(), {{}}
-            else:
-                return response.text, {{}}
-        except Exception as e:
-            return repr(e), {{}}
-''',
-        f"BeamlitChain{name},",
-    )
-
-
-def generate(destination: str, dry_run: bool = False):
-    imports = """from logging import getLogger
-from typing import Dict, List, Literal, Optional, Tuple, Type, Union
-
-from langchain_core.callbacks import CallbackManagerForToolRun
-from langchain_core.tools import BaseTool
-from pydantic import BaseModel, Field
-from beamlit.authentication import (RunClientWithCredentials,
-                                    load_credentials_from_settings,
-                                    new_client_with_credentials)
-from beamlit.common.settings import get_settings
-from beamlit.run import RunClient
-
-logger = getLogger(__name__)
-settings = get_settings()
-credentials = load_credentials_from_settings(settings)
-
-client_config = RunClientWithCredentials(
-    credentials=credentials,
-    workspace=settings.workspace,
-)
-client = new_client_with_credentials(client_config)
-run_client = RunClient(client=client)
-"""
-    settings = get_settings()
-    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 function_config.spec.kit and len(function_config.spec.kit) > 0:
-                new_code, export = generate_kit_function_code(
-                    settings, function_config, function_config.spec.kit
-                )
-                code += new_code
-                export_code += export
-            else:
-                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:
-            new_code, export = generate_chain_code(settings, agent)
-            code += new_code
-            export_chain += export
-    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:
-        export_chain = export_chain[:-1]
-    export_chain += "]"
-    content = code + export_code + export_chain
-    if not dry_run:
-        with open(destination, "w") as f:
-            f.write(content)
-    return content