agno 1.7.4__py3-none-any.whl → 1.7.6__py3-none-any.whl

agno/agent/agent.py

@@ -119,6 +119,8 @@ class Agent:
     session_state: Optional[Dict[str, Any]] = None
     search_previous_sessions_history: Optional[bool] = False
     num_history_sessions: Optional[int] = None
+    # If True, cache the session in memory
+    cache_session: bool = True
 
     # --- Agent Context ---
     # Context available for tools and prompt functions
@@ -351,6 +353,7 @@ class Agent:
         session_state: Optional[Dict[str, Any]] = None,
         search_previous_sessions_history: Optional[bool] = False,
         num_history_sessions: Optional[int] = None,
+        cache_session: bool = True,
         context: Optional[Dict[str, Any]] = None,
         add_context: bool = False,
         resolve_context: bool = True,
@@ -441,6 +444,8 @@ class Agent:
         self.search_previous_sessions_history = search_previous_sessions_history
         self.num_history_sessions = num_history_sessions
 
+        self.cache_session = cache_session
+
         self.context = context
         self.add_context = add_context
         self.resolve_context = resolve_context
@@ -754,9 +759,6 @@ class Agent:
 
         self._initialize_session_state(user_id=user_id, session_id=session_id)
 
-        # Read existing session from storage
-        self.read_from_storage(session_id=session_id)
-
         return session_id, user_id
 
     def _run(
@@ -996,16 +998,18 @@ class Agent:
         **kwargs: Any,
     ) -> Union[RunResponse, Iterator[RunResponseEvent]]:
         """Run the Agent and return the response."""
-
         session_id, user_id = self._initialize_session(
             session_id=session_id, user_id=user_id, session_state=session_state
         )
 
-        log_debug(f"Session ID: {session_id}", center=True)
-
         # Initialize the Agent
         self.initialize_agent()
 
+        # Read existing session from storage
+        self.read_from_storage(session_id=session_id)
+
+        log_debug(f"Session ID: {session_id}", center=True)
+
         # Initialize Knowledge Filters
         effective_filters = knowledge_filters
 
@@ -1382,6 +1386,9 @@ class Agent:
         # Initialize the Agent
         self.initialize_agent()
 
+        # Read existing session from storage
+        self.read_from_storage(session_id=session_id)
+
         effective_filters = knowledge_filters
         # When filters are passed manually
         if self.knowledge_filters or knowledge_filters:
@@ -1606,6 +1613,9 @@ class Agent:
             retries: The number of retries to continue the run for.
             knowledge_filters: The knowledge filters to use for the run.
         """
+        # Initialize the Agent
+        self.initialize_agent()
+
         if session_id is not None:
             self.reset_run_state()
             # Reset session state if a session_id is provided. Session name and session state will be loaded from storage.
@@ -1614,9 +1624,6 @@ class Agent:
             if self.session_id is not None and session_id != self.session_id:
                 self.session_state = None
 
-        # Initialize the Agent
-        self.initialize_agent()
-
         # Initialize Session
         # Use the default user_id and session_id when necessary
         user_id = user_id if user_id is not None else self.user_id
@@ -1996,6 +2003,9 @@ class Agent:
             retries: The number of retries to continue the run for.
             knowledge_filters: The knowledge filters to use for the run.
         """
+        # Initialize the Agent
+        self.initialize_agent()
+
         if session_id is not None:
             self.reset_run_state()
             # Reset session state if a session_id is provided. Session name and session state will be loaded from storage.
@@ -2004,9 +2014,6 @@ class Agent:
             if self.session_id is not None and session_id != self.session_id:
                 self.session_state = None
 
-        # Initialize the Agent
-        self.initialize_agent()
-
         # Initialize Session
         # Use the default user_id and session_id when necessary
         user_id = user_id if user_id is not None else self.user_id
@@ -4056,6 +4063,7 @@ class Agent:
                 # Convert dict to Memory
             elif isinstance(self.memory, dict):
                 memory_dict = self.memory
