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

mindsdb/__about__.py

@@ -1,6 +1,6 @@
 __title__ = "MindsDB"
 __package_name__ = "mindsdb"
-__version__ = "25.7.4.0"
+__version__ = "25.8.3.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

@@ -39,7 +39,7 @@ from mindsdb.utilities.starters import (
 )
 from mindsdb.utilities.ps import is_pid_listen_port, get_child_pids
 import mindsdb.interfaces.storage.db as db
-from mindsdb.utilities.fs import clean_process_marks, clean_unlinked_process_marks
+from mindsdb.utilities.fs import clean_process_marks, clean_unlinked_process_marks, create_pid_file, delete_pid_file
 from mindsdb.utilities.context import context as ctx
 from mindsdb.utilities.auth import register_oauth_client, get_aws_meta_data
 from mindsdb.utilities.sentry import sentry_sdk  # noqa: F401
@@ -134,6 +134,9 @@ class TrunkProcessData:
 
 def close_api_gracefully(trunc_processes_struct):
     _stop_event.set()
+
+    delete_pid_file()
+
     try:
         for trunc_processes_data in trunc_processes_struct.values():
             process = trunc_processes_data.process
@@ -335,6 +338,13 @@ if __name__ == "__main__":
         print(f"MindsDB {mindsdb_version}")
         sys.exit(0)
 
+    if config.cmd_args.update_gui:
+        from mindsdb.api.http.initialize import initialize_static
+
+        logger.info("Updating the GUI version")
+        initialize_static()
+        sys.exit(0)
+
     config.raise_warnings(logger=logger)
     os.environ["MINDSDB_RUNTIME"] = "1"
 
@@ -510,6 +520,8 @@ if __name__ == "__main__":
     if config.cmd_args.ml_task_queue_consumer is True:
         trunc_processes_struct[TrunkProcessEnum.ML_TASK_QUEUE].need_to_run = True
 
+    create_pid_file()
+
     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:
             continue

mindsdb/api/a2a/agent.py

@@ -3,7 +3,7 @@ from typing import Any, AsyncIterable, Dict, List
 import requests
 import logging
 import httpx
-from mindsdb.api.a2a.utils import to_serializable
+from mindsdb.api.a2a.utils import to_serializable, convert_a2a_message_to_qa_format
 from mindsdb.api.a2a.constants import DEFAULT_STREAM_TIMEOUT
 
 logger = logging.getLogger(__name__)
@@ -117,22 +117,12 @@ class MindsDBAgent:
         """Stream responses from the MindsDB agent (uses streaming API endpoint)."""
         try:
             logger.info(f"Using streaming API for query: {query[:100]}...")
-            formatted_messages = []
+            # Create A2A message structure with history and current query
+            a2a_message = {"role": "user", "parts": [{"text": query}]}
             if history:
-                for msg in history:
-                    msg_dict = msg.dict() if hasattr(msg, "dict") else msg
-                    role = msg_dict.get("role", "user")
-                    text = ""
-                    for part in msg_dict.get("parts", []):
-                        if part.get("type") == "text":
-                            text = part.get("text", "")
-                            break
-                    if text:
-                        if role == "user":
-                            formatted_messages.append({"question": text, "answer": None})
-                        elif role == "assistant" and formatted_messages:
-                            formatted_messages[-1]["answer"] = text
-            formatted_messages.append({"question": query, "answer": None})
+                a2a_message["history"] = history
+            # Convert to Q&A format using centralized utility
+            formatted_messages = convert_a2a_message_to_qa_format(a2a_message)
             logger.debug(f"Formatted messages for agent: {formatted_messages}")
             streaming_response = self.streaming_invoke(formatted_messages, timeout=timeout)
             async for chunk in streaming_response:

mindsdb/api/a2a/common/types.py

@@ -35,9 +35,7 @@ class FileContent(BaseModel):
         if not (self.bytes or self.uri):
             raise ValueError("Either 'bytes' or 'uri' must be present in the file data")
         if self.bytes and self.uri:
-            raise ValueError(
-                "Only one of 'bytes' or 'uri' can be present in the file data"
-            )
+            raise ValueError("Only one of 'bytes' or 'uri' can be present in the file data")
         return self
 
 
