agno 2.4.6__py3-none-any.whl → 2.4.8__py3-none-any.whl

agno/os/routers/workflows/router.py

@@ -555,7 +555,13 @@ def get_workflow_router(
             db_workflows = get_workflows(db=os.db, registry=os.registry)
             if db_workflows:
                 for db_workflow in db_workflows:
-                    workflows.append(WorkflowSummaryResponse.from_workflow(workflow=db_workflow))
+                    try:
+                        workflows.append(WorkflowSummaryResponse.from_workflow(workflow=db_workflow))
+                    except Exception as e:
+                        workflow_id = getattr(db_workflow, "id", "unknown")
+                        logger.error(f"Error converting workflow {workflow_id} to response: {e}")
+                        # Continue processing other workflows even if this one fails
+                        continue
 
         return workflows
 

agno/os/schema.py

@@ -618,6 +618,7 @@ class ComponentUpdate(BaseModel):
     description: Optional[str] = None
     component_type: Optional[str] = None
     metadata: Optional[Dict[str, Any]] = None
+    current_version: Optional[int] = None
 
 
 class ConfigUpdate(BaseModel):
@@ -626,3 +627,106 @@ class ConfigUpdate(BaseModel):
     stage: Optional[str] = None
     notes: Optional[str] = None
     links: Optional[List[Dict[str, Any]]] = None
+
+
+class RegistryResourceType(str, Enum):
+    """Types of resources that can be stored in a registry."""
+
+    TOOL = "tool"
+    MODEL = "model"
+    DB = "db"
+    VECTOR_DB = "vector_db"
+    SCHEMA = "schema"
+    FUNCTION = "function"
+
+
+class CallableMetadata(BaseModel):
+    """Common metadata for callable components (tools, functions)."""
+
+    name: str = Field(..., description="Callable name")
+    description: Optional[str] = Field(None, description="Callable description")
+    class_path: str = Field(..., description="Full module path to the class/function")
+    module: Optional[str] = Field(None, description="Module where the callable is defined")
+    qualname: Optional[str] = Field(None, description="Qualified name of the callable")
+    has_entrypoint: bool = Field(..., description="Whether the callable has an executable entrypoint")
+    parameters: Dict[str, Any] = Field(default_factory=dict, description="JSON schema of parameters")
+    requires_confirmation: Optional[bool] = Field(None, description="Whether execution requires user confirmation")
+    external_execution: Optional[bool] = Field(None, description="Whether execution happens externally")
+    signature: Optional[str] = Field(None, description="Function signature string")
+    return_annotation: Optional[str] = Field(None, description="Return type annotation")
+
+
+class ToolMetadata(BaseModel):
+    """Metadata for tool registry components."""
+
+    class_path: str = Field(..., description="Full module path to the tool class")
+    is_toolkit: bool = Field(False, description="Whether this is a toolkit containing multiple functions")
+    functions: Optional[List[CallableMetadata]] = Field(
+        None, description="Functions in the toolkit (if is_toolkit=True)"
+    )
+
+    # Fields for non-toolkit tools (Function or raw callable)
+    module: Optional[str] = Field(None, description="Module where the callable is defined")
+    qualname: Optional[str] = Field(None, description="Qualified name of the callable")
+    has_entrypoint: Optional[bool] = Field(None, description="Whether the tool has an executable entrypoint")
+    parameters: Optional[Dict[str, Any]] = Field(None, description="JSON schema of parameters")
+    requires_confirmation: Optional[bool] = Field(None, description="Whether execution requires user confirmation")
+    external_execution: Optional[bool] = Field(None, description="Whether execution happens externally")
+    signature: Optional[str] = Field(None, description="Function signature string")
+    return_annotation: Optional[str] = Field(None, description="Return type annotation")
+
+
+class ModelMetadata(BaseModel):
+    """Metadata for model registry components."""
+
+    class_path: str = Field(..., description="Full module path to the model class")
+    provider: Optional[str] = Field(None, description="Model provider (e.g., openai, anthropic)")
+    model_id: Optional[str] = Field(None, description="Model identifier")
+
+
+class DbMetadata(BaseModel):
+    """Metadata for database registry components."""
+
+    class_path: str = Field(..., description="Full module path to the database class")
+    db_id: Optional[str] = Field(None, description="Database identifier")
+
+
+class VectorDbMetadata(BaseModel):
+    """Metadata for vector database registry components."""
+
+    class_path: str = Field(..., description="Full module path to the vector database class")
+    vector_db_id: Optional[str] = Field(None, description="Vector database identifier")
+    collection: Optional[str] = Field(None, description="Collection name")
+    table_name: Optional[str] = Field(None, description="Table name (for SQL-based vector stores)")
+
+
+class SchemaMetadata(BaseModel):
+    """Metadata for schema registry components."""
+
+    class_path: str = Field(..., description="Full module path to the schema class")
+    schema_: Optional[Dict[str, Any]] = Field(None, alias="schema", description="JSON schema definition")
+    schema_error: Optional[str] = Field(None, description="Error message if schema generation failed")
+
+
+class FunctionMetadata(CallableMetadata):
+    """Metadata for function registry components (workflow conditions, selectors, etc.)."""
+
+    pass
+
+
+# Union of all metadata types for type hints
+RegistryMetadata = Union[
+    ToolMetadata,
+    ModelMetadata,
+    DbMetadata,
+    VectorDbMetadata,
+    SchemaMetadata,
+    FunctionMetadata,
+]
+
+
+class RegistryContentResponse(BaseModel):
+    name: str
+    type: RegistryResourceType
+    description: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None

agno/registry/registry.py

@@ -26,6 +26,7 @@ class Registry:
     dbs: List[BaseDb] = field(default_factory=list)
     vector_dbs: List[VectorDb] = field(default_factory=list)
     schemas: List[Type[BaseModel]] = field(default_factory=list)
+    functions: List[Callable] = field(default_factory=list)
 
     @cached_property
     def _entrypoint_lookup(self) -> Dict[str, Callable]:
@@ -66,3 +67,6 @@ class Registry:
         if self.dbs:
             return next((db for db in self.dbs if db.id == db_id), None)
         return None
+
+    def get_function(self, name: str) -> Optional[Callable]:
+        return next((f for f in self.functions if f.__name__ == name), None)

agno/run/workflow.py

@@ -311,6 +311,9 @@ class ConditionExecutionCompletedEvent(BaseWorkflowRunOutputEvent):
     condition_result: Optional[bool] = None
     executed_steps: Optional[int] = None
 
+    # Which branch was executed: "if", "else", or None (condition false with no else_steps)
+    branch: Optional[str] = None
+
     # Results from executed steps
     step_results: List[StepOutput] = field(default_factory=list)
 

agno/session/workflow.py

@@ -16,7 +16,7 @@ from agno.utils.log import log_debug, logger
 
 @dataclass
 class WorkflowSession:
-    """Workflow Session V2 for pipeline-based workflows"""
+    """Workflow Session for pipeline-based workflows"""
 
     # Session UUID - this is the workflow_session_id that gets set on agents/teams
     session_id: str

agno/skills/utils.py

@@ -1,8 +1,10 @@
 """Utility functions for the skills module."""
 
 import os
+import platform
 import stat
 import subprocess
+import sys
 from dataclasses import dataclass
 from pathlib import Path
 from typing import List, Optional
@@ -41,6 +43,95 @@ def ensure_executable(file_path: Path) -> None:
         os.chmod(file_path, current_mode | stat.S_IXUSR)
 
 
+def parse_shebang(script_path: Path) -> Optional[str]:
+    """Parse the shebang line from a script file to determine the interpreter.
+
+    Handles various shebang formats:
+    - #!/usr/bin/env python3  -> "python3"
+    - #!/usr/bin/python3      -> "python3"
+    - #!/bin/bash             -> "bash"
+    - #!/usr/bin/env -S node  -> "node"
+
+    Args:
+        script_path: Path to the script file.
+
+    Returns:
+        The interpreter name (e.g., "python3", "bash") or None if no valid shebang.
+    """
+    try:
+        with open(script_path, "r", encoding="utf-8") as f:
+            first_line = f.readline().strip()
+    except (OSError, UnicodeDecodeError):
+        return None
+
+    if not first_line.startswith("#!"):
+        return None
+
+    shebang = first_line[2:].strip()
+    if not shebang:
+        return None
+
+    parts = shebang.split()
+
+    # Handle /usr/bin/env style shebangs
+    if Path(parts[0]).name == "env":
+        # Skip any flags (like -S) and get the interpreter
+        for part in parts[1:]:
+            if not part.startswith("-"):
+                return part
+        return None
+
+    # Handle direct path shebangs like #!/bin/bash or #!/usr/bin/python3
+    # Extract the basename of the path
+    interpreter_path = parts[0]
+    return Path(interpreter_path).name
+
+
+def get_interpreter_command(interpreter: str) -> List[str]:
+    """Map an interpreter name to a Windows-compatible command.
+
+    Args:
+        interpreter: The interpreter name from shebang (e.g., "python3", "bash").
+
+    Returns:
+        A list representing the command to invoke the interpreter.
+    """
+    # Normalize interpreter name
+    interpreter_lower = interpreter.lower()
+
+    # Python interpreters - use current Python executable
+    if interpreter_lower in ("python", "python3", "python2"):
+        return [sys.executable]
+
+    # Other interpreters - pass through as-is
+    # This includes: bash, sh, node, ruby, perl, etc.
+    # These need to be available in PATH on Windows
+    return [interpreter]
+
+
+def _build_windows_command(script_path: Path, args: List[str]) -> List[str]:
+    """Build the command list for executing a script on Windows.
+
+    On Windows, shebang lines are not processed by the OS, so we need to
+    parse the shebang and explicitly invoke the interpreter.
+
+    Args:
+        script_path: Path to the script file.
+        args: Arguments to pass to the script.
+
+    Returns:
+        A list representing the full command to execute.
+    """
+    interpreter = parse_shebang(script_path)
+
+    if interpreter:
+        cmd_prefix = get_interpreter_command(interpreter)
+        return [*cmd_prefix, str(script_path), *args]
+
+    # Fallback: try direct execution (may fail, but provides clear error)
+    return [str(script_path), *args]
+
+
 @dataclass
 class ScriptResult:
     """Result of a script execution."""
@@ -58,6 +149,10 @@ def run_script(
 ) -> ScriptResult:
     """Execute a script and return the result.
 
+    On Unix-like systems, scripts are executed directly using their shebang.
+    On Windows, the shebang is parsed to determine the interpreter since
+    Windows does not natively support shebang lines.
+
     Args:
         script_path: Path to the script to execute.
         args: Optional list of arguments to pass to the script.
@@ -71,8 +166,11 @@ def run_script(
         subprocess.TimeoutExpired: If script exceeds timeout.
         FileNotFoundError: If script or interpreter not found.
     """
-    ensure_executable(script_path)
-    cmd = [str(script_path), *(args or [])]
+    if platform.system() == "Windows":
+        cmd = _build_windows_command(script_path, args or [])
+    else:
+        ensure_executable(script_path)
+        cmd = [str(script_path), *(args or [])]
 
     result = subprocess.run(
         cmd,

agno/team/team.py

@@ -7094,7 +7094,7 @@ class Team:
             get_chat_history_func = get_chat_history  # type: ignore
         return Function.from_callable(get_chat_history_func, name="get_chat_history")
 
-    def _update_session_state_tool(self, session_state, session_state_updates: dict) -> str:
+    def _update_session_state_tool(self, run_context: RunContext, session_state_updates: dict) -> str:
         """
         Update the shared session state.  Provide any updates as a dictionary of key-value pairs.
         Example:
@@ -7103,6 +7103,9 @@ class Team:
         Args:
             session_state_updates (dict): The updates to apply to the shared session state. Should be a dictionary of key-value pairs.
         """
+        if run_context.session_state is None:
+            run_context.session_state = {}
+        session_state = run_context.session_state
         for key, value in session_state_updates.items():
             session_state[key] = value
 
@@ -8731,8 +8734,8 @@ class Team:
             tool_choice=config.get("tool_choice"),
             get_member_information_tool=config.get("get_member_information_tool", False),
             # --- Schema settings ---
-            # input_schema=config.get("input_schema"),  # TODO
-            # output_schema=config.get("output_schema"),  # TODO
+            input_schema=config.get("input_schema"),
+            output_schema=config.get("output_schema"),
             # --- Parser and output settings ---
             # parser_model=config.get("parser_model"),  # TODO
             parser_model_prompt=config.get("parser_model_prompt"),

agno/tools/mcp/mcp.py

@@ -74,6 +74,13 @@ class MCPTools(Toolkit):
                 Only relevant with HTTP transports (Streamable HTTP or SSE).
                 Creates a new session per agent run with dynamic headers merged into connection config.
         """
+        # Extract these before super().__init__() to bypass early validation
+        # (tools aren't available until build_tools() is called)
+        requires_confirmation_tools = kwargs.pop("requires_confirmation_tools", None)
+        external_execution_required_tools = kwargs.pop("external_execution_required_tools", None)
+        stop_after_tool_call_tools = kwargs.pop("stop_after_tool_call_tools", None)
+        show_result_tools = kwargs.pop("show_result_tools", None)
+
         super().__init__(name="MCPTools", **kwargs)
 
         if url is not None:
@@ -92,6 +99,10 @@ class MCPTools(Toolkit):
         # because tools are not available until `initialize()` is called.
         self.include_tools = include_tools
         self.exclude_tools = exclude_tools
+        self.requires_confirmation_tools = requires_confirmation_tools or []
+        self.external_execution_required_tools = external_execution_required_tools or []
+        self.stop_after_tool_call_tools = stop_after_tool_call_tools or []
+        self.show_result_tools = show_result_tools or []
         self.refresh_connection = refresh_connection
         self.tool_name_prefix = tool_name_prefix
 
@@ -575,13 +586,27 @@ class MCPTools(Toolkit):
                         mcp_tools_instance=self,
                     )
                     # Create a Function for the tool
+                    # Apply toolkit-level settings
+                    tool_name = tool.name
+                    stop_after = tool_name in self.stop_after_tool_call_tools
+                    show_result = tool_name in self.show_result_tools or stop_after
+
                     f = Function(
-                        name=tool_name_prefix + tool.name,
+                        name=tool_name_prefix + tool_name,
                         description=tool.description,
                         parameters=tool.inputSchema,
                         entrypoint=entrypoint,
                         # Set skip_entrypoint_processing to True to avoid processing the entrypoint
                         skip_entrypoint_processing=True,
+                        # Apply toolkit-level settings for HITL and control flow
+                        requires_confirmation=tool_name in self.requires_confirmation_tools,
+                        external_execution=tool_name in self.external_execution_required_tools,
+                        stop_after_tool_call=stop_after,
+                        show_result=show_result,
+                        # Apply toolkit-level cache settings
+                        cache_results=self.cache_results,
+                        cache_dir=self.cache_dir,
+                        cache_ttl=self.cache_ttl,
                     )
 
                     # Register the Function with the toolkit

agno/vectordb/lancedb/lance_db.py

@@ -104,7 +104,7 @@ class LanceDb(VectorDb):
         self.async_connection: Optional[lancedb.AsyncConnection] = async_connection
         self.async_table: Optional[lancedb.db.AsyncTable] = async_table
 
-        if table_name and table_name in self.connection.table_names():
+        if table_name and table_name in self._get_table_names(self.connection):
             # Open the table if it exists
             try:
                 self.table = self.connection.open_table(name=table_name)
@@ -157,6 +157,21 @@ class LanceDb(VectorDb):
 
         log_debug(f"Initialized LanceDb with table: '{self.table_name}'")
 
+    def _get_table_names(self, conn: lancedb.DBConnection) -> List[str]:
+        """Get table names with backward compatibility for older LanceDB versions."""
+        # Prefer list_tables over table_names (deprecated in new versions)
+        if hasattr(conn, "list_tables"):
+            return conn.list_tables().tables
+        return conn.table_names()
+
+    async def _get_async_table_names(self, conn: lancedb.AsyncConnection) -> List[str]:
+        """Get table names asynchronously with backward compatibility for older LanceDB versions."""
+        # Prefer list_tables over table_names (deprecated in new versions)
+        if hasattr(conn, "list_tables"):
+            table_list = await conn.list_tables()
+            return table_list.tables
+        return await conn.table_names()
+
     def _prepare_vector(self, embedding) -> List[float]:
         """Prepare vector embedding for insertion, ensuring correct dimensions and type."""
         if embedding is not None and len(embedding) > 0:
@@ -186,7 +201,7 @@ class LanceDb(VectorDb):
             self.async_connection = await lancedb.connect_async(self.uri)
         # Only try to open table if it exists and we don't have it already
         if self.async_table is None:
-            table_names = await self.async_connection.table_names()
+            table_names = await self._get_async_table_names(self.async_connection)
             if self.table_name in table_names:
                 try:
                     self.async_table = await self.async_connection.open_table(self.table_name)
@@ -199,7 +214,7 @@ class LanceDb(VectorDb):
         """Refresh the sync connection to see changes made by async operations."""
         try:
             # Re-establish sync connection to see async changes
-            if self.connection and self.table_name in self.connection.table_names():
+            if self.connection is not None and self.table_name in self._get_table_names(self.connection):
                 self.table = self.connection.open_table(self.table_name)
         except Exception as e:
             log_debug(f"Could not refresh sync connection: {e}")
@@ -459,7 +474,7 @@ class LanceDb(VectorDb):
         Returns:
             List[Document]: List of matching documents
         """
-        if self.connection:
+        if self.connection is not None:
             self.table = self.connection.open_table(name=self.table_name)
 
         results = None
@@ -641,8 +656,8 @@ class LanceDb(VectorDb):
         # If we have an async table that was created, the table exists
         if self.async_table is not None:
             return True
-        if self.connection:
-            return self.table_name in self.connection.table_names()
+        if self.connection is not None:
+            return self.table_name in self._get_table_names(self.connection)
         return False
 
     async def async_exists(self) -> bool:
@@ -653,7 +668,7 @@ class LanceDb(VectorDb):
         # Check if table exists in database without trying to open it
         if self.async_connection is None:
             self.async_connection = await lancedb.connect_async(self.uri)
-        table_names = await self.async_connection.table_names()
+        table_names = await self._get_async_table_names(self.async_connection)
         return self.table_name in table_names
 
     async def async_get_count(self) -> int:

agno/workflow/__init__.py

@@ -1,4 +1,5 @@
 from agno.workflow.agent import WorkflowAgent
+from agno.workflow.cel import CEL_AVAILABLE, validate_cel_expression
 from agno.workflow.condition import Condition
 from agno.workflow.loop import Loop
 from agno.workflow.parallel import Parallel
@@ -24,4 +25,7 @@ __all__ = [
     "StepOutput",
     "get_workflow_by_id",
     "get_workflows",
+    # CEL utilities
+    "CEL_AVAILABLE",
+    "validate_cel_expression",
 ]