agenta 0.20.0a13__py3-none-any.whl → 0.21.0a1__py3-none-any.whl

agenta/__init__.py

@@ -3,6 +3,7 @@ from .sdk.context import get_contexts, save_context
 from .sdk.types import (
     Context,
     DictInput,
+    MultipleChoice,
     FloatParam,
     InFile,
     IntParam,
@@ -22,7 +23,7 @@ from .sdk.agenta_init import Config, AgentaSingleton, init
 from .sdk.utils.helper.openai_cost import calculate_token_usage
 from .sdk.client import Agenta
 from .sdk.tracing import callbacks
-
+from .sdk.config_manager import ConfigManager
 
 config = PreInitObject("agenta.config", Config)
 DEFAULT_AGENTA_SINGLETON_INSTANCE = AgentaSingleton()

agenta/docker/docker_utils.py

@@ -3,12 +3,13 @@ import shutil
 import tarfile
 import tempfile
 from pathlib import Path
+import os
 
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.DEBUG)
 
-DEBUG = False
+DEBUG = os.environ.get("AGENTA_CLI_DEBUG", False)
 
 
 def create_dockerfile(out_folder: Path) -> Path:

agenta/sdk/__init__.py

@@ -3,6 +3,7 @@ from .context import get_contexts, save_context
 from .types import (
     Context,
     DictInput,
+    MultipleChoice,
     FloatParam,
     InFile,
     IntParam,
@@ -19,6 +20,7 @@ from .decorators.tracing import instrument
 from .decorators.llm_entrypoint import entrypoint, app, route
 from .agenta_init import Config, AgentaSingleton, init
 from .utils.helper.openai_cost import calculate_token_usage
+from .config_manager import ConfigManager
 
 config = PreInitObject("agenta.config", Config)
 DEFAULT_AGENTA_SINGLETON_INSTANCE = AgentaSingleton()

agenta/sdk/config_manager.py

@@ -0,0 +1,205 @@
+import json
+import logging
+from pathlib import Path
+from typing import Optional, Type, TypeVar
+
+import yaml
+from pydantic import BaseModel, ValidationError
+
+from agenta.client.backend.client import AgentaApi
+from agenta.sdk.decorators.llm_entrypoint import route_context
+
+from . import AgentaSingleton
+
+T = TypeVar("T", bound=BaseModel)
+
+logger = logging.getLogger(__name__)
+singleton = AgentaSingleton()
+
+
+class ConfigManager:
+    client = None
+
+    @staticmethod
+    def get_from_route(schema: Type[T]) -> T:
+        """
+        Retrieves the configuration from the route context and returns a config object.
+
+        This method checks the route context for configuration information and returns
+        an instance of the specified schema based on the available context data.
+
+        Args:
+            schema (Type[T]): A Pydantic model class that defines the structure of the configuration.
+
+        Returns:
+            T: An instance of the specified schema populated with the configuration data.
+
+        Raises:
+            ValueError: If conflicting configuration sources are provided or if no valid
+                        configuration source is found in the context.
+
+        Note:
+            The method prioritizes the inputs in the following way:
+            1. 'config' (i.e. when called explicitly from the playground)
+            2. 'environment'
+            3. 'variant'
+            Only one of these should be provided.
+        """
+        context = route_context.get()
+        if ("config" in context and context["config"]) and (
+            ("environment" in context and context["environment"])
+            or ("variant" in context and context["variant"])
+        ):
+            raise ValueError(
+                "Either config, environment or variant must be provided. Not both."
+            )
+        if "config" in context and context["config"]:
+            return schema(**context["config"])
+        elif "environment" in context and context["environment"]:
+            return ConfigManager.get_from_backend(
+                schema, environment=context["environment"]
+            )
+        elif "variant" in context and context["variant"]:
+            return ConfigManager.get_from_backend(schema, variant=context["variant"])
+        else:
+            raise ValueError("Either config, environment or variant must be provided")
+
+    @staticmethod
+    def get_from_backend(
+        schema: Type[T],
+        environment: Optional[str] = None,
+        version: Optional[str] = None,
+        variant: Optional[str] = None,
+    ) -> T:
+        """
+        Pulls the parameters for the app variant from the server and returns a config object.
+
+        This method retrieves the configuration from the backend server based on the provided
+        environment or variant. It then validates and returns the configuration as an instance
+        of the specified schema.
+
+        Args:
+            schema (Type[T]): A Pydantic model class that defines the structure of the configuration.
+            environment (Optional[str]): The environment name to fetch the configuration for.
+                                         Must be one of "development", "production", or "staging".
+            version (Optional[str]): Currently not implemented. Will raise NotImplementedError if provided.
+            variant (Optional[str]): The variant name to fetch the configuration for.
+
+        Returns:
+            T: An instance of the specified schema populated with the configuration data.
+
+        Raises:
+            ValueError: If neither environment nor variant is provided.
+            NotImplementedError: If a specific version is requested (not yet implemented).
+            ValidationError: If the retrieved configuration data doesn't match the schema.
+            Exception: For any other errors during the process (e.g., API communication issues).
+
+        Note:
+            Either environment or variant must be provided, but not both.
+        """
+        if not ConfigManager.client:
+            try:
+                ConfigManager.client = AgentaApi(
+                    base_url=singleton.host + "/api",
+                    api_key=singleton.api_key if singleton.api_key else "",
+                )
+            except Exception as ex:
+                logger.error(
+                    "Failed to initialize Agenta client with error: %s", str(ex)
+                )
+                raise
+        if not environment and not variant:
+            raise ValueError("Either environment or variant must be provided")
+        try:
+            if environment:
+                if version:
+                    raise NotImplementedError(
+                        "Getting config for a specific version is not implemented yet."
+                    )
+                else:
+                    assert environment in [
+                        "development",
+                        "production",
+                        "staging",
+                    ], "Environment must be either development, production or staging"
+                    config = ConfigManager.client.configs.get_config(
+                        base_id=singleton.base_id, environment_name=environment
+                    )
+            elif variant:
+                config = ConfigManager.client.configs.get_config(
+                    base_id=singleton.base_id, config_name=variant
+                )
+        except Exception as ex:
+            logger.error(
+                "Failed to pull the configuration from the server with error: %s",
+                str(ex),
+            )
+
+        try:
+            result = schema(**config.parameters)
+        except ValidationError as ex:
+            logger.error("Failed to validate the configuration with error: %s", str(ex))
+            raise
+        return result
+
+    @staticmethod
+    def get_from_yaml(filename: str, schema: Type[T]) -> T:
+        """
+        Loads configuration from a YAML file and returns a config object.
+
+        Args:
+            filename (str): The name of the YAML file to load.
+            schema (Type[T]): A Pydantic model class that defines the structure of the configuration.
+
+        Returns:
+            T: An instance of the specified schema populated with the configuration data.
+
+        Raises:
+            FileNotFoundError: If the specified file doesn't exist.
+            ValidationError: If the loaded configuration data doesn't match the schema.
+        """
+        file_path = Path(filename)
+        if not file_path.exists():
+            raise FileNotFoundError(f"Config file not found: {filename}")
+
+        with open(file_path, "r") as file:
+            config_data = yaml.safe_load(file)
+
+        try:
+            return schema(**config_data)
+        except ValidationError as ex:
+            logger.error(
+                f"Failed to validate the configuration from {filename} with error: {str(ex)}"
+            )
+            raise
+
+    @staticmethod
+    def get_from_json(filename: str, schema: Type[T]) -> T:
+        """
+        Loads configuration from a JSON file and returns a config object.
+
+        Args:
+            filename (str): The name of the JSON file to load.
+            schema (Type[T]): A Pydantic model class that defines the structure of the configuration.
+
+        Returns:
+            T: An instance of the specified schema populated with the configuration data.
+
+        Raises:
+            FileNotFoundError: If the specified file doesn't exist.
+            ValidationError: If the loaded configuration data doesn't match the schema.
+        """
+        file_path = Path(filename)
+        if not file_path.exists():
+            raise FileNotFoundError(f"Config file not found: {filename}")
+
+        with open(file_path, "r") as file:
+            config_data = json.load(file)
+
+        try:
+            return schema(**config_data)
+        except ValidationError as ex:
+            logger.error(
+                f"Failed to validate the configuration from {filename} with error: {str(ex)}"
+            )
+            raise

agenta/sdk/decorators/llm_entrypoint.py

@@ -1,5 +1,6 @@
 """The code for the Agenta SDK"""
 
+from agenta.sdk.utils.debug import debug, DEBUG, SHIFT
 import os
 import sys
 import time
@@ -30,6 +31,7 @@ from agenta.sdk.types import (
     InFile,
     IntParam,
     MultipleChoiceParam,
+    MultipleChoice,
     GroupedMultipleChoiceParam,
     TextParam,
     MessagesInput,
@@ -37,8 +39,16 @@ from agenta.sdk.types import (
     BaseResponse,
     BinaryParam,
 )
+import pydantic
+
+from pydantic import BaseModel
+from typing import Type
+from annotated_types import Ge, Le, Gt, Lt
 
 from pydantic import BaseModel, HttpUrl
+import contextvars
+from contextlib import contextmanager
+
 
 app = FastAPI()
 
@@ -56,11 +66,31 @@ app.add_middleware(
 
 app.include_router(router, prefix="")
 
-from agenta.sdk.utils.debug import debug, DEBUG, SHIFT
-
 
 logging.setLevel("DEBUG")
 
+route_context = contextvars.ContextVar("route_context", default={})
+
+
+@contextmanager
+def route_context_manager(
+    config: Optional[Dict[str, Any]] = None,
+    environment: Optional[str] = None,
+    version: Optional[str] = None,
+    variant: Optional[str] = None,
+):
+    context = {
+        "config": config,
+        "environment": environment,
+        "version": version,
+        "variant": variant,
+    }
+    token = route_context.set(context)
+    try:
+        yield
+    finally:
+        route_context.reset(token)
+
 
 class PathValidator(BaseModel):
     url: HttpUrl
@@ -72,16 +102,18 @@ class route(BaseDecorator):
     # the @entrypoint decorator, which has certain limitations. By using @route(), we can create new
     # routes without altering the main workflow entrypoint. This helps in modularizing the services
     # and provides flexibility in how we expose different functionalities as APIs.
-    def __init__(self, path):
-        path = "/" + path.strip("/").strip()
-        path = "" if path == "/" else path
-
+    def __init__(self, path, config_schema: BaseModel):
+        self.config_schema: BaseModel = config_schema
+        if path != "" and path[0] != "/":
+            path = "/" + path
         PathValidator(url=f"http://example.com{path}")
 
         self.route_path = path
 
     def __call__(self, f):
-        self.e = entrypoint(f, route_path=self.route_path)
+        self.e = entrypoint(
+            f, route_path=self.route_path, config_schema=self.config_schema
+        )
 
         return f
 
@@ -119,15 +151,29 @@ class entrypoint(BaseDecorator):
 
     routes = list()
 
-    def __init__(self, func: Callable[..., Any], route_path=""):
+    def __init__(
+        self, func: Callable[..., Any], route_path="", config_schema: BaseModel = None
+    ):
         logging.info(f"Using Agenta Python SDK version {version('agenta')}")
 
         DEFAULT_PATH = "generate"
         PLAYGROUND_PATH = "/playground"
         RUN_PATH = "/run"
-
         func_signature = inspect.signature(func)
-        config_params = ag.config.all()
+        try:
+            config = (
+                config_schema() if config_schema else None
+            )  # we initialize the config object to be able to use it
+        except pydantic.ValidationError as e:
+            raise ValueError(
+                f"Error initializing config_schema. Please ensure all required fields have default values: {str(e)}"
+            ) from e
+        except Exception as e:
+            raise ValueError(
+                f"Unexpected error initializing config_schema: {str(e)}"
+            ) from e
+
+        config_params = config.dict() if config else ag.config.all()
         ingestible_files = self.extract_ingestible_files(func_signature)
 
         ### --- Playground  --- #
@@ -136,36 +182,44 @@ class entrypoint(BaseDecorator):
         async def wrapper(*args, **kwargs) -> Any:
             func_params, api_config_params = self.split_kwargs(kwargs, config_params)
             self.ingest_files(func_params, ingestible_files)
-            ag.config.set(**api_config_params)
+            if not config_schema:
+                ag.config.set(**api_config_params)
 
             # Set the configuration and environment of the LLM app parent span at run-time
             ag.tracing.update_baggage(
                 {"config": config_params, "environment": "playground"}
             )
-
-            entrypoint_result = await self.execute_function(
-                func,
-                True,  # inline trace: True
-                *args,
-                params=func_params,
-                config_params=config_params,
-            )
+            with route_context_manager(config=api_config_params):
+                entrypoint_result = await self.execute_function(
+                    func,
+                    True,  # inline trace: True
+                    *args,
+                    params=func_params,
+                    config_params=config_params,
+                )
 
             return entrypoint_result
 
         self.update_function_signature(
-            wrapper, func_signature, config_params, ingestible_files
+            wrapper=wrapper,
+            func_signature=func_signature,
+            config_class=config,
+            config_dict=config_params,
+            ingestible_files=ingestible_files,
         )
 
         #
-        if route_path == "":
+        if route_path == "" or route_path == "/":
             route = f"/{DEFAULT_PATH}"
             app.post(route, response_model=BaseResponse)(wrapper)
             entrypoint.routes.append(
                 {
                     "func": func.__name__,
                     "endpoint": route,
-                    "params": {**config_params, **func_signature.parameters},
+                    "params": {**config_params, **func_signature.parameters}
+                    if not config
+                    else func_signature.parameters,
+                    "config": config,
                 }
             )
 
@@ -175,7 +229,10 @@ class entrypoint(BaseDecorator):
             {
                 "func": func.__name__,
                 "endpoint": route,
-                "params": {**config_params, **func_signature.parameters},
+                "params": {**config_params, **func_signature.parameters}
+                if not config
+                else func_signature.parameters,
+                "config": config,
             }
         )
         ### ---------------------------- #
@@ -187,26 +244,28 @@ class entrypoint(BaseDecorator):
             func_params = {
                 k: v for k, v in kwargs.items() if k not in ["config", "environment"]
             }
-
-            if "environment" in kwargs and kwargs["environment"] is not None:
-                ag.config.pull(environment_name=kwargs["environment"])
-            elif "config" in kwargs and kwargs["config"] is not None:
-                ag.config.pull(config_name=kwargs["config"])
-            else:
-                ag.config.pull(config_name="default")
+            if not config_schema:
+                if "environment" in kwargs and kwargs["environment"] is not None:
+                    ag.config.pull(environment_name=kwargs["environment"])
+                elif "config" in kwargs and kwargs["config"] is not None:
+                    ag.config.pull(config_name=kwargs["config"])
+                else:
+                    ag.config.pull(config_name="default")
 
             # Set the configuration and environment of the LLM app parent span at run-time
             ag.tracing.update_baggage(
                 {"config": config_params, "environment": kwargs["environment"]}
             )
-
-            entrypoint_result = await self.execute_function(
-                func,
-                False,  # inline trace: False
-                *args,
-                params=func_params,
-                config_params=config_params,
-            )
+            with route_context_manager(
+                variant=kwargs["config"], environment=kwargs["environment"]
+            ):
+                entrypoint_result = await self.execute_function(
+                    func,
+                    False,  # inline trace: False
+                    *args,
+                    params=func_params,
+                    config_params=config_params,
+                )
 
             return entrypoint_result
 
@@ -215,8 +274,7 @@ class entrypoint(BaseDecorator):
             func_signature,
             ingestible_files,
         )
-
-        if route_path == "":
+        if route_path == "" or route_path == "/":
             route_deployed = f"/{DEFAULT_PATH}_deployed"
             app.post(route_deployed, response_model=BaseResponse)(wrapper_deployed)
 
@@ -231,11 +289,18 @@ class entrypoint(BaseDecorator):
         for route in entrypoint.routes:
             self.override_schema(
                 openapi_schema=openapi_schema,
-                func=route["func"],
+                func_name=route["func"],
                 endpoint=route["endpoint"],
                 params=route["params"],
             )
-        ### ---------------------- #
+            if route["config"] is not None:  # new SDK version
+                self.override_config_in_schema(
+                    openapi_schema=openapi_schema,
+                    func_name=route["func"],
+                    endpoint=route["endpoint"],
+                    config=route["config"],
+                )
+
         if self.is_main_script(func) and route_path == "":
             self.handle_terminal_run(
                 func,
@@ -393,13 +458,17 @@ class entrypoint(BaseDecorator):
         self,
         wrapper: Callable[..., Any],
         func_signature: inspect.Signature,
-        config_params: Dict[str, Any],
+        config_class: Type[BaseModel],  # TODO: change to our type
+        config_dict: Dict[str, Any],
         ingestible_files: Dict[str, inspect.Parameter],
     ) -> None:
         """Update the function signature to include new parameters."""
 
         updated_params: List[inspect.Parameter] = []
-        self.add_config_params_to_parser(updated_params, config_params)
+        if config_class:
+            self.add_config_params_to_parser(updated_params, config_class)
+        else:
+            self.depracated_add_config_params_to_parser(updated_params, config_dict)
         self.add_func_params_to_parser(updated_params, func_signature, ingestible_files)
         self.update_wrapper_signature(wrapper, updated_params)
 
@@ -419,8 +488,8 @@ class entrypoint(BaseDecorator):
         ]:  # we add the config and environment parameters
             updated_params.append(
                 inspect.Parameter(
-                    param,
-                    inspect.Parameter.KEYWORD_ONLY,
+                    name=param,
+                    kind=inspect.Parameter.KEYWORD_ONLY,
                     default=Body(None),
                     annotation=str,
                 )
@@ -428,17 +497,32 @@ class entrypoint(BaseDecorator):
         self.update_wrapper_signature(wrapper, updated_params)
 
     def add_config_params_to_parser(
-        self, updated_params: list, config_params: Dict[str, Any]
+        self, updated_params: list, config_class: Type[BaseModel]
     ) -> None:
         """Add configuration parameters to function signature."""
-        for name, param in config_params.items():
+        for name, field in config_class.__fields__.items():
+            assert field.default is not None, f"Field {name} has no default value"
+            updated_params.append(
+                inspect.Parameter(
+                    name=name,
+                    kind=inspect.Parameter.KEYWORD_ONLY,
+                    annotation=field.annotation.__name__,
+                    default=Body(field.default),
+                )
+            )
+
+    def depracated_add_config_params_to_parser(
+        self, updated_params: list, config_dict: Dict[str, Any]
+    ) -> None:
+        """Add configuration parameters to function signature."""
+        for name, param in config_dict.items():
             assert (
                 len(param.__class__.__bases__) == 1
             ), f"Inherited standard type of {param.__class__} needs to be one."
             updated_params.append(
                 inspect.Parameter(
-                    name,
-                    inspect.Parameter.KEYWORD_ONLY,
+                    name=name,
+                    kind=inspect.Parameter.KEYWORD_ONLY,
                     default=Body(param),
                     annotation=param.__class__.__bases__[
                         0
@@ -546,10 +630,17 @@ class entrypoint(BaseDecorator):
                 file_path=args_func_params[name],
             )
 
-        ag.config.set(**args_config_params)
+        # Update args_config_params with default values from config_params if not provided in command line arguments
+        args_config_params.update(
+            {
+                key: value
+                for key, value in config_params.items()
+                if key not in args_config_params
+            }
+        )
 
         # Set the configuration and environment of the LLM app parent span at run-time
-        ag.tracing.update_baggage({"config": ag.config.all(), "environment": "bash"})
+        ag.tracing.update_baggage({"config": args_config_params, "environment": "bash"})
 
         loop = asyncio.get_event_loop()
 
@@ -561,15 +652,92 @@ class entrypoint(BaseDecorator):
             )
         )
 
-        print(f"\n========== Result ==========\n")
+        print("\n========== Result ==========\n")
 
         print("-> data")
         print(json.dumps(result.data, indent=2))
         print("-> trace")
         print(json.dumps(result.trace, indent=2))
 
+        with open("trace.json", "w") as trace_file:
+            json.dump(result.trace, trace_file, indent=4)
+
+    def override_config_in_schema(
+        self,
+        openapi_schema: dict,
+        func_name: str,
+        endpoint: str,
+        config: Type[BaseModel],
+    ):
+        endpoint = endpoint[1:].replace("/", "_")
+        schema_to_override = openapi_schema["components"]["schemas"][
+            f"Body_{func_name}_{endpoint}_post"
+        ]["properties"]
+        # New logic
+        for param_name, param_val in config.__fields__.items():
+            if param_val.annotation is str:
+                if any(
+                    isinstance(constraint, MultipleChoice)
+                    for constraint in param_val.metadata
+                ):
+                    choices = next(
+                        constraint.choices
+                        for constraint in param_val.metadata
+                        if isinstance(constraint, MultipleChoice)
+                    )
+                    if isinstance(choices, dict):
+                        schema_to_override[param_name]["x-parameter"] = "grouped_choice"
+                        schema_to_override[param_name]["choices"] = choices
+                    elif isinstance(choices, list):
+                        schema_to_override[param_name]["x-parameter"] = "choice"
+                        schema_to_override[param_name]["enum"] = choices
+                else:
+                    schema_to_override[param_name]["x-parameter"] = "text"
+            if param_val.annotation is bool:
+                schema_to_override[param_name]["x-parameter"] = "bool"
+            if param_val.annotation in (int, float):
+                schema_to_override[param_name]["x-parameter"] = (
+                    "int" if param_val.annotation is int else "float"
+                )
+                # Check for greater than or equal to constraint
+                if any(isinstance(constraint, Ge) for constraint in param_val.metadata):
+                    min_value = next(
+                        constraint.ge
+                        for constraint in param_val.metadata
+                        if isinstance(constraint, Ge)
+                    )
+                    schema_to_override[param_name]["minimum"] = min_value
+                # Check for greater than constraint
+                elif any(
+                    isinstance(constraint, Gt) for constraint in param_val.metadata
+                ):
+                    min_value = next(
+                        constraint.gt
+                        for constraint in param_val.metadata
+                        if isinstance(constraint, Gt)
+                    )
+                    schema_to_override[param_name]["exclusiveMinimum"] = min_value
+                # Check for less than or equal to constraint
+                if any(isinstance(constraint, Le) for constraint in param_val.metadata):
+                    max_value = next(
+                        constraint.le
+                        for constraint in param_val.metadata
+                        if isinstance(constraint, Le)
+                    )
+                    schema_to_override[param_name]["maximum"] = max_value
+                # Check for less than constraint
+                elif any(
+                    isinstance(constraint, Lt) for constraint in param_val.metadata
+                ):
+                    max_value = next(
+                        constraint.lt
+                        for constraint in param_val.metadata
+                        if isinstance(constraint, Lt)
+                    )
+                    schema_to_override[param_name]["exclusiveMaximum"] = max_value
+
     def override_schema(
-        self, openapi_schema: dict, func: str, endpoint: str, params: dict
+        self, openapi_schema: dict, func_name: str, endpoint: str, params: dict
     ):
         """
         Overrides the default openai schema generated by fastapi with additional information about:
@@ -641,7 +809,7 @@ class entrypoint(BaseDecorator):
         endpoint = endpoint[1:].replace("/", "_")
 
         schema_to_override = openapi_schema["components"]["schemas"][
-            f"Body_{func}_{endpoint}_post"
+            f"Body_{func_name}_{endpoint}_post"
         ]["properties"]
 
         for param_name, param_val in params.items():

agenta/sdk/types.py

@@ -2,6 +2,13 @@ import json
 from typing import Dict, List, Optional, Any, Union
 
 from pydantic import ConfigDict, BaseModel, HttpUrl
+from dataclasses import dataclass
+from typing import Union
+
+
+@dataclass
+class MultipleChoice:
+    choices: Union[List[str], Dict[str, List[str]]]
 
 
 class InFile:

{agenta-0.20.0a13.dist-info → agenta-0.21.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: agenta
-Version: 0.20.0a13
+Version: 0.21.0a1
 Summary: The SDK for agenta is an open-source LLMOps platform.
 Home-page: https://agenta.ai
 Keywords: LLMOps,LLM,evaluation,prompt engineering
@@ -27,6 +27,7 @@ Requires-Dist: pydantic (>=2)
 Requires-Dist: pymongo (>=4.6.3,<5.0.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Requires-Dist: python-multipart (>=0.0.6,<0.0.10)
+Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
 Requires-Dist: questionary (>=1.10,<3.0)
 Requires-Dist: toml (>=0.10.2,<0.11.0)
 Project-URL: Documentation, https://docs.agenta.ai

{agenta-0.20.0a13.dist-info → agenta-0.21.0a1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-agenta/__init__.py,sha256=nL_Fogmx_64xS--WjhE4gE_0h5LIJDbDGKpjZoNJ9oI,894
+agenta/__init__.py,sha256=xTGdwyG08dOtbW_jZNMQ7fXwxeZnIIFXdYEnJfSBW8s,959
 agenta/cli/evaluation_commands.py,sha256=fs6492tprPId9p8eGO02Xy-NCBm2RZNJLZWcUxugwd8,474
 agenta/cli/helper.py,sha256=vRxHyeNaltzNIGrfU2vO0H28_rXDzx9QqIZ_S-W6zL4,6212
 agenta/cli/main.py,sha256=Wz0ODhoeKK3Qg_CFUhu6D909szk05tc8ZVBB6H1-w7k,9763
@@ -125,13 +125,14 @@ agenta/docker/docker-assets/README.md,sha256=XHxwh2ks_ozrtAU7SLbL3J14SB2holG6buo
 agenta/docker/docker-assets/entrypoint.sh,sha256=29XK8VQjQsx4hN2j-4JDy-6kQb5y4LCqZEa7PD4eqCQ,74
 agenta/docker/docker-assets/lambda_function.py,sha256=h4UZSSfqwpfsCgERv6frqwm_4JrYu9rLz3I-LxCfeEg,83
 agenta/docker/docker-assets/main.py,sha256=7MI-21n81U7N7A0GxebNi0cmGWtJKcR2sPB6FcH2QfA,251
-agenta/docker/docker_utils.py,sha256=5uHMCzXkCvIsDdEiwbnnn97KkzsFbBvyMwogCsv_Z5U,3509
-agenta/sdk/__init__.py,sha256=ewYNjm6AHlqkIrPfX2D_pXZMwShOdhEUcWXb7xGA2bk,769
+agenta/docker/docker_utils.py,sha256=kO1q2_IR0fEAo4M-2Pt_v-zC7GxxnkLogjKFhU869Ps,3555
+agenta/sdk/__init__.py,sha256=XyxMUm8-fCH6G6KAFU0iAfiKTGEzNzBtbAfCp9i1Y7o,831
 agenta/sdk/agenta_init.py,sha256=8MfDuypxohd0qRTdtGjX7L17KW-1UGmzNVdiqF15_ak,9790
 agenta/sdk/client.py,sha256=trKyBOYFZRk0v5Eptxvh87yPf50Y9CqY6Qgv4Fy-VH4,2142
+agenta/sdk/config_manager.py,sha256=D4VhCvoDe65IhMYSiNzdmcQSvc32ho9lovxpAPFHIiE,8011
 agenta/sdk/context.py,sha256=q-PxL05-I84puunUAs9LGsffEXcYhDxhQxjuOz2vK90,901
 agenta/sdk/decorators/base.py,sha256=9aNdX5h8a2mFweuhdO-BQPwXGKY9ONPIdLRhSGAGMfY,217
-agenta/sdk/decorators/llm_entrypoint.py,sha256=9GFT6dpVWY2_1Ckh1Y_N0xSXwosoSjtNtqMEM7u55uY,28224
+agenta/sdk/decorators/llm_entrypoint.py,sha256=38l7S17HH09gO_t7A8Qwd2m8_Ldk8BFBknK7aKWeelU,35483
 agenta/sdk/decorators/tracing.py,sha256=e0olx2EEdjXY0NqpIoDJSVxCnUmv0woewTUuCJXy2tM,4166
 agenta/sdk/router.py,sha256=0sbajvn5C7t18anH6yNo7-oYxldHnYfwcbmQnIXBePw,269
 agenta/sdk/tracing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -140,7 +141,7 @@ agenta/sdk/tracing/llm_tracing.py,sha256=FfZQcID-8E4G0R34H29SA05yFUNDMEPccb4MqVc
 agenta/sdk/tracing/logger.py,sha256=GfH7V-jBHcn7h5dbdrnkDMe_ml3wkXFBeoQiqR4KVRc,474
 agenta/sdk/tracing/tasks_manager.py,sha256=FBSFOWIKBycyA4ShB2ZVMzrzYQ8pWGWWBClFX8nlZFA,3726
 agenta/sdk/tracing/tracing_context.py,sha256=nt3ewa-TK9BRJviGIZYazsAQUiG4daWxjtsbjeaDprs,789
-agenta/sdk/types.py,sha256=DSsKtoYh1ka_ketfkN10F0v8Oe2O4BB0WfnTkdIEyxE,5773
+agenta/sdk/types.py,sha256=1AXUKTURFFgPH5iWeTYcNcg6dxVo1RrD0WuVe9e-NgU,5919
 agenta/sdk/utils/debug.py,sha256=QyuPsSoN0425UD13x_msPxSF_VT6YwHiQunZUibI-jg,2149
 agenta/sdk/utils/globals.py,sha256=JmhJcCOSbwvjQ6GDyUc2_SYR27DZk7YcrRH80ktHHOM,435
 agenta/sdk/utils/helper/openai_cost.py,sha256=1VkgvucDnNZm1pTfcVLz9icWunntp1d7zwMmnviy3Uw,5877
@@ -160,7 +161,7 @@ agenta/templates/simple_prompt/app.py,sha256=kODgF6lhzsaJPdgL5b21bUki6jkvqjWZzWR
 agenta/templates/simple_prompt/env.example,sha256=g9AE5bYcGPpxawXMJ96gh8oenEPCHTabsiOnfQo3c5k,70
 agenta/templates/simple_prompt/requirements.txt,sha256=ywRglRy7pPkw8bljmMEJJ4aOOQKrt9FGKULZ-DGkoBU,23
 agenta/templates/simple_prompt/template.toml,sha256=DQBtRrF4GU8LBEXOZ-GGuINXMQDKGTEG5y37tnvIUIE,60
-agenta-0.20.0a13.dist-info/METADATA,sha256=oJVH3pqpuNq7If3Mhg9s6_4ZqYo-wNbF5IjFWIxYQvo,26463
-agenta-0.20.0a13.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-agenta-0.20.0a13.dist-info/entry_points.txt,sha256=PDiu8_8AsL7ibU9v4iNoOKR1S7F2rdxjlEprjM9QOgo,46
-agenta-0.20.0a13.dist-info/RECORD,,
+agenta-0.21.0a1.dist-info/METADATA,sha256=g-T2aQrTVGXMV5YNnX4nf2cKLGdyk6Dq39IBGLk3SU4,26501
+agenta-0.21.0a1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+agenta-0.21.0a1.dist-info/entry_points.txt,sha256=PDiu8_8AsL7ibU9v4iNoOKR1S7F2rdxjlEprjM9QOgo,46
+agenta-0.21.0a1.dist-info/RECORD,,