@@ -57,9 +55,10 @@ Part = Annotated[Union[TextPart, FilePart, DataPart], Field(discriminator="type"
 
 
 class Message(BaseModel):
-    role: Literal["user", "agent"]
+    role: Literal["user", "agent", "assistant"]
     parts: List[Part]
     metadata: dict[str, Any] | None = None
+    history: Optional[List["Message"]] = None
 
 
 class TaskStatus(BaseModel):

mindsdb/api/a2a/task_manager.py

@@ -18,7 +18,7 @@ from mindsdb.api.a2a.common.types import (
 )
 from mindsdb.api.a2a.common.server.task_manager import InMemoryTaskManager
 from mindsdb.api.a2a.agent import MindsDBAgent
-from mindsdb.api.a2a.utils import to_serializable
+from mindsdb.api.a2a.utils import to_serializable, convert_a2a_message_to_qa_format
 
 from typing import Union
 import logging
@@ -94,22 +94,8 @@ class AgentTaskManager(InMemoryTaskManager):
 
         agent = self._create_agent(agent_name)
 
-        # Get the history from the task
+        # Get the history from the task object (where it was properly extracted and stored)
         history = task.history if task and task.history else []
-        logger.info(f"Using history with length {len(history)} for request")
-
-        # Log the history for debugging
-        logger.info(f"Conversation history for task {task_send_params.id}:")
-        for idx, msg in enumerate(history):
-            # Convert Message object to dict if needed
-            msg_dict = msg.dict() if hasattr(msg, "dict") else msg
-            role = msg_dict.get("role", "unknown")
-            text = ""
-            for part in msg_dict.get("parts", []):
-                if part.get("type") == "text":
-                    text = part.get("text", "")
-                    break
-            logger.info(f"Message {idx + 1} ({role}): {text[:100]}...")
 
         if not streaming:
             # If streaming is disabled, use invoke and return a single response
@@ -183,17 +169,16 @@ class AgentTaskManager(InMemoryTaskManager):
         # If streaming is enabled (default), use the streaming implementation
         try:
             logger.debug(f"[TaskManager] Entering agent.stream() at {time.time()}")
-            # Transform to agent-compatible format
-            agent_messages = to_question_format(
-                [
-                    {
-                        "role": task_send_params.message.role,
-                        "parts": task_send_params.message.parts,
-                        "metadata": task_send_params.message.metadata,
-                    }
-                ]
-            )
-            async for item in agent.streaming_invoke(agent_messages, timeout=60):
+            # Create A2A message structure and convert using centralized utility
+            a2a_message = task_send_params.message.model_dump()
+            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"]:
                     item["artifact"]["parts"] = [to_serializable(p) for p in item["artifact"]["parts"]]
@@ -235,19 +220,23 @@ class AgentTaskManager(InMemoryTaskManager):
                 message = task_send_params.message
                 message_dict = message.dict() if hasattr(message, "dict") else message
 
-                # Get history from request if available
+                # Get history from request if available - check both locations
                 history = []
+
+                # First check if history is at top level (task_send_params.history)
                 if hasattr(task_send_params, "history") and task_send_params.history:
-                    # Convert each history item to dict if needed and ensure proper role
+                    # Convert each history item to dict if needed
                     for item in task_send_params.history:
-                        item_dict = item.dict() if hasattr(item, "dict") else item
-                        # Ensure the role is properly set
-                        if "role" not in item_dict:
-                            item_dict["role"] = "assistant" if "answer" in item_dict else "user"
+                        item_dict = item.model_dump() if hasattr(item, "model_dump") else item
+                        history.append(item_dict)
+                # Also check if history is nested under message (message.history)
+                elif hasattr(task_send_params.message, "history") and task_send_params.message.history:
+                    for item in task_send_params.message.history:
+                        item_dict = item.model_dump() if hasattr(item, "model_dump") else item
                         history.append(item_dict)
 
-                # Add current message to history
-                history.append(message_dict)
+                # DO NOT add current message to history - it should be processed separately
+                # The current message will be extracted during streaming from task_send_params.message
 
                 # Create a new task
                 task = Task(

mindsdb/api/a2a/utils.py

@@ -1,3 +1,9 @@
+from typing import Dict, List
+from mindsdb.utilities.log import getLogger
+
+logger = getLogger(__name__)
+
+
 def to_serializable(obj):
     # Primitives
     if isinstance(obj, (str, int, float, bool, type(None))):
@@ -19,3 +25,60 @@ def to_serializable(obj):
         return [to_serializable(v) for v in obj]
     # Fallback: string
     return str(obj)
+
+
+def convert_a2a_message_to_qa_format(a2a_message: Dict) -> List[Dict[str, str]]:
+    """
+    Convert A2A message format to question/answer format.
+
+    This is the format that the langchain agent expects and ensure effective multi-turn conversation
+
+    Args:
+        a2a_message: A2A message containing history and current message parts
+
+    Returns:
+        List of messages in question/answer format
+    """
+    converted_messages = []
+
+    # Process conversation history first
+    if "history" in a2a_message:
+        for hist_msg in a2a_message["history"]:
+            if hist_msg.get("role") == "user":
+                # Extract text from parts
+                text = ""
+                for part in hist_msg.get("parts", []):
+                    if part.get("type") == "text":
+                        text = part.get("text", "")
+                        break
+                # Create question with empty answer initially
+                converted_messages.append({"question": text, "answer": ""})
+            elif hist_msg.get("role") in ["agent", "assistant"]:
+                # Extract text from parts
+                text = ""
+                for part in hist_msg.get("parts", []):
+                    if part.get("type") == "text":
+                        text = part.get("text", "")
+                        break
+                # Pair with the most recent question that has empty answer
+                paired = False
+                for i in range(len(converted_messages) - 1, -1, -1):
+                    if converted_messages[i].get("answer") == "":
+                        converted_messages[i]["answer"] = text
+                        paired = True
+                        break
+
+                if not paired:
+                    logger.warning("Could not pair agent response with question (no empty answer found)")
+
+        logger.debug(f"Converted {len(a2a_message['history'])} A2A history messages to Q&A format")
+
+    # Add current message as final question with empty answer
+    current_text = ""
+    for part in a2a_message.get("parts", []):
+        if part.get("type") == "text":
+            current_text = part.get("text", "")
+            break
+    converted_messages.append({"question": current_text, "answer": ""})
+
+    return converted_messages

mindsdb/api/executor/command_executor.py

@@ -1195,11 +1195,17 @@ class ExecuteCommands:
                 msg = dedent(
                     f"""\
                     The '{handler_module_meta["name"]}' handler cannot be used. Reason is:
-                        {handler_module_meta["import"]["error_message"]}
+                        {handler_module_meta["import"]["error_message"] or msg}
                 """
                 )
                 is_cloud = self.session.config.get("cloud", False)
-                if is_cloud is False and "No module named" in handler_module_meta["import"]["error_message"]:
+                if (
+                    is_cloud is False
+                    # NOTE: BYOM may raise these errors if there is an error in the user's code,
+                    # therefore error_message will be None
+                    and handler_module_meta["name"] != "byom"
+                    and "No module named" in handler_module_meta["import"]["error_message"]
+                ):
                     logger.info(get_handler_install_message(handler_module_meta["name"]))
             ast_drop = DropMLEngine(name=Identifier(name))
             self.answer_drop_ml_engine(ast_drop)
@@ -1342,24 +1348,12 @@ class ExecuteCommands:
                 from_table=NativeQuery(integration=statement.from_table, query=statement.query_str),
             )
             query_str = query.to_string()
-        else:
-            query = parse_sql(query_str)
-
-        if isinstance(query, Select):
-            # check create view sql
-            query.limit = Constant(1)
-
-            query_context_controller.set_context(query_context_controller.IGNORE_CONTEXT)
-            try:
-                SQLQuery(query, session=self.session, database=database_name)
-            finally:
-                query_context_controller.release_context(query_context_controller.IGNORE_CONTEXT)
 
         project = self.session.database_controller.get_project(project_name)
 
         if isinstance(statement, CreateView):
             try:
-                project.create_view(view_name, query=query_str)
+                project.create_view(view_name, query=query_str, session=self.session)
             except EntityExistsError:
                 if getattr(statement, "if_not_exists", False) is False:
                     raise

mindsdb/api/executor/sql_query/steps/fetch_dataframe.py

@@ -50,29 +50,26 @@ def get_table_alias(table_obj, default_db_name):
 
 def get_fill_param_fnc(steps_data):
     def fill_params(node, callstack=None, **kwargs):
-        if isinstance(node, Parameter):
-            rs = steps_data[node.value.step_num]
-            items = [Constant(i) for i in rs.get_column_values(col_idx=0)]
-
-            is_single_item = True
-            if callstack:
-                node_prev = callstack[0]
-                if isinstance(node_prev, BinaryOperation):
-                    # Check case: 'something IN Parameter()'
-                    if node_prev.op.lower() == "in" and node_prev.args[1] is node:
-                        is_single_item = False
-
-            if is_single_item and len(items) == 1:
-                # extract one value for option 'col=(subselect)'
-                node = items[0]
-            else:
-                node = Tuple(items)
-            return node
-
-        if isinstance(node, Parameter):
-            rs = steps_data[node.value.step_num]
-            items = [Constant(i) for i in rs.get_column_values(col_idx=0)]
-            return Tuple(items)
+        if not isinstance(node, Parameter):
+            return
+
+        rs = steps_data[node.value.step_num]
+        items = [Constant(i) for i in rs.get_column_values(col_idx=0)]
+
+        is_single_item = True
+        if callstack:
+            node_prev = callstack[0]
+            if isinstance(node_prev, BinaryOperation):
+                # Check case: 'something IN Parameter()'
+                if node_prev.op.lower() == "in" and node_prev.args[1] is node:
+                    is_single_item = False
+
+        if is_single_item and len(items) == 1:
+            # extract one value for option 'col=(subselect)'
+            node = items[0]
+        else:
+            node = Tuple(items)
+        return node
 
     return fill_params
 
@@ -115,7 +112,7 @@ class FetchDataframeStepCall(BaseStepCall):
 
         # if query registered, set progress
         if self.sql_query.run_query is not None:
-            self.sql_query.run_query.set_progress(df, None)
+            self.sql_query.run_query.set_progress(processed_rows=len(df))
         return ResultSet.from_df(
             df,
             table_name=table_alias[1],

mindsdb/api/executor/sql_query/steps/fetch_dataframe_partition.py

@@ -97,6 +97,7 @@ class FetchDataframePartitionCall(BaseStepCall):
         for df in run_query.get_partitions(self.dn, self, query):
             try:
                 sub_data = self.exec_sub_steps(df)
+                run_query.set_progress(processed_rows=len(df))
                 results.append(sub_data)
             except Exception as e:
                 if on_error == "skip":
@@ -175,17 +176,22 @@ class FetchDataframePartitionCall(BaseStepCall):
                 # split into chunks and send to workers
                 futures = []
                 for df2 in split_data_frame(df, partition_size):
-                    futures.append(executor.submit(self.exec_sub_steps, df2))
+                    futures.append([executor.submit(self.exec_sub_steps, df2), len(df2)])
 
-                for future in futures:
+                error = None
+                for future, rows_count in futures:
                     try:
                         results.append(future.result())
+                        run_query.set_progress(processed_rows=rows_count)
                     except Exception as e:
                         if on_error == "skip":
                             logger.error(e)
                         else:
                             executor.shutdown()
-                            raise e
+                            error = e
+
+                if error:
+                    raise error
                 if self.sql_query.stop_event is not None and self.sql_query.stop_event.is_set():
                     executor.shutdown()
                     raise RuntimeError("Query is interrupted")

mindsdb/api/executor/sql_query/steps/subselect_step.py

@@ -2,7 +2,15 @@ from collections import defaultdict
 
 import pandas as pd
 
-from mindsdb_sql_parser.ast import Identifier, Select, Star, Constant, Parameter, Function, Variable, BinaryOperation
+from mindsdb_sql_parser.ast import (
+    Identifier,
+    Select,
+    Star,
+    Constant,
+    Function,
+    Variable,
+    BinaryOperation,
+)
 
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import SERVER_VARIABLES
 from mindsdb.api.executor.planner.step_result import Result
@@ -52,13 +60,8 @@ class SubSelectStepCall(BaseStepCall):
 
         # inject previous step values
         if isinstance(query, Select):
-
-            def inject_values(node, **kwargs):
-                if isinstance(node, Parameter) and isinstance(node.value, Result):
-                    prev_result = self.steps_data[node.value.step_num]
-                    return Constant(prev_result.get_column_values(col_idx=0)[0])
-
-            query_traversal(query, inject_values)
+            fill_params = get_fill_param_fnc(self.steps_data)
+            query_traversal(query, fill_params)
 
         df = result.to_df()
         res = query_df(df, query, session=self.session)