weni-cli 3.7.0a0__tar.gz → 3.7.2__tar.gz

{weni_cli-3.7.0a0 → weni_cli-3.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: weni-cli
-Version: 3.7.0a0
+Version: 3.7.2
 Summary: 
 Author: Paulo Bernardo
 Author-email: paulo.bernardo@weni.ai
@@ -20,7 +20,7 @@ Requires-Dist: rich (>=13.9.4,<14.0.0)
 Requires-Dist: rich-click (>=1.8.6,<2.0.0)
 Requires-Dist: waitress (>=3.0.2,<4.0.0)
 Requires-Dist: weni-agenteval (>=1.1.0,<2.0.0)
-Requires-Dist: weni-agents-toolkit (==2.6.4a0)
+Requires-Dist: weni-agents-toolkit (==2.6.4)
 Description-Content-Type: text/markdown
 
 # Weni-CLI

{weni_cli-3.7.0a0 → weni_cli-3.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "weni-cli"
-version = "3.7.0a0"
+version = "3.7.2"
 description = ""
 authors = ["Paulo Bernardo <paulo.bernardo@weni.ai>", "Matheus Leal <matheus.cardoso@vtex.com>"]
 readme = "README.md"
@@ -14,7 +14,7 @@ waitress = "^3.0.2"
 pyyaml = "^6.0.2"
 python-slugify = "^8.0.4"
 regex = "^2024.11.6"
-weni-agents-toolkit = "2.6.4a0"
+weni-agents-toolkit = "2.6.4"
 rich-click = "^1.8.6"
 rich = "^13.9.4"
 weni-agenteval = "^1.1.0"

{weni_cli-3.7.0a0 → weni_cli-3.7.2}/weni_cli/cli.py

@@ -101,7 +101,9 @@ def current_project():
 @project.command("push")
 @click.argument("definition", required=True, type=click.Path(exists=True, dir_okay=False))
 @click.option("--force-update", is_flag=True, help="Force update to the project")
-def push_project(definition, force_update):
+@click.option("--use-apm", is_flag=True, help="Enable Elastic APM instrumentation for passive agent tool lambdas")
+@click.option("--remove-apm", is_flag=True, help="Remove Elastic APM instrumentation from passive agent tool lambdas")
+def push_project(definition, force_update, use_apm, remove_apm):
     """Push an Agent definition to the current project
 
     DEFINITION: The path to the YAML agent definition file
@@ -109,7 +111,12 @@ def push_project(definition, force_update):
     from weni_cli.commands.project_push import ProjectPushHandler
 
     try:
-        ProjectPushHandler().execute(definition=definition, force_update=force_update)
+        ProjectPushHandler().execute(
+            definition=definition,
+            force_update=force_update,
+            use_apm=use_apm,
+            remove_apm=remove_apm,
+        )
     except Exception as e:
         click.echo(f"Error: {e}")
 

{weni_cli-3.7.0a0 → weni_cli-3.7.2}/weni_cli/clients/cli_client.py

@@ -50,15 +50,22 @@ def get_cli_version() -> str:
     return importlib.metadata.version("weni-cli")
 
 
-def create_default_payload(project_uuid: str, definition: Dict, agent_type: str) -> Dict[str, str]:
+def create_default_payload(
+    project_uuid: str, definition: Dict, agent_type: str, apm_instrumentation: Optional[str] = None
+) -> Dict[str, str]:
     """Create a default payload for API requests."""
-    return {
+    payload = {
         "project_uuid": project_uuid,
         "definition": json.dumps(definition, ensure_ascii=False),
         "toolkit_version": get_toolkit_version(),
         "type": agent_type,
     }
 
+    if apm_instrumentation:
+        payload["apm_instrumentation"] = apm_instrumentation
+
+    return payload
+
 
 class CLIClient:
     """Client for interacting with the Weni CLI API."""
@@ -179,10 +186,15 @@ class CLIClient:
             raise RequestError(f"Failed to check project permission: {e.message}")
 
     def push_agents(
-        self, project_uuid: str, agents_definition: Dict, resources_folder: Dict[str, BinaryIO], agent_type: str
+        self,
+        project_uuid: str,
+        agents_definition: Dict,
+        resources_folder: Dict[str, BinaryIO],
+        agent_type: str,
+        apm_instrumentation: Optional[str] = None,
     ) -> None:
         """Push agents to the API."""
-        data = create_default_payload(project_uuid, agents_definition, agent_type)
+        data = create_default_payload(project_uuid, agents_definition, agent_type, apm_instrumentation)
 
         with spinner():
             try:

{weni_cli-3.7.0a0 → weni_cli-3.7.2}/weni_cli/commands/project_push.py

@@ -19,12 +19,36 @@ from weni_cli.validators.agent_definition import (
 
 CONTACT_FIELD_NAME_REGEX = r"^[a-z][a-z0-9_]*$"
 
+APM_OBSERVABILITY_WARNING = (
+    "Use Elastic APM instrumentation only for observability—for example, while debugging or "
+    "investigating an issue. APM adds Lambda layers and environment variables that increase cold "
+    "start time and runtime overhead.\n\n"
+    "When you no longer need it, disable instrumentation with:\n"
+    "  weni project push <definition> --remove-apm"
+)
+
 
 class ProjectPushHandler(Handler):
     def execute(self, **kwargs):
         force_update = self.load_param(kwargs, "force_update", False)
+        use_apm = self.load_param(kwargs, "use_apm", False)
+        remove_apm = self.load_param(kwargs, "remove_apm", False)
         definition_path = self.load_param(kwargs, "definition", None, True)
 
+        if use_apm and remove_apm:
+            formatter = Formatter()
+            formatter.print_error_panel(
+                "Cannot use --use-apm and --remove-apm together. Choose one option.",
+                title="Invalid APM options",
+            )
+            return
+
+        apm_instrumentation = None
+        if use_apm:
+            apm_instrumentation = "enabled"
+        elif remove_apm:
+            apm_instrumentation = "disabled"
+
         store = Store()
         project_uuid = store.get(STORE_PROJECT_UUID_KEY)
 
@@ -55,11 +79,11 @@ class ProjectPushHandler(Handler):
             return
 
         if agent_type == "passive":
-            self.push_passive_agent(force_update, project_uuid, definition_data)
+            self.push_passive_agent(force_update, project_uuid, definition_data, apm_instrumentation)
         elif agent_type == "active":
-            self.push_active_agent(force_update, project_uuid, definition_data)
+            self.push_active_agent(force_update, project_uuid, definition_data, apm_instrumentation)
 
-    def push_passive_agent(self, force_update, project_uuid, definition):
+    def push_passive_agent(self, force_update, project_uuid, definition, apm_instrumentation=None):
         formatter = Formatter()
         error = validate_agent_definition_schema(definition)
         if error:
@@ -74,9 +98,9 @@ class ProjectPushHandler(Handler):
             return
 
         definition = format_definition(definition)
-        self.push_definition(force_update, "passive", project_uuid, definition, tools_folders_map)
+        self.push_definition(force_update, "passive", project_uuid, definition, tools_folders_map, apm_instrumentation)
 
-    def push_active_agent(self, force_update, project_uuid, definition):
+    def push_active_agent(self, force_update, project_uuid, definition, apm_instrumentation=None):
         formatter = Formatter()
         error = validate_active_agent_definition_schema(definition)
         if error:
@@ -98,7 +122,7 @@ class ProjectPushHandler(Handler):
         rules_folders_map.update(preprocessing_folders_map)
         resources_folders_map = rules_folders_map
         definition = format_definition(definition)
-        self.push_definition(force_update, "active", project_uuid, definition, resources_folders_map)
+        self.push_definition(force_update, "active", project_uuid, definition, resources_folders_map, None)
 
     def load_param(self, params, key, default=None, required=False):
         value = params.get(key, default)
@@ -115,13 +139,19 @@ class ProjectPushHandler(Handler):
     def load_preprocessing_folder(self, definition) -> tuple[Optional[dict], Optional[str]]:
         return _load_preprocessing_folder(definition)
 
-    def push_definition(self, force_update, agent_type, project_uuid, definition, resources_folder_map):
+    def push_definition(
+        self, force_update, agent_type, project_uuid, definition, resources_folder_map, apm_instrumentation=None
+    ):
         client = CLIClient()
+        formatter = Formatter()
 
         try:
-            client.push_agents(project_uuid, definition, resources_folder_map, agent_type)
+            client.push_agents(
+                project_uuid, definition, resources_folder_map, agent_type, apm_instrumentation=apm_instrumentation
+            )
         except Exception as e:
-            formatter = Formatter()
             formatter.print_error_panel(f"Failed to push definition: {e}")
         else:
             click.echo("Definition pushed successfully")
+            if apm_instrumentation == "enabled":
+                formatter.print_warning_panel(APM_OBSERVABILITY_WARNING, title="APM instrumentation enabled")

{weni_cli-3.7.0a0 → weni_cli-3.7.2}/weni_cli/commands/run.py

@@ -18,7 +18,9 @@ from weni_cli.validators.agent_definition import (
     format_definition,
     load_agent_definition,
     load_test_definition,
+    validate_active_agent_definition_schema,
     validate_active_test_definition,
+    validate_agent_definition_schema,
 )
 
 DEFAULT_TEST_DEFINITION_FILE = "test_definition.yaml"
@@ -94,6 +96,18 @@ class RunHandler(Handler):
 
         agent_type = detect_agent_type(definition_data)
 
+        schema_validator = (
+            validate_active_agent_definition_schema
+            if agent_type == ACTIVE_TYPE
+            else validate_agent_definition_schema
+        )
+        if validation_error := schema_validator(definition_data):
+            formatter.print_error_panel(
+                f"Invalid agent definition YAML file format, error:\n{validation_error}",
+                title="Failed to load definition file",
+            )
+            return
+
         if agent_type == ACTIVE_TYPE:
             self._execute_active(
                 definition_data=definition_data,

{weni_cli-3.7.0a0 → weni_cli-3.7.2}/weni_cli/formatter/formatter.py

@@ -32,3 +32,14 @@ class Formatter:
             expand=False,
         )
         print(success_panel)
+
+    def print_warning_panel(self, message, title="Warning"):
+        warning_panel = Panel(
+            self._to_renderable(message),
+            title=f"[bold yellow]{title}[/bold yellow]",
+            title_align="left",
+            style="bold yellow",
+            expand=False,
+            padding=(1, 1),
+        )
+        print(warning_panel)

{weni_cli-3.7.0a0 → weni_cli-3.7.2}/weni_cli/formatter/tests/test_formatter.py

@@ -53,6 +53,24 @@ def test_print_success_panel(formatter, mocker):
     assert panel_arg.expand is False
 
 
+def test_print_warning_panel(formatter, mocker):
+    """Test the warning panel creation and printing."""
+    mock_print = mocker.patch("weni_cli.formatter.formatter.print")
+
+    warning_message = "This is a warning message"
+
+    formatter.print_warning_panel(warning_message, title="Custom warning")
+
+    mock_print.assert_called_once()
+
+    panel_arg = mock_print.call_args[0][0]
+    assert isinstance(panel_arg, Panel)
+    assert panel_arg.title == "[bold yellow]Custom warning[/bold yellow]"
+    assert panel_arg.renderable == warning_message
+    assert panel_arg.style == "bold yellow"
+    assert panel_arg.expand is False
+
+
 def test_print_error_panel_with_exception(formatter, mocker):
     """Test printing an error panel with an exception object."""
     mock_print = mocker.patch("weni_cli.formatter.formatter.print")

{weni_cli-3.7.0a0 → weni_cli-3.7.2}/weni_cli/validators/agent_definition.py

@@ -5,6 +5,8 @@ import yaml
 
 from slugify import slugify
 
+from weni_cli.validators.source import validate_entrypoint
+
 MIN_INSTRUCTION_LENGTH = 40
 MIN_GUARDRAIL_LENGTH = 40
 MAX_AGENT_NAME_LENGTH = 55
@@ -174,6 +176,13 @@ def validate_agent_definition_schema(data):
             if not isinstance(tool_data["source"]["entrypoint"], str):
                 return f"Agent '{agent_key}': tool '{tool_name}': 'source.entrypoint' must be a string in the agent definition file"
 
+            if error := validate_entrypoint(
+                context=f"Agent '{agent_key}': tool '{tool_name}'",
+                source_path=tool_data["source"]["path"],
+                entrypoint=tool_data["source"]["entrypoint"],
+            ):
+                return error
+
             # Validate source path_test if present (must be string)
             if "path_test" in tool_data["source"] and not isinstance(tool_data["source"]["path_test"], str):
                 return f"Agent '{agent_key}': tool '{tool_name}': 'source.path_test' must be a string in the agent definition file"
@@ -419,6 +428,13 @@ def validate_active_agent_definition_schema(data):
                 if not isinstance(rule_data["source"]["entrypoint"], str):
                     return f"Agent '{agent_key}': rule '{rule_key}': 'source.entrypoint' must be a string in the agent definition file"
 
+                if error := validate_entrypoint(
+                    context=f"Agent '{agent_key}': rule '{rule_key}'",
+                    source_path=rule_data["source"]["path"],
+                    entrypoint=rule_data["source"]["entrypoint"],
+                ):
+                    return error
+
                 # Validate start_condition (required, must be a string)
                 if not rule_data.get("start_condition"):
                     return f"Agent '{agent_key}': rule '{rule_key}' is missing required field 'start_condition' in the agent definition file"
@@ -461,6 +477,13 @@ def validate_active_agent_definition_schema(data):
             if not isinstance(agent_data["pre_processing"]["source"]["entrypoint"], str):
                 return f"Agent '{agent_key}': 'pre_processing.source.entrypoint' must be a string in the agent definition file"
 
+            if error := validate_entrypoint(
+                context=f"Agent '{agent_key}': pre_processing",
+                source_path=agent_data["pre_processing"]["source"]["path"],
+                entrypoint=agent_data["pre_processing"]["source"]["entrypoint"],
+            ):
+                return error
+
             # Validate result_examples_file (required, must be a string with a .json in suffix)
             if "result_examples_file" not in agent_data["pre_processing"]:
                 return f"Agent '{agent_key}': 'pre_processing' is missing required field 'result_examples_file' in the agent definition file"

weni_cli-3.7.2/weni_cli/validators/source.py

@@ -0,0 +1,134 @@
+"""Filesystem and AST-based validation for ``source.entrypoint`` definitions.
+
+The schema validator in :mod:`weni_cli.validators.agent_definition` only checks
+type and shape of YAML fields. This module complements it by verifying that
+the ``source.path`` actually exists on disk, that the referenced module file
+is present, and that the class named in ``entrypoint`` is declared in that
+module — all without importing or executing any user code.
+"""
+
+from __future__ import annotations
+
+import ast
+import os
+from typing import Optional
+
+
+ENTRYPOINT_FORMAT = "module.ClassName"
+
+
+def _is_valid_python_identifier(name: str) -> bool:
+    return name.isidentifier()
+
+
+def _parse_entrypoint(entrypoint: str) -> Optional[tuple[str, str]]:
+    """Return ``(module, class_name)`` if entrypoint matches ``module.ClassName``.
+
+    Rules:
+    - Exactly one dot separating two non-empty parts.
+    - Both parts must be valid Python identifiers (no digits leading, no spaces).
+    """
+    if not isinstance(entrypoint, str):
+        return None
+
+    parts = entrypoint.split(".")
+    if len(parts) != 2:
+        return None
+
+    module, class_name = parts
+    if not module or not class_name:
+        return None
+
+    if not _is_valid_python_identifier(module):
+        return None
+
+    if not _is_valid_python_identifier(class_name):
+        return None
+
+    return module, class_name
+
+
+def _class_exists_in_module(module_file: str, class_name: str) -> tuple[bool, Optional[str]]:
+    """Parse ``module_file`` with AST and check whether ``class_name`` is declared.
+
+    Returns ``(found, syntax_error)``. ``syntax_error`` is set only when the
+    file cannot be parsed as Python.
+    """
+    try:
+        with open(module_file, "r", encoding="utf-8") as handle:
+            source_code = handle.read()
+    except OSError as error:
+        return False, str(error)
+
+    try:
+        tree = ast.parse(source_code, filename=module_file)
+    except SyntaxError as error:
+        return False, f"{error.msg} (line {error.lineno})"
+
+    for node in tree.body:
+        if isinstance(node, ast.ClassDef) and node.name == class_name:
+            return True, None
+
+    return False, None
+
+
+def validate_entrypoint(
+    context: str,
+    source_path: str,
+    entrypoint: str,
+    base_dir: Optional[str] = None,
+) -> Optional[str]:
+    """Validate ``entrypoint`` against the local filesystem.
+
+    Args:
+        context: Human-readable prefix for the error message (e.g.
+            ``"Agent 'cep_agent': tool 'get_address'"``).
+        source_path: Path to the resource folder, as written in the YAML.
+        entrypoint: ``module.ClassName`` string from ``source.entrypoint``.
+        base_dir: Directory to resolve relative paths against. Defaults to the
+            current working directory, matching how the packager resolves paths.
+
+    Returns:
+        ``None`` if everything checks out, otherwise a user-facing error
+        message describing the first problem encountered.
+    """
+    parsed = _parse_entrypoint(entrypoint)
+    if parsed is None:
+        return (
+            f"{context}: entrypoint '{entrypoint}' must follow the format "
+            f"'{ENTRYPOINT_FORMAT}'"
+        )
+
+    module, class_name = parsed
+
+    resolved_root = base_dir if base_dir is not None else os.getcwd()
+    resolved_source_path = (
+        source_path
+        if os.path.isabs(source_path)
+        else os.path.join(resolved_root, source_path)
+    )
+
+    if not os.path.isdir(resolved_source_path):
+        return f"{context}: source path '{source_path}' does not exist"
+
+    module_file = os.path.join(resolved_source_path, f"{module}.py")
+    if not os.path.isfile(module_file):
+        return (
+            f"{context}: module file '{source_path}{os.sep}{module}.py' not found "
+            f"for entrypoint '{entrypoint}'"
+        )
+
+    found, syntax_error = _class_exists_in_module(module_file, class_name)
+    if syntax_error is not None:
+        return (
+            f"{context}: failed to parse '{source_path}{os.sep}{module}.py' for "
+            f"entrypoint '{entrypoint}': {syntax_error}"
+        )
+
+    if not found:
+        return (
+            f"{context}: class '{class_name}' not found in "
+            f"'{source_path}{os.sep}{module}.py' for entrypoint '{entrypoint}'"
+        )
+
+    return None

weni_cli-3.7.2/weni_cli/validators/tests/conftest.py

@@ -0,0 +1,19 @@
+"""Shared fixtures for validator tests.
+
+The schema tests in :mod:`test_definition` operate on synthetic agent
+definitions and don't ship with real source paths or module files on disk.
+The newly introduced :func:`validate_entrypoint` would otherwise reject every
+one of them. Auto-mock it to ``None`` here so schema-shape tests keep their
+focus. Tests that exercise the entrypoint validator itself should import it
+directly from :mod:`weni_cli.validators.source`, which is not patched.
+"""
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def _bypass_entrypoint_validation(mocker):
+    mocker.patch(
+        "weni_cli.validators.agent_definition.validate_entrypoint",
+        return_value=None,
+    )

weni_cli-3.7.2/weni_cli/validators/tests/test_source.py

@@ -0,0 +1,156 @@
+"""Tests for :mod:`weni_cli.validators.source`.
+
+The autouse fixture in this folder's ``conftest.py`` patches
+``weni_cli.validators.agent_definition.validate_entrypoint``. The function
+under test here is imported directly from ``weni_cli.validators.source``, so
+those tests bypass the schema-level patch and exercise the real validator.
+"""
+
+from __future__ import annotations
+
+import os
+
+import pytest
+from click.testing import CliRunner
+
+from weni_cli.validators.source import (
+    ENTRYPOINT_FORMAT,
+    validate_entrypoint,
+)
+
+
+CONTEXT = "Agent 'cep_agent': tool 'get_address'"
+
+
+def _write_module(path: str, body: str) -> None:
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w") as handle:
+        handle.write(body)
+
+
+@pytest.mark.parametrize(
+    "bad_entrypoint",
+    [
+        "main",
+        "main.Foo.Bar",
+        "123.Foo",
+        ".Foo",
+        "main.",
+        "main Foo.Bar",
+        "",
+    ],
+)
+def test_invalid_entrypoint_format_is_rejected(bad_entrypoint):
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        os.makedirs("tools/get_address", exist_ok=True)
+
+        error = validate_entrypoint(CONTEXT, "tools/get_address", bad_entrypoint)
+
+        assert error is not None
+        assert ENTRYPOINT_FORMAT in error
+        assert CONTEXT in error
+
+
+def test_missing_source_path_is_rejected():
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        error = validate_entrypoint(CONTEXT, "tools/get_address", "main.GetAddress")
+
+        assert error is not None
+        assert "source path 'tools/get_address' does not exist" in error
+        assert CONTEXT in error
+
+
+def test_missing_module_file_is_rejected():
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        os.makedirs("tools/get_address", exist_ok=True)
+
+        error = validate_entrypoint(CONTEXT, "tools/get_address", "main.GetAddress")
+
+        assert error is not None
+        assert "module file" in error
+        assert "main.py" in error
+        assert CONTEXT in error
+
+
+def test_missing_class_is_rejected():
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        _write_module("tools/get_address/main.py", "class SomethingElse:\n    pass\n")
+
+        error = validate_entrypoint(CONTEXT, "tools/get_address", "main.GetAddress")
+
+        assert error is not None
+        assert "class 'GetAddress' not found" in error
+        assert CONTEXT in error
+
+
+def test_syntax_error_in_module_is_reported():
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        _write_module("tools/get_address/main.py", "class :::: pass\n")
+
+        error = validate_entrypoint(CONTEXT, "tools/get_address", "main.GetAddress")
+
+        assert error is not None
+        assert "failed to parse" in error
+        assert CONTEXT in error
+
+
+def test_happy_path_returns_none():
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        _write_module(
+            "tools/get_address/main.py",
+            "class GetAddress:\n    def execute(self, context):\n        return 'ok'\n",
+        )
+
+        assert (
+            validate_entrypoint(CONTEXT, "tools/get_address", "main.GetAddress")
+            is None
+        )
+
+
+def test_class_nested_inside_function_is_not_detected():
+    """Only top-level ``class`` declarations count, mirroring how the backend
+    imports the module to grab the entrypoint."""
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        _write_module(
+            "tools/get_address/main.py",
+            "def factory():\n    class GetAddress:\n        pass\n    return GetAddress\n",
+        )
+
+        error = validate_entrypoint(CONTEXT, "tools/get_address", "main.GetAddress")
+
+        assert error is not None
+        assert "class 'GetAddress' not found" in error
+
+
+def test_absolute_source_path_is_supported(tmp_path):
+    module_dir = tmp_path / "tools" / "get_address"
+    module_dir.mkdir(parents=True)
+    (module_dir / "main.py").write_text("class GetAddress: pass\n")
+
+    assert (
+        validate_entrypoint(CONTEXT, str(module_dir), "main.GetAddress")
+        is None
+    )
+
+
+def test_base_dir_resolves_relative_paths(tmp_path):
+    module_dir = tmp_path / "tools" / "get_address"
+    module_dir.mkdir(parents=True)
+    (module_dir / "main.py").write_text("class GetAddress: pass\n")
+
+    assert (
+        validate_entrypoint(
+            CONTEXT,
+            "tools/get_address",
+            "main.GetAddress",
+            base_dir=str(tmp_path),
+        )
+        is None
+    )