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

mindsdb/__about__.py

@@ -1,6 +1,6 @@
 __title__ = 'MindsDB'
 __package_name__ = 'mindsdb'
-__version__ = '25.5.3.0'
+__version__ = '25.5.4.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

@@ -25,8 +25,16 @@ logger.debug("Starting MindsDB...")
 from mindsdb.__about__ import __version__ as mindsdb_version
 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_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
@@ -40,9 +48,9 @@ try:
 except Exception:
     import multiprocessing as mp
 try:
-    mp.set_start_method('spawn')
+    mp.set_start_method("spawn")
 except RuntimeError:
-    logger.info('Torch multiprocessing context already set, ignoring...')
+    logger.info("Torch multiprocessing context already set, ignoring...")
 
 gc.enable()
 
@@ -50,15 +58,16 @@ _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'
+    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):
@@ -96,7 +105,8 @@ class TrunkProcessData:
         self._restarts_time.append(current_time_seconds)
         if self.max_restart_interval_seconds > 0:
             self._restarts_time = [
-                x for x in self._restarts_time
+                x
+                for x in self._restarts_time
                 if x >= (current_time_seconds - self.max_restart_interval_seconds)
             ]
         if len(self._restarts_time) > self.max_restart_count:
@@ -113,12 +123,17 @@ class TrunkProcessData:
         """
         if config.is_cloud:
             return False
-        if sys.platform in ('linux', 'darwin'):
-            return self.restart_on_failure and self.process.exitcode == -signal.SIGKILL.value
+        if sys.platform in ("linux", "darwin"):
+            return (
+                self.restart_on_failure
+                and self.process.exitcode == -signal.SIGKILL.value
+            )
         else:
             if self.max_restart_count == 0:
                 # to prevent infinity restarts, max_restart_count should be > 0
-                logger.warning('In the current OS, it is not possible to use `max_restart_count=0`')
+                logger.warning(
+                    "In the current OS, it is not possible to use `max_restart_count=0`"
+                )
                 return False
             return self.restart_on_failure
 
@@ -159,22 +174,25 @@ def set_error_model_status_by_pids(unexisting_pids: List[int]):
         db.session.query(db.Predictor)
         .filter(
             db.Predictor.deleted_at.is_(None),
-            db.Predictor.status.not_in([
-                db.PREDICTOR_STATUS.COMPLETE,
-                db.PREDICTOR_STATUS.ERROR
-            ])
+            db.Predictor.status.not_in(
+                [db.PREDICTOR_STATUS.COMPLETE, db.PREDICTOR_STATUS.ERROR]
+            ),
         )
         .all()
     )
     for predictor_record in predictor_records:
-        predictor_process_id = (predictor_record.training_metadata or {}).get('process_id')
+        predictor_process_id = (predictor_record.training_metadata or {}).get(
+            "process_id"
+        )
         if predictor_process_id in unexisting_pids:
             predictor_record.status = db.PREDICTOR_STATUS.ERROR
             if isinstance(predictor_record.data, dict) is False:
                 predictor_record.data = {}
-            if 'error' not in predictor_record.data:
-                predictor_record.data['error'] = 'The training process was terminated for unknown reasons'
-                flag_modified(predictor_record, 'data')
+            if "error" not in predictor_record.data:
+                predictor_record.data["error"] = (
+                    "The training process was terminated for unknown reasons"
+                )
+                flag_modified(predictor_record, "data")
             db.session.commit()
 
 
@@ -186,10 +204,9 @@ def set_error_model_status_for_unfinished():
         db.session.query(db.Predictor)
         .filter(
             db.Predictor.deleted_at.is_(None),
-            db.Predictor.status.not_in([
-                db.PREDICTOR_STATUS.COMPLETE,
-                db.PREDICTOR_STATUS.ERROR
-            ])
+            db.Predictor.status.not_in(
+                [db.PREDICTOR_STATUS.COMPLETE, db.PREDICTOR_STATUS.ERROR]
+            ),
         )
         .all()
     )
@@ -197,15 +214,14 @@ def set_error_model_status_for_unfinished():
         predictor_record.status = db.PREDICTOR_STATUS.ERROR
         if isinstance(predictor_record.data, dict) is False:
             predictor_record.data = {}
-        if 'error' not in predictor_record.data:
-            predictor_record.data['error'] = 'Unknown error'
-            flag_modified(predictor_record, 'data')
+        if "error" not in predictor_record.data:
+            predictor_record.data["error"] = "Unknown error"
+            flag_modified(predictor_record, "data")
         db.session.commit()
 
 
 def do_clean_process_marks():
-    """delete unexisting 'process marks'
-    """
+    """delete unexisting 'process marks'"""
     while _stop_event.wait(timeout=5) is False:
         unexisting_pids = clean_unlinked_process_marks()
         if not config.is_cloud and len(unexisting_pids) > 0:
@@ -217,8 +233,12 @@ def create_permanent_integrations():
     Create permanent integrations, for now only the 'files' integration.
     NOTE: this is intentional to avoid importing integration_controller
     """
