asksql 2.1.0__tar.gz → 2.2.0__tar.gz

{asksql-2.1.0 → asksql-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asksql
-Version: 2.1.0
+Version: 2.2.0
 Summary: Community-maintained, security-focused fork of Vanna: generate SQL from natural language. Drop-in: keeps `import vanna`.
 Author-email: Zain Hoda <zain@vanna.ai>
 Maintainer: Ayush Srivastava
@@ -176,6 +176,11 @@ Provides-Extra: zhipuai
 
 # asksql
 
+[![PyPI](https://img.shields.io/pypi/v/asksql.svg)](https://pypi.org/project/asksql/)
+[![Tests](https://github.com/buhtig47/vanna/actions/workflows/tests.yml/badge.svg)](https://github.com/buhtig47/vanna/actions/workflows/tests.yml)
+[![Python](https://img.shields.io/badge/python-3.10%E2%80%933.13-blue.svg)](https://github.com/buhtig47/vanna/actions/workflows/tests.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/buhtig47/vanna/blob/main/LICENSE)
+
 **The community-maintained, security-focused continuation of [Vanna](https://github.com/vanna-ai/vanna).**
 
 > 🚧 **Work in progress.** Vanna was archived on 29 March 2026 with ~227 open issues. asksql picks it up: security fixes first, then bug fixes and dependency updates.
@@ -187,7 +192,11 @@ pip uninstall vanna
 pip install asksql
 ```
 
-asksql keeps the `vanna` import name (like Pillow did for PIL), so `import vanna`, `from vanna import Agent` and the legacy 1.x `VannaBase` API work as before. Don't install both packages in the same environment.
+asksql keeps the `vanna` import name (like Pillow did for PIL), so `import vanna`, `from vanna import Agent` and the legacy `VannaBase` API work as before. Uninstall Vanna **before** installing asksql, because both ship the same `vanna/` folder.
+
+📘 **[Migration guide](https://github.com/buhtig47/vanna/blob/main/MIGRATING_FROM_VANNA.md)**: requirements files, coming from Vanna 0.x, behaviour changes, troubleshooting.
+
+🔌 **[Server API](https://github.com/buhtig47/vanna/blob/main/SERVER_API.md)**: HTTP endpoints (`/health`, `chat_poll`, `chat_sse`), request/response format, CORS.
 
 ### What's fixed so far
 

{asksql-2.1.0 → asksql-2.2.0}/README.md

@@ -1,5 +1,10 @@
 # asksql
 
+[![PyPI](https://img.shields.io/pypi/v/asksql.svg)](https://pypi.org/project/asksql/)
+[![Tests](https://github.com/buhtig47/vanna/actions/workflows/tests.yml/badge.svg)](https://github.com/buhtig47/vanna/actions/workflows/tests.yml)
+[![Python](https://img.shields.io/badge/python-3.10%E2%80%933.13-blue.svg)](https://github.com/buhtig47/vanna/actions/workflows/tests.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/buhtig47/vanna/blob/main/LICENSE)
+
 **The community-maintained, security-focused continuation of [Vanna](https://github.com/vanna-ai/vanna).**
 
 > 🚧 **Work in progress.** Vanna was archived on 29 March 2026 with ~227 open issues. asksql picks it up: security fixes first, then bug fixes and dependency updates.
@@ -11,7 +16,11 @@ pip uninstall vanna
 pip install asksql
 ```
 
-asksql keeps the `vanna` import name (like Pillow did for PIL), so `import vanna`, `from vanna import Agent` and the legacy 1.x `VannaBase` API work as before. Don't install both packages in the same environment.
+asksql keeps the `vanna` import name (like Pillow did for PIL), so `import vanna`, `from vanna import Agent` and the legacy `VannaBase` API work as before. Uninstall Vanna **before** installing asksql, because both ship the same `vanna/` folder.
+
+📘 **[Migration guide](https://github.com/buhtig47/vanna/blob/main/MIGRATING_FROM_VANNA.md)**: requirements files, coming from Vanna 0.x, behaviour changes, troubleshooting.
+
+🔌 **[Server API](https://github.com/buhtig47/vanna/blob/main/SERVER_API.md)**: HTTP endpoints (`/health`, `chat_poll`, `chat_sse`), request/response format, CORS.
 
 ### What's fixed so far
 

{asksql-2.1.0 → asksql-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "asksql"
-version = "2.1.0"
+version = "2.2.0"
 authors = [
   { name="Zain Hoda", email="zain@vanna.ai" },
 ]

{asksql-2.1.0 → asksql-2.2.0}/src/vanna/__init__.py

@@ -6,7 +6,7 @@ with tool execution, conversation management, and user scoping.
 """
 
 # Version information
-__version__ = "2.1.0"  # keep in sync with pyproject.toml
+__version__ = "2.2.0"  # keep in sync with pyproject.toml
 
 # Import core framework components
 from .core import (

{asksql-2.1.0 → asksql-2.2.0}/src/vanna/core/agent/agent.py

@@ -980,8 +980,35 @@ class Agent:
 
                             if has_tool_error_access:
                                 yield result.ui_component
+                        elif result.metadata.get("contains_schema_details"):
+                            # Table/column listings from schema lookups are only shown to
+                            # users with the "schema_details" UI feature (vanna-ai/vanna#1105)
+                            has_schema_access = (
+                                self.config.ui_features.can_user_access_feature(
+                                    UiFeature.UI_FEATURE_SHOW_SCHEMA_DETAILS, user
+                                )
+                            )
+
+                            if (
+                                self.audit_logger
+                                and self.config.audit_config.enabled
+                                and self.config.audit_config.log_ui_feature_checks
+                            ):
+                                await self.audit_logger.log_ui_feature_access(
+                                    user=user,
+                                    feature_name=UiFeature.UI_FEATURE_SHOW_SCHEMA_DETAILS,
+                                    access_granted=has_schema_access,
+                                    required_groups=self.config.ui_features.feature_group_access.get(
+                                        UiFeature.UI_FEATURE_SHOW_SCHEMA_DETAILS, []
+                                    ),
+                                    conversation_id=conversation.id,
+                                    request_id=request_id,
+                                )
+
+                            if has_schema_access:
+                                yield result.ui_component
                         else:
-                            # Success results are always shown if they exist
+                            # Other success results are always shown if they exist
                             yield result.ui_component
 
                     # Collect tool result data

{asksql-2.1.0 → asksql-2.2.0}/src/vanna/core/agent/config.py

@@ -6,7 +6,7 @@ This module contains configuration models that control agent behavior.
 
 from typing import TYPE_CHECKING, Dict, List, Optional
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 
 from .._compat import StrEnum
 
@@ -20,6 +20,8 @@ class UiFeature(StrEnum):
     UI_FEATURE_SHOW_TOOL_ERROR = "tool_error"
     UI_FEATURE_SHOW_TOOL_INVOCATION_MESSAGE_IN_CHAT = "tool_invocation_message_in_chat"
     UI_FEATURE_SHOW_MEMORY_DETAILED_RESULTS = "memory_detailed_results"
+    # Results of queries that inspect the database structure (tables, columns)
+    UI_FEATURE_SHOW_SCHEMA_DETAILS = "schema_details"
 
 
 # Optional: you can also define defaults if you want a shared baseline
@@ -29,6 +31,7 @@ DEFAULT_UI_FEATURES: Dict[str, List[str]] = {
     UiFeature.UI_FEATURE_SHOW_TOOL_ERROR: ["admin"],
     UiFeature.UI_FEATURE_SHOW_TOOL_INVOCATION_MESSAGE_IN_CHAT: ["admin"],
     UiFeature.UI_FEATURE_SHOW_MEMORY_DETAILED_RESULTS: ["admin"],
+    UiFeature.UI_FEATURE_SHOW_SCHEMA_DETAILS: ["admin"],
 }
 
 
@@ -46,6 +49,19 @@ class UiFeatures(BaseModel):
         description="Which groups can access UI features",
     )
 
+    @field_validator("feature_group_access")
+    @classmethod
+    def _add_new_default_features(
+        cls, value: Dict[str, List[str]]
+    ) -> Dict[str, List[str]]:
+        # Configs written before "schema_details" existed would otherwise hide it from
+        # everyone (unknown features are denied), so give it its default groups.
+        value.setdefault(
+            UiFeature.UI_FEATURE_SHOW_SCHEMA_DETAILS,
+            list(DEFAULT_UI_FEATURES[UiFeature.UI_FEATURE_SHOW_SCHEMA_DETAILS]),
+        )
+        return value
+
     def can_user_access_feature(self, feature_name: str, user: "User") -> bool:
         """Check if user can access a UI feature using same logic as tools.
 

{asksql-2.1.0 → asksql-2.2.0}/src/vanna/core/workflow/default.py

@@ -158,6 +158,10 @@ class DefaultWorkflowHandler(WorkflowHandler):
             memory_id = message.strip()[8:].strip()  # Extract ID after "/delete "
             return await self._delete_memory(agent, user, conversation, memory_id)
 
+        if message.strip().lower().startswith("/save_memory "):
+            pending_id = message.strip()[len("/save_memory ") :].strip()
+            return await self._approve_memory(agent, user, conversation, pending_id)
+
         # Don't handle other messages, pass to LLM
         return WorkflowResult(should_skip_llm=False)
 
@@ -680,6 +684,53 @@ class DefaultWorkflowHandler(WorkflowHandler):
                 ],
             )
 
+    async def _approve_memory(
+        self,
+        agent: "Agent",
+        user: "User",
+        conversation: "Conversation",
+        pending_id: str,
+    ) -> WorkflowResult:
+        """Save a memory the user approved with the "Save to memory" button (vanna-ai/vanna#1103)."""
+        from vanna.core.tool import ToolContext
+        from vanna.tools.agent_memory import SaveQuestionToolArgsTool
+
+        def reply(content: str) -> WorkflowResult:
+            return WorkflowResult(
+                should_skip_llm=True,
+                components=[
+                    UiComponent(
+                        rich_component=RichTextComponent(
+                            content=content, markdown=True
+                        ),
+                        simple_component=None,
+                    )
+                ],
+            )
+
+        tool = await agent.tool_registry.get_tool("save_question_tool_args")
+        # register_local_tool(..., access_groups=[...]) wraps the tool
+        tool = getattr(tool, "_wrapped_tool", tool)
+        if not isinstance(tool, SaveQuestionToolArgsTool) or not getattr(
+            agent, "agent_memory", None
+        ):
+            return reply("# ⚠️ Nothing to save\n\nMemory saving is not configured.")
+
+        context = ToolContext(
+            user=user,
+            conversation_id=conversation.id,
+            request_id=str(uuid.uuid4()),
+            agent_memory=agent.agent_memory,
+        )
+        if await tool.approve(pending_id, context):
+            return reply(
+                "# ✅ Saved to memory\n\nSimilar questions will reuse this query."
+            )
+        return reply(
+            "# ❌ Nothing to save\n\nThis save request has expired, was already saved, "
+            "or belongs to another user."
+        )
+
     async def _delete_memory(
         self, agent: "Agent", user: "User", conversation: "Conversation", memory_id: str
     ) -> WorkflowResult:

{asksql-2.1.0 → asksql-2.2.0}/src/vanna/integrations/postgres/sql_runner.py

@@ -87,11 +87,10 @@ class PostgresRunner(SqlRunner):
             # Execute the query
             cursor.execute(args.sql)
 
-            # Determine if this is a SELECT query or modification query
-            query_type = args.sql.strip().upper().split()[0]
-
-            if query_type == "SELECT":
-                # Fetch results for SELECT queries
+            # DB-API: description is set only for statements that return rows. Checking the
+            # first word missed WITH ... SELECT and queries starting with a comment.
+            if cursor.description is not None:
+                # Fetch results for queries that return rows
                 rows = cursor.fetchall()
                 if not rows:
                     # Return empty DataFrame

{asksql-2.1.0 → asksql-2.2.0}/src/vanna/integrations/sqlite/sql_runner.py

@@ -40,11 +40,10 @@ class SqliteRunner(SqlRunner):
             # Execute the query
             cursor.execute(args.sql)
 
-            # Determine if this is a SELECT query or modification query
-            query_type = args.sql.strip().upper().split()[0]
-
-            if query_type == "SELECT":
-                # Fetch results for SELECT queries
+            # DB-API: description is set only for statements that return rows. Checking the
+            # first word missed WITH ... SELECT and queries starting with a comment.
+            if cursor.description is not None:
+                # Fetch results for queries that return rows
                 rows = cursor.fetchall()
                 if not rows:
                     # Return empty DataFrame

{asksql-2.1.0 → asksql-2.2.0}/src/vanna/legacy/adapter.py

@@ -125,17 +125,18 @@ class LegacyVannaAdapter(ToolRegistry, AgentMemory):
         sql_runner = LegacySqlRunner(self.vn)
 
         # Register the RunSqlTool with user and admin access
+        config = getattr(self.vn, "config", None) or {}
         run_sql_tool = RunSqlTool(
             sql_runner,
-            allow_write_sql=bool(
-                (getattr(self.vn, "config", None) or {}).get("allow_write_sql", False)
-            ),
+            allow_write_sql=bool(config.get("allow_write_sql", False)),
         )
         self.register_local_tool(run_sql_tool, access_groups=["user", "admin"])
 
         # Register memory tools using the internal _agent_memory instance
         # SaveQuestionToolArgsTool - for saving question-tool-args patterns (admin only)
-        save_memory_tool = SaveQuestionToolArgsTool()
+        save_memory_tool = SaveQuestionToolArgsTool(
+            require_approval=bool(config.get("require_memory_approval", False))
+        )
         self.register_local_tool(save_memory_tool, access_groups=["admin"])
 
         # SearchSavedCorrectToolUsesTool - for searching similar patterns (user and admin)

{asksql-2.1.0 → asksql-2.2.0}/src/vanna/servers/fastapi/app.py

@@ -2,6 +2,7 @@
 FastAPI server factory for Vanna Agents.
 """
 
+import warnings
 from typing import Any, Dict, Optional
 
 from fastapi import FastAPI
@@ -49,7 +50,18 @@ class VannaFastAPIServer:
 
             # Set sensible defaults
             cors_params.setdefault("allow_origins", ["*"])
-            cors_params.setdefault("allow_credentials", True)
+            # Wildcard origins + credentials lets ANY website send requests with the
+            # user's cookies and read the answers. Only allow credentials by default
+            # when the origins are an explicit allow-list.
+            wildcard = "*" in cors_params["allow_origins"]
+            cors_params.setdefault("allow_credentials", not wildcard)
+            if wildcard and cors_params["allow_credentials"]:
+                warnings.warn(
+                    "CORS allow_origins=['*'] with allow_credentials=True lets any website "
+                    "call this server with your users' cookies. List your frontend origins "
+                    "in config['cors']['allow_origins'] instead.",
+                    stacklevel=2,
+                )
             cors_params.setdefault("allow_methods", ["*"])
             cors_params.setdefault("allow_headers", ["*"])
 

{asksql-2.1.0 → asksql-2.2.0}/src/vanna/tools/agent_memory.py

@@ -7,7 +7,9 @@ The tools access AgentMemory via ToolContext, which is populated by the Agent.
 """
 
 import logging
-from typing import Any, Dict, List, Optional, Type
+import uuid
+from collections import OrderedDict
+from typing import Any, Dict, List, Optional, Tuple, Type
 from pydantic import BaseModel, Field
 
 logger = logging.getLogger(__name__)
@@ -19,8 +21,14 @@ from vanna.components import (
     UiComponent,
     StatusBarUpdateComponent,
     CardComponent,
+    ButtonComponent,
+    SimpleTextComponent,
 )
 
+# Chat command the "Save to memory" button sends (handled by DefaultWorkflowHandler)
+SAVE_MEMORY_COMMAND = "/save_memory"
+MAX_PENDING_APPROVALS = 1000
+
 
 class SaveQuestionToolArgsParams(BaseModel):
     """Parameters for saving question-tool-argument combinations."""
@@ -58,7 +66,66 @@ class SaveTextMemoryParams(BaseModel):
 
 
 class SaveQuestionToolArgsTool(Tool[SaveQuestionToolArgsParams]):
-    """Tool for saving successful question-tool-argument combinations."""
+    """Tool for saving successful question-tool-argument combinations.
+
+    Args:
+        require_approval: If True, the LLM can only *propose* a memory. The user
+            sees a "Save to memory" button and the pattern is saved only when
+            they click it. Prevents SQL that ran but returned wrong data from
+            being saved and reused (vanna-ai/vanna#1103).
+    """
+
+    def __init__(self, require_approval: bool = False):
+        self.require_approval = require_approval
+        # pending_id -> (user_id, args); bounded so it can't grow forever
+        self._pending: "OrderedDict[str, Tuple[str, SaveQuestionToolArgsParams]]" = (
+            OrderedDict()
+        )
+
+    async def approve(self, pending_id: str, context: ToolContext) -> bool:
+        """Save a pending memory. Only the user it was proposed to can approve it, once."""
+        pending = self._pending.get(pending_id)
+        if pending is None or pending[0] != context.user.id:
+            return False
+        del self._pending[pending_id]
+        _, args = pending
+        await context.agent_memory.save_tool_usage(
+            question=args.question,
+            tool_name=args.tool_name,
+            args=args.args,
+            context=context,
+            success=True,
+        )
+        return True
+
+    def _propose(
+        self, context: ToolContext, args: SaveQuestionToolArgsParams
+    ) -> ToolResult:
+        pending_id = uuid.uuid4().hex[:12]
+        self._pending[pending_id] = (context.user.id, args)
+        while len(self._pending) > MAX_PENDING_APPROVALS:
+            self._pending.popitem(last=False)
+
+        command = f"{SAVE_MEMORY_COMMAND} {pending_id}"
+        return ToolResult(
+            success=True,
+            result_for_llm=(
+                "Not saved yet: the user must approve saving this pattern to memory. "
+                "A 'Save to memory' button has been shown to them. Do not call this tool again for it."
+            ),
+            ui_component=UiComponent(
+                rich_component=ButtonComponent(
+                    label="Save to memory",
+                    action=command,
+                    variant="secondary",
+                    size="small",
+                    icon="👍",
+                ),
+                simple_component=SimpleTextComponent(
+                    text=f"If this answer is correct, send `{command}` to save it to memory."
+                ),
+            ),
+        )
 
     @property
     def name(self) -> str:
@@ -77,6 +144,9 @@ class SaveQuestionToolArgsTool(Tool[SaveQuestionToolArgsParams]):
         self, context: ToolContext, args: SaveQuestionToolArgsParams
     ) -> ToolResult:
         """Save the tool usage pattern to agent memory."""
+        if self.require_approval:
+            return self._propose(context, args)
+
         try:
             await context.agent_memory.save_tool_usage(
                 question=args.question,

{asksql-2.1.0 → asksql-2.2.0}/src/vanna/tools/run_sql.py

@@ -1,6 +1,7 @@
 """Generic SQL query execution tool with dependency injection."""
 
 from typing import Any, Dict, List, Optional, Type, cast
+import re
 import uuid
 from vanna.core.tool import Tool, ToolContext, ToolResult
 from vanna.components import (
@@ -13,7 +14,22 @@ from vanna.components import (
 from vanna.capabilities.sql_runner import SqlRunner, RunSqlToolArgs
 from vanna.capabilities.file_system import FileSystem
 from vanna.integrations.local import LocalFileSystem
-from vanna.utils.sql_safety import ensure_read_only_sql
+from vanna.utils.sql_safety import ensure_read_only_sql, sql_returns_rows
+
+# Catalog tables/commands that describe the database structure rather than business data
+_SCHEMA_QUERY = re.compile(
+    r"\b(information_schema|sqlite_master|sqlite_schema|pg_catalog|pg_tables|pg_class"
+    r"|pg_attribute|sys\.(tables|columns|objects|schemas)|all_tables|user_tables"
+    r"|all_tab_columns|user_tab_columns|all_views|system\.(tables|columns)"
+    r"|duckdb_tables|duckdb_columns|table_info|pragma_\w+)\b"
+    r"|^\s*(show|describe|desc|pragma)\b",
+    re.IGNORECASE,
+)
+
+
+def is_schema_query(sql: str) -> bool:
+    """True if the query inspects database structure (tables, columns) - vanna-ai/vanna#1105."""
+    return bool(_SCHEMA_QUERY.search(sql or ""))
 
 
 class RunSqlTool(Tool[RunSqlToolArgs]):
@@ -70,7 +86,7 @@ class RunSqlTool(Tool[RunSqlToolArgs]):
             # Determine query type
             query_type = args.sql.strip().upper().split()[0]
 
-            if query_type == "SELECT":
+            if sql_returns_rows(args.sql):
                 # Handle SELECT queries with results
                 if df.empty:
                     result = "Query executed successfully. No rows returned."
@@ -135,7 +151,11 @@ class RunSqlTool(Tool[RunSqlToolArgs]):
             else:
                 # For non-SELECT queries (INSERT, UPDATE, DELETE, etc.)
                 # The SqlRunner should return a DataFrame with affected row count
-                rows_affected = len(df) if not df.empty else 0
+                if "rows_affected" in df.columns and not df.empty:
+                    # Built-in runners report the count as a one-row DataFrame
+                    rows_affected = int(df["rows_affected"].iloc[0])
+                else:
+                    rows_affected = len(df)
                 result = (
                     f"Query executed successfully. {rows_affected} row(s) affected."
                 )
@@ -148,6 +168,9 @@ class RunSqlTool(Tool[RunSqlToolArgs]):
                     simple_component=SimpleTextComponent(text=result),
                 )
 
+            # The agent hides these results from users without the "schema_details" UI feature
+            metadata["contains_schema_details"] = is_schema_query(args.sql)
+
             return ToolResult(
                 success=True,
                 result_for_llm=result,

{asksql-2.1.0 → asksql-2.2.0}/src/vanna/utils/sql_safety.py

@@ -82,3 +82,22 @@ def ensure_read_only_sql(sql: str) -> None:
         word = token.value.strip('`"[]').upper()
         if word in DENIED_WORDS or word.startswith(DENIED_PREFIXES):
             raise UnsafeSqlError(f"'{token.value}' is not allowed. {WRITE_SQL_HINT}")
+
+
+# Leading keywords of statements that return a result set but that sqlparse types as UNKNOWN
+_ROW_RETURNING_KEYWORDS = {"SHOW", "DESCRIBE", "DESC", "EXPLAIN", "PRAGMA", "VALUES"}
+
+
+def sql_returns_rows(sql: str) -> bool:
+    """True if `sql` returns a result set (SELECT, WITH ... SELECT, SHOW, ...).
+
+    Unlike checking the first word, this handles CTEs and leading comments.
+    """
+    statements = [s for s in sqlparse.parse(sql or "") if s.value.strip(" \t\r\n;")]
+    if not statements:
+        return False
+    statement = statements[-1]
+    if statement.get_type() == "SELECT":
+        return True
+    first = statement.token_first(skip_cm=True, skip_ws=True)
+    return first is not None and first.normalized.upper() in _ROW_RETURNING_KEYWORDS