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

mindsdb/api/http/namespaces/config.py

@@ -20,121 +20,109 @@ from mindsdb.integrations.libs.response import HandlerStatusResponse
 logger = log.getLogger(__name__)
 
 
-@ns_conf.route('/')
-@ns_conf.param('name', 'Get config')
+@ns_conf.route("/")
+@ns_conf.param("name", "Get config")
 class GetConfig(Resource):
-    @ns_conf.doc('get_config')
-    @api_endpoint_metrics('GET', '/config')
+    @ns_conf.doc("get_config")
+    @api_endpoint_metrics("GET", "/config")
     def get(self):
         config = Config()
-        resp = {
-            'auth': {
-                'http_auth_enabled': config['auth']['http_auth_enabled']
-            }
-        }
-        for key in ['default_llm', 'default_embedding_model']:
+        resp = {"auth": {"http_auth_enabled": config["auth"]["http_auth_enabled"]}}
+        for key in ["default_llm", "default_embedding_model", "default_reranking_model"]:
             value = config.get(key)
             if value is not None:
                 resp[key] = value
         return resp
 
-    @ns_conf.doc('put_config')
-    @api_endpoint_metrics('PUT', '/config')
+    @ns_conf.doc("put_config")
+    @api_endpoint_metrics("PUT", "/config")
     def put(self):
         data = request.json
 
-        allowed_arguments = {'auth', 'default_llm', 'default_embedding_model'}
+        allowed_arguments = {"auth", "default_llm", "default_embedding_model", "default_reranking_model"}
         unknown_arguments = list(set(data.keys()) - allowed_arguments)
         if len(unknown_arguments) > 0:
-            return http_error(
-                HTTPStatus.BAD_REQUEST, 'Wrong arguments',
-                f'Unknown argumens: {unknown_arguments}'
-            )
+            return http_error(HTTPStatus.BAD_REQUEST, "Wrong arguments", f"Unknown argumens: {unknown_arguments}")
 
-        nested_keys_to_validate = {'auth'}
+        nested_keys_to_validate = {"auth"}
         for key in data.keys():
             if key in nested_keys_to_validate:
-                unknown_arguments = list(
-                    set(data[key].keys()) - set(Config()[key].keys())
-                )
+                unknown_arguments = list(set(data[key].keys()) - set(Config()[key].keys()))
                 if len(unknown_arguments) > 0:
                     return http_error(
-                        HTTPStatus.BAD_REQUEST, 'Wrong arguments',
-                        f'Unknown argumens: {unknown_arguments}'
+                        HTTPStatus.BAD_REQUEST, "Wrong arguments", f"Unknown argumens: {unknown_arguments}"
                     )
 
         Config().update(data)
 
-        return '', 200
+        return "", 200
 
 
-@ns_conf.route('/integrations')
-@ns_conf.param('name', 'List all database integration')
+@ns_conf.route("/integrations")
+@ns_conf.param("name", "List all database integration")
 class ListIntegration(Resource):
-    @api_endpoint_metrics('GET', '/config/integrations')
+    @api_endpoint_metrics("GET", "/config/integrations")
     def get(self):
-        return {
-            'integrations': [k for k in ca.integration_controller.get_all(show_secrets=False)]
-        }
+        return {"integrations": [k for k in ca.integration_controller.get_all(show_secrets=False)]}
 
 
-@ns_conf.route('/all_integrations')
-@ns_conf.param('name', 'List all database integration')
+@ns_conf.route("/all_integrations")
+@ns_conf.param("name", "List all database integration")
 class AllIntegration(Resource):
-    @ns_conf.doc('get_all_integrations')
-    @api_endpoint_metrics('GET', '/config/all_integrations')
+    @ns_conf.doc("get_all_integrations")
+    @api_endpoint_metrics("GET", "/config/all_integrations")
     def get(self):
         integrations = ca.integration_controller.get_all(show_secrets=False)
         return integrations
 
 
-@ns_conf.route('/integrations/<name>')
-@ns_conf.param('name', 'Database integration')
+@ns_conf.route("/integrations/<name>")
+@ns_conf.param("name", "Database integration")
 class Integration(Resource):
