agno 2.4.7__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/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/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.list_tables().tables:
+        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,8 +201,8 @@ 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_list = await self.async_connection.list_tables()
-            if self.table_name in table_list.tables:
+            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)
                 except ValueError:
@@ -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 is not None and self.table_name in self.connection.list_tables().tables:
+            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}")
@@ -642,7 +657,7 @@ class LanceDb(VectorDb):
         if self.async_table is not None:
             return True
         if self.connection is not None:
-            return self.table_name in self.connection.list_tables().tables
+            return self.table_name in self._get_table_names(self.connection)
         return False
 
     async def async_exists(self) -> bool:
@@ -653,8 +668,8 @@ 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_list = await self.async_connection.list_tables()
-        return self.table_name in table_list.tables
+        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:
         """Get the number of rows in the table asynchronously."""

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",
 ]