MindsDB 25.5.4.2__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.5.4.2"
+__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

@@ -28,9 +28,7 @@ class MindsDBAgent:
         self.host = host
         self.port = port
         self.base_url = f"http://{host}:{port}"
-        self.agent_url = (
-            f"{self.base_url}/api/projects/{project_name}/agents/{agent_name}"
-        )
+        self.agent_url = f"{self.base_url}/api/projects/{project_name}/agents/{agent_name}"
         self.sql_url = f"{self.base_url}/api/sql/query"
         logger.info(f"Initialized MindsDB agent connector to {self.base_url}")
 
@@ -65,9 +63,7 @@ class MindsDBAgent:
                 for column in ["response", "result", "answer", "completion", "output"]:
                     if column in result_row:
                         content = result_row[column]
-                        logger.info(
-                            f"Found result in column '{column}': {content[:100]}..."
-                        )
+                        logger.info(f"Found result in column '{column}': {content[:100]}...")
                         return {
                             "content": content,
                             "parts": [{"type": "text", "text": content}],
@@ -122,9 +118,7 @@ class MindsDBAgent:
                 "parts": [{"type": "text", "text": error_msg}],
             }
 
-    def streaming_invoke(
-        self, messages: List[dict], timeout: int = DEFAULT_STREAM_TIMEOUT
-    ) -> Iterator[Dict[str, Any]]:
+    def streaming_invoke(self, messages: List[dict], timeout: int = DEFAULT_STREAM_TIMEOUT) -> Iterator[Dict[str, Any]]:
         """Stream responses from the MindsDB agent using the direct API endpoint.
 
         Args:
@@ -140,15 +134,11 @@ class MindsDBAgent:
             url = f"{self.base_url}/api/projects/{self.project_name}/agents/{self.agent_name}/completions/stream"
 
             # Log request for debugging
-            logger.info(
-                f"Sending streaming request to MindsDB agent: {self.agent_name}"
-            )
+            logger.info(f"Sending streaming request to MindsDB agent: {self.agent_name}")
             logger.debug(f"Request messages: {json.dumps(messages)[:200]}...")
 
             # Send the request to MindsDB streaming API with timeout
-            stream = requests.post(
-                url, json={"messages": messages}, stream=True, timeout=timeout
-            )
+            stream = requests.post(url, json={"messages": messages}, stream=True, timeout=timeout)
             stream.raise_for_status()
 
             # Process the streaming response directly
@@ -165,9 +155,7 @@ class MindsDBAgent:
                                 # Pass through the chunk with minimal modifications
                                 yield chunk
                             except json.JSONDecodeError as e:
-                                logger.warning(
-                                    f"Failed to parse JSON from line: {data}. Error: {str(e)}"
-                                )
+                                logger.warning(f"Failed to parse JSON from line: {data}. Error: {str(e)}")
                                 # Yield error information but continue processing
                                 yield {
                                     "error": f"JSON parse error: {str(e)}",
@@ -186,9 +174,7 @@ class MindsDBAgent:
                             logger.debug(f"Received non-data line: {line}")
 
                             # If it looks like a raw text response (not SSE format), wrap it
-                            if not line.startswith("event:") and not line.startswith(
-                                ":"
-                            ):
+                            if not line.startswith("event:") and not line.startswith(":"):
                                 yield {"content": line, "is_task_complete": False}
                     except UnicodeDecodeError as e:
                         logger.warning(f"Failed to decode line: {str(e)}")
@@ -252,16 +238,54 @@ class MindsDBAgent:
         # Send a final completion message
         yield {"is_task_complete": True, "metadata": {"complete": True}}
 
-    async def stream(self, query, session_id) -> AsyncIterable[Dict[str, Any]]:
-        """Stream responses from the MindsDB agent (uses streaming API endpoint)."""
+    async def stream(
+        self,
+        query: str,
+        session_id: str,
+        history: List[dict] | None = None,
+    ) -> AsyncIterable[Dict[str, Any]]:
+        """Stream responses from the MindsDB agent (uses streaming API endpoint).
+
+        Args:
+            query: The current query to send to the agent.
+            session_id: Unique identifier for the conversation session.
+            history: Optional list of previous messages in the conversation.
+
+        Returns:
+            AsyncIterable yielding chunks of the streaming response.
+        """
         try:
             logger.info(f"Using streaming API for query: {query[:100]}...")
 
-            # Format the query into the message structure expected by streaming_invoke
-            messages = [{"question": query, "answer": None}]
+            # 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
+            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/common/server/server.py

@@ -20,7 +20,8 @@ from ...common.types import (
 )
 from pydantic import ValidationError
 import json
-from typing import AsyncIterable, Any
+import time
+from typing import AsyncIterable, Any, Dict
 from ...common.server.task_manager import TaskManager
 
 import logging
@@ -44,9 +45,9 @@ class A2AServer:
         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"]
-        )
+        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"])
         # TODO: Remove this when we have a proper CORS policy
         self.app.add_middleware(
             CORSMiddleware,
@@ -55,6 +56,7 @@ class A2AServer:
             allow_methods=["*"],
             allow_headers=["*"],
         )
+        self.start_time = time.time()
 
     def start(self):
         if self.agent_card is None:
@@ -66,18 +68,30 @@ class A2AServer:
         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="info"
-        )
+        uvicorn.run(self.app, host=self.host, port=self.port, http="h11", timeout_keep_alive=65, log_level="info")
 
     def _get_agent_card(self, request: Request) -> JSONResponse:
         return JSONResponse(self.agent_card.model_dump(exclude_none=True))
 
+    def _get_status(self, request: Request) -> JSONResponse:
+        """
+        Status endpoint that returns basic server information.
+        This endpoint can be used by the frontend to check if the A2A server is running.
+        """
+        uptime_seconds = time.time() - self.start_time
+
+        status_info: Dict[str, Any] = {
+            "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",
+        }
+
+        return JSONResponse(status_info)
+
     async def _process_request(self, request: Request):
         try:
             body = await request.json()
@@ -89,23 +103,15 @@ class A2AServer:
                 result = await self.task_manager.on_send_task(json_rpc_request)
             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)
             elif isinstance(json_rpc_request, CancelTaskRequest):
                 result = await self.task_manager.on_cancel_task(json_rpc_request)
             elif isinstance(json_rpc_request, SetTaskPushNotificationRequest):
-                result = await self.task_manager.on_set_task_push_notification(
-                    json_rpc_request
-                )
+                result = await self.task_manager.on_set_task_push_notification(json_rpc_request)
             elif isinstance(json_rpc_request, GetTaskPushNotificationRequest):
-                result = await self.task_manager.on_get_task_push_notification(
-                    json_rpc_request
-                )
+                result = await self.task_manager.on_get_task_push_notification(json_rpc_request)
             elif isinstance(json_rpc_request, TaskResubscriptionRequest):
-                result = await self.task_manager.on_resubscribe_to_task(
-                    json_rpc_request
-                )
+                result = await self.task_manager.on_resubscribe_to_task(json_rpc_request)
             else:
                 logger.warning(f"Unexpected request type: {type(json_rpc_request)}")
                 raise ValueError(f"Unexpected request type: {type(request)}")
@@ -152,10 +158,10 @@ class A2AServer:
                     "X-Accel-Buffering": "no",
                     "Connection": "keep-alive",
                     "Content-Type": "text/event-stream",
-                    "Transfer-Encoding": "chunked"
+                    "Transfer-Encoding": "chunked",
                 },
                 # Explicitly set media_type
-                media_type="text/event-stream"
+                media_type="text/event-stream",
             )
         elif isinstance(result, JSONRPCResponse):
             return JSONResponse(result.model_dump(exclude_none=True))

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/command_executor.py

@@ -6,6 +6,7 @@ from functools import reduce
 
 import pandas as pd
 from mindsdb_sql_parser import parse_sql
+from mindsdb_sql_parser.ast.mindsdb import AlterDatabase
 from mindsdb_sql_parser.ast import (
     Alter,
     ASTNode,
@@ -39,6 +40,7 @@ from mindsdb_sql_parser.ast import (
 
 # typed models
 from mindsdb_sql_parser.ast.mindsdb import (
+    AlterView,
     CreateAgent,
     CreateAnomalyDetectionModel,
     CreateChatBot,
@@ -51,6 +53,7 @@ from mindsdb_sql_parser.ast.mindsdb import (
     CreateTrigger,
     CreateView,
     CreateKnowledgeBaseIndex,
+    EvaluateKnowledgeBase,
     DropAgent,
     DropChatBot,
     DropDatasource,
@@ -189,6 +192,8 @@ class ExecuteCommands:
             return self.answer_drop_tables(statement, database_name)
         elif statement_type is DropDatasource or statement_type is DropDatabase:
             return self.answer_drop_database(statement)
+        elif statement_type is AlterDatabase:
+            return self.answer_alter_database(statement)
         elif statement_type is Describe:
             # NOTE in sql 'describe table' is same as 'show columns'
             obj_type = statement.type
@@ -551,7 +556,9 @@ class ExecuteCommands:
         ):
             return self.answer_create_predictor(statement, database_name)
         elif statement_type is CreateView:
-            return self.answer_create_view(statement, database_name)
+            return self.answer_create_or_alter_view(statement, database_name)
+        elif statement_type is AlterView:
+            return self.answer_create_or_alter_view(statement, database_name)
         elif statement_type is DropView:
             return self.answer_drop_view(statement, database_name)
         elif statement_type is Delete:
@@ -618,6 +625,8 @@ class ExecuteCommands:
             return self.answer_evaluate_metric(statement, database_name)
         elif statement_type is CreateKnowledgeBaseIndex:
             return self.answer_create_kb_index(statement, database_name)
+        elif statement_type is EvaluateKnowledgeBase:
+            return self.answer_evaluate_kb(statement, database_name)
         else:
             logger.warning(f"Unknown SQL statement: {sql}")
             raise NotSupportedYet(f"Unknown SQL statement: {sql}")
@@ -906,6 +915,14 @@ class ExecuteCommands:
         self.session.kb_controller.create_index(table_name=table_name, project_name=project_name)
         return ExecuteAnswer()
 
+    def answer_evaluate_kb(self, statement: EvaluateKnowledgeBase, database_name):
+        table_name = statement.name.parts[-1]
+        project_name = statement.name.parts[0] if len(statement.name.parts) > 1 else database_name
+        scores = self.session.kb_controller.evaluate(
+            table_name=table_name, project_name=project_name, params=statement.params
+        )
+        return ExecuteAnswer(data=ResultSet.from_df(scores))
+
     def _get_model_info(self, identifier, except_absent=True, database_name=None):
         if len(identifier.parts) == 1:
             identifier.parts = [database_name, identifier.parts[0]]
@@ -1181,6 +1198,13 @@ class ExecuteCommands:
                 raise
         return ExecuteAnswer()
 
+    def answer_alter_database(self, statement):
+        if len(statement.name.parts) != 1:
+            raise Exception("Database name should contain only 1 part.")
+        db_name = statement.name.parts[0]
+        self.session.database_controller.update(db_name, data=statement.params)
+        return ExecuteAnswer()
+
     def answer_drop_tables(self, statement, database_name):
         """answer on 'drop table [if exists] {name}'
         Args:
@@ -1214,17 +1238,35 @@ class ExecuteCommands:
 
         return ExecuteAnswer()
 
-    def answer_create_view(self, statement, database_name):
+    def answer_create_or_alter_view(self, statement: ASTNode, database_name: str) -> ExecuteAnswer:
+        """Process CREATE and ALTER VIEW commands
+
+        Args:
+            statement (ASTNode): data for creating or altering view
+            database_name (str): name of the current database
+
+        Returns:
+            ExecuteAnswer: answer for the command
+        """
         project_name = database_name
-        # TEMP
-        if isinstance(statement.name, Identifier):
+
+        if isinstance(statement.name, str):
+            parts = statement.name.split(".")
+        elif isinstance(statement.name, Identifier):
             parts = statement.name.parts
         else:
-            parts = statement.name.split(".")
+            raise ValueError(f"Unknown type of view name: {statement.name}")
 
-        view_name = parts[-1]
-        if len(parts) == 2:
-            project_name = parts[0]
+        match parts:
+            case [project_name, view_name]:
+                pass
+            case [view_name]:
+                pass
+            case _:
+                raise ValueError(
+                    'View name should be in the form "project_name.view_name" '
+                    f'or "view_name", got {statement.name.parts}'
+                )
 
         query_str = statement.query_str
 