+
                 memory_dict.pop("runs")
                 self.memory = Memory(**memory_dict)
             else:
@@ -4111,6 +4119,7 @@ class Agent:
                         self.memory.runs[session.session_id] = []
                         for run in session.memory["runs"]:
                             run_session_id = run["session_id"]
+
                             if "team_id" in run:
                                 self.memory.runs[run_session_id].append(TeamRunResponse.from_dict(run))
                             else:
@@ -4179,10 +4188,10 @@ class Agent:
         if not self.storage:
             return
 
-        agent_session_from_db = self.storage.read(session_id=session_id) # type: ignore
+        agent_session_from_db = self.storage.read(session_id=session_id)  # type: ignore
         if (
             agent_session_from_db is not None
-            and agent_session_from_db.memory is not None # type: ignore
+            and agent_session_from_db.memory is not None  # type: ignore
             and "runs" in agent_session_from_db.memory  # type: ignore
         ):
             if isinstance(self.memory, AgentMemory):
@@ -4224,6 +4233,11 @@ class Agent:
                 AgentSession,
                 self.storage.upsert(session=self.get_agent_session(session_id=session_id, user_id=user_id)),
             )
+
+        if not self.cache_session:
+            if self.memory is not None and self.memory.runs is not None and session_id in self.memory.runs:
+                self.memory.runs.pop(session_id)  # type: ignore
+
         return self.agent_session
 
     def add_introduction(self, introduction: str) -> None:
@@ -4355,7 +4369,6 @@ class Agent:
             # Format the system message with the session state variables
             if self.add_state_in_messages:
                 sys_message_content = self.format_message_with_state_variables(sys_message_content)
-                print("HELLO", sys_message_content)
 
             # Add the JSON output prompt if response_model is provided and the model does not support native structured outputs or JSON schema outputs
             # or if use_json_mode is True

agno/app/agui/async_router.py

@@ -16,7 +16,7 @@ from fastapi import APIRouter
 from fastapi.responses import StreamingResponse
 
 from agno.agent.agent import Agent
-from agno.app.agui.utils import async_stream_agno_response_as_agui_events, get_last_user_message
+from agno.app.agui.utils import async_stream_agno_response_as_agui_events, convert_agui_messages_to_agno_messages
 from agno.team.team import Team
 
 logger = logging.getLogger(__name__)
