MindsDB 25.8.3.0__py3-none-any.whl → 25.9.1.0__py3-none-any.whl

mindsdb/__about__.py

@@ -1,6 +1,6 @@
 __title__ = "MindsDB"
 __package_name__ = "mindsdb"
-__version__ = "25.8.3.0"
+__version__ = "25.9.1.0"
 __description__ = "MindsDB's AI SQL Server enables developers to build AI tools that need access to real-time data to perform their tasks"
 __email__ = "jorge@mindsdb.com"
 __author__ = "MindsDB Inc"

mindsdb/__main__.py

@@ -8,7 +8,6 @@ import atexit
 import signal
 import psutil
 import asyncio
-import secrets
 import traceback
 import threading
 from enum import Enum
@@ -28,14 +27,11 @@ from mindsdb.utilities.config import config
 from mindsdb.utilities.starters import (
     start_http,
     start_mysql,
-    start_mongo,
     start_postgres,
     start_ml_task_queue,
     start_scheduler,
     start_tasks,
-    start_mcp,
     start_litellm,
-    start_a2a,
 )
 from mindsdb.utilities.ps import is_pid_listen_port, get_child_pids
 import mindsdb.interfaces.storage.db as db
@@ -61,18 +57,15 @@ _stop_event = threading.Event()
 class TrunkProcessEnum(Enum):
     HTTP = "http"
     MYSQL = "mysql"
-    MONGODB = "mongodb"
     POSTGRES = "postgres"
     JOBS = "jobs"
     TASKS = "tasks"
     ML_TASK_QUEUE = "ml_task_queue"
-    MCP = "mcp"
     LITELLM = "litellm"
-    A2A = "a2a"
 
     @classmethod
     def _missing_(cls, value):
-        print(f'"{value}" is not a valid name of subprocess')
+        logger.error(f'"{value}" is not a valid name of subprocess')
         sys.exit(1)
 
 
@@ -348,9 +341,6 @@ if __name__ == "__main__":
     config.raise_warnings(logger=logger)
     os.environ["MINDSDB_RUNTIME"] = "1"
 