-    integration_name = 'files'
-    existing = db.session.query(db.Integration).filter_by(name=integration_name, company_id=None).first()
+    integration_name = "files"
+    existing = (
+        db.session.query(db.Integration)
+        .filter_by(name=integration_name, company_id=None)
+        .first()
+    )
     if existing is None:
         integration_record = db.Integration(
             name=integration_name,
@@ -230,7 +250,9 @@ def create_permanent_integrations():
         try:
             db.session.commit()
         except Exception as e:
-            logger.error(f"Failed to commit permanent integration {integration_name}: {e}")
+            logger.error(
+                f"Failed to commit permanent integration {integration_name}: {e}"
+            )
             db.session.rollback()
 
 
@@ -240,38 +262,40 @@ def validate_default_project() -> None:
     'is_default' metadata. If it is not possible, then terminate the process with error.
     Note: this can be done using 'project_controller', but we want to save init time and used RAM.
     """
-    new_default_project_name = config.get('default_project')
+    new_default_project_name = config.get("default_project")
     logger.debug(f"Checking if default project {new_default_project_name} exists")
     filter_company_id = ctx.company_id if ctx.company_id is not None else 0
 
-    current_default_project: db.Project | None = (
-        db.Project.query.filter(
-            db.Project.company_id == filter_company_id,
-            db.Project.metadata_['is_default'].as_boolean() == True  # noqa
-        ).first()
-    )
+    current_default_project: db.Project | None = db.Project.query.filter(
+        db.Project.company_id == filter_company_id,
+        db.Project.metadata_["is_default"].as_boolean() == True,  # noqa
+    ).first()
 
     if current_default_project is None:
         # Legacy: If the default project does not exist, mark the new one as default.
         existing_project = db.Project.query.filter(
             db.Project.company_id == filter_company_id,
-            func.lower(db.Project.name) == func.lower(new_default_project_name)
+            func.lower(db.Project.name) == func.lower(new_default_project_name),
         ).first()
         if existing_project is None:
-            logger.critical(f"A project with the name '{new_default_project_name}' does not exist")
+            logger.critical(
+                f"A project with the name '{new_default_project_name}' does not exist"
+            )
             sys.exit(1)
 
-        existing_project.metadata_ = {'is_default': True}
-        flag_modified(existing_project, 'metadata_')
+        existing_project.metadata_ = {"is_default": True}
+        flag_modified(existing_project, "metadata_")
         db.session.commit()
     elif current_default_project.name != new_default_project_name:
         # If the default project exists, but the name is different, update the name.
         existing_project = db.Project.query.filter(
             db.Project.company_id == filter_company_id,
-            func.lower(db.Project.name) == func.lower(new_default_project_name)
+            func.lower(db.Project.name) == func.lower(new_default_project_name),
         ).first()
         if existing_project is not None:
-            logger.critical(f"A project with the name '{new_default_project_name}' already exists")
+            logger.critical(
+                f"A project with the name '{new_default_project_name}' already exists"
+            )
             sys.exit(1)
         current_default_project.name = new_default_project_name
         db.session.commit()
@@ -289,7 +313,7 @@ def start_process(trunc_process_data: TrunkProcessData) -> None:
         trunc_process_data.process = mp_ctx.Process(
             target=trunc_process_data.entrypoint,
             args=trunc_process_data.args,
-            name=trunc_process_data.name
+            name=trunc_process_data.name,
         )
         trunc_process_data.process.start()
     except Exception as e:
@@ -300,20 +324,21 @@ def start_process(trunc_process_data: TrunkProcessData) -> None:
         raise e
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     mp.freeze_support()
     # warn if less than 1Gb of free RAM
     if psutil.virtual_memory().available < (1 << 30):
         logger.warning(
-            'The system is running low on memory. '
-            + 'This may impact the stability and performance of the program.'
+            "The system is running low on memory. "
+            + "This may impact the stability and performance of the program."
         )
 
     ctx.set_default()
 
     # ---- CHECK SYSTEM ----
     if not (sys.version_info[0] >= 3 and sys.version_info[1] >= 10):
-        print("""
+        print(
+            """
      MindsDB requires Python >= 3.10 to run
 
      Once you have supported Python version installed you can start mindsdb as follows:
@@ -329,11 +354,12 @@ if __name__ == '__main__':
      python3 -m mindsdb
 
      More instructions in https://docs.mindsdb.com
-         """)
+         """
+        )
         exit(1)
 
     if config.cmd_args.version:
-        print(f'MindsDB {mindsdb_version}')
+        print(f"MindsDB {mindsdb_version}")
         sys.exit(0)
 
     config.raise_warnings(logger=logger)
@@ -342,18 +368,19 @@ if __name__ == '__main__':
     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:
+    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
             requests. This is related to 'memory pool' that is 'mimalloc' by default: it is fastest but use a lot of ram
             """
             import pyarrow as pa
+
             try:
                 pa.jemalloc_memory_pool()
-                os.environ['ARROW_DEFAULT_MEMORY_POOL'] = 'jemalloc'
+                os.environ["ARROW_DEFAULT_MEMORY_POOL"] = "jemalloc"
             except NotImplementedError:
                 pa.system_memory_pool()
-                os.environ['ARROW_DEFAULT_MEMORY_POOL'] = 'system'
+                os.environ["ARROW_DEFAULT_MEMORY_POOL"] = "system"
         except Exception:
             pass
 
@@ -368,20 +395,18 @@ if __name__ == '__main__':
     elif environment != "local":
         try:
             aws_meta_data = get_aws_meta_data()
-            config.update({
-                'aws_meta_data': aws_meta_data
-            })
+            config.update({"aws_meta_data": aws_meta_data})
         except Exception:
             pass
 
-    apis = os.getenv('MINDSDB_APIS') or config.cmd_args.api
+    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]
     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
