MindsDB 25.9.3rc1__py3-none-any.whl → 25.10.0__py3-none-any.whl

mindsdb/__about__.py

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

@@ -27,7 +27,6 @@ from mindsdb.utilities.config import config
 from mindsdb.utilities.starters import (
     start_http,
     start_mysql,
-    start_postgres,
     start_ml_task_queue,
     start_scheduler,
     start_tasks,
@@ -58,7 +57,6 @@ _stop_event = threading.Event()
 class TrunkProcessEnum(Enum):
     HTTP = "http"
     MYSQL = "mysql"
-    POSTGRES = "postgres"
     JOBS = "jobs"
     TASKS = "tasks"
     ML_TASK_QUEUE = "ml_task_queue"
@@ -447,12 +445,6 @@ if __name__ == "__main__":
                 "max_restart_interval_seconds", TrunkProcessData.max_restart_interval_seconds
             ),
         ),
-        TrunkProcessEnum.POSTGRES: TrunkProcessData(
-            name=TrunkProcessEnum.POSTGRES.value,
-            entrypoint=start_postgres,
-            port=config["api"]["postgres"]["port"],
-            args=(config.cmd_args.verbose,),
-        ),
         TrunkProcessEnum.JOBS: TrunkProcessData(
             name=TrunkProcessEnum.JOBS.value, entrypoint=start_scheduler, args=(config.cmd_args.verbose,)
         ),
@@ -550,7 +542,7 @@ if __name__ == "__main__":
                         trunc_process_data.process = None
                         if trunc_process_data.name == TrunkProcessEnum.HTTP.value:
                             # do not open GUI on HTTP API restart
-                            trunc_process_data.args = (config.cmd_args.verbose, True)
+                            trunc_process_data.args = (config.cmd_args.verbose, None, True)
                         start_process(trunc_process_data)
                         api_name, port, started = await wait_api_start(
                             trunc_process_data.name,

mindsdb/api/a2a/__init__.py

@@ -33,7 +33,7 @@ def get_a2a_app(
     agent_card = AgentCard(
         name="MindsDB Agent Connector",
         description=(f"A2A connector that proxies requests to MindsDB agents in project '{project_name}'."),
-        url=f"http://127.0.0.1:{mindsdb_port}",
+        url=f"http://127.0.0.1:{mindsdb_port}/a2a/",
         version="1.0.0",
         defaultInputModes=MindsDBAgent.SUPPORTED_CONTENT_TYPES,
         defaultOutputModes=MindsDBAgent.SUPPORTED_CONTENT_TYPES,

mindsdb/api/a2a/agent.py

@@ -24,7 +24,15 @@ class MindsDBAgent:
         self.agent_name = agent_name
         self.project_name = project_name
         port = config.get("api", {}).get("http", {}).get("port", 47334)
-        self.base_url = f"http://localhost:{port}"
+        host = config.get("api", {}).get("http", {}).get("host", "127.0.0.1")
+
+        # Use 127.0.0.1 instead of localhost for better compatibility
+        if host in ("0.0.0.0", ""):
+            url = f"http://127.0.0.1:{port}/"
+        else:
+            url = f"http://{host}:{port}/"
+
+        self.base_url = url
         self.agent_url = f"{self.base_url}/api/projects/{project_name}/agents/{agent_name}"
         self.sql_url = f"{self.base_url}/api/sql/query"
         self.headers = {k: v for k, v in user_info.items() if v is not None} or {}

mindsdb/api/a2a/common/server/server.py

@@ -22,6 +22,7 @@ from ...common.types import (
     AgentCard,
     TaskResubscriptionRequest,
     SendTaskStreamingRequest,
+    MessageStreamRequest,
 )
 from pydantic import ValidationError
 from ...common.server.task_manager import TaskManager
@@ -43,6 +44,7 @@ class A2AServer:
             routes=[
                 Route("/", self._process_request, methods=["POST"]),
                 Route("/.well-known/agent.json", self._get_agent_card, methods=["GET"]),
+                Route("/.well-known/agent-card.json", self._get_agent_card, methods=["GET"]),
                 Route("/status", self._get_status, methods=["GET"]),
             ]
         )
@@ -103,6 +105,8 @@ class A2AServer:
                 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)
+            elif isinstance(json_rpc_request, MessageStreamRequest):
+                result = await self.task_manager.on_message_stream(json_rpc_request, user_info)
             else:
                 logger.warning(f"Unexpected request type: {type(json_rpc_request)}")
                 raise ValueError(f"Unexpected request type: {type(request)}")

mindsdb/api/a2a/common/server/task_manager.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from typing import Union, AsyncIterable, List, Dict
-from ...common.types import Task
 from ...common.types import (
+    Task,
     JSONRPCResponse,
     TaskIdParams,
     TaskQueryParams,
@@ -29,6 +29,7 @@ from ...common.types import (
     JSONRPCError,
     TaskPushNotificationConfig,
     InternalError,
+    MessageStreamRequest,
 )
 from ...common.server.utils import new_not_implemented_error
 from mindsdb.utilities import log
@@ -74,6 +75,12 @@ class TaskManager(ABC):
     ) -> Union[AsyncIterable[SendTaskResponse], JSONRPCResponse]:
         pass
 
+    @abstractmethod
+    async def on_message_stream(
+        self, request: MessageStreamRequest, user_info: Dict
+    ) -> Union[AsyncIterable[SendTaskStreamingResponse], JSONRPCResponse]:
+        pass
+
 
 class InMemoryTaskManager(TaskManager):
     def __init__(self):

mindsdb/api/a2a/common/types.py

@@ -59,6 +59,47 @@ class Message(BaseModel):
     parts: List[Part]
     metadata: dict[str, Any] | None = None
     history: Optional[List["Message"]] = None
+    messageId: str | None = None
+
+
+class FlexibleMessage(BaseModel):
+    """Message that can handle both 'type' and 'kind' in parts."""
+
+    role: Literal["user", "agent", "assistant"]
+    parts: List[dict[str, Any]]  # Raw parts that we'll process manually
+    metadata: dict[str, Any] | None = None
+    history: Optional[List["FlexibleMessage"]] = None
+
+    @model_validator(mode="after")
+    def normalize_parts(self):
+        """Convert parts with 'kind' to parts with 'type'."""
+        normalized_parts = []
+        for part in self.parts:
+            if isinstance(part, dict):
+                # Convert 'kind' to 'type' if needed
+                if "kind" in part and "type" not in part:
+                    normalized_part = part.copy()
+                    normalized_part["type"] = normalized_part.pop("kind")
+                else:
+                    normalized_part = part
+
+                # Validate the normalized part
+                try:
+                    if normalized_part.get("type") == "text":
+                        normalized_parts.append(TextPart.model_validate(normalized_part))
+                    elif normalized_part.get("type") == "file":
+                        normalized_parts.append(FilePart.model_validate(normalized_part))
+                    elif normalized_part.get("type") == "data":
+                        normalized_parts.append(DataPart.model_validate(normalized_part))
+                    else:
+                        raise ValueError(f"Unknown part type: {normalized_part.get('type')}")
+                except Exception as e:
+                    raise ValueError(f"Invalid part: {normalized_part}, error: {e}")
+            else:
+                normalized_parts.append(part)
+
+        self.parts = normalized_parts
+        return self
 
 
 class TaskStatus(BaseModel):
@@ -88,6 +129,7 @@ class Task(BaseModel):
     artifacts: List[Artifact] | None = None
     history: List[Message] | None = None
     metadata: dict[str, Any] | None = None
+    contextId: str | None = None
 
 
 class TaskStatusUpdateEvent(BaseModel):
@@ -95,12 +137,16 @@ class TaskStatusUpdateEvent(BaseModel):
     status: TaskStatus
     final: bool = False
     metadata: dict[str, Any] | None = None
+    contextId: str | None = None
+    taskId: str | None = None
 
 
 class TaskArtifactUpdateEvent(BaseModel):
     id: str
     artifact: Artifact
     metadata: dict[str, Any] | None = None
+    contextId: str | None = None
+    taskId: str | None = None
 
 
 class AuthenticationInfo(BaseModel):
@@ -182,6 +228,25 @@ class SendTaskStreamingResponse(JSONRPCResponse):
     result: TaskStatusUpdateEvent | TaskArtifactUpdateEvent | None = None
 
 
+class MessageStreamParams(BaseModel):
+    sessionId: str = Field(default_factory=lambda: uuid4().hex)
+    message: FlexibleMessage
+    metadata: dict[str, Any] | None = None
+
+
+class MessageStreamRequest(JSONRPCRequest):
+    method: Literal["message/stream"] = "message/stream"
+    params: MessageStreamParams
+
+
+class MessageStreamResponse(JSONRPCResponse):
+    result: Message | None = None
+
+
+class SendStreamingMessageSuccessResponse(JSONRPCResponse):
+    result: Union[Task, TaskStatusUpdateEvent, TaskArtifactUpdateEvent] | None = None
+
+
 class GetTaskRequest(JSONRPCRequest):
     method: Literal["tasks/get"] = "tasks/get"
     params: TaskQueryParams
@@ -233,6 +298,7 @@ A2ARequest = TypeAdapter(
             GetTaskPushNotificationRequest,
             TaskResubscriptionRequest,
             SendTaskStreamingRequest,
+            MessageStreamRequest,
         ],
         Field(discriminator="method"),
     ]

mindsdb/api/a2a/task_manager.py

@@ -19,10 +19,13 @@ from mindsdb.api.a2a.common.types import (
     SendTaskStreamingRequest,
     SendTaskStreamingResponse,
     InvalidRequestError,
+    MessageStreamRequest,
+    SendStreamingMessageSuccessResponse,
 )
 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, convert_a2a_message_to_qa_format
+from mindsdb.interfaces.agents.agents_controller import AgentsController
 
 
 logger = logging.getLogger(__name__)
@@ -472,3 +475,50 @@ class AgentTaskManager(InMemoryTaskManager):
                 [Artifact(parts=parts)],
             )
             return to_serializable(SendTaskResponse(id=request.id, result=task))
+
+    async def on_message_stream(
+        self, request: MessageStreamRequest, user_info: Dict
+    ) -> Union[AsyncIterable[SendStreamingMessageSuccessResponse], JSONRPCResponse]:
+        """
+        Handle message streaming requests.
+        """
+        logger.info(f"Processing message stream request for session {request.params.sessionId}")
+
+        query = self._get_user_query(request.params)
+        params = self._get_task_params(request.params)
+
+        try:
+            task_id = f"msg_stream_{request.params.sessionId}_{request.id}"
+            context_id = f"ctx_{request.params.sessionId}"
+            message_id = f"msg_{request.id}"
+
+            agents_controller = AgentsController()
+            existing_agent = agents_controller.get_agent(params["agent_name"])
+            resp = agents_controller.get_completion(existing_agent, [{"question": query}])
+            response_message = resp["answer"][0]
+
+            response_message = Message(
+                role="agent", parts=[{"type": "text", "text": response_message}], metadata={}, messageId=message_id
+            )
+
+            task_status = TaskStatus(state=TaskState.COMPLETED, message=response_message)
+
+            task_status_update = TaskStatusUpdateEvent(
+                id=task_id,
+                status=task_status,
+                final=True,
+                metadata={"message_stream": True},
+                contextId=context_id,
+                taskId=task_id,
+            )
+
+            async def message_stream_generator():
+                yield to_serializable(SendStreamingMessageSuccessResponse(id=request.id, result=task_status_update))
+
+            return message_stream_generator()
+
+        except Exception as e:
+            logger.error(f"Error processing message stream: {e}")
+            return SendStreamingMessageSuccessResponse(
+                id=request.id, error=InternalError(message=f"Error processing message stream: {str(e)}")
+            )

mindsdb/api/common/middleware.py

@@ -75,7 +75,7 @@ class PATAuthMiddleware(BaseHTTPMiddleware):
         return await call_next(request)
 
 
-# Used by mysql and postgres protocols
+# Used by mysql protocol
 def check_auth(username, password, scramble_func, salt, company_id, config):
     try:
         hardcoded_user = config["auth"].get("username")

mindsdb/api/executor/command_executor.py

@@ -49,6 +49,7 @@ from mindsdb_sql_parser.ast.mindsdb import (
     CreateDatabase,
     CreateJob,
     CreateKnowledgeBase,
+    AlterKnowledgeBase,
     CreateMLEngine,
     CreatePredictor,
     CreateSkill,
@@ -196,11 +197,13 @@ def match_two_part_name(
         ValueError: If the identifier does not contain one or two parts, or if ensure_lower_case is True and the name is not lowercase.
     """
     db_name = None
+
     match identifier.parts, identifier.is_quoted:
         case [name], [is_quoted]:
             ...
-        case [db_name, name], [_, is_quoted]:
-            ...
+        case [db_name, name], [db_is_quoted, is_quoted]:
+            if not db_is_quoted:
+                db_name = db_name.lower()
         case _:
             raise ValueError(f"Only single-part or two-part names are allowed: {identifier}")
     if not is_quoted:
@@ -655,6 +658,8 @@ class ExecuteCommands:
             return self.answer_drop_chatbot(statement, database_name)
         elif statement_type is CreateKnowledgeBase:
             return self.answer_create_kb(statement, database_name)
+        elif statement_type is AlterKnowledgeBase:
+            return self.answer_alter_kb(statement, database_name)
         elif statement_type is DropKnowledgeBase:
             return self.answer_drop_kb(statement, database_name)
         elif statement_type is CreateSkill:
@@ -710,9 +715,7 @@ class ExecuteCommands:
 
     def answer_create_trigger(self, statement, database_name):
         triggers_controller = TriggersController()
-        project_name, trigger_name = match_two_part_name(
-            statement.name, ensure_lower_case=True, default_db_name=database_name
-        )
+        project_name, trigger_name = match_two_part_name(statement.name, default_db_name=database_name)
 
         triggers_controller.add(
             trigger_name,
@@ -726,9 +729,7 @@ class ExecuteCommands:
     def answer_drop_trigger(self, statement, database_name):
         triggers_controller = TriggersController()
 
-        name = statement.name
-        trigger_name = statement.name.parts[-1]
-        project_name = name.parts[-2] if len(name.parts) > 1 else database_name
+        project_name, trigger_name = match_two_part_name(statement.name, default_db_name=database_name)
 
         triggers_controller.delete(trigger_name, project_name)
 
@@ -736,9 +737,7 @@ class ExecuteCommands:
 
     def answer_create_job(self, statement: CreateJob, database_name):
         jobs_controller = JobsController()
-        project_name, job_name = match_two_part_name(
-            statement.name, ensure_lower_case=True, default_db_name=database_name
-        )
+        project_name, job_name = match_two_part_name(statement.name, default_db_name=database_name)
 
         try:
             jobs_controller.create(job_name, project_name, statement)
@@ -762,7 +761,7 @@ class ExecuteCommands:
 
     def answer_create_chatbot(self, statement, database_name):
         chatbot_controller = ChatBotController()
-        project_name, name = match_two_part_name(statement.name, ensure_lower_case=True, default_db_name=database_name)
+        project_name, name = match_two_part_name(statement.name, default_db_name=database_name)
 
         is_running = statement.params.pop("is_running", True)
 
@@ -794,9 +793,7 @@ class ExecuteCommands:
     def answer_update_chatbot(self, statement, database_name):
         chatbot_controller = ChatBotController()
 
-        name = statement.name
-        name_no_project = name.parts[-1]
-        project_name = name.parts[-2] if len(name.parts) > 1 else database_name
+        project_name, name = match_two_part_name(statement.name, default_db_name=database_name)
 
         # From SET keyword parameters
         updated_name = statement.params.pop("name", None)
@@ -813,7 +810,7 @@ class ExecuteCommands:
             database_id = database["id"]
 
         updated_chatbot = chatbot_controller.update_chatbot(
-            name_no_project,
+            name,
             project_name=project_name,
             name=updated_name,
             model_name=model_name,
@@ -823,16 +820,15 @@ class ExecuteCommands:
             params=statement.params,
         )
         if updated_chatbot is None:
-            raise ExecutorException(f"Chatbot with name {name_no_project} not found")
+            raise ExecutorException(f"Chatbot with name {name} not found")
         return ExecuteAnswer()
 
     def answer_drop_chatbot(self, statement, database_name):
         chatbot_controller = ChatBotController()
 
-        name = statement.name
-        project_name = name.parts[-2] if len(name.parts) > 1 else database_name
+        project_name, name = match_two_part_name(statement.name, default_db_name=database_name)
 
-        chatbot_controller.delete_chatbot(name.parts[-1], project_name=project_name)
+        chatbot_controller.delete_chatbot(name, project_name=project_name)
         return ExecuteAnswer()
 
     def answer_evaluate_metric(self, statement, database_name):
@@ -972,6 +968,10 @@ class ExecuteCommands:
             identifier.is_quoted = [False] + identifier.is_quoted
 
         database_name, model_name, model_version = resolve_model_identifier(identifier)
+        # at least two part in identifier
+        identifier.parts[0] = database_name
+        identifier.parts[1] = model_name
+
         if database_name is None:
             database_name = database_name
 
@@ -1159,7 +1159,7 @@ class ExecuteCommands:
         Raises:
             ValueError: If the ml_engine name format is invalid.
         """
-        name = match_one_part_name(statement.name, ensure_lower_case=True)
+        name = match_one_part_name(statement.name)
 
         handler = statement.handler
         params = statement.params
@@ -1245,7 +1245,7 @@ class ExecuteCommands:
         Returns:
             ExecuteAnswer: 'ok' answer
         """
-        database_name = match_one_part_name(statement.name, ensure_lower_case=True)
+        database_name = match_one_part_name(statement.name)
 
         engine = (statement.engine or "mindsdb").lower()
 
@@ -1334,9 +1334,7 @@ class ExecuteCommands:
         Returns:
             ExecuteAnswer: answer for the command
         """
-        project_name, view_name = match_two_part_name(
-            statement.name, default_db_name=database_name, ensure_lower_case=isinstance(statement, CreateView)
-        )
+        project_name, view_name = match_two_part_name(statement.name, default_db_name=database_name)
 
         query_str = statement.query_str
 
@@ -1388,10 +1386,15 @@ class ExecuteCommands:
                 case _:
                     raise ValueError(f"Invalid view name: {name}")
 
+            if not db_name_quoted:
+                database_name = database_name.lower()
+            if not view_name_quoted:
+                view_name = view_name.lower()
+
             project = self.session.database_controller.get_project(database_name, db_name_quoted)
 
             try:
-                project.drop_view(view_name, strict_case=view_name_quoted)
+                project.drop_view(view_name, strict_case=True)
             except EntityNotExistsError:
                 if statement.if_exists is not True:
                     raise
@@ -1405,9 +1408,7 @@ class ExecuteCommands:
                 "Please pass the model parameters as a JSON object in the embedding_model field."
             )
 
-        project_name, kb_name = match_two_part_name(
-            statement.name, ensure_lower_case=True, default_db_name=database_name
-        )
+        project_name, kb_name = match_two_part_name(statement.name, default_db_name=database_name)
 
         if statement.storage is not None:
             if len(statement.storage.parts) != 2:
@@ -1431,6 +1432,20 @@ class ExecuteCommands:
 
         return ExecuteAnswer()
 
+    def answer_alter_kb(self, statement: AlterKnowledgeBase, database_name: str):
+        project_name, kb_name = match_two_part_name(
+            statement.name, ensure_lower_case=True, default_db_name=database_name
+        )
+
+        # update the knowledge base
+        self.session.kb_controller.update(
+            name=kb_name,
+            project_name=project_name,
+            params=statement.params,
+        )
+
+        return ExecuteAnswer()
+
     def answer_drop_kb(self, statement: DropKnowledgeBase, database_name: str) -> ExecuteAnswer:
         project_name, kb_name = match_two_part_name(statement.name, default_db_name=database_name)
 
@@ -1444,7 +1459,7 @@ class ExecuteCommands:
         return ExecuteAnswer()
 
     def answer_create_skill(self, statement, database_name):
-        project_name, name = match_two_part_name(statement.name, ensure_lower_case=True, default_db_name=database_name)
+        project_name, name = match_two_part_name(statement.name, default_db_name=database_name)
 
         try:
             _ = self.session.skills_controller.add_skill(name, project_name, statement.type, statement.params)
@@ -1480,7 +1495,7 @@ class ExecuteCommands:
         return ExecuteAnswer()
 
     def answer_create_agent(self, statement, database_name):
-        project_name, name = match_two_part_name(statement.name, ensure_lower_case=True, default_db_name=database_name)
+        project_name, name = match_two_part_name(statement.name, default_db_name=database_name)
 
         skills = statement.params.pop("skills", [])
         provider = statement.params.pop("provider", None)
@@ -1536,11 +1551,9 @@ class ExecuteCommands:
 
     @mark_process("learn")
     def answer_create_predictor(self, statement: CreatePredictor, database_name: str):
-        integration_name, model_name = match_two_part_name(
-            statement.name, ensure_lower_case=True, default_db_name=database_name
-        )
+        integration_name, model_name = match_two_part_name(statement.name, default_db_name=database_name)
 
-        statement.name.parts = [integration_name.lower(), model_name]
+        statement.name.parts = [integration_name, model_name]
         statement.name.is_quoted = [False, False]
 
         ml_integration_name = "lightwood"  # default
@@ -2016,7 +2029,7 @@ class ExecuteCommands:
         else:
             # drop model
             try:
-                project = self.session.database_controller.get_project(project_name)
+                project = self.session.database_controller.get_project(project_name, strict_case=True)
                 project.drop_model(model_name)
             except Exception as e:
                 if not statement.if_exists:

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

@@ -94,17 +94,7 @@ class InformationSchemaDataNode(DataNode):
         self.integration_controller = session.integration_controller
         self.project_controller = ProjectController()
         self.database_controller = session.database_controller
-
-        self.persis_datanodes = {"log": self.database_controller.logs_db_controller}
-
-        databases = self.database_controller.get_dict()
-        if "files" in databases:
-            self.persis_datanodes["files"] = IntegrationDataNode(
-                "files",
-                ds_type="file",
-                integration_controller=self.session.integration_controller,
-            )
-
+        self.persist_datanodes_names = ("log", "files")
         self.tables = {t.name: t for t in self.tables_list}
 
     def __getitem__(self, key):
@@ -119,8 +109,12 @@ class InformationSchemaDataNode(DataNode):
         if name_lower == "log":
             return self.database_controller.get_system_db("log")
 
-        if name_lower in self.persis_datanodes:
-            return self.persis_datanodes[name_lower]
+        if name_lower == "files":
+            return IntegrationDataNode(
+                "files",
+                ds_type="file",
+                integration_controller=self.session.integration_controller,
+            )
 
         existing_databases_meta = self.database_controller.get_dict()  # filter_type='project'
         database_name = None

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

@@ -124,7 +124,7 @@ class IntegrationDataNode(DataNode):
         df.columns = [name.upper() for name in df.columns]
         if "FIELD" not in df.columns or "TYPE" not in df.columns:
             logger.warning(
-                f"Response from the handler's `get_columns` call does not contain required columns: f{df.columns}"
+                f"Response from the handler's `get_columns` call does not contain required columns: {list(df.columns)}"
             )
             return pd.DataFrame([], columns=astuple(INF_SCHEMA_COLUMNS_NAMES))
 
@@ -294,7 +294,7 @@ class IntegrationDataNode(DataNode):
                 db_type=self.integration_handler.__class__.name,
                 db_error_msg=result.error_message,
                 failed_query=query_str,
-                is_acceptable=result.is_acceptable_error,
+                is_expected=result.is_expected_error,
             )
 
             if result.exception is None:

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

