agno 2.3.21__py3-none-any.whl → 2.3.23__py3-none-any.whl

agno/client/a2a/utils.py

@@ -0,0 +1,369 @@
+"""Utility functions for mapping between A2A and Agno data structures.
+
+This module provides bidirectional mapping between:
+- A2A TaskResult ↔ Agno RunOutput / TeamRunOutput / WorkflowRunOutput
+- A2A StreamEvent ↔ Agno RunOutputEvent / TeamRunOutputEvent / WorkflowRunOutputEvent
+"""
+
+from typing import AsyncIterator, List, Optional, Union
+
+from agno.client.a2a.schemas import Artifact, StreamEvent, TaskResult
+from agno.media import Audio, File, Image, Video
+from agno.run.agent import (
+    RunCompletedEvent,
+    RunContentEvent,
+    RunOutput,
+    RunOutputEvent,
+    RunStartedEvent,
+)
+from agno.run.team import (
+    RunCompletedEvent as TeamRunCompletedEvent,
+)
+from agno.run.team import (
+    RunContentEvent as TeamRunContentEvent,
+)
+from agno.run.team import (
+    RunStartedEvent as TeamRunStartedEvent,
+)
+from agno.run.team import (
+    TeamRunOutput,
+    TeamRunOutputEvent,
+)
+from agno.run.workflow import (
+    WorkflowCompletedEvent,
+    WorkflowRunOutput,
+    WorkflowRunOutputEvent,
+    WorkflowStartedEvent,
+)
+
+
+def map_task_result_to_run_output(
+    task_result: TaskResult,
+    agent_id: str,
+    user_id: Optional[str] = None,
+) -> RunOutput:
+    """Convert A2A TaskResult to Agno RunOutput.
+
+    Maps the A2A protocol response structure to Agno's internal format,
+    enabling seamless integration with Agno's agent infrastructure.
+
+    Args:
+        task_result: A2A TaskResult from send_message()
+        agent_id: Agent identifier to include in output
+        user_id: Optional user identifier to include in output
+
+    Returns:
+        RunOutput: Agno-compatible run output
+    """
+    # Extract media from artifacts
+    images: List[Image] = []
+    videos: List[Video] = []
+    audio: List[Audio] = []
+    files: List[File] = []
+
+    for artifact in task_result.artifacts:
+        _classify_artifact(artifact, images, videos, audio, files)
+
+    return RunOutput(
+        content=task_result.content,
+        run_id=task_result.task_id,
+        session_id=task_result.context_id,
+        agent_id=agent_id,
+        user_id=user_id,
+        images=images if images else None,
+        videos=videos if videos else None,
+        audio=audio if audio else None,
+        files=files if files else None,
+        metadata=task_result.metadata,
+    )
+
+
+def _classify_artifact(
+    artifact: Artifact,
+    images: List[Image],
+    videos: List[Video],
+    audio: List[Audio],
+    files: List[File],
+) -> None:
+    """Classify an A2A artifact into the appropriate media type list.
+
+    Args:
+        artifact: A2A artifact to classify
+        images: List to append images to
+        videos: List to append videos to
+        audio: List to append audio to
+        files: List to append generic files to
+    """
+    mime_type = artifact.mime_type or ""
+    uri = artifact.uri
+
+    if not uri:
+        return
+
+    if mime_type.startswith("image/"):
+        images.append(Image(url=uri, name=artifact.name))
+    elif mime_type.startswith("video/"):
+        videos.append(Video(url=uri, name=artifact.name))
+    elif mime_type.startswith("audio/"):
+        audio.append(Audio(url=uri, name=artifact.name))
+    else:
+        files.append(File(url=uri, name=artifact.name, mime_type=mime_type or None))
+
+
+async def map_stream_events_to_run_events(
+    stream: AsyncIterator[StreamEvent],
+    agent_id: str,
+) -> AsyncIterator[RunOutputEvent]:
+    """Convert A2A stream events to Agno run events.
+
+    Transforms the A2A streaming protocol events into Agno's event system,
+    enabling real-time streaming from A2A servers to work with Agno consumers.
+
+    Args:
+        stream: AsyncIterator of A2A StreamEvents
+        agent_id: Optional agent identifier to include in events
+        user_id: Optional user identifier to include in events
+
+    Yields:
+        RunOutputEvent: Agno-compatible run output events
+    """
+    run_id: Optional[str] = None
+    session_id: Optional[str] = None
+    accumulated_content = ""
+
+    async for event in stream:
+        # Capture IDs from events
+        if event.task_id:
+            run_id = event.task_id
+        if event.context_id:
+            session_id = event.context_id
+
+        # Map event types
+        if event.event_type == "working":
+            yield RunStartedEvent(
+                run_id=run_id,
+                session_id=session_id,
+                agent_id=agent_id,
+            )
+
+        elif event.is_content and event.content:
+            accumulated_content += event.content
+            yield RunContentEvent(
+                content=event.content,
+                run_id=run_id,
+                session_id=session_id,
+                agent_id=agent_id,
+            )
+
+        elif event.is_final:
+            # Use content from final event or accumulated content
+            final_content = event.content if event.content else accumulated_content
+            yield RunCompletedEvent(
+                content=final_content,
+                run_id=run_id,
+                session_id=session_id,
+                agent_id=agent_id,
+            )
+            break  # Stream complete
+
+
+# =============================================================================
+# Team Run Output Mapping Functions
+# =============================================================================
+
+
+def map_task_result_to_team_run_output(
+    task_result: TaskResult,
+    team_id: str,
+    user_id: Optional[str] = None,
+) -> TeamRunOutput:
+    """Convert A2A TaskResult to Agno TeamRunOutput.
+
+    Maps the A2A protocol response structure to Agno's team format,
+    enabling seamless integration with Agno's team infrastructure.
+
+    Args:
+        task_result: A2A TaskResult from send_message()
+        team_id: Optional team identifier to include in output
+        user_id: Optional user identifier to include in output
+    Returns:
+        TeamRunOutput: Agno-compatible team run output
+    """
+    # Extract media from artifacts
+    images: List[Image] = []
+    videos: List[Video] = []
+    audio: List[Audio] = []
+    files: List[File] = []
+
+    for artifact in task_result.artifacts:
+        _classify_artifact(artifact, images, videos, audio, files)
+
+    return TeamRunOutput(
+        content=task_result.content,
+        run_id=task_result.task_id,
+        session_id=task_result.context_id,
+        team_id=team_id,
+        user_id=user_id,
+        images=images if images else None,
+        videos=videos if videos else None,
+        audio=audio if audio else None,
+        files=files if files else None,
+        metadata=task_result.metadata,
+    )
+
+
+async def map_stream_events_to_team_run_events(
+    stream: AsyncIterator[StreamEvent],
+    team_id: str,
+) -> AsyncIterator[TeamRunOutputEvent]:
+    """Convert A2A stream events to Agno team run events.
+
+    Transforms the A2A streaming protocol events into Agno's team event system,
+    enabling real-time streaming from A2A servers to work with Agno team consumers.
+
+    Args:
+        stream: AsyncIterator of A2A StreamEvents
+        team_id: Optional team identifier to include in events
+        user_id: Optional user identifier to include in events
+    Yields:
+        TeamRunOutputEvent: Agno-compatible team run output events
+    """
+    run_id: Optional[str] = None
+    session_id: Optional[str] = None
+    accumulated_content = ""
+
+    async for event in stream:
+        # Capture IDs from events
+        if event.task_id:
+            run_id = event.task_id
+        if event.context_id:
+            session_id = event.context_id
+
+        # Map event types
+        if event.event_type == "working":
+            yield TeamRunStartedEvent(
+                run_id=run_id,
+                session_id=session_id,
+                team_id=team_id,
+            )
+
+        elif event.is_content and event.content:
+            accumulated_content += event.content
+            yield TeamRunContentEvent(
+                content=event.content,
+                run_id=run_id,
+                session_id=session_id,
+                team_id=team_id,
+            )
+
+        elif event.is_final:
+            # Use content from final event or accumulated content
+            final_content = event.content if event.content else accumulated_content
+            yield TeamRunCompletedEvent(
+                content=final_content,
+                run_id=run_id,
+                session_id=session_id,
+                team_id=team_id,
+            )
+            break  # Stream complete
+
+
+# =============================================================================
+# Workflow Run Output Mapping Functions
+# =============================================================================
+
+
+def map_task_result_to_workflow_run_output(
+    task_result: TaskResult,
+    workflow_id: str,
+    user_id: Optional[str] = None,
+) -> WorkflowRunOutput:
+    """Convert A2A TaskResult to Agno WorkflowRunOutput.
+
+    Maps the A2A protocol response structure to Agno's workflow format,
+    enabling seamless integration with Agno's workflow infrastructure.
+
+    Args:
+        task_result: A2A TaskResult from send_message()
+        workflow_id: Optional workflow identifier to include in output
+        user_id: Optional user identifier to include in output
+    Returns:
+        WorkflowRunOutput: Agno-compatible workflow run output
+    """
+    # Extract media from artifacts
+    images: List[Image] = []
+    videos: List[Video] = []
+    audio: List[Audio] = []
+    files: List[File] = []
+
+    for artifact in task_result.artifacts:
+        _classify_artifact(artifact, images, videos, audio, files)
+
+    return WorkflowRunOutput(
+        content=task_result.content,
+        run_id=task_result.task_id,
+        session_id=task_result.context_id,
+        workflow_id=workflow_id,
+        user_id=user_id,
+        images=images if images else None,
+        videos=videos if videos else None,
+        audio=audio if audio else None,
+        metadata=task_result.metadata,
+    )
+
+
+async def map_stream_events_to_workflow_run_events(
+    stream: AsyncIterator[StreamEvent],
+    workflow_id: str,
+) -> AsyncIterator[Union[WorkflowRunOutputEvent, TeamRunOutputEvent, RunOutputEvent]]:
+    """Convert A2A stream events to Agno workflow run events.
+
+    Transforms the A2A streaming protocol events into Agno's workflow event system,
+    enabling real-time streaming from A2A servers to work with Agno workflow consumers.
+
+    Args:
+        stream: AsyncIterator of A2A StreamEvents
+        workflow_id: Optional workflow identifier to include in events
+        user_id: Optional user identifier to include in events
+    Yields:
+        WorkflowRunOutputEvent: Agno-compatible workflow run output events
+    """
+    run_id: Optional[str] = None
+    session_id: Optional[str] = None
+    accumulated_content = ""
+
+    async for event in stream:
+        # Capture IDs from events
+        if event.task_id:
+            run_id = event.task_id
+        if event.context_id:
+            session_id = event.context_id
+
+        # Map event types
+        if event.event_type == "working":
+            yield WorkflowStartedEvent(
+                run_id=run_id,
+                session_id=session_id,
+                workflow_id=workflow_id,
+            )
+
+        elif event.is_content and event.content:
+            accumulated_content += event.content
+            # TODO: We don't have workflow content events and we don't know which agent or team created the content, so we're using the workflow_id as the agent_id.
+            yield RunContentEvent(
+                content=event.content,
+                run_id=run_id,
+                session_id=session_id,
+                agent_id=workflow_id,
+            )
+
+        elif event.is_final:
+            # Use content from final event or accumulated content
+            final_content = event.content if event.content else accumulated_content
+            yield WorkflowCompletedEvent(
+                content=final_content,
+                run_id=run_id,
+                session_id=session_id,
+                workflow_id=workflow_id,
+            )
+            break  # Stream complete

agno/db/migrations/utils.py

@@ -0,0 +1,19 @@
+def quote_db_identifier(db_type: str, identifier: str) -> str:
+    """Add the right quotes to the given identifier string (table name, schema name) based on db type.
+
+    Args:
+        db_type: The database type name (e.g., "PostgresDb", "MySQLDb", "SqliteDb")
+        identifier: The identifier string to add quotes to
+
+    Returns:
+        The properly quoted identifier string
+    """
+    if db_type in ("PostgresDb", "AsyncPostgresDb"):
+        return f'"{identifier}"'
+    elif db_type in ("MySQLDb", "AsyncMySQLDb", "SingleStoreDb"):
+        return f"`{identifier}`"
+    elif db_type in ("SqliteDb", "AsyncSqliteDb"):
+        return f'"{identifier}"'
+    else:
+        # Default to double quotes for unknown types
+        return f'"{identifier}"'

agno/db/migrations/v1_to_v2.py

@@ -7,9 +7,11 @@ from typing import Any, Dict, List, Optional, Union, cast
 from sqlalchemy import text
 
 from agno.db.base import BaseDb
+from agno.db.migrations.utils import quote_db_identifier
 from agno.db.schemas.memory import UserMemory
 from agno.session import AgentSession, TeamSession, WorkflowSession
 from agno.utils.log import log_error, log_info, log_warning