@@ -1233,7 +1275,7 @@ class ExecuteCommands:
                 targets=[Star()],
                 from_table=NativeQuery(integration=statement.from_table, query=statement.query_str),
             )
-            query_str = str(query)
+            query_str = query.to_string()
         else:
             query = parse_sql(query_str)
 
@@ -1248,11 +1290,21 @@ class ExecuteCommands:
                 query_context_controller.release_context(query_context_controller.IGNORE_CONTEXT)
 
         project = self.session.database_controller.get_project(project_name)
-        try:
-            project.create_view(view_name, query=query_str)
-        except EntityExistsError:
-            if getattr(statement, "if_not_exists", False) is False:
-                raise
+
+        if isinstance(statement, CreateView):
+            try:
+                project.create_view(view_name, query=query_str)
+            except EntityExistsError:
+                if getattr(statement, "if_not_exists", False) is False:
+                    raise
+        elif isinstance(statement, AlterView):
+            try:
+                project.update_view(view_name, query=query_str)
+            except EntityNotExistsError:
+                raise ExecutorException(f"View {view_name} does not exist in {project_name}")
+        else:
+            raise ValueError(f"Unknown view DDL statement: {statement}")
+
         return ExecuteAnswer()
 
     def answer_drop_view(self, statement, database_name):
@@ -1467,6 +1519,9 @@ class ExecuteCommands:
         is_full=False,
         database_name=None,
     ):
+        if isinstance(target, Identifier) is False:
+            raise TableNotExistError("The table name is required for the query.")
+
         if len(target.parts) > 1:
             db = target.parts[0]
         elif isinstance(database_name, str) and len(database_name) > 0: