agno 1.8.0__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

agno/utils/events.py

@@ -4,7 +4,7 @@ from agno.media import AudioResponse, ImageArtifact
 from agno.models.message import Citations
 from agno.models.response import ToolExecution
 from agno.reasoning.step import ReasoningStep
-from agno.run.response import (
+from agno.run.agent import (
     MemoryUpdateCompletedEvent,
     MemoryUpdateStartedEvent,
     OutputModelResponseCompletedEvent,
@@ -14,14 +14,14 @@ from agno.run.response import (
     ReasoningCompletedEvent,
     ReasoningStartedEvent,
     ReasoningStepEvent,
-    RunResponse,
-    RunResponseCancelledEvent,
-    RunResponseCompletedEvent,
-    RunResponseContentEvent,
-    RunResponseContinuedEvent,
-    RunResponseErrorEvent,
-    RunResponsePausedEvent,
-    RunResponseStartedEvent,
+    RunCancelledEvent,
+    RunCompletedEvent,
+    RunContentEvent,
+    RunContinuedEvent,
+    RunErrorEvent,
+    RunOutput,
+    RunPausedEvent,
+    RunStartedEvent,
     ToolCallCompletedEvent,
     ToolCallStartedEvent,
 )
@@ -34,219 +34,208 @@ from agno.run.team import ParserModelResponseStartedEvent as TeamParserModelResp
 from agno.run.team import ReasoningCompletedEvent as TeamReasoningCompletedEvent
 from agno.run.team import ReasoningStartedEvent as TeamReasoningStartedEvent
 from agno.run.team import ReasoningStepEvent as TeamReasoningStepEvent
-from agno.run.team import RunResponseCancelledEvent as TeamRunResponseCancelledEvent
-from agno.run.team import RunResponseCompletedEvent as TeamRunResponseCompletedEvent
-from agno.run.team import RunResponseContentEvent as TeamRunResponseContentEvent
-from agno.run.team import RunResponseErrorEvent as TeamRunResponseErrorEvent
-from agno.run.team import RunResponseStartedEvent as TeamRunResponseStartedEvent
-from agno.run.team import TeamRunResponse
+from agno.run.team import RunCancelledEvent as TeamRunCancelledEvent
+from agno.run.team import RunCompletedEvent as TeamRunCompletedEvent
+from agno.run.team import RunContentEvent as TeamRunContentEvent
+from agno.run.team import RunErrorEvent as TeamRunErrorEvent
+from agno.run.team import RunStartedEvent as TeamRunStartedEvent
+from agno.run.team import TeamRunOutput
 from agno.run.team import ToolCallCompletedEvent as TeamToolCallCompletedEvent
 from agno.run.team import ToolCallStartedEvent as TeamToolCallStartedEvent
 
 
-def create_team_run_response_started_event(from_run_response: TeamRunResponse) -> TeamRunResponseStartedEvent:
-    return TeamRunResponseStartedEvent(
+def create_team_run_started_event(from_run_response: TeamRunOutput) -> TeamRunStartedEvent:
+    return TeamRunStartedEvent(
         session_id=from_run_response.session_id,
         team_id=from_run_response.team_id,  # type: ignore
         team_name=from_run_response.team_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
         model=from_run_response.model,  # type: ignore
         model_provider=from_run_response.model_provider,  # type: ignore
     )
 
 
-def create_run_response_started_event(from_run_response: RunResponse) -> RunResponseStartedEvent:
-    return RunResponseStartedEvent(
+def create_run_started_event(from_run_response: RunOutput) -> RunStartedEvent:
+    return RunStartedEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
         model=from_run_response.model,  # type: ignore
         model_provider=from_run_response.model_provider,  # type: ignore
     )
 
 
-def create_team_run_response_completed_event(from_run_response: TeamRunResponse) -> TeamRunResponseCompletedEvent:
-    return TeamRunResponseCompletedEvent(
+def create_team_run_completed_event(from_run_response: TeamRunOutput) -> TeamRunCompletedEvent:
+    return TeamRunCompletedEvent(
         session_id=from_run_response.session_id,
         team_id=from_run_response.team_id,  # type: ignore
         team_name=from_run_response.team_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
         content=from_run_response.content,  # type: ignore
         content_type=from_run_response.content_type,  # type: ignore
         reasoning_content=from_run_response.reasoning_content,  # type: ignore
-        thinking=from_run_response.thinking,  # type: ignore
         citations=from_run_response.citations,  # type: ignore
         images=from_run_response.images,  # type: ignore
         videos=from_run_response.videos,  # type: ignore
         audio=from_run_response.audio,  # type: ignore
         response_audio=from_run_response.response_audio,  # type: ignore
-        extra_data=from_run_response.extra_data,  # type: ignore
+        references=from_run_response.references,  # type: ignore
+        additional_input=from_run_response.additional_input,  # type: ignore
+        reasoning_steps=from_run_response.reasoning_steps,  # type: ignore
+        reasoning_messages=from_run_response.reasoning_messages,  # type: ignore
         member_responses=from_run_response.member_responses,  # type: ignore
+        metadata=from_run_response.metadata,  # type: ignore
+        metrics=from_run_response.metrics,  # type: ignore
     )
 
 
-def create_run_response_completed_event(from_run_response: RunResponse) -> RunResponseCompletedEvent:
-    return RunResponseCompletedEvent(
+def create_run_completed_event(from_run_response: RunOutput) -> RunCompletedEvent:
+    return RunCompletedEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
         content=from_run_response.content,  # type: ignore
         content_type=from_run_response.content_type,  # type: ignore
         reasoning_content=from_run_response.reasoning_content,  # type: ignore
-        thinking=from_run_response.thinking,  # type: ignore
         citations=from_run_response.citations,  # type: ignore
         images=from_run_response.images,  # type: ignore
         videos=from_run_response.videos,  # type: ignore
         audio=from_run_response.audio,  # type: ignore
         response_audio=from_run_response.response_audio,  # type: ignore
-        extra_data=from_run_response.extra_data,  # type: ignore
+        references=from_run_response.references,  # type: ignore
+        additional_input=from_run_response.additional_input,  # type: ignore
+        reasoning_steps=from_run_response.reasoning_steps,  # type: ignore
+        reasoning_messages=from_run_response.reasoning_messages,  # type: ignore
+        metadata=from_run_response.metadata,  # type: ignore
+        metrics=from_run_response.metrics,  # type: ignore
     )
 
 
-def create_run_response_paused_event(
-    from_run_response: RunResponse, tools: Optional[List[ToolExecution]] = None
-) -> RunResponsePausedEvent:
-    return RunResponsePausedEvent(
+def create_run_paused_event(
+    from_run_response: RunOutput, tools: Optional[List[ToolExecution]] = None
+) -> RunPausedEvent:
+    return RunPausedEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
         tools=tools,
         content=from_run_response.content,
     )
 
 
-def create_run_response_continued_event(from_run_response: RunResponse) -> RunResponseContinuedEvent:
-    return RunResponseContinuedEvent(
+def create_run_continued_event(from_run_response: RunOutput) -> RunContinuedEvent:
+    return RunContinuedEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
     )
 
 
-def create_team_run_response_error_event(from_run_response: TeamRunResponse, error: str) -> TeamRunResponseErrorEvent:
-    return TeamRunResponseErrorEvent(
+def create_team_run_error_event(from_run_response: TeamRunOutput, error: str) -> TeamRunErrorEvent:
+    return TeamRunErrorEvent(
         session_id=from_run_response.session_id,
         team_id=from_run_response.team_id,  # type: ignore
         team_name=from_run_response.team_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
         content=error,
     )
 
 
-def create_run_response_error_event(from_run_response: RunResponse, error: str) -> RunResponseErrorEvent:
-    return RunResponseErrorEvent(
+def create_run_error_event(from_run_response: RunOutput, error: str) -> RunErrorEvent:
+    return RunErrorEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
         content=error,
     )
 
 
-def create_team_run_response_cancelled_event(
-    from_run_response: TeamRunResponse, reason: str
-) -> TeamRunResponseCancelledEvent:
-    return TeamRunResponseCancelledEvent(
+def create_team_run_cancelled_event(from_run_response: TeamRunOutput, reason: str) -> TeamRunCancelledEvent:
+    return TeamRunCancelledEvent(
         session_id=from_run_response.session_id,
         team_id=from_run_response.team_id,  # type: ignore
         team_name=from_run_response.team_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
         reason=reason,
     )
 
 
-def create_run_response_cancelled_event(from_run_response: RunResponse, reason: str) -> RunResponseCancelledEvent:
-    return RunResponseCancelledEvent(
+def create_run_cancelled_event(from_run_response: RunOutput, reason: str) -> RunCancelledEvent:
+    return RunCancelledEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
         reason=reason,
     )
 
 
-def create_memory_update_started_event(from_run_response: RunResponse) -> MemoryUpdateStartedEvent:
+def create_memory_update_started_event(from_run_response: RunOutput) -> MemoryUpdateStartedEvent:
     return MemoryUpdateStartedEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
     )
 
 
-def create_team_memory_update_started_event(from_run_response: TeamRunResponse) -> TeamMemoryUpdateStartedEvent:
+def create_team_memory_update_started_event(from_run_response: TeamRunOutput) -> TeamMemoryUpdateStartedEvent:
     return TeamMemoryUpdateStartedEvent(
         session_id=from_run_response.session_id,
         team_id=from_run_response.team_id,  # type: ignore
         team_name=from_run_response.team_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
     )
 
 
-def create_memory_update_completed_event(from_run_response: RunResponse) -> MemoryUpdateCompletedEvent:
+def create_memory_update_completed_event(from_run_response: RunOutput) -> MemoryUpdateCompletedEvent:
     return MemoryUpdateCompletedEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
     )
 
 
-def create_team_memory_update_completed_event(from_run_response: TeamRunResponse) -> TeamMemoryUpdateCompletedEvent:
+def create_team_memory_update_completed_event(from_run_response: TeamRunOutput) -> TeamMemoryUpdateCompletedEvent:
     return TeamMemoryUpdateCompletedEvent(
         session_id=from_run_response.session_id,
         team_id=from_run_response.team_id,  # type: ignore
         team_name=from_run_response.team_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
     )
 
 
-def create_reasoning_started_event(from_run_response: RunResponse) -> ReasoningStartedEvent:
+def create_reasoning_started_event(from_run_response: RunOutput) -> ReasoningStartedEvent:
     return ReasoningStartedEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
     )
 
 
-def create_team_reasoning_started_event(from_run_response: TeamRunResponse) -> TeamReasoningStartedEvent:
+def create_team_reasoning_started_event(from_run_response: TeamRunOutput) -> TeamReasoningStartedEvent:
     return TeamReasoningStartedEvent(
         session_id=from_run_response.session_id,
         team_id=from_run_response.team_id,  # type: ignore
         team_name=from_run_response.team_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
     )
 
 
 def create_reasoning_step_event(
-    from_run_response: RunResponse, reasoning_step: ReasoningStep, reasoning_content: str
+    from_run_response: RunOutput, reasoning_step: ReasoningStep, reasoning_content: str
 ) -> ReasoningStepEvent:
     return ReasoningStepEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
         content=reasoning_step,
         content_type=reasoning_step.__class__.__name__,
@@ -255,13 +244,12 @@ def create_reasoning_step_event(
 
 
 def create_team_reasoning_step_event(
-    from_run_response: TeamRunResponse, reasoning_step: ReasoningStep, reasoning_content: str
+    from_run_response: TeamRunOutput, reasoning_step: ReasoningStep, reasoning_content: str
 ) -> TeamReasoningStepEvent:
     return TeamReasoningStepEvent(
         session_id=from_run_response.session_id,
         team_id=from_run_response.team_id,  # type: ignore
         team_name=from_run_response.team_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
         content=reasoning_step,
         content_type=reasoning_step.__class__.__name__,
@@ -270,13 +258,12 @@ def create_team_reasoning_step_event(
 
 
 def create_reasoning_completed_event(
-    from_run_response: RunResponse, content: Optional[Any] = None, content_type: Optional[str] = None
+    from_run_response: RunOutput, content: Optional[Any] = None, content_type: Optional[str] = None
 ) -> ReasoningCompletedEvent:
     return ReasoningCompletedEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
         content=content,
         content_type=content_type or "str",
@@ -284,51 +271,47 @@ def create_reasoning_completed_event(
 
 
 def create_team_reasoning_completed_event(
-    from_run_response: TeamRunResponse, content: Optional[Any] = None, content_type: Optional[str] = None
+    from_run_response: TeamRunOutput, content: Optional[Any] = None, content_type: Optional[str] = None
 ) -> TeamReasoningCompletedEvent:
     return TeamReasoningCompletedEvent(
         session_id=from_run_response.session_id,
         team_id=from_run_response.team_id,  # type: ignore
         team_name=from_run_response.team_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
         content=content,
         content_type=content_type or "str",
     )
 
 
-def create_tool_call_started_event(from_run_response: RunResponse, tool: ToolExecution) -> ToolCallStartedEvent:
+def create_tool_call_started_event(from_run_response: RunOutput, tool: ToolExecution) -> ToolCallStartedEvent:
     return ToolCallStartedEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
         tool=tool,
     )
 
 
 def create_team_tool_call_started_event(
-    from_run_response: TeamRunResponse, tool: ToolExecution
+    from_run_response: TeamRunOutput, tool: ToolExecution
 ) -> TeamToolCallStartedEvent:
     return TeamToolCallStartedEvent(
         session_id=from_run_response.session_id,
         team_id=from_run_response.team_id,  # type: ignore
         team_name=from_run_response.team_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
         tool=tool,
     )
 
 
 def create_tool_call_completed_event(
-    from_run_response: RunResponse, tool: ToolExecution, content: Optional[Any] = None
+    from_run_response: RunOutput, tool: ToolExecution, content: Optional[Any] = None
 ) -> ToolCallCompletedEvent:
     return ToolCallCompletedEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
         tool=tool,
         content=content,
@@ -339,13 +322,12 @@ def create_tool_call_completed_event(
 
 
 def create_team_tool_call_completed_event(
-    from_run_response: TeamRunResponse, tool: ToolExecution, content: Optional[Any] = None
+    from_run_response: TeamRunOutput, tool: ToolExecution, content: Optional[Any] = None
 ) -> TeamToolCallCompletedEvent:
     return TeamToolCallCompletedEvent(
         session_id=from_run_response.session_id,
         team_id=from_run_response.team_id,  # type: ignore
         team_name=from_run_response.team_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
         tool=tool,
         content=content,
@@ -355,150 +337,145 @@ def create_team_tool_call_completed_event(
     )
 
 
-def create_run_response_content_event(
-    from_run_response: RunResponse,
+def create_run_output_content_event(
+    from_run_response: RunOutput,
     content: Optional[Any] = None,
     content_type: Optional[str] = None,
-    thinking: Optional[str] = None,
     reasoning_content: Optional[str] = None,
-    redacted_thinking: Optional[str] = None,
+    redacted_reasoning_content: Optional[str] = None,
     citations: Optional[Citations] = None,
     response_audio: Optional[AudioResponse] = None,
     image: Optional[ImageArtifact] = None,
-) -> RunResponseContentEvent:
-    thinking_combined = (thinking or "") + (redacted_thinking or "")
+) -> RunContentEvent:
+    thinking_combined = (reasoning_content or "") + (redacted_reasoning_content or "")
 
-    return RunResponseContentEvent(
+    return RunContentEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
         content=content,
         content_type=content_type or "str",
-        thinking=thinking_combined,
-        reasoning_content=reasoning_content,
+        reasoning_content=thinking_combined,
         citations=citations,
         response_audio=response_audio,
         image=image,
-        extra_data=from_run_response.extra_data,
+        references=from_run_response.references,
+        additional_input=from_run_response.additional_input,
+        reasoning_steps=from_run_response.reasoning_steps,
+        reasoning_messages=from_run_response.reasoning_messages,
     )
 
 
-def create_team_run_response_content_event(
-    from_run_response: TeamRunResponse,
+def create_team_run_output_content_event(
+    from_run_response: TeamRunOutput,
     content: Optional[Any] = None,
     content_type: Optional[str] = None,
-    thinking: Optional[str] = None,
-    redacted_thinking: Optional[str] = None,
+    reasoning_content: Optional[str] = None,
+    redacted_reasoning_content: Optional[str] = None,
     citations: Optional[Citations] = None,
     response_audio: Optional[AudioResponse] = None,
     image: Optional[ImageArtifact] = None,
-) -> TeamRunResponseContentEvent:
-    thinking_combined = (thinking or "") + (redacted_thinking or "")
-    return TeamRunResponseContentEvent(
+) -> TeamRunContentEvent:
+    thinking_combined = (reasoning_content or "") + (redacted_reasoning_content or "")
+
+    return TeamRunContentEvent(
         session_id=from_run_response.session_id,
         team_id=from_run_response.team_id,  # type: ignore
         team_name=from_run_response.team_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
         content=content,
         content_type=content_type or "str",
-        thinking=thinking_combined,
+        reasoning_content=thinking_combined,
         citations=citations,
         response_audio=response_audio,
         image=image,
-        extra_data=from_run_response.extra_data,
+        references=from_run_response.references,  # type: ignore
+        additional_input=from_run_response.additional_input,  # type: ignore
+        reasoning_steps=from_run_response.reasoning_steps,  # type: ignore
+        reasoning_messages=from_run_response.reasoning_messages,  # type: ignore
     )
 
 
 def create_parser_model_response_started_event(
-    from_run_response: RunResponse,
+    from_run_response: RunOutput,
 ) -> ParserModelResponseStartedEvent:
     return ParserModelResponseStartedEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
     )
 
 
 def create_parser_model_response_completed_event(
-    from_run_response: RunResponse,
+    from_run_response: RunOutput,
 ) -> ParserModelResponseCompletedEvent:
     return ParserModelResponseCompletedEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
     )
 
 
 def create_team_parser_model_response_started_event(
-    from_run_response: TeamRunResponse,
+    from_run_response: TeamRunOutput,
 ) -> TeamParserModelResponseStartedEvent:
     return TeamParserModelResponseStartedEvent(
         session_id=from_run_response.session_id,
         team_id=from_run_response.team_id,  # type: ignore
         team_name=from_run_response.team_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
     )
 
 
 def create_team_parser_model_response_completed_event(
-    from_run_response: TeamRunResponse,
+    from_run_response: TeamRunOutput,
 ) -> TeamParserModelResponseCompletedEvent:
     return TeamParserModelResponseCompletedEvent(
         session_id=from_run_response.session_id,
         team_id=from_run_response.team_id,  # type: ignore
         team_name=from_run_response.team_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
     )
 
 
-def create_output_model_response_started_event(from_run_response: RunResponse) -> OutputModelResponseStartedEvent:
+def create_output_model_response_started_event(from_run_response: RunOutput) -> OutputModelResponseStartedEvent:
     return OutputModelResponseStartedEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
     )
 
 
-def create_output_model_response_completed_event(from_run_response: RunResponse) -> OutputModelResponseCompletedEvent:
+def create_output_model_response_completed_event(from_run_response: RunOutput) -> OutputModelResponseCompletedEvent:
     return OutputModelResponseCompletedEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
     )
 
 
 def create_team_output_model_response_started_event(
-    from_run_response: TeamRunResponse,
+    from_run_response: TeamRunOutput,
 ) -> TeamOutputModelResponseStartedEvent:
     return TeamOutputModelResponseStartedEvent(
         session_id=from_run_response.session_id,
         team_id=from_run_response.team_id,  # type: ignore
         team_name=from_run_response.team_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
     )
 
 
 def create_team_output_model_response_completed_event(
-    from_run_response: TeamRunResponse,
+    from_run_response: TeamRunOutput,
 ) -> TeamOutputModelResponseCompletedEvent:
     return TeamOutputModelResponseCompletedEvent(
         session_id=from_run_response.session_id,
         team_id=from_run_response.team_id,  # type: ignore
         team_name=from_run_response.team_name,  # type: ignore
-        team_session_id=from_run_response.team_session_id,  # type: ignore
         run_id=from_run_response.run_id,
     )

agno/utils/knowledge.py

@@ -0,0 +1,29 @@
+from typing import Any, Dict, Optional
+
+from agno.utils.log import log_info
+
+
+def get_agentic_or_user_search_filters(
+    filters: Optional[Dict[str, Any]], effective_filters: Optional[Dict[str, Any]]
+) -> Dict[str, Any]:
+    """Helper function to determine the final filters to use for the search.
+
+    Args:
+        filters: Filters passed by the agent.
+        effective_filters: Filters passed by user.
+
+    Returns:
+        Dict[str, Any]: The final filters to use for the search.
+    """
+    search_filters = {}
+
+    # If agentic filters exist and manual filters (passed by user) do not, use agentic filters
+    if filters and not effective_filters:
+        search_filters = filters
+
+    # If both agentic filters exist and manual filters (passed by user) exist, use manual filters (give priority to user and override)
+    if filters and effective_filters:
+        search_filters = effective_filters
+
+    log_info(f"Filters used by Agent: {search_filters}")
+    return search_filters

agno/utils/location.py

@@ -10,10 +10,10 @@ def get_location() -> Dict[str, Any]:
     try:
         response = requests.get("https://api.ipify.org?format=json", timeout=5)
         ip = response.json()["ip"]
-        response = requests.get(f"https://ipapi.co/{ip}/json/", timeout=5)
+        response = requests.get(f"http://ip-api.com/json/{ip}", timeout=5)
         if response.status_code == 200:
             data = response.json()
-            return {"city": data.get("city"), "region": data.get("region"), "country": data.get("country_name")}
+            return {"city": data.get("city"), "region": data.get("region"), "country": data.get("country")}
     except Exception as e:
         log_warning(f"Failed to get location: {e}")
     return {}

agno/utils/log.py

@@ -52,12 +52,12 @@ class AgnoLogger(logging.Logger):
     def __init__(self, name: str, level: int = logging.NOTSET):
         super().__init__(name, level)
 
-    def debug(self, msg: str, center: bool = False, symbol: str = "*", *args, **kwargs):
+    def debug(self, msg: str, center: bool = False, symbol: str = "*", *args, **kwargs):  # type: ignore
         if center:
             msg = center_header(str(msg), symbol)
         super().debug(msg, *args, **kwargs)
 
-    def info(self, msg: str, center: bool = False, symbol: str = "*", *args, **kwargs):
+    def info(self, msg: str, center: bool = False, symbol: str = "*", *args, **kwargs):  # type: ignore
         if center:
             msg = center_header(str(msg), symbol)
         super().info(msg, *args, **kwargs)