+from agno.utils.string import sanitize_postgres_string, sanitize_postgres_strings
 
 
 def convert_v1_metrics_to_v2(metrics_dict: Dict[str, Any]) -> Dict[str, Any]:
@@ -45,7 +47,10 @@ def convert_v1_metrics_to_v2(metrics_dict: Dict[str, Any]) -> Dict[str, Any]:
 
 
 def convert_any_metrics_in_data(data: Any) -> Any:
-    """Recursively find and convert any metrics dictionaries and handle v1 to v2 field conversion."""
+    """Recursively find and convert any metrics dictionaries and handle v1 to v2 field conversion.
+
+    Also sanitizes all string values to remove null bytes for PostgreSQL compatibility.
+    """
     if isinstance(data, dict):
         # First apply v1 to v2 field conversion (handles extra_data extraction, thinking/reasoning_content consolidation, etc.)
         data = convert_v1_fields_to_v2(data)
@@ -62,13 +67,19 @@ def convert_any_metrics_in_data(data: Any) -> Any:
                 converted_dict[key] = convert_v1_metrics_to_v2(value)
             else:
                 converted_dict[key] = convert_any_metrics_in_data(value)
-        return converted_dict
+
+        # Sanitize all strings in the converted dict to remove null bytes
+        return sanitize_postgres_strings(converted_dict)
 
     elif isinstance(data, list):
         return [convert_any_metrics_in_data(item) for item in data]
 