-    if os.environ.get("FLASK_SECRET_KEY") is None:
-        os.environ["FLASK_SECRET_KEY"] = secrets.token_hex(32)
-
     if os.environ.get("ARROW_DEFAULT_MEMORY_POOL") is None:
         try:
             """It seems like snowflake handler have memory issue that related to pyarrow. Memory usage keep growing with
@@ -385,7 +375,7 @@ if __name__ == "__main__":
     apis = os.getenv("MINDSDB_APIS") or config.cmd_args.api
 
     if apis is None:  # If "--api" option is not specified, start the default APIs
-        api_arr = [TrunkProcessEnum.HTTP, TrunkProcessEnum.MYSQL, TrunkProcessEnum.MCP, TrunkProcessEnum.A2A]
+        api_arr = [TrunkProcessEnum.HTTP, TrunkProcessEnum.MYSQL]
     elif apis == "":  # If "--api=" (blank) is specified, don't start any APIs
         api_arr = []
     else:  # The user has provided a list of APIs to start
@@ -421,9 +411,7 @@ if __name__ == "__main__":
     # Get config values for APIs
     http_api_config = config.get("api", {}).get("http", {})
     mysql_api_config = config.get("api", {}).get("mysql", {})
-    mcp_api_config = config.get("api", {}).get("mcp", {})
     litellm_api_config = config.get("api", {}).get("litellm", {})
-    a2a_api_config = config.get("api", {}).get("a2a", {})
     trunc_processes_struct = {
         TrunkProcessEnum.HTTP: TrunkProcessData(
             name=TrunkProcessEnum.HTTP.value,
@@ -447,12 +435,6 @@ if __name__ == "__main__":
                 "max_restart_interval_seconds", TrunkProcessData.max_restart_interval_seconds
             ),
         ),
-        TrunkProcessEnum.MONGODB: TrunkProcessData(
-            name=TrunkProcessEnum.MONGODB.value,
-            entrypoint=start_mongo,
-            port=config["api"]["mongodb"]["port"],
-            args=(config.cmd_args.verbose,),
-        ),
         TrunkProcessEnum.POSTGRES: TrunkProcessData(
             name=TrunkProcessEnum.POSTGRES.value,
             entrypoint=start_postgres,
@@ -468,18 +450,6 @@ if __name__ == "__main__":
         TrunkProcessEnum.ML_TASK_QUEUE: TrunkProcessData(
             name=TrunkProcessEnum.ML_TASK_QUEUE.value, entrypoint=start_ml_task_queue, args=(config.cmd_args.verbose,)
         ),
-        TrunkProcessEnum.MCP: TrunkProcessData(
-            name=TrunkProcessEnum.MCP.value,
-            entrypoint=start_mcp,
-            port=mcp_api_config.get("port", 47337),
-            args=(config.cmd_args.verbose,),
-            need_to_run=mcp_api_config.get("need_to_run", False),
-            restart_on_failure=mcp_api_config.get("restart_on_failure", False),
-            max_restart_count=mcp_api_config.get("max_restart_count", TrunkProcessData.max_restart_count),
-            max_restart_interval_seconds=mcp_api_config.get(
-                "max_restart_interval_seconds", TrunkProcessData.max_restart_interval_seconds
-            ),
-        ),
         TrunkProcessEnum.LITELLM: TrunkProcessData(
             name=TrunkProcessEnum.LITELLM.value,
             entrypoint=start_litellm,
@@ -491,18 +461,6 @@ if __name__ == "__main__":
                 "max_restart_interval_seconds", TrunkProcessData.max_restart_interval_seconds
             ),
         ),
-        TrunkProcessEnum.A2A: TrunkProcessData(
-            name=TrunkProcessEnum.A2A.value,
-            entrypoint=start_a2a,
-            port=a2a_api_config.get("port", 8001),
-            args=(config.cmd_args.verbose,),
-            need_to_run=a2a_api_config.get("enabled", False),
-            restart_on_failure=a2a_api_config.get("restart_on_failure", True),
-            max_restart_count=a2a_api_config.get("max_restart_count", TrunkProcessData.max_restart_count),
-            max_restart_interval_seconds=a2a_api_config.get(
-                "max_restart_interval_seconds", TrunkProcessData.max_restart_interval_seconds
-            ),
-        ),
     }
 
     for api_enum in api_arr:

mindsdb/api/a2a/__init__.py

@@ -0,0 +1,52 @@
+# A2A specific imports
+from mindsdb.api.a2a.common.types import (
+    AgentCard,
+    AgentCapabilities,
+    AgentSkill,
+)
+from mindsdb.api.a2a.common.server.server import A2AServer
+from mindsdb.api.a2a.task_manager import AgentTaskManager
+from mindsdb.api.a2a.agent import MindsDBAgent
+from mindsdb.utilities.config import config
+
+
+def get_a2a_app(
+    project_name: str = "mindsdb",
+):
+    mindsdb_port = config.get("api", {}).get("http", {}).get("port", 47334)
+
+    # Prepare A2A artefacts (agent card & task-manager)
+    capabilities = AgentCapabilities(streaming=True)
+    skill = AgentSkill(
+        id="mindsdb_query",
+        name="MindsDB Query",
+        description="Executes natural-language queries via MindsDB agents.",
+        tags=["database", "mindsdb", "query", "analytics"],
+        examples=[
+            "What trends exist in my sales data?",
+            "Generate insights from the support tickets dataset.",
+        ],
+        inputModes=MindsDBAgent.SUPPORTED_CONTENT_TYPES,
+        outputModes=MindsDBAgent.SUPPORTED_CONTENT_TYPES,
+    )
+
+    agent_card = AgentCard(
+        name="MindsDB Agent Connector",
+        description=(f"A2A connector that proxies requests to MindsDB agents in project '{project_name}'."),
+        url=f"http://127.0.0.1:{mindsdb_port}",
+        version="1.0.0",
+        defaultInputModes=MindsDBAgent.SUPPORTED_CONTENT_TYPES,
+        defaultOutputModes=MindsDBAgent.SUPPORTED_CONTENT_TYPES,
+        capabilities=capabilities,
+        skills=[skill],
+    )
+
+    task_manager = AgentTaskManager(
+        project_name=project_name,
+    )
+
+    server = A2AServer(
+        agent_card=agent_card,
+        task_manager=task_manager,
+    )
+    return server.app

mindsdb/api/a2a/agent.py

@@ -1,12 +1,13 @@
 import json
 from typing import Any, AsyncIterable, Dict, List
 import requests
-import logging
 import httpx
 from mindsdb.api.a2a.utils import to_serializable, convert_a2a_message_to_qa_format
 from mindsdb.api.a2a.constants import DEFAULT_STREAM_TIMEOUT
+from mindsdb.utilities import log
+from mindsdb.utilities.config import config
 
-logger = logging.getLogger(__name__)
+logger = log.getLogger(__name__)
 
 
 class MindsDBAgent:
@@ -18,16 +19,15 @@ class MindsDBAgent:
         self,
         agent_name="my_agent",
         project_name="mindsdb",
-        host="localhost",
-        port=47334,
+        user_info: Dict[str, Any] = None,
     ):
         self.agent_name = agent_name
         self.project_name = project_name
-        self.host = host
-        self.port = port
-        self.base_url = f"http://{host}:{port}"
+        port = config.get("api", {}).get("http", {}).get("port", 47334)
+        self.base_url = f"http://localhost:{port}"
         self.agent_url = f"{self.base_url}/api/projects/{project_name}/agents/{agent_name}"
         self.sql_url = f"{self.base_url}/api/sql/query"
+        self.headers = {k: v for k, v in user_info.items() if v is not None} or {}
         logger.info(f"Initialized MindsDB agent connector to {self.base_url}")
 
     def invoke(self, query, session_id) -> Dict[str, Any]:
@@ -35,8 +35,8 @@ class MindsDBAgent:
         try:
             escaped_query = query.replace("'", "''")
             sql_query = f"SELECT * FROM {self.project_name}.{self.agent_name} WHERE question = '{escaped_query}'"
-            logger.info(f"Sending SQL query to MindsDB: {sql_query[:100]}...")
-            response = requests.post(self.sql_url, json={"query": sql_query})
+            logger.debug(f"Sending SQL query to MindsDB: {sql_query[:100]}...")
+            response = requests.post(self.sql_url, json={"query": sql_query}, headers=self.headers)
             response.raise_for_status()
             data = response.json()
             logger.debug(f"Received response from MindsDB: {json.dumps(data)[:200]}...")
@@ -89,8 +89,8 @@ class MindsDBAgent:
 
     async def streaming_invoke(self, messages, timeout=DEFAULT_STREAM_TIMEOUT):
         url = f"{self.base_url}/api/projects/{self.project_name}/agents/{self.agent_name}/completions/stream"
-        logger.info(f"Sending streaming request to MindsDB agent: {self.agent_name}")
-        async with httpx.AsyncClient(timeout=timeout) as client:
+        logger.debug(f"Sending streaming request to MindsDB agent: {self.agent_name}")
+        async with httpx.AsyncClient(timeout=timeout, headers=self.headers) as client:
             async with client.stream("POST", url, json={"messages": to_serializable(messages)}) as response:
                 response.raise_for_status()
                 async for line in response.aiter_lines():
@@ -116,7 +116,6 @@ class MindsDBAgent:
     ) -> AsyncIterable[Dict[str, Any]]:
         """Stream responses from the MindsDB agent (uses streaming API endpoint)."""
         try:
-            logger.info(f"Using streaming API for query: {query[:100]}...")
             # Create A2A message structure with history and current query
             a2a_message = {"role": "user", "parts": [{"text": query}]}
             if history:

mindsdb/api/a2a/common/server/server.py

@@ -7,6 +7,7 @@ from starlette.middleware.cors import CORSMiddleware
 from starlette.responses import JSONResponse
 from sse_starlette.sse import EventSourceResponse
 from starlette.requests import Request
+from starlette.routing import Route
 from ...common.types import (
     A2ARequest,
     JSONRPCResponse,
@@ -26,7 +27,6 @@ from pydantic import ValidationError
 from ...common.server.task_manager import TaskManager
 
 from mindsdb.utilities import log
-from mindsdb.utilities.log import get_uvicorn_logging_config, get_mindsdb_log_level
 
 logger = log.getLogger(__name__)
 
@@ -34,22 +34,18 @@ logger = log.getLogger(__name__)
 class A2AServer:
     def __init__(
         self,
-        host="0.0.0.0",
-        port=5000,
-        endpoint="/",
         agent_card: AgentCard = None,
         task_manager: TaskManager = None,
     ):
-        self.host = host
-        self.port = port
-        self.endpoint = endpoint
         self.task_manager = task_manager
         self.agent_card = agent_card
-        self.app = Starlette()
-        self.app.add_route(self.endpoint, self._process_request, methods=["POST"])
-        self.app.add_route("/.well-known/agent.json", self._get_agent_card, methods=["GET"])
-        # Add status endpoint
-        self.app.add_route("/status", self._get_status, methods=["GET"])
+        self.app = Starlette(
+            routes=[
+                Route("/", self._process_request, methods=["POST"]),
+                Route("/.well-known/agent.json", self._get_agent_card, methods=["GET"]),
+                Route("/status", self._get_status, methods=["GET"]),
+            ]
+        )
         # TODO: Remove this when we have a proper CORS policy
         self.app.add_middleware(
             CORSMiddleware,
@@ -60,26 +56,6 @@ class A2AServer:
         )
         self.start_time = time.time()
 
-    def start(self):
-        if self.agent_card is None:
-            raise ValueError("agent_card is not defined")
-
-        if self.task_manager is None:
-            raise ValueError("request_handler is not defined")
-
-        import uvicorn
-
-        # Configure uvicorn with optimized settings for streaming
-        uvicorn.run(
-            self.app,
-            host=self.host,
-            port=self.port,
-            http="h11",
-            timeout_keep_alive=65,
-            log_level=get_mindsdb_log_level(),
-            log_config=get_uvicorn_logging_config("uvicorn_a2a"),
-        )
-
     def _get_agent_card(self, request: Request) -> JSONResponse:
         return JSONResponse(self.agent_card.model_dump(exclude_none=True))
 
@@ -94,8 +70,6 @@ class A2AServer:
             "status": "ok",
             "service": "mindsdb-a2a",
             "uptime_seconds": round(uptime_seconds, 2),
-            "host": self.host,
-            "port": self.port,
             "agent_name": self.agent_card.name if self.agent_card else None,
             "version": self.agent_card.version if self.agent_card else "unknown",
         }
@@ -107,13 +81,20 @@ class A2AServer:
             body = await request.json()
             json_rpc_request = A2ARequest.validate_python(body)
 
+            user_info = {
+                "user-id": request.headers.get("user-id", None),
+                "company-id": request.headers.get("company-id", None),
+                "user-class": request.headers.get("user-class", None),
+                "authorization": request.headers.get("Authorization", None),
+            }
+
             if isinstance(json_rpc_request, GetTaskRequest):
                 result = await self.task_manager.on_get_task(json_rpc_request)
             elif isinstance(json_rpc_request, SendTaskRequest):
-                result = await self.task_manager.on_send_task(json_rpc_request)
+                result = await self.task_manager.on_send_task(json_rpc_request, user_info)
             elif isinstance(json_rpc_request, SendTaskStreamingRequest):
                 # Don't await the async generator, just pass it to _create_response
-                result = self.task_manager.on_send_task_subscribe(json_rpc_request)
+                result = self.task_manager.on_send_task_subscribe(json_rpc_request, user_info)
             elif isinstance(json_rpc_request, CancelTaskRequest):
                 result = await self.task_manager.on_cancel_task(json_rpc_request)
             elif isinstance(json_rpc_request, SetTaskPushNotificationRequest):

mindsdb/api/a2a/common/server/task_manager.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Union, AsyncIterable, List
+from typing import Union, AsyncIterable, List, Dict
 from ...common.types import Task
 from ...common.types import (
     JSONRPCResponse,
@@ -31,10 +31,10 @@ from ...common.types import (
     InternalError,
 )
 from ...common.server.utils import new_not_implemented_error
+from mindsdb.utilities import log
 import asyncio
-import logging
 
-logger = logging.getLogger(__name__)
+logger = log.getLogger(__name__)
 
 
 class TaskManager(ABC):
@@ -47,12 +47,12 @@ class TaskManager(ABC):
         pass
 
     @abstractmethod
-    async def on_send_task(self, request: SendTaskRequest) -> SendTaskResponse:
+    async def on_send_task(self, request: SendTaskRequest, user_info: Dict) -> SendTaskResponse:
         pass
 
     @abstractmethod
     async def on_send_task_subscribe(
-        self, request: SendTaskStreamingRequest
+        self, request: SendTaskStreamingRequest, user_info: Dict
     ) -> Union[AsyncIterable[SendTaskStreamingResponse], JSONRPCResponse]:
         pass
 
@@ -92,9 +92,7 @@ class InMemoryTaskManager(TaskManager):
             if task is None:
                 return GetTaskResponse(id=request.id, error=TaskNotFoundError())
 
-            task_result = self.append_task_history(
-                task, task_query_params.historyLength
-            )
+            task_result = self.append_task_history(task, task_query_params.historyLength)
 
         return GetTaskResponse(id=request.id, result=task_result)
 
@@ -110,18 +108,16 @@ class InMemoryTaskManager(TaskManager):
         return CancelTaskResponse(id=request.id, error=TaskNotCancelableError())
 
     @abstractmethod
-    async def on_send_task(self, request: SendTaskRequest) -> SendTaskResponse:
+    async def on_send_task(self, request: SendTaskRequest, user_info: Dict) -> SendTaskResponse:
         pass
 
     @abstractmethod
     async def on_send_task_subscribe(
-        self, request: SendTaskStreamingRequest
+        self, request: SendTaskStreamingRequest, user_info: Dict
     ) -> Union[AsyncIterable[SendTaskStreamingResponse], JSONRPCResponse]:
         pass
 
-    async def set_push_notification_info(
-        self, task_id: str, notification_config: PushNotificationConfig
-    ):
+    async def set_push_notification_info(self, task_id: str, notification_config: PushNotificationConfig):
         async with self.lock:
             task = self.tasks.get(task_id)
             if task is None:
@@ -160,14 +156,10 @@ class InMemoryTaskManager(TaskManager):
             logger.error(f"Error while setting push notification info: {e}")
             return JSONRPCResponse(
                 id=request.id,
-                error=InternalError(
-                    message="An error occurred while setting push notification info"
-                ),
+                error=InternalError(message="An error occurred while setting push notification info"),
             )
 
-        return SetTaskPushNotificationResponse(
-            id=request.id, result=task_notification_params
-        )
+        return SetTaskPushNotificationResponse(id=request.id, result=task_notification_params)
 
     async def on_get_task_push_notification(
         self, request: GetTaskPushNotificationRequest
@@ -181,16 +173,12 @@ class InMemoryTaskManager(TaskManager):
             logger.error(f"Error while getting push notification info: {e}")
             return GetTaskPushNotificationResponse(
                 id=request.id,
-                error=InternalError(
-                    message="An error occurred while getting push notification info"
-                ),
+                error=InternalError(message="An error occurred while getting push notification info"),
             )
 
         return GetTaskPushNotificationResponse(
             id=request.id,
-            result=TaskPushNotificationConfig(
-                id=task_params.id, pushNotificationConfig=notification_info
-            ),
+            result=TaskPushNotificationConfig(id=task_params.id, pushNotificationConfig=notification_info),
         )
 
     async def upsert_task(self, task_send_params: TaskSendParams) -> Task:
@@ -216,9 +204,7 @@ class InMemoryTaskManager(TaskManager):
     ) -> Union[AsyncIterable[SendTaskStreamingResponse], JSONRPCResponse]:
         return new_not_implemented_error(request.id)
 
-    async def update_store(
-        self, task_id: str, status: TaskStatus, artifacts: list[Artifact]
-    ) -> Task:
+    async def update_store(self, task_id: str, status: TaskStatus, artifacts: list[Artifact]) -> Task:
         async with self.lock:
             try:
                 task = self.tasks[task_id]

mindsdb/api/a2a/task_manager.py

@@ -1,4 +1,4 @@
-from typing import AsyncIterable
+from typing import AsyncIterable, Dict
 from mindsdb.api.a2a.common.types import (
     SendTaskRequest,
     TaskSendParams,
@@ -24,6 +24,7 @@ from typing import Union
 import logging
 import asyncio
 import time
+import traceback
 
 logger = logging.getLogger(__name__)
 
@@ -46,19 +47,15 @@ class AgentTaskManager(InMemoryTaskManager):
     def __init__(
         self,
         project_name: str,
-        mindsdb_host: str,
-        mindsdb_port: int,
         agent_name: str = None,
     ):
         super().__init__()
         self.project_name = project_name
-        self.mindsdb_host = mindsdb_host
-        self.mindsdb_port = mindsdb_port
         self.agent_name = agent_name
         self.tasks = {}  # Task storage
         self.lock = asyncio.Lock()  # Lock for task operations
 
-    def _create_agent(self, agent_name: str = None) -> MindsDBAgent:
+    def _create_agent(self, user_info: Dict, agent_name: str = None) -> MindsDBAgent:
         """Create a new MindsDBAgent instance for the given agent name."""
         if not agent_name:
             raise ValueError("Agent name is required but was not provided in the request")
@@ -66,11 +63,12 @@ class AgentTaskManager(InMemoryTaskManager):
         return MindsDBAgent(
             agent_name=agent_name,
             project_name=self.project_name,
-            host=self.mindsdb_host,
-            port=self.mindsdb_port,
+            user_info=user_info,
         )
 
-    async def _stream_generator(self, request: SendTaskStreamingRequest) -> AsyncIterable[SendTaskStreamingResponse]:
+    async def _stream_generator(
+        self, request: SendTaskStreamingRequest, user_info: Dict
+    ) -> AsyncIterable[SendTaskStreamingResponse]:
         task_send_params: TaskSendParams = request.params
         query = self._get_user_query(task_send_params)
         params = self._get_task_params(task_send_params)
@@ -92,7 +90,7 @@ class AgentTaskManager(InMemoryTaskManager):
             yield error_result
             return  # Early return from generator
 
-        agent = self._create_agent(agent_name)
+        agent = self._create_agent(user_info, agent_name)
 
         # Get the history from the task object (where it was properly extracted and stored)
         history = task.history if task and task.history else []
@@ -168,16 +166,16 @@ class AgentTaskManager(InMemoryTaskManager):
 
         # If streaming is enabled (default), use the streaming implementation
         try:
-            logger.debug(f"[TaskManager] Entering agent.stream() at {time.time()}")
+            logger.debug(f"Entering agent.stream() at {time.time()}")
             # Create A2A message structure and convert using centralized utility
             a2a_message = task_send_params.message.model_dump()
+            logger.debug(f"History: {history}")
             if history:
                 a2a_message["history"] = [msg.model_dump() if hasattr(msg, "model_dump") else msg for msg in history]
 
             # Convert to Q&A format using centralized utility function
             all_messages = convert_a2a_message_to_qa_format(a2a_message)
 
-            logger.debug(f"Sending {len(all_messages)} total messages to streaming agent")
             async for item in agent.streaming_invoke(all_messages, timeout=60):
                 # Clean up: Remove verbose debug logs, keep only errors and essential info
                 if isinstance(item, dict) and "artifact" in item and "parts" in item["artifact"]:
@@ -185,6 +183,7 @@ class AgentTaskManager(InMemoryTaskManager):
                 yield to_serializable(item)
         except Exception as e:
             logger.error(f"An error occurred while streaming the response: {e}")
+            logger.error(traceback.format_exc())
             error_text = f"An error occurred while streaming the response: {str(e)}"
             # Ensure all parts are plain dicts
             parts = [{"type": "text", "text": error_text}]
@@ -310,27 +309,27 @@ class AgentTaskManager(InMemoryTaskManager):
 
         return None
 
-    async def on_send_task(self, request: SendTaskRequest) -> SendTaskResponse:
+    async def on_send_task(self, request: SendTaskRequest, user_info: Dict) -> SendTaskResponse:
         error = self._validate_request(request)
         if error:
             return error
 
-        return await self._invoke(request)
+        return await self._invoke(request, user_info=user_info)
 
     async def on_send_task_subscribe(
-        self, request: SendTaskStreamingRequest
+        self, request: SendTaskStreamingRequest, user_info: Dict
     ) -> AsyncIterable[SendTaskStreamingResponse]:
         error = self._validate_request(request)
         if error:
-            logger.info(f"[TaskManager] Yielding error at {time.time()} for invalid request: {error}")
+            logger.info(f"Yielding error at {time.time()} for invalid request: {error}")
             yield to_serializable(SendTaskStreamingResponse(id=request.id, error=to_serializable(error.error)))
             return
 
         # We can't await an async generator directly, so we need to use it as is
         try:
-            logger.debug(f"[TaskManager] Entering streaming path at {time.time()}")
-            async for response in self._stream_generator(request):
-                logger.debug(f"[TaskManager] Yielding streaming response at {time.time()} with: {str(response)[:120]}")
+            logger.debug(f"Entering streaming path at {time.time()}")
+            async for response in self._stream_generator(request, user_info):
+                logger.debug(f"Yielding streaming response at {time.time()} with: {str(response)[:120]}")
                 yield response
         except Exception as e:
             # If an error occurs, yield an error response
@@ -409,13 +408,13 @@ class AgentTaskManager(InMemoryTaskManager):
             "session_id": task_send_params.sessionId,
         }
 
-    async def _invoke(self, request: SendTaskRequest) -> SendTaskResponse:
+    async def _invoke(self, request: SendTaskRequest, user_info: Dict) -> SendTaskResponse:
         task_send_params: TaskSendParams = request.params
         query = self._get_user_query(task_send_params)
         params = self._get_task_params(task_send_params)
         agent_name = params["agent_name"]
         streaming = params["streaming"]
-        agent = self._create_agent(agent_name)
+        agent = self._create_agent(user_info, agent_name)
 
         try:
             # Get the history from the task

mindsdb/api/a2a/utils.py

@@ -42,7 +42,7 @@ def convert_a2a_message_to_qa_format(a2a_message: Dict) -> List[Dict[str, str]]:
     converted_messages = []
 
     # Process conversation history first
-    if "history" in a2a_message:
+    if "history" in a2a_message and a2a_message["history"] is not None:
         for hist_msg in a2a_message["history"]:
             if hist_msg.get("role") == "user":
                 # Extract text from parts