-    @ns_conf.doc('get_integration')
-    @api_endpoint_metrics('GET', '/config/integrations/integration')
+    @ns_conf.doc("get_integration")
+    @api_endpoint_metrics("GET", "/config/integrations/integration")
     def get(self, name):
         integration = ca.integration_controller.get(name, show_secrets=False)
         if integration is None:
-            return http_error(HTTPStatus.NOT_FOUND, 'Not found', f'Can\'t find integration: {name}')
+            return http_error(HTTPStatus.NOT_FOUND, "Not found", f"Can't find integration: {name}")
         integration = copy.deepcopy(integration)
         return integration
 
-    @ns_conf.doc('put_integration')
-    @api_endpoint_metrics('PUT', '/config/integrations/integration')
+    @ns_conf.doc("put_integration")
+    @api_endpoint_metrics("PUT", "/config/integrations/integration")
     def put(self, name):
         params = {}
         if request.is_json:
-            params.update((request.json or {}).get('params', {}))
+            params.update((request.json or {}).get("params", {}))
         else:
             params.update(request.form or {})
 
         if len(params) == 0:
-            return http_error(HTTPStatus.BAD_REQUEST, 'Wrong argument', "type of 'params' must be dict")
+            return http_error(HTTPStatus.BAD_REQUEST, "Wrong argument", "type of 'params' must be dict")
 
         files = request.files
         temp_dir = None
         if files is not None and len(files) > 0:
-            temp_dir = tempfile.mkdtemp(prefix='integration_files_')
+            temp_dir = tempfile.mkdtemp(prefix="integration_files_")
             for key, file in files.items():
                 temp_dir_path = Path(temp_dir)
                 file_name = Path(file.filename)
                 file_path = temp_dir_path.joinpath(file_name).resolve()
                 if temp_dir_path not in file_path.parents:
-                    raise Exception(f'Can not save file at path: {file_path}')
+                    raise Exception(f"Can not save file at path: {file_path}")
                 file.save(file_path)
                 params[key] = str(file_path)
 
-        is_test = params.get('test', False)
+        is_test = params.get("test", False)
         # TODO: Move this to new Endpoint
 
         config = Config()
-        secret_key = config.get('secret_key', 'dummy-key')
+        secret_key = config.get("secret_key", "dummy-key")
 
         if is_test:
-            del params['test']
-            handler_type = params.pop('type', None)
-            params.pop('publish', None)
+            del params["test"]
+            handler_type = params.pop("type", None)
+            params.pop("publish", None)
             try:
                 handler = ca.integration_controller.create_tmp_handler(name, handler_type, params)
                 status = handler.check_connection()
@@ -145,33 +133,32 @@ class Integration(Resource):
 
             resp = status.to_json()
 
-            if status.success and 'code' in params:
-                if hasattr(handler, 'handler_storage'):
+            if status.success and "code" in params:
+                if hasattr(handler, "handler_storage"):
                     # attach storage if exists
                     export = handler.handler_storage.export_files()
                     if export:
                         # encrypt with flask secret key
                         encrypted = encrypt(export, secret_key)
-                        resp['storage'] = encrypted.decode()
+                        resp["storage"] = encrypted.decode()
 
             return resp, 200
 
         config = Config()
-        secret_key = config.get('secret_key', 'dummy-key')
+        secret_key = config.get("secret_key", "dummy-key")
 
         integration = ca.integration_controller.get(name, show_secrets=False)
         if integration is not None:
             return http_error(
-                HTTPStatus.BAD_REQUEST, 'Wrong argument',
-                f"Integration with name '{name}' already exists"
+                HTTPStatus.BAD_REQUEST, "Wrong argument", f"Integration with name '{name}' already exists"
             )
 
         try:
-            engine = params['type']
+            engine = params["type"]
             if engine is not None:
-                del params['type']
-            params.pop('publish', False)
-            storage = params.pop('storage', None)
+                del params["type"]
+            params.pop("publish", False)
+            storage = params.pop("storage", None)
             ca.integration_controller.add(name, engine, params)
 
             # copy storage