@@ -102,9 +102,10 @@ class TablesTable(Table):
             row = TablesRow(TABLE_TYPE=TABLES_ROW_TYPE.SYSTEM_VIEW, TABLE_NAME=name)
             data.append(row.to_list())
 
-        for ds_name, ds in inf_schema.persis_datanodes.items():
+        for ds_name in inf_schema.persist_datanodes_names:
             if databases is not None and ds_name not in databases:
                 continue
+            ds = inf_schema.get(ds_name)
 
             if hasattr(ds, "get_tables_rows"):
                 ds_tables = ds.get_tables_rows()

mindsdb/api/executor/planner/query_prepare.py

@@ -286,26 +286,8 @@ class PreparedStatementPlanner:
 
                 if step.result_data is not None:
                     # save results
-
-                    if len(step.result_data["tables"]) > 0:
-                        table_info = step.result_data["tables"][0]
-                        columns_info = step.result_data["columns"][table_info]
-
-                        table.columns = []
-                        table.ds = table_info[0]
-                        for col in columns_info:
-                            if isinstance(col, tuple):
-                                # is predictor
-                                col = dict(name=col[0], type="str")
-                            table.columns.append(
-                                Column(
-                                    name=col["name"],
-                                    type=col["type"],
-                                )
-                            )
-
-                    # map by names
-                    table.columns_map = {i.name.upper(): i for i in table.columns}
+                    table.columns = step.result_data.columns
+                    table.columns_map = {column.name.upper(): column for column in step.result_data.columns}
 
         # === create columns list ===
         columns_result = []

mindsdb/api/executor/utilities/sql.py

@@ -4,6 +4,7 @@ from typing import List
 import duckdb
 from duckdb import InvalidInputException
 import numpy as np
+import orjson
 
 from mindsdb_sql_parser import parse_sql
 from mindsdb_sql_parser.ast import ASTNode, Select, Identifier, Function, Constant
@@ -244,13 +245,13 @@ def query_df(df, query, session=None):
 
     query_traversal(query_ast, adapt_query)
 
-    # convert json columns
-    encoder = CustomJSONEncoder()
-
     def _convert(v):
         if isinstance(v, dict) or isinstance(v, list):
             try:
-                return encoder.encode(v)
+                default_encoder = CustomJSONEncoder().default
+                return orjson.dumps(
+                    v, default=default_encoder, option=orjson.OPT_SERIALIZE_NUMPY | orjson.OPT_PASSTHROUGH_DATETIME
+                ).decode("utf-8")
             except Exception:
                 pass
         return v