@@ -28,12 +28,12 @@ async def run_agent(agent: Agent, run_input: RunAgentInput) -> AsyncIterator[Bas
 
     try:
         # Preparing the input for the Agent and emitting the run started event
-        message = get_last_user_message(run_input.messages)
+        messages = convert_agui_messages_to_agno_messages(run_input.messages or [])
         yield RunStartedEvent(type=EventType.RUN_STARTED, thread_id=run_input.thread_id, run_id=run_id)
 
         # Request streaming response from agent
         response_stream = await agent.arun(
-            message=message,
+            messages=messages,
             session_id=run_input.thread_id,
             stream=True,
             stream_intermediate_steps=True,
@@ -56,12 +56,12 @@ async def run_team(team: Team, input: RunAgentInput) -> AsyncIterator[BaseEvent]
     run_id = input.run_id or str(uuid.uuid4())
     try:
         # Extract the last user message for team execution
-        user_message = get_last_user_message(input.messages) if input.messages else ""
+        messages = convert_agui_messages_to_agno_messages(input.messages or [])
         yield RunStartedEvent(type=EventType.RUN_STARTED, thread_id=input.thread_id, run_id=run_id)
 
         # Request streaming response from team
         response_stream = await team.arun(
-            message=user_message,
+            message=messages,
             session_id=input.thread_id,
             stream=True,
             stream_intermediate_steps=True,

agno/app/agui/sync_router.py

@@ -16,7 +16,7 @@ from fastapi import APIRouter
 from fastapi.responses import StreamingResponse
 
 from agno.agent.agent import Agent
-from agno.app.agui.utils import get_last_user_message, stream_agno_response_as_agui_events
+from agno.app.agui.utils import convert_agui_messages_to_agno_messages, stream_agno_response_as_agui_events
 from agno.team.team import Team
 
 logger = logging.getLogger(__name__)
@@ -28,12 +28,12 @@ def run_agent(agent: Agent, run_input: RunAgentInput) -> Iterator[BaseEvent]:
 
     try:
         # Preparing the input for the Agent and emitting the run started event
-        message = get_last_user_message(run_input.messages)
+        messages = convert_agui_messages_to_agno_messages(run_input.messages or [])
         yield RunStartedEvent(type=EventType.RUN_STARTED, thread_id=run_input.thread_id, run_id=run_id)
 
         # Request streaming response from agent
         response_stream = agent.run(
-            message=message,
+            messages=messages,
             session_id=run_input.thread_id,
             stream=True,
             stream_intermediate_steps=True,
@@ -56,12 +56,12 @@ def run_team(team: Team, input: RunAgentInput) -> Iterator[BaseEvent]:
     run_id = input.run_id or str(uuid.uuid4())
     try:
         # Extract the last user message for team execution
-        user_message = get_last_user_message(input.messages) if input.messages else ""
+        messages = convert_agui_messages_to_agno_messages(input.messages or [])
         yield RunStartedEvent(type=EventType.RUN_STARTED, thread_id=input.thread_id, run_id=run_id)
 
         # Request streaming response from team
         response_stream = team.run(
-            message=user_message,
+            message=messages,
             session_id=input.thread_id,
             stream=True,
             stream_intermediate_steps=True,

agno/app/agui/utils.py

@@ -1,5 +1,6 @@
 """Logic used by the AG-UI router."""
 
+import json
 import uuid
 from collections import deque
 from collections.abc import Iterator
@@ -17,11 +18,13 @@ from ag_ui.core import (
     TextMessageStartEvent,
     ToolCallArgsEvent,
     ToolCallEndEvent,
+    ToolCallResultEvent,
     ToolCallStartEvent,
 )
 from ag_ui.core.types import Message as AGUIMessage
 
-from agno.run.response import RunEvent, RunResponseContentEvent, RunResponseEvent
+from agno.models.message import Message
+from agno.run.response import RunEvent, RunResponseContentEvent, RunResponseEvent, RunResponsePausedEvent
 from agno.run.team import RunResponseContentEvent as TeamRunResponseContentEvent
 from agno.run.team import TeamRunEvent, TeamRunResponseEvent
 
@@ -64,13 +67,26 @@ class EventBuffer:
         return False
 
 
-def get_last_user_message(messages: Optional[List[AGUIMessage]]) -> str:
-    if not messages:
-        return ""
-    for msg in reversed(messages):
-        if msg.role == "user" and msg.content:
-            return msg.content
-    return ""
+def convert_agui_messages_to_agno_messages(messages: List[AGUIMessage]) -> List[Message]:
+    """Convert AG-UI messages to Agno messages."""
+    result = []
+    for msg in messages:
+        if msg.role == "tool":
+            result.append(Message(role="tool", tool_call_id=msg.tool_call_id, content=msg.content))
+        elif msg.role == "assistant":
+            tool_calls = None
+            if msg.tool_calls:
+                tool_calls = [call.model_dump() for call in msg.tool_calls]
+            result.append(
+                Message(
+                    role="assistant",
+                    content=msg.content,
+                    tool_calls=tool_calls,
+                )
+            )
+        elif msg.role == "user":
+            result.append(Message(role="user", content=msg.content))
+    return result
 
 
 def extract_team_response_chunk_content(response: TeamRunResponseContentEvent) -> str:
@@ -159,7 +175,7 @@ def _create_events_from_chunk(
             args_event = ToolCallArgsEvent(
                 type=EventType.TOOL_CALL_ARGS,
                 tool_call_id=tool_call.tool_call_id,  # type: ignore
-                delta=str(tool_call.tool_args),
+                delta=json.dumps(tool_call.tool_args),
             )
             events_to_emit.append(args_event)
 
@@ -174,6 +190,16 @@ def _create_events_from_chunk(
                 )
                 events_to_emit.append(end_event)
 
+                if tool_call.result is not None:
+                    result_event = ToolCallResultEvent(
+                        type=EventType.TOOL_CALL_RESULT,
+                        tool_call_id=tool_call.tool_call_id,  # type: ignore
+                        content=str(tool_call.result),
+                        role="tool",
+                        message_id=str(uuid.uuid4()),
+                    )
+                    events_to_emit.append(result_event)
+
     # Handle reasoning
     elif chunk.event == RunEvent.reasoning_started:
         step_event = StepStartedEvent(type=EventType.STEP_STARTED, step_name="reasoning")
@@ -186,7 +212,12 @@ def _create_events_from_chunk(
 
 
 def _create_completion_events(
-    event_buffer: EventBuffer, message_started: bool, message_id: str, thread_id: str, run_id: str
+    chunk: Union[RunResponseEvent, TeamRunResponseEvent],
+    event_buffer: EventBuffer,
+    message_started: bool,
+    message_id: str,
+    thread_id: str,
+    run_id: str,
 ) -> List[BaseEvent]:
     """Create events for run completion."""
     events_to_emit = []
@@ -205,6 +236,33 @@ def _create_completion_events(
         end_message_event = TextMessageEndEvent(type=EventType.TEXT_MESSAGE_END, message_id=message_id)
         events_to_emit.append(end_message_event)
 
+    # emit frontend tool calls, i.e. external_execution=True
+    if isinstance(chunk, RunResponsePausedEvent) and chunk.tools is not None:
+        for tool in chunk.tools:
+            if tool.tool_call_id is None or tool.tool_name is None:
+                continue
+
+            start_event = ToolCallStartEvent(
+                type=EventType.TOOL_CALL_START,
+                tool_call_id=tool.tool_call_id,
+                tool_call_name=tool.tool_name,
+                parent_message_id=message_id,
+            )
+            events_to_emit.append(start_event)
+
+            args_event = ToolCallArgsEvent(
+                type=EventType.TOOL_CALL_ARGS,
+                tool_call_id=tool.tool_call_id,
+                delta=json.dumps(tool.tool_args),
+            )
+            events_to_emit.append(args_event)
+
+            end_event = ToolCallEndEvent(
+                type=EventType.TOOL_CALL_END,
+                tool_call_id=tool.tool_call_id,
+            )
+            events_to_emit.append(end_event)
+
     run_finished_event = RunFinishedEvent(type=EventType.RUN_FINISHED, thread_id=thread_id, run_id=run_id)
     events_to_emit.append(run_finished_event)
 
@@ -271,8 +329,14 @@ def stream_agno_response_as_agui_events(
 
     for chunk in response_stream:
         # Handle the lifecycle end event
-        if chunk.event == RunEvent.run_completed or chunk.event == TeamRunEvent.run_completed:
-            completion_events = _create_completion_events(event_buffer, message_started, message_id, thread_id, run_id)
+        if (
+            chunk.event == RunEvent.run_completed
+            or chunk.event == TeamRunEvent.run_completed
+            or chunk.event == RunEvent.run_paused
+        ):
+            completion_events = _create_completion_events(
+                chunk, event_buffer, message_started, message_id, thread_id, run_id
+            )
             for event in completion_events:
                 events_to_emit = _emit_event_logic(event_buffer=event_buffer, event=event)
                 for emit_event in events_to_emit:
@@ -302,8 +366,14 @@ async def async_stream_agno_response_as_agui_events(
 
     async for chunk in response_stream:
         # Handle the lifecycle end event
-        if chunk.event == RunEvent.run_completed or chunk.event == TeamRunEvent.run_completed:
-            completion_events = _create_completion_events(event_buffer, message_started, message_id, thread_id, run_id)
+        if (
+            chunk.event == RunEvent.run_completed
+            or chunk.event == TeamRunEvent.run_completed
+            or chunk.event == RunEvent.run_paused
+        ):
+            completion_events = _create_completion_events(
+                chunk, event_buffer, message_started, message_id, thread_id, run_id
+            )
             for event in completion_events:
                 events_to_emit = _emit_event_logic(event_buffer=event_buffer, event=event)
                 for emit_event in events_to_emit:

agno/app/fastapi/app.py

@@ -77,7 +77,7 @@ class FastAPIApp(BaseAPIApp):
 
         if self.workflows:
             for workflow in self.workflows:
-                if not workflow.app_id:
+                if hasattr(workflow, "app_id") and not workflow.app_id:
                     workflow.app_id = self.app_id
                 if not workflow.workflow_id:
                     workflow.workflow_id = generate_id(workflow.name)

agno/app/fastapi/async_router.py

@@ -1,7 +1,7 @@
 import json
 from dataclasses import asdict
 from io import BytesIO
-from typing import AsyncGenerator, List, Optional, cast
+from typing import Any, AsyncGenerator, Dict, List, Optional, Union, cast
 from uuid import uuid4
 
 from fastapi import APIRouter, File, Form, HTTPException, Query, UploadFile
@@ -14,8 +14,10 @@ from agno.media import File as FileMedia
 from agno.run.response import RunResponseErrorEvent
 from agno.run.team import RunResponseErrorEvent as TeamRunResponseErrorEvent
 from agno.run.team import TeamRunResponseEvent
+from agno.run.v2.workflow import WorkflowErrorEvent
 from agno.team.team import Team
 from agno.utils.log import logger
+from agno.workflow.v2.workflow import Workflow as WorkflowV2
 from agno.workflow.workflow import Workflow
 
 
@@ -83,6 +85,42 @@ async def team_chat_response_streamer(
         return
 
 
+async def workflow_response_streamer(
+    workflow: WorkflowV2,
+    body: Union[Dict[str, Any], str],
+    session_id: Optional[str] = None,
+    user_id: Optional[str] = None,
+) -> AsyncGenerator:
+    try:
+        if isinstance(body, dict):
+            run_response = await workflow.arun(  # type: ignore
+                **body,
+                user_id=user_id,
+                session_id=session_id,
+                stream=True,
+                stream_intermediate_steps=True,
+            )
+        else:
+            run_response = await workflow.arun(  # type: ignore
+                body,
+                user_id=user_id,
+                session_id=session_id,
+                stream=True,
+                stream_intermediate_steps=True,
+            )
+        async for run_response_chunk in run_response:
+            yield run_response_chunk.to_json()
+    except Exception as e:
+        import traceback
+
+        traceback.print_exc(limit=3)
+        error_response = WorkflowErrorEvent(
+            error=str(e),
+        )
+        yield error_response.to_json()
+        return
+
+
 def get_async_router(
     agents: Optional[List[Agent]] = None, teams: Optional[List[Team]] = None, workflows: Optional[List[Workflow]] = None
 ) -> APIRouter:
@@ -351,17 +389,24 @@ def get_async_router(
                     media_type="text/event-stream",
                 )
             elif workflow:
-                workflow_instance = workflow.deep_copy(update={"workflow_id": workflow_id})
-                workflow_instance.user_id = user_id
-                workflow_instance.session_name = None
-                if isinstance(workflow_input, dict):
-                    return StreamingResponse(
-                        (json.dumps(asdict(result)) for result in await workflow_instance.arun(**workflow_input)),
-                        media_type="text/event-stream",
-                    )
+                if isinstance(workflow, Workflow):
+                    workflow_instance = workflow.deep_copy(update={"workflow_id": workflow_id})
+                    workflow_instance.user_id = user_id
+                    workflow_instance.session_name = None
+
+                    if isinstance(workflow_input, dict):
+                        return StreamingResponse(
+                            (json.dumps(asdict(result)) for result in await workflow_instance.arun(**workflow_input)),
+                            media_type="text/event-stream",
+                        )
+                    else:
+                        return StreamingResponse(
+                            (json.dumps(asdict(result)) for result in await workflow_instance.arun(workflow_input)),  # type: ignore
+                            media_type="text/event-stream",
+                        )
                 else:
                     return StreamingResponse(
-                        (json.dumps(asdict(result)) for result in await workflow_instance.arun(workflow_input)),  # type: ignore
+                        workflow_response_streamer(workflow, workflow_input, session_id=session_id, user_id=user_id),  # type: ignore
                         media_type="text/event-stream",
                     )
         else:
@@ -392,12 +437,18 @@ def get_async_router(
                 )
                 return team_run_response.to_dict()
             elif workflow:
-                workflow_instance = workflow.deep_copy(update={"workflow_id": workflow_id})
-                workflow_instance.user_id = user_id
-                workflow_instance.session_name = None
-                if isinstance(workflow_input, dict):
-                    return (await workflow_instance.arun(**workflow_input)).to_dict()
+                if isinstance(workflow, Workflow):
+                    workflow_instance = workflow.deep_copy(update={"workflow_id": workflow_id})
+                    workflow_instance.user_id = user_id
+                    workflow_instance.session_name = None
+                    if isinstance(workflow_input, dict):
+                        return (await workflow_instance.arun(**workflow_input)).to_dict()
+                    else:
+                        return (await workflow_instance.arun(workflow_input)).to_dict()  # type: ignore
                 else:
-                    return (await workflow_instance.arun(workflow_input)).to_dict()  # type: ignore
+                    if isinstance(workflow_input, dict):
+                        return (await workflow.arun(**workflow_input, session_id=session_id, user_id=user_id)).to_dict()
+                    else:
+                        return (await workflow.arun(workflow_input, session_id=session_id, user_id=user_id)).to_dict()  # type: ignore
 
     return router

agno/app/fastapi/sync_router.py

@@ -1,7 +1,7 @@
 import json
 from dataclasses import asdict
 from io import BytesIO
-from typing import Any, Dict, Generator, List, Optional, cast
+from typing import Any, Dict, Generator, List, Optional, Union, cast
 from uuid import uuid4
 
 from fastapi import APIRouter, File, Form, HTTPException, Query, UploadFile
@@ -15,8 +15,10 @@ from agno.run.base import RunStatus
 from agno.run.response import RunResponseEvent
 from agno.run.team import RunResponseErrorEvent as TeamRunResponseErrorEvent
 from agno.run.team import TeamRunResponseEvent
+from agno.run.v2.workflow import WorkflowErrorEvent
 from agno.team.team import Team
 from agno.utils.log import logger
+from agno.workflow.v2.workflow import Workflow as WorkflowV2
 from agno.workflow.workflow import Workflow
 
 
@@ -82,6 +84,42 @@ def team_chat_response_streamer(
         return
 
 
+def workflow_response_streamer(
+    workflow: WorkflowV2,
+    body: Union[Dict[str, Any], str],
+    session_id: Optional[str] = None,
+    user_id: Optional[str] = None,
+) -> Generator:
+    try:
+        if isinstance(body, dict):
+            run_response = workflow.run(
+                **body,
+                user_id=user_id,
+                session_id=session_id,
+                stream=True,
+                stream_intermediate_steps=True,
+            )
+        else:
+            run_response = workflow.run(
+                body,
+                user_id=user_id,
+                session_id=session_id,
+                stream=True,
+                stream_intermediate_steps=True,
+            )
+        for run_response_chunk in run_response:
+            yield run_response_chunk.to_json()
+    except Exception as e:
+        import traceback
+
+        traceback.print_exc(limit=3)
+        error_response = WorkflowErrorEvent(
+            error=str(e),
+        )
+        yield error_response.to_json()
+        return
+
+
 def get_sync_router(
     agents: Optional[List[Agent]] = None, teams: Optional[List[Team]] = None, workflows: Optional[List[Workflow]] = None
 ) -> APIRouter:
@@ -251,12 +289,12 @@ def get_sync_router(
     @router.post("/runs")
     def run_agent_or_team_or_workflow(
         message: str = Form(None),
-        stream: bool = Form(True),
+        stream: bool = Form(False),
         monitor: bool = Form(False),
         agent_id: Optional[str] = Query(None),
         team_id: Optional[str] = Query(None),
         workflow_id: Optional[str] = Query(None),
-        workflow_input: Optional[Dict[str, Any]] = Form(None),
+        workflow_input: Optional[str] = Form(None),
         session_id: Optional[str] = Form(None),
         user_id: Optional[str] = Form(None),
         files: Optional[List[UploadFile]] = File(None),
@@ -297,6 +335,13 @@ def get_sync_router(
             if not workflow_input:
                 raise HTTPException(status_code=400, detail="Workflow input is required")
 
+            # Parse workflow_input into a dict if it is a valid JSON
+            try:
+                parsed_workflow_input = json.loads(workflow_input)
+                workflow_input = parsed_workflow_input
+            except json.JSONDecodeError:
+                pass
+
         if agent:
             agent.monitoring = bool(monitor)
         elif team:
@@ -339,13 +384,25 @@ def get_sync_router(
                     media_type="text/event-stream",
                 )
             elif workflow:
-                workflow_instance = workflow.deep_copy(update={"workflow_id": workflow_id})
-                workflow_instance.user_id = user_id
-                workflow_instance.session_name = None
-                return StreamingResponse(
-                    (json.dumps(asdict(result)) for result in workflow_instance.run(**(workflow_input or {}))),
-                    media_type="text/event-stream",
-                )
+                if isinstance(workflow, Workflow):
+                    workflow_instance = workflow.deep_copy(update={"workflow_id": workflow_id})
+                    workflow_instance.user_id = user_id
+                    workflow_instance.session_name = None
+                    if isinstance(workflow_input, dict):
+                        return StreamingResponse(
+                            (json.dumps(asdict(result)) for result in workflow_instance.run(**workflow_input)),
+                            media_type="text/event-stream",
+                        )
+                    else:
+                        return StreamingResponse(
+                            (json.dumps(asdict(result)) for result in workflow_instance.run(workflow_input)),  # type: ignore
+                            media_type="text/event-stream",
+                        )
+                else:
+                    return StreamingResponse(
+                        workflow_response_streamer(workflow, workflow_input, session_id=session_id, user_id=user_id),
+                        media_type="text/event-stream",
+                    )
         else:
             if agent:
                 run_response = cast(
@@ -374,9 +431,18 @@ def get_sync_router(
                 )
                 return team_run_response.to_dict()
             elif workflow:
-                workflow_instance = workflow.deep_copy(update={"workflow_id": workflow_id})
-                workflow_instance.user_id = user_id
-                workflow_instance.session_name = None
-                return workflow_instance.run(**(workflow_input or {})).to_dict()
+                if isinstance(workflow, Workflow):
+                    workflow_instance = workflow.deep_copy(update={"workflow_id": workflow_id})
+                    workflow_instance.user_id = user_id
+                    workflow_instance.session_name = None
+                    if isinstance(workflow_input, dict):
+                        return workflow_instance.run(**workflow_input).to_dict()
+                    else:
+                        return workflow_instance.run(workflow_input).to_dict()  # type: ignore
+                else:
+                    if isinstance(workflow_input, dict):
+                        return workflow.run(**workflow_input, session_id=session_id, user_id=user_id).to_dict()
+                    else:
+                        return workflow.run(workflow_input, session_id=session_id, user_id=user_id).to_dict()
 
     return router