MindsDB 25.7.2.0__py3-none-any.whl → 25.7.3.0__py3-none-any.whl

mindsdb/__about__.py

@@ -1,6 +1,6 @@
 __title__ = "MindsDB"
 __package_name__ = "mindsdb"
-__version__ = "25.7.2.0"
+__version__ = "25.7.3.0"
 __description__ = "MindsDB's AI SQL Server enables developers to build AI tools that need access to real-time data to perform their tasks"
 __email__ = "jorge@mindsdb.com"
 __author__ = "MindsDB Inc"

mindsdb/__main__.py

@@ -375,7 +375,7 @@ if __name__ == "__main__":
     apis = os.getenv("MINDSDB_APIS") or config.cmd_args.api
 
     if apis is None:  # If "--api" option is not specified, start the default APIs
-        api_arr = [TrunkProcessEnum.HTTP, TrunkProcessEnum.MYSQL]
+        api_arr = [TrunkProcessEnum.HTTP, TrunkProcessEnum.MYSQL, TrunkProcessEnum.MCP, TrunkProcessEnum.A2A]
     elif apis == "":  # If "--api=" (blank) is specified, don't start any APIs
         api_arr = []
     else:  # The user has provided a list of APIs to start

mindsdb/api/executor/command_executor.py

@@ -84,7 +84,7 @@ from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import (
     TYPES,
 )
 
-from .exceptions import (
+from mindsdb.api.executor.exceptions import (
     ExecutorException,
     BadDbError,
     NotSupportedYet,
@@ -1221,9 +1221,11 @@ class ExecuteCommands:
                 db_name = database_name
 
             dn = self.session.datahub[db_name]
+            if dn is None:
+                raise ExecutorException(f"Cannot delete a table from database '{db_name}': the database does not exist")
+
             if db_name is not None:
                 dn.drop_table(table, if_exists=statement.if_exists)
-
             elif db_name in self.session.database_controller.get_dict(filter_type="project"):
                 # TODO do we need feature: delete object from project via drop table?
 
@@ -1428,6 +1430,9 @@ class ExecuteCommands:
                 provider=provider,
                 params=statement.params,
             )
+        except EntityExistsError as e:
+            if statement.if_not_exists is not True:
+                raise ExecutorException(str(e))
         except ValueError as e:
             # Project does not exist or agent already exists.
             raise ExecutorException(str(e))

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

@@ -164,7 +164,11 @@ class IntegrationDataNode(DataNode):
             df = result_set.to_df()
 
             result: HandlerResponse = self.integration_handler.insert(table_name.parts[-1], df)
-            return DataHubResponse(affected_rows=result.affected_rows)
+            if result is not None:
+                affected_rows = result.affected_rows
+            else:
+                affected_rows = None
+            return DataHubResponse(affected_rows=affected_rows)
 
         insert_columns = [Identifier(parts=[x.alias]) for x in result_set.columns]
 

mindsdb/api/http/namespaces/agents.py

@@ -54,7 +54,7 @@ def create_agent(project_name, name, agent):
             name=name, project_name=project_name, model_name=model_name, skills=skills, provider=provider, params=params
         )
         return created_agent.as_dict(), HTTPStatus.CREATED