@@ -185,62 +172,50 @@ class Integration(Resource):
             logger.error(str(e))
             if temp_dir is not None:
                 shutil.rmtree(temp_dir)
-            return http_error(
-                HTTPStatus.INTERNAL_SERVER_ERROR, 'Error',
-                f'Error during config update: {str(e)}'
-            )
+            return http_error(HTTPStatus.INTERNAL_SERVER_ERROR, "Error", f"Error during config update: {str(e)}")
 
         if temp_dir is not None:
             shutil.rmtree(temp_dir)
         return {}, 200
 
-    @ns_conf.doc('delete_integration')
-    @api_endpoint_metrics('DELETE', '/config/integrations/integration')
+    @ns_conf.doc("delete_integration")
+    @api_endpoint_metrics("DELETE", "/config/integrations/integration")
     def delete(self, name):
         integration = ca.integration_controller.get(name)
         if integration is None:
             return http_error(
-                HTTPStatus.BAD_REQUEST, 'Integration does not exists',
-                f"Nothing to delete. '{name}' not exists."
+                HTTPStatus.BAD_REQUEST, "Integration does not exists", f"Nothing to delete. '{name}' not exists."
             )
         try:
             ca.integration_controller.delete(name)
         except Exception as e:
             logger.error(str(e))
-            return http_error(
-                HTTPStatus.INTERNAL_SERVER_ERROR, 'Error',
-                f"Error during integration delete: {str(e)}"
-            )
+            return http_error(HTTPStatus.INTERNAL_SERVER_ERROR, "Error", f"Error during integration delete: {str(e)}")
         return "", 200
 
-    @ns_conf.doc('modify_integration')
-    @api_endpoint_metrics('POST', '/config/integrations/integration')
+    @ns_conf.doc("modify_integration")
+    @api_endpoint_metrics("POST", "/config/integrations/integration")
     def post(self, name):
         params = {}
-        params.update((request.json or {}).get('params', {}))
+        params.update((request.json or {}).get("params", {}))
         params.update(request.form or {})
 
         if not isinstance(params, dict):
-            return http_error(
-                HTTPStatus.BAD_REQUEST, 'Wrong argument',
-                "type of 'params' must be dict"
-            )
+            return http_error(HTTPStatus.BAD_REQUEST, "Wrong argument", "type of 'params' must be dict")
         integration = ca.integration_controller.get(name)
         if integration is None:
             return http_error(
-                HTTPStatus.BAD_REQUEST, 'Integration does not exists',
-                f"Nothin to modify. '{name}' not exists."
+                HTTPStatus.BAD_REQUEST, "Integration does not exists", f"Nothin to modify. '{name}' not exists."
             )
         try:
-            if 'enabled' in params:
-                params['publish'] = params['enabled']
-                del params['enabled']
+            if "enabled" in params:
+                params["publish"] = params["enabled"]
+                del params["enabled"]
             ca.integration_controller.modify(name, params)
 
         except Exception as e:
             logger.error(str(e))
             return http_error(
-                HTTPStatus.INTERNAL_SERVER_ERROR, 'Error',
-                f"Error during integration modification: {str(e)}"
+                HTTPStatus.INTERNAL_SERVER_ERROR, "Error", f"Error during integration modification: {str(e)}"
             )
         return "", 200

mindsdb/api/http/namespaces/file.py

@@ -84,8 +84,14 @@ class File(Resource):
             parser.finalize()
             parser.close()
 
-            if file_object is not None and not file_object.closed:
-                file_object.close()
+            if file_object is not None:
+                if not file_object.closed:
+                    try:
+                        file_object.flush()
+                    except (AttributeError, ValueError, OSError):
+                        logger.debug("Failed to flush file_object before closing.", exc_info=True)
+                    file_object.close()
+                file_object = None
         else:
             data = request.json
 

mindsdb/api/http/namespaces/sql.py

@@ -8,6 +8,7 @@ import mindsdb.utilities.hooks as hooks
 import mindsdb.utilities.profiler as profiler
 from mindsdb.api.http.utils import http_error
 from mindsdb.api.http.namespaces.configs.sql import ns_conf
