MindsDB 25.6.2.0__py3-none-any.whl → 25.6.3.0__py3-none-any.whl

mindsdb/__about__.py

@@ -1,6 +1,6 @@
 __title__ = "MindsDB"
 __package_name__ = "mindsdb"
-__version__ = "25.6.2.0"
+__version__ = "25.6.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/api/a2a/agent.py

@@ -257,14 +257,35 @@ class MindsDBAgent:
         try:
             logger.info(f"Using streaming API for query: {query[:100]}...")
 
-            # Start with history if provided, otherwise empty list
-            messages = history or []
+            # Format history into the expected format
+            formatted_messages = []
+            if history:
+                for msg in history:
+                    # Convert Message object to dict if needed
+                    msg_dict = msg.dict() if hasattr(msg, "dict") else msg
+                    role = msg_dict.get("role", "user")
+
+                    # Extract text from parts
+                    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:
+                            # Add the answer to the last question
+                            formatted_messages[-1]["answer"] = text
 
             # Add the current query to the messages
-            messages.append({"question": query, "answer": None})
+            formatted_messages.append({"question": query, "answer": None})
+
+            logger.debug(f"Formatted messages for agent: {formatted_messages}")
 
             # Use the streaming_invoke method to get real streaming responses
-            streaming_response = self.streaming_invoke(messages)
+            streaming_response = self.streaming_invoke(formatted_messages)
 
             # Yield all chunks directly from the streaming response
             for chunk in streaming_response:

mindsdb/api/a2a/task_manager.py

@@ -63,7 +63,8 @@ class AgentTaskManager(InMemoryTaskManager):
 
         # Create and store the task first to ensure it exists
         try:
-            await self.upsert_task(task_send_params)
+            task = await self.upsert_task(task_send_params)
+            logger.info(f"Task created/updated with history length: {len(task.history) if task.history else 0}")
         except Exception as e:
             logger.error(f"Error creating task: {str(e)}")
             yield SendTaskStreamingResponse(
@@ -74,10 +75,27 @@ class AgentTaskManager(InMemoryTaskManager):
 
         agent = self._create_agent(agent_name)
 
+        # Get the history from the task
+        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
             try:
-                result = agent.invoke(query, task_send_params.sessionId)
+                result = agent.invoke(query, task_send_params.sessionId, history=history)
 
                 # Use the parts from the agent response if available, or create them
                 if "parts" in result:
@@ -134,7 +152,7 @@ class AgentTaskManager(InMemoryTaskManager):
             # Track the chunks we've seen to avoid duplicates
             seen_chunks = set()
 
-            async for item in agent.stream(query, task_send_params.sessionId):
+            async for item in agent.stream(query, task_send_params.sessionId, history=history):
                 # Ensure item has the required fields or provide defaults
                 is_task_complete = item.get("is_task_complete", False)
 
@@ -356,13 +374,26 @@ class AgentTaskManager(InMemoryTaskManager):
                 message = task_send_params.message
                 message_dict = message.dict() if hasattr(message, "dict") else message
 
+                # Get history from request if available
+                history = []
+                if hasattr(task_send_params, "history") and task_send_params.history:
+                    # Convert each history item to dict if needed and ensure proper role
+                    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"
+                        history.append(item_dict)
+
+                # Add current message to history
+                history.append(message_dict)
+
                 # Create a new task
                 task = Task(
                     id=task_send_params.id,
                     sessionId=task_send_params.sessionId,
-                    messages=[message_dict],
                     status=TaskStatus(state=TaskState.SUBMITTED),
-                    history=[message_dict],
+                    history=history,
                     artifacts=[],
                 )
                 self.tasks[task_send_params.id] = task
@@ -372,6 +403,22 @@ class AgentTaskManager(InMemoryTaskManager):
                 message_dict = message.dict() if hasattr(message, "dict") else message
 
                 # Update the existing task
+                if task.history is None:
+                    task.history = []
+
+                # If we have new history from the request, use it
+                if hasattr(task_send_params, "history") and task_send_params.history:
+                    # Convert each history item to dict if needed and ensure proper role
+                    history = []
+                    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"
+                        history.append(item_dict)
+                    task.history = history
+
+                # Add current message to history
                 task.history.append(message_dict)
             return task
 
@@ -459,6 +506,17 @@ class AgentTaskManager(InMemoryTaskManager):
                 self.tasks[task_id] = task
 
             task.status = status
+
+            # Store assistant's response in history if we have a message
+            if status.message and status.message.role == "agent":
+                if task.history is None:
+                    task.history = []
+                # Convert message to dict if needed
+                message_dict = status.message.dict() if hasattr(status.message, "dict") else status.message
+                # Ensure role is set to assistant
+                message_dict["role"] = "assistant"
+                task.history.append(message_dict)
+
             if artifacts is not None:
                 for artifact in artifacts:
                     if artifact.append and len(task.artifacts) > 0:
@@ -505,12 +563,16 @@ class AgentTaskManager(InMemoryTaskManager):
         agent = self._create_agent(agent_name)
 
         try:
+            # Get the history from the task
+            task = self.tasks.get(task_send_params.id)
+            history = task.history if task and task.history else []
+
             # Always use streaming internally, but handle the response differently based on the streaming parameter
             all_parts = []
             final_metadata = {}
 
             # Create a streaming generator
-            stream_gen = agent.stream(query, task_send_params.sessionId)
+            stream_gen = agent.stream(query, task_send_params.sessionId, history=history)
 
             if streaming:
                 # For streaming mode, we'll use the streaming endpoint instead

mindsdb/api/executor/datahub/datanodes/mindsdb_tables.py

@@ -26,18 +26,17 @@ def to_json(obj):
 def get_project_name(query: ASTNode = None):
     project_name = None
     if (
-            isinstance(query, Select)
-            and type(query.where) is BinaryOperation
-            and query.where.op == '='
-            and query.where.args[0].parts == ['project']
-            and isinstance(query.where.args[1], Constant)
+        isinstance(query, Select)
+        and type(query.where) is BinaryOperation
+        and query.where.op == "="
+        and query.where.args[0].parts == ["project"]
+        and isinstance(query.where.args[1], Constant)
     ):
         project_name = query.where.args[1].value
     return project_name
 
 
 class MdbTable(Table):
-
     visible: bool = True
 
 
@@ -75,27 +74,29 @@ class ModelsTable(MdbTable):
                 table_name = row["name"]
                 table_meta = row["metadata"]
 
-                data.append([
-                    table_name,
-                    table_meta["engine"],
-                    project_name,
-                    table_meta["active"],
-                    table_meta["version"],
-                    table_meta["status"],
-                    table_meta["accuracy"],
-                    table_meta["predict"],
-                    table_meta["update_status"],
-                    table_meta["mindsdb_version"],
-                    table_meta["error"],
-                    table_meta["select_data_query"],
-                    to_json(table_meta["training_options"]),
-                    table_meta["current_training_phase"],
-                    table_meta["total_training_phases"],
-                    table_meta["training_phase_name"],
-                    table_meta["label"],
-                    row["created_at"],
-                    table_meta["training_time"],
-                ])
+                data.append(
+                    [
+                        table_name,
+                        table_meta["engine"],
+                        project_name,
+                        table_meta["active"],
+                        table_meta["version"],
+                        table_meta["status"],
+                        table_meta["accuracy"],
+                        table_meta["predict"],
+                        table_meta["update_status"],
+                        table_meta["mindsdb_version"],
+                        table_meta["error"],
+                        table_meta["select_data_query"],
+                        to_json(table_meta["training_options"]),
+                        table_meta["current_training_phase"],
+                        table_meta["total_training_phases"],
+                        table_meta["training_phase_name"],
+                        table_meta["label"],
+                        row["created_at"],
+                        table_meta["training_time"],
+                    ]
+                )
             # TODO optimise here
             # if target_table is not None and target_table != project_name:
             #     continue
@@ -110,12 +111,8 @@ class DatabasesTable(MdbTable):
 
     @classmethod
     def get_data(cls, session, inf_schema, **kwargs):
-
         project = inf_schema.database_controller.get_list(with_secrets=session.show_secrets)
-        data = [
-            [x["name"], x["type"], x["engine"], to_json(x.get("connection_data"))]
-            for x in project
-        ]
+        data = [[x["name"], x["type"], x["engine"], to_json(x.get("connection_data"))] for x in project]
 
         df = pd.DataFrame(data, columns=cls.columns)
         return df
@@ -123,17 +120,12 @@ class DatabasesTable(MdbTable):
 
 class MLEnginesTable(MdbTable):
     name = "ML_ENGINES"
-    columns = [
-        "NAME", "HANDLER", "CONNECTION_DATA"
-    ]
+    columns = ["NAME", "HANDLER", "CONNECTION_DATA"]
 
     @classmethod
     def get_data(cls, session, inf_schema, **kwargs):
-
         integrations = inf_schema.integration_controller.get_all(show_secrets=session.show_secrets)
-        ml_integrations = {
-            key: val for key, val in integrations.items() if val["type"] == "ml"
-        }
+        ml_integrations = {key: val for key, val in integrations.items() if val["type"] == "ml"}
 
         data = []
         for _key, val in ml_integrations.items():
@@ -158,7 +150,6 @@ class HandlersTable(MdbTable):
 
     @classmethod
     def get_data(cls, inf_schema, **kwargs):
-
         handlers = inf_schema.integration_controller.get_handlers_import_status()
 
         data = []
@@ -272,7 +263,7 @@ class TriggersTable(MdbTable):
         data = triggers_controller.get_list(project_name)
 
         columns = cls.mindsdb_columns
-        if inf_schema.session.api_type == 'sql':
+        if inf_schema.session.api_type == "sql":
             columns = columns + cls.columns
         columns_lower = [col.lower() for col in columns]
 
@@ -283,7 +274,7 @@ class TriggersTable(MdbTable):
 
 
 class ChatbotsTable(MdbTable):
-    name = 'CHATBOTS'
+    name = "CHATBOTS"
     columns = [
         "NAME",
         "PROJECT",
@@ -319,62 +310,78 @@ class ChatbotsTable(MdbTable):
         # to list of lists
         data = []
         for row in chatbot_data:
-            row['params'] = to_json(row['params'])
+            row["params"] = to_json(row["params"])
             data.append([row[k] for k in columns_lower])
 
         return pd.DataFrame(data, columns=columns)
 
 
 class KBTable(MdbTable):
-    name = 'KNOWLEDGE_BASES'
-    columns = ["NAME", "PROJECT", "MODEL", "STORAGE", "PARAMS",
-               "INSERT_STARTED_AT", "INSERT_FINISHED_AT", "PROCESSED_ROWS", "ERROR", "QUERY_ID"]
+    name = "KNOWLEDGE_BASES"
+    columns = [
+        "NAME",
+        "PROJECT",
+        "EMBEDDING_MODEL",
+        "RERANKING_MODEL",
+        "STORAGE",
+        "METADATA_COLUMNS",
+        "CONTENT_COLUMNS",
+        "ID_COLUMN",
+        "PARAMS",
+        "INSERT_STARTED_AT",
+        "INSERT_FINISHED_AT",
+        "PROCESSED_ROWS",
+        "ERROR",
+        "QUERY_ID",
+    ]
 
     @classmethod
     def get_data(cls, query: ASTNode = None, inf_schema=None, **kwargs):
         project_name = get_project_name(query)
 
         from mindsdb.interfaces.knowledge_base.controller import KnowledgeBaseController
+
         controller = KnowledgeBaseController(inf_schema.session)
         kb_list = controller.list(project_name)
 
         # shouldn't be a lot of queries, we can fetch them all
-        queries_data = {
-            item['id']: item
-            for item in query_context_controller.list_queries()
-        }
+        queries_data = {item["id"]: item for item in query_context_controller.list_queries()}
 
         data = []
 
         for kb in kb_list:
-            vector_database_name = kb['vector_database'] or ''
-
             query_item = {}
-            query_id = kb['query_id']
+            query_id = kb["query_id"]
             if query_id is not None:
                 if query_id in queries_data:
                     query_item = queries_data.get(query_id)
                 else:
                     query_id = None
 
-            data.append((
-                kb['name'],
-                kb['project_name'],
-                kb['embedding_model'],
-                vector_database_name + '.' + kb['vector_database_table'],
-                to_json(kb['params']),
-                query_item.get('started_at'),
-                query_item.get('finished_at'),
-                query_item.get('processed_rows'),
-                query_item.get('error'),
-                query_id,
-            ))
+            data.append(
+                (
+                    kb["name"],
+                    kb["project_name"],
+                    to_json(kb["embedding_model"]),
+                    to_json(kb["reranking_model"]),
+                    kb["vector_database"] + "." + kb["vector_database_table"],
+                    to_json(kb["metadata_columns"]),
+                    to_json(kb["content_columns"]),
+                    kb["id_column"],
+                    to_json(kb["params"]),
+                    query_item.get("started_at"),
+                    query_item.get("finished_at"),
+                    query_item.get("processed_rows"),
+                    query_item.get("error"),
+                    query_id,
+                )
+            )
 
         return pd.DataFrame(data, columns=cls.columns)
 
 
 class SkillsTable(MdbTable):
-    name = 'SKILLS'
+    name = "SKILLS"
     columns = ["NAME", "PROJECT", "TYPE", "PARAMS"]
 
     @classmethod
@@ -394,14 +401,8 @@ class SkillsTable(MdbTable):
 
 
 class AgentsTable(MdbTable):
-    name = 'AGENTS'
-    columns = [
-        "NAME",
-        "PROJECT",
-        "MODEL_NAME",
-        "SKILLS",
-        "PARAMS"
-    ]
+    name = "AGENTS"
+    columns = ["NAME", "PROJECT", "MODEL_NAME", "SKILLS", "PARAMS"]
 
     @classmethod
     def get_data(cls, query: ASTNode = None, inf_schema=None, **kwargs):
@@ -411,10 +412,7 @@ class AgentsTable(MdbTable):
         all_agents = agents_controller.get_agents(project_name)
 
         project_controller = ProjectController()
-        project_names = {
-            i.id: i.name
-            for i in project_controller.get_list()
-        }
+        project_names = {i.id: i.name for i in project_controller.get_list()}
 
         # NAME, PROJECT, MODEL, SKILLS, PARAMS
         data = [
@@ -423,7 +421,7 @@ class AgentsTable(MdbTable):
                 project_names[a.project_id],
                 a.model_name,
                 [rel.skill.name for rel in a.skills_relationships],
-                to_json(a.params)
+                to_json(a.params),
             )
             for a in all_agents
         ]
@@ -431,12 +429,11 @@ class AgentsTable(MdbTable):
 
 
 class ViewsTable(MdbTable):
-    name = 'VIEWS'
+    name = "VIEWS"
     columns = ["NAME", "PROJECT", "QUERY"]
 
     @classmethod
     def get_data(cls, query: ASTNode = None, **kwargs):
-
         project_name = get_project_name(query)
 
         data = ViewController().list(project_name)
@@ -450,9 +447,19 @@ class ViewsTable(MdbTable):
 
 
 class QueriesTable(MdbTable):
-    name = 'QUERIES'
-    columns = ["ID", "STARTED_AT", "FINISHED_AT", "PROCESSED_ROWS", "ERROR", "SQL", "DATABASE",
-               "PARAMETERS", "CONTEXT", "UPDATED_AT"]
+    name = "QUERIES"
+    columns = [
+        "ID",
+        "STARTED_AT",
+        "FINISHED_AT",
+        "PROCESSED_ROWS",
+        "ERROR",
+        "SQL",
+        "DATABASE",
+        "PARAMETERS",
+        "CONTEXT",
+        "UPDATED_AT",
+    ]
 
     @classmethod
     def get_data(cls, **kwargs):