+    elif isinstance(data, str):
+        # Sanitize string values to remove null bytes
+        return sanitize_postgres_string(data)
+
     else:
-        # Not a dict or list, return as-is
+        # Not a dict, list, or string, return as-is
         return data
 
 
@@ -485,15 +496,21 @@ def get_table_content_in_batches(db: BaseDb, db_schema: str, table_name: str, ba
             else:
                 raise ValueError(f"Invalid database type: {type(db).__name__}")
 
+            db_type = type(db).__name__
+            quoted_schema = (
+                quote_db_identifier(db_type=db_type, identifier=db_schema) if db_schema and db_schema.strip() else None
+            )
+            quoted_table = quote_db_identifier(db_type=db_type, identifier=table_name)
+
             offset = 0
             while True:
                 # Create a new session for each batch to avoid transaction conflicts
                 with db.Session() as sess:
                     # Handle empty schema by omitting the schema prefix (needed for SQLite)
-                    if db_schema and db_schema.strip():
-                        sql_query = f"SELECT * FROM {db_schema}.{table_name} LIMIT {batch_size} OFFSET {offset}"
+                    if quoted_schema:
+                        sql_query = f"SELECT * FROM {quoted_schema}.{quoted_table} LIMIT {batch_size} OFFSET {offset}"
                     else:
-                        sql_query = f"SELECT * FROM {table_name} LIMIT {batch_size} OFFSET {offset}"
+                        sql_query = f"SELECT * FROM {quoted_table} LIMIT {batch_size} OFFSET {offset}"
 
                     result = sess.execute(text(sql_query))
                     batch = [row._asdict() for row in result]
@@ -530,13 +547,16 @@ def get_all_table_content(db, db_schema: str, table_name: str) -> list[dict[str,
 
 
 def parse_agent_sessions(v1_content: List[Dict[str, Any]]) -> List[AgentSession]:
-    """Parse v1 Agent sessions into v2 Agent sessions and Memories"""
+    """Parse v1 Agent sessions into v2 Agent sessions and Memories
+
+    Sanitizes all string and JSON fields to remove null bytes for PostgreSQL compatibility.
+    """
     sessions_v2 = []
 
     for item in v1_content:
         session = {
             "agent_id": item.get("agent_id"),
-            "agent_data": item.get("agent_data"),
+            "agent_data": sanitize_postgres_strings(item.get("agent_data")) if item.get("agent_data") else None,
             "session_id": item.get("session_id"),
             "user_id": item.get("user_id"),
             "session_data": convert_session_data_comprehensively(item.get("session_data")),
@@ -545,6 +565,7 @@ def parse_agent_sessions(v1_content: List[Dict[str, Any]]) -> List[AgentSession]
             "created_at": item.get("created_at"),
             "updated_at": item.get("updated_at"),
         }
+        # Summary field sanitization is handled in convert_session_data_comprehensively
 
         try:
             agent_session = AgentSession.from_dict(session)
@@ -559,13 +580,16 @@ def parse_agent_sessions(v1_content: List[Dict[str, Any]]) -> List[AgentSession]
 
 
 def parse_team_sessions(v1_content: List[Dict[str, Any]]) -> List[TeamSession]:
-    """Parse v1 Team sessions into v2 Team sessions and Memories"""
+    """Parse v1 Team sessions into v2 Team sessions and Memories
+
+    Sanitizes all string and JSON fields to remove null bytes for PostgreSQL compatibility.
+    """
     sessions_v2 = []
 
     for item in v1_content:
         session = {
             "team_id": item.get("team_id"),
-            "team_data": item.get("team_data"),
+            "team_data": sanitize_postgres_strings(item.get("team_data")) if item.get("team_data") else None,
             "session_id": item.get("session_id"),
             "user_id": item.get("user_id"),
             "session_data": convert_session_data_comprehensively(item.get("session_data")),
@@ -574,6 +598,8 @@ def parse_team_sessions(v1_content: List[Dict[str, Any]]) -> List[TeamSession]:
             "created_at": item.get("created_at"),
             "updated_at": item.get("updated_at"),
         }
+        # Summary field sanitization is handled in convert_session_data_comprehensively
+
         try:
             team_session = TeamSession.from_dict(session)
         except Exception as e:
@@ -587,13 +613,18 @@ def parse_team_sessions(v1_content: List[Dict[str, Any]]) -> List[TeamSession]:
 
 
 def parse_workflow_sessions(v1_content: List[Dict[str, Any]]) -> List[WorkflowSession]:
-    """Parse v1 Workflow sessions into v2 Workflow sessions"""
+    """Parse v1 Workflow sessions into v2 Workflow sessions
+
+    Sanitizes all string and JSON fields to remove null bytes for PostgreSQL compatibility.
+    """
     sessions_v2 = []
 
     for item in v1_content:
         session = {
             "workflow_id": item.get("workflow_id"),
-            "workflow_data": item.get("workflow_data"),
+            "workflow_data": sanitize_postgres_strings(item.get("workflow_data"))
+            if item.get("workflow_data")
+            else None,
             "session_id": item.get("session_id"),
             "user_id": item.get("user_id"),
             "session_data": convert_session_data_comprehensively(item.get("session_data")),
@@ -601,9 +632,11 @@ def parse_workflow_sessions(v1_content: List[Dict[str, Any]]) -> List[WorkflowSe
             "created_at": item.get("created_at"),
             "updated_at": item.get("updated_at"),
             # Workflow v2 specific fields
-            "workflow_name": item.get("workflow_name"),
+            "workflow_name": sanitize_postgres_string(item.get("workflow_name")) if item.get("workflow_name") else None,
             "runs": convert_any_metrics_in_data(item.get("runs")),
         }
+        # Summary field sanitization is handled in convert_session_data_comprehensively
+
         try:
             workflow_session = WorkflowSession.from_dict(session)
         except Exception as e:
@@ -617,18 +650,23 @@ def parse_workflow_sessions(v1_content: List[Dict[str, Any]]) -> List[WorkflowSe
 
 
 def parse_memories(v1_content: List[Dict[str, Any]]) -> List[UserMemory]:
-    """Parse v1 Memories into v2 Memories"""
+    """Parse v1 Memories into v2 Memories
+
+    Sanitizes all string fields to remove null bytes for PostgreSQL compatibility.
+    """
     memories_v2 = []
 
     for item in v1_content:
         memory = {
             "memory_id": item.get("memory_id"),
-            "memory": item.get("memory"),
-            "input": item.get("input"),
+            "memory": sanitize_postgres_strings(item.get("memory")) if item.get("memory") else None,
+            "input": sanitize_postgres_string(item.get("input")) if item.get("input") else None,
             "updated_at": item.get("updated_at"),
             "agent_id": item.get("agent_id"),
             "team_id": item.get("team_id"),
             "user_id": item.get("user_id"),
+            "topics": sanitize_postgres_strings(item.get("topics")) if item.get("topics") else None,
+            "feedback": sanitize_postgres_string(item.get("feedback")) if item.get("feedback") else None,
         }
         memories_v2.append(UserMemory.from_dict(memory))