-        api_arr = [TrunkProcessEnum(name) for name in apis.split(',')]
+        api_arr = [TrunkProcessEnum(name) for name in apis.split(",")]
 
     logger.info(f"Version: {mindsdb_version}")
     logger.info(f"Configuration file: {config.config_path or 'absent'}")
@@ -396,6 +421,7 @@ if __name__ == '__main__':
         logger.debug("Applying database migrations")
         try:
             from mindsdb.migrations import migrate
+
             migrate.migrate_to_head()
         except Exception as e:
             logger.error(f"Error! Something went wrong during DB migrations: {e}")
@@ -410,10 +436,11 @@ if __name__ == '__main__':
     clean_process_marks()
 
     # 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', {})
+    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("a2a", {})
     trunc_processes_struct = {
         TrunkProcessEnum.HTTP: TrunkProcessData(
             name=TrunkProcessEnum.HTTP.value,
@@ -469,6 +496,7 @@ if __name__ == '__main__':
             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(
@@ -485,6 +513,20 @@ if __name__ == '__main__':
             max_restart_interval_seconds=litellm_api_config.get(
                 '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
+            )
         )
     }
 
@@ -494,17 +536,20 @@ if __name__ == '__main__':
         else:
             logger.error(f"ERROR: {api_enum} API is not a valid api in config")
 
-    if config['jobs']['disable'] is False:
+    if config["jobs"]["disable"] is False:
         trunc_processes_struct[TrunkProcessEnum.JOBS].need_to_run = True
 
-    if config['tasks']['disable'] is False:
+    if config["tasks"]["disable"] is False:
         trunc_processes_struct[TrunkProcessEnum.TASKS].need_to_run = True
 
     if config.cmd_args.ml_task_queue_consumer is True:
         trunc_processes_struct[TrunkProcessEnum.ML_TASK_QUEUE].need_to_run = True
 
     for trunc_process_data in trunc_processes_struct.values():
-        if trunc_process_data.started is True or trunc_process_data.need_to_run is False:
+        if (
+            trunc_process_data.started is True
+            or trunc_process_data.need_to_run is False
+        ):
             continue
         start_process(trunc_process_data)
 
@@ -524,10 +569,11 @@ if __name__ == '__main__':
             wait_api_start(
                 trunc_process_data.name,
                 trunc_process_data.process.pid,
-                trunc_process_data.port
+                trunc_process_data.port,
             )
             for trunc_process_data in trunc_processes_struct.values()
-            if trunc_process_data.port is not None and trunc_process_data.need_to_run is True
+            if trunc_process_data.port is not None
+            and trunc_process_data.need_to_run is True
         ]
         for future in asyncio.as_completed(futures):
             api_name, port, started = await future