-    except ValueError:
+    except (ValueError, EntityExistsError):
         # Model or skill doesn't exist.
         return http_error(
             HTTPStatus.NOT_FOUND,

mindsdb/integrations/handlers/litellm_handler/litellm_handler.py

@@ -2,7 +2,8 @@ import ast
 from typing import Dict, Optional, List
 
 
-from litellm import completion, batch_completion, embedding, acompletion
+from litellm import completion, batch_completion, embedding, acompletion, supports_response_schema
+
 import pandas as pd
 
 from mindsdb.integrations.libs.base import BaseMLEngine
@@ -58,6 +59,15 @@ class LiteLLMHandler(BaseMLEngine):
     @classmethod
     def completion(cls, provider: str, model: str, messages: List[dict], args: dict):
         model, args = cls.prepare_arguments(provider, model, args)
+        json_output = args.pop("json_output", False)
+
+        supports_json_output = supports_response_schema(model=model, custom_llm_provider=provider)
+
+        if json_output and supports_json_output:
+            args["response_format"] = {"type": "json_object"}
+        else:
+            args["response_format"] = None
+
         return completion(model=model, messages=messages, stream=False, **args)
 
     def create(

mindsdb/integrations/handlers/llama_index_handler/requirements.txt

@@ -1,4 +1,4 @@
-llama-index==0.12.28
+llama-index==0.12.41
 pydantic-settings >= 2.1.0
 llama-index-readers-web
 llama-index-embeddings-openai

mindsdb/integrations/handlers/s3_handler/s3_handler.py

@@ -7,6 +7,7 @@ from duckdb import HTTPException
 from mindsdb_sql_parser import parse_sql
 import pandas as pd
 from typing import Text, Dict, Optional
+from botocore.client import Config
 from botocore.exceptions import ClientError
 
 from mindsdb_sql_parser.ast.base import ASTNode
@@ -16,7 +17,7 @@ from mindsdb.utilities import log
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
-    RESPONSE_TYPE
+    RESPONSE_TYPE,
 )
 
 from mindsdb.integrations.libs.api_handler import APIResource, APIHandler
@@ -26,16 +27,12 @@ logger = log.getLogger(__name__)
 
 
 class ListFilesTable(APIResource):
-
-    def list(self,
-             targets: List[str] = None,
-             conditions: List[FilterCondition] = None,
-             limit: int = None,
-             *args, **kwargs) -> pd.DataFrame:
-
+    def list(
+        self, targets: List[str] = None, conditions: List[FilterCondition] = None, limit: int = None, *args, **kwargs
+    ) -> pd.DataFrame:
         buckets = None
         for condition in conditions:
-            if condition.column == 'bucket':
+            if condition.column == "bucket":
                 if condition.op == FilterOperator.IN:
                     buckets = condition.value
                 elif condition.op == FilterOperator.EQUAL:
@@ -44,25 +41,27 @@ class ListFilesTable(APIResource):
 
         data = []
         for obj in self.handler.get_objects(limit=limit, buckets=buckets):
-            path = obj['Key']
-            path = path.replace('`', '')
+            path = obj["Key"]
+            path = path.replace("`", "")
             item = {
-                'path': path,
-                'bucket': obj['Bucket'],
-                'name': path[path.rfind('/') + 1:],
-                'extension': path[path.rfind('.') + 1:]
+                "path": path,
+                "bucket": obj["Bucket"],
+                "name": path[path.rfind("/") + 1 :],
+                "extension": path[path.rfind(".") + 1 :],
             }
 
+            if targets and "public_url" in targets:
+                item["public_url"] = self.handler.generate_sas_url(path, obj["Bucket"])
+
             data.append(item)
 
         return pd.DataFrame(data=data, columns=self.get_columns())
 
     def get_columns(self) -> List[str]:
-        return ["path", "name", "extension", "bucket", "content"]
+        return ["path", "name", "extension", "bucket", "content", "public_url"]
 
 
 class FileTable(APIResource):
-
     def list(self, targets: List[str] = None, table_name=None, *args, **kwargs) -> pd.DataFrame:
         return self.handler.read_as_table(table_name)
 
@@ -76,9 +75,9 @@ class S3Handler(APIHandler):
     This handler handles connection and execution of the SQL statements on AWS S3.
     """
 
-    name = 's3'
+    name = "s3"
     # TODO: Can other file formats be supported?
-    supported_file_formats = ['csv', 'tsv', 'json', 'parquet']
+    supported_file_formats = ["csv", "tsv", "json", "parquet"]
 
     def __init__(self, name: Text, connection_data: Optional[Dict], **kwargs):
         """
@@ -96,7 +95,7 @@ class S3Handler(APIHandler):
         self.connection = None
         self.is_connected = False
         self.thread_safe = True
-        self.bucket = self.connection_data.get('bucket')
+        self.bucket = self.connection_data.get("bucket")
         self._regions = {}
 
         self._files_table = ListFilesTable(self)
@@ -119,8 +118,8 @@ class S3Handler(APIHandler):
             return self.connection
 
         # Validate mandatory parameters.
-        if not all(key in self.connection_data for key in ['aws_access_key_id', 'aws_secret_access_key']):
-            raise ValueError('Required parameters (aws_access_key_id, aws_secret_access_key) must be provided.')
+        if not all(key in self.connection_data for key in ["aws_access_key_id", "aws_secret_access_key"]):
+            raise ValueError("Required parameters (aws_access_key_id, aws_secret_access_key) must be provided.")
 
         # Connect to S3 and configure mandatory credentials.
         self.connection = self._connect_boto3()
@@ -152,13 +151,13 @@ class S3Handler(APIHandler):
         duckdb_conn.execute(f"SET s3_secret_access_key='{self.connection_data['aws_secret_access_key']}'")
 
         # Configure optional parameters.
-        if 'aws_session_token' in self.connection_data:
+        if "aws_session_token" in self.connection_data:
             duckdb_conn.execute(f"SET s3_session_token='{self.connection_data['aws_session_token']}'")
 
         # detect region for bucket
         if bucket not in self._regions:
             client = self.connect()
-            self._regions[bucket] = client.get_bucket_location(Bucket=bucket)['LocationConstraint']
+            self._regions[bucket] = client.get_bucket_location(Bucket=bucket)["LocationConstraint"]
 
         region = self._regions[bucket]
         duckdb_conn.execute(f"SET s3_region='{region}'")
@@ -177,15 +176,17 @@ class S3Handler(APIHandler):
         """
         # Configure mandatory credentials.
         config = {
-            'aws_access_key_id': self.connection_data['aws_access_key_id'],
-            'aws_secret_access_key': self.connection_data['aws_secret_access_key']
+            "aws_access_key_id": self.connection_data["aws_access_key_id"],
+            "aws_secret_access_key": self.connection_data["aws_secret_access_key"],
         }
 
         # Configure optional parameters.
-        if 'aws_session_token' in self.connection_data:
-            config['aws_session_token'] = self.connection_data['aws_session_token']
+        optional_parameters = ["region_name", "aws_session_token"]
+        for parameter in optional_parameters:
+            if parameter in self.connection_data:
+                config[parameter] = self.connection_data[parameter]
 
-        client = boto3.client('s3', **config)
+        client = boto3.client("s3", **config, config=Config(signature_version="s3v4"))
 
         # check connection
         if self.bucket is not None:
@@ -219,7 +220,7 @@ class S3Handler(APIHandler):
             self._connect_boto3()
             response.success = True
         except (ClientError, ValueError) as e:
-            logger.error(f'Error connecting to S3 with the given credentials, {e}!')
+            logger.error(f"Error connecting to S3 with the given credentials, {e}!")
             response.error_message = str(e)
 
         if response.success and need_to_close:
@@ -235,8 +236,8 @@ class S3Handler(APIHandler):
             return self.bucket, key
 
         # get bucket from first part of the key
-        ar = key.split('/')
-        return ar[0], '/'.join(ar[1:])
+        ar = key.split("/")
+        return ar[0], "/".join(ar[1:])
 
     def read_as_table(self, key) -> pd.DataFrame:
         """
@@ -245,7 +246,6 @@ class S3Handler(APIHandler):
         bucket, key = self._get_bucket(key)
 
         with self._connect_duckdb(bucket) as connection:
-
             cursor = connection.execute(f"SELECT * FROM 's3://{bucket}/{key}'")
 
             return cursor.fetchdf()
@@ -259,7 +259,7 @@ class S3Handler(APIHandler):
         client = self.connect()
 
         obj = client.get_object(Bucket=bucket, Key=key)
-        content = obj['Body'].read()
+        content = obj["Body"].read()
         return content
 
     def add_data_to_table(self, key, df) -> None:
@@ -277,7 +277,7 @@ class S3Handler(APIHandler):
             client = self.connect()
             client.head_object(Bucket=bucket, Key=key)
         except ClientError as e:
-            logger.error(f'Error querying the file {key} in the bucket {bucket}, {e}!')
+            logger.error(f"Error querying the file {key} in the bucket {bucket}, {e}!")
             raise e
 
         with self._connect_duckdb(bucket) as connection:
@@ -309,31 +309,28 @@ class S3Handler(APIHandler):
         if isinstance(query, Select):
             table_name = query.from_table.parts[-1]
 
-            if table_name == 'files':
+            if table_name == "files":
                 table = self._files_table
                 df = table.select(query)
 
                 # add content
                 has_content = False
                 for target in query.targets:
-                    if isinstance(target, Identifier) and target.parts[-1].lower() == 'content':
+                    if isinstance(target, Identifier) and target.parts[-1].lower() == "content":
                         has_content = True
                         break
                 if has_content:
-                    df['content'] = df['path'].apply(self._read_as_content)
+                    df["content"] = df["path"].apply(self._read_as_content)
             else:
-                extension = table_name.split('.')[-1]
+                extension = table_name.split(".")[-1]
                 if extension not in self.supported_file_formats:
-                    logger.error(f'The file format {extension} is not supported!')
-                    raise ValueError(f'The file format {extension} is not supported!')
+                    logger.error(f"The file format {extension} is not supported!")
+                    raise ValueError(f"The file format {extension} is not supported!")
 
                 table = FileTable(self, table_name=table_name)
                 df = table.select(query)
 
-            response = Response(
-                RESPONSE_TYPE.TABLE,
-                data_frame=df
-            )
+            response = Response(RESPONSE_TYPE.TABLE, data_frame=df)
         elif isinstance(query, Insert):
             table_name = query.table.parts[-1]
             table = FileTable(self, table_name=table_name)
@@ -364,7 +361,7 @@ class S3Handler(APIHandler):
             scan_buckets = [self.bucket]
         else:
             add_bucket_to_name = True
-            scan_buckets = [b['Name'] for b in client.list_buckets()['Buckets']]
+            scan_buckets = [b["Name"] for b in client.list_buckets()["Buckets"]]
 
         objects = []
         for bucket in scan_buckets:
@@ -372,23 +369,38 @@ class S3Handler(APIHandler):
                 continue
 
             resp = client.list_objects_v2(Bucket=bucket)
-            if 'Contents' not in resp:
+            if "Contents" not in resp:
                 continue
 
-            for obj in resp['Contents']:
-                if obj.get('StorageClass', 'STANDARD') != 'STANDARD':
+            for obj in resp["Contents"]:
+                if obj.get("StorageClass", "STANDARD") != "STANDARD":
                     continue
 
-                obj['Bucket'] = bucket
+                obj["Bucket"] = bucket
                 if add_bucket_to_name:
                     # bucket is part of the name
-                    obj['Key'] = f'{bucket}/{obj["Key"]}'
+                    obj["Key"] = f"{bucket}/{obj['Key']}"
                 objects.append(obj)
             if limit is not None and len(objects) >= limit:
                 break
 
         return objects
 
+    def generate_sas_url(self, key: str, bucket: str) -> str:
+        """
+        Generates a pre-signed URL for accessing an object in the S3 bucket.
+
+        Args:
+            key (str): The key (path) of the object in the S3 bucket.
+            bucket (str): The name of the S3 bucket.
+
+        Returns:
+            str: The pre-signed URL for accessing the object.
+        """
+        client = self.connect()
+        url = client.generate_presigned_url("get_object", Params={"Bucket": bucket, "Key": key}, ExpiresIn=3600)
+        return url
+
     def get_tables(self) -> Response:
         """
         Retrieves a list of tables (objects) in the S3 bucket.
@@ -402,21 +414,13 @@ class S3Handler(APIHandler):
         # Get only the supported file formats.
         # Wrap the object names with backticks to prevent SQL syntax errors.
         supported_names = [
-            f"`{obj['Key']}`"
-            for obj in self.get_objects()
-            if obj['Key'].split('.')[-1] in self.supported_file_formats
+            f"`{obj['Key']}`" for obj in self.get_objects() if obj["Key"].split(".")[-1] in self.supported_file_formats
         ]
 
         # virtual table with list of files
-        supported_names.insert(0, 'files')
+        supported_names.insert(0, "files")
 
-        response = Response(
-            RESPONSE_TYPE.TABLE,
-            data_frame=pd.DataFrame(
-                supported_names,
-                columns=['table_name']
-            )
-        )
+        response = Response(RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame(supported_names, columns=["table_name"]))
 
         return response
 
@@ -433,11 +437,7 @@ class S3Handler(APIHandler):
         Returns:
             Response: A response object containing the column details, formatted as per the `Response` class.
         """
-        query = Select(
-            targets=[Star()],
-            from_table=Identifier(parts=[table_name]),
-            limit=Constant(1)
-        )
+        query = Select(targets=[Star()], from_table=Identifier(parts=[table_name]), limit=Constant(1))
 
         result = self.query(query)
 
@@ -445,10 +445,12 @@ class S3Handler(APIHandler):
             RESPONSE_TYPE.TABLE,
             data_frame=pd.DataFrame(
                 {
-                    'column_name': result.data_frame.columns,
-                    'data_type': [data_type if data_type != 'object' else 'string' for data_type in result.data_frame.dtypes]
+                    "column_name": result.data_frame.columns,
+                    "data_type": [
+                        data_type if data_type != "object" else "string" for data_type in result.data_frame.dtypes
+                    ],
                 }
-            )
+            ),
         )
 
         return response

mindsdb/integrations/handlers/salesforce_handler/salesforce_handler.py

@@ -72,7 +72,7 @@ class SalesforceHandler(MetaAPIHandler):
 
             resource_tables = self._get_resource_names()
             for resource_name in resource_tables:
-                table_class = create_table_class(resource_name)
+                table_class = create_table_class(resource_name.lower())
                 self._register_table(resource_name, table_class(self))
 
             return self.connection

mindsdb/integrations/handlers/salesforce_handler/salesforce_tables.py

@@ -164,9 +164,18 @@ def create_table_class(resource_name: Text) -> MetaAPIResource:
             """
             client = self.handler.connect()
 
-            resource_metadata = next(
-                (resource for resource in main_metadata if resource["name"].lower() == resource_name),
-            )
+            try:
+                resource_metadata = next(
+                    (resource for resource in main_metadata if resource["name"].lower() == resource_name),
+                )
+            except Exception as e:
+                logger.warning(f"Failed to get resource metadata for {resource_name}: {e}")
+                return {
+                    "table_name": table_name,
+                    "table_type": "BASE TABLE",
+                    "table_description": "",
+                    "row_count": None,
+                }
 
             # Get row count if Id column is aggregatable.
             row_count = None