MindsDB 25.5.4.0__py3-none-any.whl → 25.5.4.2__py3-none-any.whl

mindsdb/__about__.py

@@ -1,10 +1,10 @@
-__title__ = 'MindsDB'
-__package_name__ = 'mindsdb'
-__version__ = '25.5.4.0'
+__title__ = "MindsDB"
+__package_name__ = "mindsdb"
+__version__ = "25.5.4.2"
 __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'
-__github__ = 'https://github.com/mindsdb/mindsdb'
-__pypi__ = 'https://pypi.org/project/mindsdb/'
-__license__ = 'Elastic License 2.0'
-__copyright__ = 'Copyright(c) 2018 MindsDB, Inc'
+__author__ = "MindsDB Inc"
+__github__ = "https://github.com/mindsdb/mindsdb"
+__pypi__ = "https://pypi.org/project/mindsdb/"
+__license__ = "Elastic License 2.0"
+__copyright__ = "Copyright(c) 2018 MindsDB, Inc"

mindsdb/api/a2a/__main__.py

@@ -4,15 +4,15 @@ import click
 from dotenv import load_dotenv
 
 # A2A specific imports
-from .common.types import (
+from mindsdb.api.a2a.common.types import (
     AgentCard,
     AgentCapabilities,
     AgentSkill,
     MissingAPIKeyError,
 )
-from .common.server.server import A2AServer
-from .task_manager import AgentTaskManager
-from .agent import MindsDBAgent
+from mindsdb.api.a2a.common.server.server import A2AServer
+from mindsdb.api.a2a.task_manager import AgentTaskManager
+from mindsdb.api.a2a.agent import MindsDBAgent
 
 logger = logging.getLogger(__name__)
 logging.basicConfig(
@@ -73,10 +73,7 @@ def main(
 
         agent_card = AgentCard(
             name="MindsDB Agent Connector",
-            description=(
-                "A2A connector that proxies requests to MindsDB agents "
-                f"in project '{project_name}'."
-            ),
+            description=(f"A2A connector that proxies requests to MindsDB agents in project '{project_name}'."),
             url=f"http://{host}:{port}",
             version="1.0.0",
             defaultInputModes=MindsDBAgent.SUPPORTED_CONTENT_TYPES,
@@ -110,5 +107,38 @@ def main(
         sys.exit(1)
 
 
+# This function is called by mindsdb/api/a2a/run_a2a.py
+def main_with_config(config=None, *args, **kwargs):
+    """
+    Alternative entry point that accepts configuration as a dictionary.
+    This is used when A2A is started as a subprocess of the main MindsDB process.
+
+    Args:
+        config (dict): Configuration dictionary
+        args: Additional positional arguments
+        kwargs: Additional keyword arguments
+    """
+    if config is None:
+        config = {}
+
+    # Extract configuration values with fallbacks to default values
+    host = config.get("host", "localhost")
+    port = int(config.get("port", 47338))
+    mindsdb_host = config.get("mindsdb_host", "localhost")
+    mindsdb_port = int(config.get("mindsdb_port", 47334))
+    project_name = config.get("project_name", "mindsdb")
+    log_level = config.get("log_level", "INFO")
+
+    # Call the main function with the extracted configuration
+    main.callback(
+        host=host,
+        port=port,
+        mindsdb_host=mindsdb_host,
+        mindsdb_port=mindsdb_port,
+        project_name=project_name,
+        log_level=log_level,
+    )
+
+
 if __name__ == "__main__":
     main()

mindsdb/api/a2a/run_a2a.py

@@ -6,9 +6,7 @@ from dotenv import load_dotenv
 from typing import Dict, Any, Optional
 
 # Configure logging
-logging.basicConfig(
-    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-)
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 
 
@@ -22,9 +20,7 @@ def setup_python_path():
     this_file_dir = os.path.dirname(os.path.abspath(__file__))
 
     # Walk three levels up:  a2a/ -> api/ -> mindsdb/ -> <repo_root>
-    repo_root = os.path.abspath(
-        os.path.join(this_file_dir, os.pardir, os.pardir, os.pardir)
-    )
+    repo_root = os.path.abspath(os.path.join(this_file_dir, os.pardir, os.pardir, os.pardir))
 
     # Prepend to PYTHONPATH if not already present
     if repo_root not in sys.path:
@@ -54,65 +50,26 @@ def main(config_override: Optional[Dict[str, Any]] = None, *args, **kwargs):
     load_dotenv()
 
     try:
-        # Import the main function from __main__.py
-        from mindsdb.api.a2a.__main__ import main as a2a_main
+        # Import the main_with_config function from __main__.py
+        from mindsdb.api.a2a.__main__ import main_with_config
         from mindsdb.utilities.config import config
 
         logger.info("Successfully imported a2a module")
 
         # Get configuration from config system or use provided override
-        a2a_config = config_override if config_override is not None else config.get('a2a', {})
+        a2a_config = config_override if config_override is not None else config.get("api", {}).get("a2a", {})
 
         # Set log level if specified
-        if a2a_config.get('log_level'):
-            log_level = getattr(logging, a2a_config['log_level'].upper(), None)
+        if a2a_config.get("log_level"):
+            log_level = getattr(logging, a2a_config["log_level"].upper(), None)
             if log_level:
                 logger.setLevel(log_level)
                 logger.info(f"Set log level to {a2a_config['log_level'].upper()}")
 
-        # Prepare command line arguments based on configuration
-        sys_argv = []  # Start with an empty list instead of copying sys.argv
+        logger.info(f"Starting A2A with configuration: {a2a_config}")
 
-        # Only add args that aren't already in sys.argv
-        if a2a_config.get('host'):
-            sys_argv.extend(['--host', a2a_config['host']])
-
-        if a2a_config.get('port'):
-            sys_argv.extend(['--port', str(a2a_config['port'])])
-
-        if a2a_config.get('mindsdb_host'):
-            sys_argv.extend(['--mindsdb-host', a2a_config['mindsdb_host']])
-
-        if a2a_config.get('mindsdb_port'):
-            sys_argv.extend(['--mindsdb-port', str(a2a_config['mindsdb_port'])])
-
-        if a2a_config.get('project_name'):
-            sys_argv.extend(['--project-name', a2a_config['project_name']])
-
-        if a2a_config.get('log_level'):
-            sys_argv.extend(['--log-level', a2a_config['log_level']])
-
-        logger.info(f"Starting A2A with arguments: {' '.join(sys_argv)}")
-
-        # Temporarily replace sys.argv with our constructed arguments
-        original_argv = sys.argv
-        sys.argv = [sys.argv[0]] + sys_argv
-
-        # Run the main function with the configured arguments
-        a2a_args = []
-        for arg in sys_argv:
-            # Skip the --api argument and its value
-            if arg.startswith('--api=') or arg == '--api':
-                continue
-            # Skip the value of --api if the previous arg was --api
-            if arg.startswith('--') and sys_argv[sys_argv.index(arg) - 1] == '--api':
-                continue
-            a2a_args.append(arg)
-
-        a2a_main(a2a_args)
-
-        # Restore original sys.argv
-        sys.argv = original_argv
+        # Call the main_with_config function with the configuration
+        main_with_config(a2a_config, *args, **kwargs)
 
     except ImportError as e:
         logger.error(f"Error importing a2a module: {e}")

mindsdb/api/a2a/task_manager.py

@@ -1,5 +1,5 @@
 from typing import AsyncIterable
-from .common.types import (
+from mindsdb.api.a2a.common.types import (
     SendTaskRequest,
     TaskSendParams,
     Message,
@@ -16,8 +16,8 @@ from .common.types import (
     SendTaskStreamingResponse,
     InvalidRequestError,
 )
-from .common.server.task_manager import InMemoryTaskManager
-from .agent import MindsDBAgent
+from mindsdb.api.a2a.common.server.task_manager import InMemoryTaskManager
+from mindsdb.api.a2a.agent import MindsDBAgent
 
 from typing import Union
 import logging
@@ -27,7 +27,6 @@ logger = logging.getLogger(__name__)
 
 
 class AgentTaskManager(InMemoryTaskManager):
-
     def __init__(
         self,
         project_name: str,
@@ -46,9 +45,7 @@ class AgentTaskManager(InMemoryTaskManager):
     def _create_agent(self, 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"
-            )
+            raise ValueError("Agent name is required but was not provided in the request")
 
         return MindsDBAgent(
             agent_name=agent_name,
@@ -57,9 +54,7 @@ class AgentTaskManager(InMemoryTaskManager):
             port=self.mindsdb_port,
         )
 
-    async def _stream_generator(
-        self, request: SendTaskStreamingRequest
-    ) -> AsyncIterable[SendTaskStreamingResponse]:
+    async def _stream_generator(self, request: SendTaskStreamingRequest) -> AsyncIterable[SendTaskStreamingResponse]:
         task_send_params: TaskSendParams = request.params
         query = self._get_user_query(task_send_params)
         params = self._get_task_params(task_send_params)
@@ -112,9 +107,7 @@ class AgentTaskManager(InMemoryTaskManager):
                 # Yield the artifact update
                 yield SendTaskStreamingResponse(
                     id=request.id,
-                    result=TaskArtifactUpdateEvent(
-                        id=task_send_params.id, artifact=artifact
-                    ),
+                    result=TaskArtifactUpdateEvent(id=task_send_params.id, artifact=artifact),
                 )
 
                 # Yield the final status update
@@ -169,9 +162,7 @@ class AgentTaskManager(InMemoryTaskManager):
                             # Include SQL queries
                             tool_input = action.get("tool_input", "")
                             if "$START$" in tool_input and "$STOP$" in tool_input:
-                                sql = tool_input.replace("$START$", "").replace(
-                                    "$STOP$", ""
-                                )
+                                sql = tool_input.replace("$START$", "").replace("$STOP$", "")
                                 parts.append(
                                     {
                                         "type": "text",
@@ -227,17 +218,13 @@ class AgentTaskManager(InMemoryTaskManager):
                             if "metadata" in part:
                                 new_part["metadata"] = part["metadata"]
                             else:
-                                new_part["metadata"] = {
-                                    "thought_type": part.get("type", "text")
-                                }
+                                new_part["metadata"] = {"thought_type": part.get("type", "text")}
 
                             parts.append(new_part)
 
                     # Try to determine the type from parts for the thought dictionary
                     for part in item["parts"]:
-                        if part.get("type") == "text" and part.get(
-                            "text", ""
-                        ).startswith("$START$"):
+                        if part.get("type") == "text" and part.get("text", "").startswith("$START$"):
                             thought_dict["type"] = "sql"
                             thought_dict["query"] = part.get("text")
                         else:
@@ -300,9 +287,7 @@ class AgentTaskManager(InMemoryTaskManager):
                             status=task_status,
                             final=False,
                         )
-                        yield SendTaskStreamingResponse(
-                            id=request.id, result=task_update_event
-                        )
+                        yield SendTaskStreamingResponse(id=request.id, result=task_update_event)
 
                 # If this is the final chunk, send a completion message
                 if is_task_complete:
@@ -311,13 +296,9 @@ class AgentTaskManager(InMemoryTaskManager):
                     task_status = TaskStatus(state=task_state)
                     yield SendTaskStreamingResponse(
                         id=request.id,
-                        result=TaskArtifactUpdateEvent(
-                            id=task_send_params.id, artifact=artifact
-                        ),
-                    )
-                    await self._update_store(
-                        task_send_params.id, task_status, [artifact]
+                        result=TaskArtifactUpdateEvent(id=task_send_params.id, artifact=artifact),
                     )
+                    await self._update_store(task_send_params.id, task_status, [artifact])
                     yield SendTaskStreamingResponse(
                         id=request.id,
                         result=TaskStatusUpdateEvent(
@@ -338,9 +319,7 @@ class AgentTaskManager(InMemoryTaskManager):
             artifact = Artifact(parts=parts, index=0, append=False)
             yield SendTaskStreamingResponse(
                 id=request.id,
-                result=TaskArtifactUpdateEvent(
-                    id=task_send_params.id, artifact=artifact
-                ),
+                result=TaskArtifactUpdateEvent(id=task_send_params.id, artifact=artifact),
             )
 
             # Then mark the task as completed with an error
@@ -415,10 +394,7 @@ class AgentTaskManager(InMemoryTaskManager):
             )
 
         # Check if the message has metadata
-        if (
-            not hasattr(request.params.message, "metadata")
-            or not request.params.message.metadata
-        ):
+        if not hasattr(request.params.message, "metadata") or not request.params.message.metadata:
             return JSONRPCResponse(
                 id=request.id,
                 error=InvalidRequestError(message="Missing metadata in message"),
@@ -462,14 +438,10 @@ class AgentTaskManager(InMemoryTaskManager):
             logger.error(f"Error in on_send_task_subscribe: {str(e)}")
             yield SendTaskStreamingResponse(
                 id=request.id,
-                error=InternalError(
-                    message=f"Error processing streaming request: {str(e)}"
-                ),
+                error=InternalError(message=f"Error processing streaming request: {str(e)}"),
             )
 
-    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]
@@ -544,9 +516,7 @@ class AgentTaskManager(InMemoryTaskManager):
                 # For streaming mode, we'll use the streaming endpoint instead
                 # Just create a minimal response to acknowledge the request
                 task_state = TaskState.WORKING
-                task = await self._update_store(
-                    task_send_params.id, TaskStatus(state=task_state), []
-                )
+                task = await self._update_store(task_send_params.id, TaskStatus(state=task_state), [])
                 return SendTaskResponse(id=request.id, result=task)
             else:
                 # For non-streaming mode, collect all chunks into a single response
@@ -571,9 +541,7 @@ class AgentTaskManager(InMemoryTaskManager):
                     task_send_params.id,
                     TaskStatus(
                         state=task_state,
-                        message=Message(
-                            role="agent", parts=all_parts, metadata=final_metadata
-                        ),
+                        message=Message(role="agent", parts=all_parts, metadata=final_metadata),
                     ),
                     [Artifact(parts=all_parts)],
                 )
@@ -586,9 +554,7 @@ class AgentTaskManager(InMemoryTaskManager):
             task_state = TaskState.FAILED
             task = await self._update_store(
                 task_send_params.id,
-                TaskStatus(
-                    state=task_state, message=Message(role="agent", parts=parts)
-                ),
+                TaskStatus(state=task_state, message=Message(role="agent", parts=parts)),
                 [Artifact(parts=parts)],
             )
             return SendTaskResponse(id=request.id, result=task)