@@ -550,7 +596,9 @@ if __name__ == '__main__':
             finally:
                 if trunc_process_data.should_restart:
                     if trunc_process_data.request_restart_attempt():
-                        logger.warning(f"{trunc_process_data.name} API: stopped unexpectedly, restarting")
+                        logger.warning(
+                            f"{trunc_process_data.name} API: stopped unexpectedly, restarting"
+                        )
                         trunc_process_data.process = None
                         if trunc_process_data.name == TrunkProcessEnum.HTTP.value:
                             # do not open GUI on HTTP API restart
@@ -559,7 +607,7 @@ if __name__ == '__main__':
                         api_name, port, started = await wait_api_start(
                             trunc_process_data.name,
                             trunc_process_data.process.pid,
-                            trunc_process_data.port
+                            trunc_process_data.port,
                         )
                         if started:
                             logger.info(f"{api_name} API: started on {port}")
@@ -569,7 +617,7 @@ if __name__ == '__main__':
                         finish = True
                         logger.error(
                             f'The "{trunc_process_data.name}" process could not restart after failure. '
-                            'There will be no further attempts to restart.'
+                            "There will be no further attempts to restart."
                         )
                 else:
                     finish = True
@@ -582,13 +630,13 @@ if __name__ == '__main__':
                 for trunc_process_data in trunc_processes_struct.values()
                 if trunc_process_data.need_to_run is True
             ],
-            return_exceptions=False
+            return_exceptions=False,
         )
 
     ioloop = asyncio.new_event_loop()
     ioloop.run_until_complete(wait_apis_start())
 
-    threading.Thread(target=do_clean_process_marks, name='clean_process_marks').start()
+    threading.Thread(target=do_clean_process_marks, name="clean_process_marks").start()
 
     ioloop.run_until_complete(gather_apis())
     ioloop.close()

mindsdb/api/a2a/__main__.py

@@ -0,0 +1,114 @@
+import sys
+import logging
+import click
+from dotenv import load_dotenv
+
+# A2A specific imports
+from .common.types import (
+    AgentCard,
+    AgentCapabilities,
+    AgentSkill,
+    MissingAPIKeyError,
+)
+from .common.server.server import A2AServer
+from .task_manager import AgentTaskManager
+from .agent import MindsDBAgent
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+
+
+@click.command()
+@click.option("--host", default="localhost", help="A2A server host")
+@click.option("--port", default=10002, help="A2A server port", type=int)
+@click.option("--mindsdb-host", default="localhost", help="MindsDB server host")
+@click.option("--mindsdb-port", default=47334, help="MindsDB server port", type=int)
+@click.option("--project-name", default="mindsdb", help="MindsDB project name")
+@click.option(
+    "--log-level",
+    default="INFO",
+    help="Logging level (DEBUG, INFO, WARNING, ERROR)",
+)
+def main(
+    host: str,
+    port: int,
+    mindsdb_host: str,
+    mindsdb_port: int,
+    project_name: str,
+    log_level: str,
+):
+    """Entry-point that starts an A2A compliant server which forwards tasks to an existing MindsDB agent."""
+
+    # Configure logging level
+    logging.getLogger().setLevel(getattr(logging, log_level.upper(), logging.INFO))
+
+    # Load .env if present
+    load_dotenv()
+
+    try:
+        logger.info(
+            "Starting MindsDB A2A connector on http://%s:%s (project=%s)",
+            host,
+            port,
+            project_name,
+        )
+
+        # --- 1. 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=(
+                "A2A connector that proxies requests to MindsDB agents "
+                f"in project '{project_name}'."
+            ),
+            url=f"http://{host}:{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,
+            mindsdb_host=mindsdb_host,
+            mindsdb_port=mindsdb_port,
+        )
+
+        # --- 2. Start A2A server ----------------------------------------------
+        logger.info("Starting A2A server…")
+        server = A2AServer(
+            agent_card=agent_card,
+            task_manager=task_manager,
+            host=host,
+            port=port,
+            endpoint="/a2a",  # Keep the same route used by the client
+        )
+        server.start()
+
+    except MissingAPIKeyError as exc:
+        logger.error("Authentication error: %s", exc)
+        sys.exit(1)
+    except Exception as exc:  # noqa: BLE001
+        logger.exception("Unexpected error: %s", exc)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()