+from mindsdb.api.mysql.mysql_proxy.mysql_proxy import SQLAnswer
 from mindsdb.api.mysql.mysql_proxy.classes.fake_mysql_proxy import FakeMysqlProxy
 from mindsdb.api.executor.data_types.response_type import (
     RESPONSE_TYPE as SQL_RESPONSE_TYPE,
@@ -56,23 +57,8 @@ class Query(Resource):
             mysql_proxy = FakeMysqlProxy()
             mysql_proxy.set_context(context)
             try:
-                result = mysql_proxy.process_query(query)
-
-                if result.type == SQL_RESPONSE_TYPE.OK:
-                    query_response = {
-                        "type": SQL_RESPONSE_TYPE.OK,
-                        "affected_rows": result.affected_rows
-                    }
-                elif result.type == SQL_RESPONSE_TYPE.TABLE:
-                    data = result.data.to_lists(json_types=True)
-                    query_response = {
-                        "type": SQL_RESPONSE_TYPE.TABLE,
-                        "data": data,
-                        "column_names": [
-                            x["alias"] or x["name"] if "alias" in x else x["name"]
-                            for x in result.columns
-                        ],
-                    }
+                result: SQLAnswer = mysql_proxy.process_query(query)
+                query_response: dict = result.dump_http_response()
             except ExecutorException as e:
                 # classified error
                 error_type = "expected"
@@ -134,7 +120,7 @@ class ListDatabases(Resource):
         listing_query = "SHOW DATABASES"
         mysql_proxy = FakeMysqlProxy()
         try:
-            result = mysql_proxy.process_query(listing_query)
+            result: SQLAnswer = mysql_proxy.process_query(listing_query)
 
             # iterate over result.data and perform a query on each item to get the name of the tables
             if result.type == SQL_RESPONSE_TYPE.ERROR:
@@ -147,15 +133,15 @@ class ListDatabases(Resource):
                 listing_query_response = {"type": "ok"}
             elif result.type == SQL_RESPONSE_TYPE.TABLE:
                 listing_query_response = {
-                    "data": [
-                        {
-                            "name": x[0],
-                            "tables": mysql_proxy.process_query(
-                                "SHOW TABLES FROM `{}`".format(x[0])
-                            ).data,
-                        }
-                        for x in result.data
-                    ]
+                    "data": [{
+                        "name": db_row[0],
+                        "tables": [
+                            table_row[0]
+                            for table_row in mysql_proxy.process_query(
+                                "SHOW TABLES FROM `{}`".format(db_row[0])
+                            ).result_set.to_lists()
+                        ]
+                    } for db_row in result.result_set.to_lists()]
                 }
         except Exception as e:
             listing_query_response = {

mindsdb/api/mcp/start.py

@@ -1,9 +1,16 @@
+import os
 from contextlib import asynccontextmanager
 from collections.abc import AsyncIterator
 from typing import Optional, Dict, Any
 from dataclasses import dataclass
 
+import uvicorn
+import anyio
 from mcp.server.fastmcp import FastMCP
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import Response
+
 from mindsdb.api.mysql.mysql_proxy.classes.fake_mysql_proxy import FakeMysqlProxy
 from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE as SQL_RESPONSE_TYPE
 from mindsdb.utilities import log
@@ -70,10 +77,10 @@ def query(query: str, context: Optional[Dict] = None) -> Dict[str, Any]:
         if result.type == SQL_RESPONSE_TYPE.TABLE:
             return {
                 "type": SQL_RESPONSE_TYPE.TABLE,
-                "data": result.data.to_lists(json_types=True),
+                "data": result.result_set.to_lists(json_types=True),
                 "column_names": [
-                    x["alias"] or x["name"] if "alias" in x else x["name"]
-                    for x in result.columns
+                    column.alias or column.name
+                    for column in result.result_set.columns
                 ],
             }
         else:
@@ -116,7 +123,7 @@ def list_databases() -> Dict[str, Any]:
             return {"type": "ok"}
 
         elif result.type == SQL_RESPONSE_TYPE.TABLE:
-            data = result.data.to_lists(json_types=True)
+            data = result.result_set.to_lists(json_types=True)
             return data
 
     except Exception as e:
@@ -127,6 +134,36 @@ def list_databases() -> Dict[str, Any]:
         }
 
 
+class CustomAuthMiddleware(BaseHTTPMiddleware):
+    """Custom middleware to handle authentication basing on header 'Authorization'
+    """
+    async def dispatch(self, request: Request, call_next):
+        mcp_access_token = os.environ.get('MINDSDB_MCP_ACCESS_TOKEN')
+        if mcp_access_token is not None:
+            auth_token = request.headers.get('Authorization', '').partition('Bearer ')[-1]
+            if mcp_access_token != auth_token:
+                return Response(status_code=401, content="Unauthorized", media_type="text/plain")
+
+        response = await call_next(request)
+
+        return response
+
+
+async def run_sse_async() -> None:
+    """Run the server using SSE transport."""
+    starlette_app = mcp.sse_app()
+    starlette_app.add_middleware(CustomAuthMiddleware)
+
+    config = uvicorn.Config(
+        starlette_app,
+        host=mcp.settings.host,
+        port=mcp.settings.port,
+        log_level=mcp.settings.log_level.lower(),
+    )
+    server = uvicorn.Server(config)
+    await server.serve()
+
+
 def start(*args, **kwargs):
     """Start the MCP server
     Args:
@@ -142,7 +179,7 @@ def start(*args, **kwargs):
     mcp.settings.port = port
 
     try:
-        mcp.run(transport="sse")  # Use SSE transport instead of stdio
+        anyio.run(run_sse_async)
     except Exception as e:
         logger.error(f"Error starting MCP server: {str(e)}")
         raise

mindsdb/api/mysql/mysql_proxy/data_types/mysql_packet.py

@@ -77,7 +77,6 @@ class Packet:
                     f"Packet with less than 4 bytes in length: {packet_string}"
                 )
                 return False
-                break
             len_header = struct.unpack("i", packet_string[:3] + b"\x00")[0]
             count_header = int(packet_string[3])
             if len_header == 0:

mindsdb/api/mysql/mysql_proxy/data_types/mysql_packets/binary_resultset_row_package.py

@@ -30,16 +30,18 @@ class BinaryResultsetRowPacket(Packet):
         columns = self._kwargs.get('columns', {})
 
         self.value = [b'\x00']
-        nulls = [0]
+
+        # NOTE: according to mysql's doc offset=0 only for COM_STMT_EXECUTE, mariadb's doc does't mention that
+        # but in fact it looks like offset=2 everywhere
+        offset = 2
+        nulls_bitmap = bytearray((len(columns) + offset + 7) // 8)
         for i, el in enumerate(data):
-            if i > 0 and (i + 2) % 8 == 0:
-                nulls.append(0)
-            if el is None:
-                if i < 6:
-                    nulls[-1] = nulls[-1] + (1 << ((i + 2) % 8))
-                else:
-                    nulls[-1] = nulls[-1] + (1 << ((i - 6) % 8))
-        self.value.append(bytes(nulls))
+            if el is not None:
+                continue
+            byte_index = (i + offset) // 8
+            bit_index = (i + offset) % 8
+            nulls_bitmap[byte_index] |= (1 << bit_index)
+        self.value.append(bytes(nulls_bitmap))
 
         for i, col in enumerate(columns):
             # NOTE at this moment all types sends as strings, and it works
@@ -65,6 +67,12 @@ class BinaryResultsetRowPacket(Packet):
             elif col_type == TYPES.MYSQL_TYPE_YEAR:
                 enc = '<h'
                 val = int(float(val))
+            elif col_type == TYPES.MYSQL_TYPE_SHORT:
+                enc = '<h'
+                val = int(val)
+            elif col_type == TYPES.MYSQL_TYPE_TINY:
+                enc = '<B'
+                val = int(val)
             elif col_type == TYPES.MYSQL_TYPE_DATE:
                 env_val = self.encode_date(val)
             elif col_type == TYPES.MYSQL_TYPE_TIMESTAMP:
@@ -72,9 +80,9 @@ class BinaryResultsetRowPacket(Packet):
             elif col_type == TYPES.MYSQL_TYPE_DATETIME:
                 env_val = self.encode_date(val)
             elif col_type == TYPES.MYSQL_TYPE_TIME:
-                enc = ''
+                env_val = self.encode_time(val)
             elif col_type == TYPES.MYSQL_TYPE_NEWDECIMAL:
-                enc = ''
+                enc = 'string'
             else:
                 enc = 'string'
 
@@ -90,21 +98,46 @@ class BinaryResultsetRowPacket(Packet):
                     env_val = struct.pack(enc, val)
                 self.value.append(env_val)
 
+    def encode_time(self, val: dt.time | str) -> bytes:
+        """ https://mariadb.com/kb/en/resultset-row/#time-binary-encoding
+        """
+        if isinstance(val, str):
+            try:
+                val = dt.datetime.strptime(val, '%H:%M:%S').time()
+            except ValueError:
+                val = dt.datetime.strptime(val, '%H:%M:%S.%f').time()
+        if val == dt.time(0, 0, 0):
+            return struct.pack('<B', 0)  # special case for 0 time
+        out = struct.pack('<B', 0)  # positive time
+        out += struct.pack('<L', 0)  # days
+        out += struct.pack('<B', val.hour)
+        out += struct.pack('<B', val.minute)
+        out += struct.pack('<B', val.second)
+        if val.microsecond > 0:
+            out += struct.pack('<L', val.microsecond)
+            len_bit = struct.pack('<B', 12)
+        else:
+            len_bit = struct.pack('<B', 8)
+        return len_bit + out
+
     def encode_date(self, val):
         # date_type = None
         # date_value = None
 
         if isinstance(val, str):
-            try:
-                date_value = dt.datetime.strptime(val, '%Y-%m-%d')
-                date_type = 'date'
-            except ValueError:
+            forms = [
+                '%Y-%m-%d', '%Y-%m-%d %H:%M:%S', '%Y-%m-%d %H:%M:%S.%f',
+                '%Y-%m-%dT%H:%M:%S', '%Y-%m-%dT%H:%M:%S.%f'
+            ]
+            for f in forms:
                 try:
-                    date_value = dt.datetime.strptime(val, '%Y-%m-%dT%H:%M:%S')
-                    date_type = 'datetime'
+                    date_value = dt.datetime.strptime(val, f)
+                    break
                 except ValueError:
-                    date_value = dt.datetime.strptime(val, '%Y-%m-%dT%H:%M:%S.%f')
-                    date_type = 'datetime'
+                    date_value = None
+            if date_value is None:
+                raise ValueError(f"Invalid date format: {val}")
+            date_type = 'datetime'
         elif isinstance(val, pd.Timestamp):
             date_value = val
             date_type = 'datetime'

mindsdb/api/mysql/mysql_proxy/executor/mysql_executor.py

@@ -7,6 +7,7 @@ from mindsdb.api.executor.sql_query import SQLQuery
 from mindsdb.api.executor.data_types.answer import ExecuteAnswer
 from mindsdb.api.executor.command_executor import ExecuteCommands
 from mindsdb.api.mysql.mysql_proxy.utilities import ErSqlSyntaxError
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 from mindsdb.utilities import log
 
 logger = log.getLogger(__name__)
@@ -19,8 +20,8 @@ class Executor:
 
         self.query = None
 
-        self.columns = []
-        self.params = []
+        self.columns: list[Column] = []
+        self.params: list[Column] = []
         self.data = None
         self.server_status = None
         self.is_executed = False
@@ -56,14 +57,11 @@ class Executor:
 
             sqlquery.prepare_query()
 
-            self.params = [
-                Column(
-                    alias=p.value,
-                    type="str",
-                    name=p.value,
-                )
-                for p in params
-            ]
+            self.params = [Column(
+                name=p.value,
+                alias=p.value,
+                type=MYSQL_DATA_TYPE.TEXT
+            ) for p in params]
 
             # TODO:
             #   select * from mindsdb.models doesn't invoke prepare_steps and columns_list is empty