sqlsaber 0.32.1__py3-none-any.whl → 0.34.0__py3-none-any.whl

sqlsaber/agents/pydantic_ai_agent.py

@@ -24,6 +24,9 @@ from sqlsaber.database import (
     SQLiteConnection,
 )
 from sqlsaber.memory.manager import MemoryManager
+from sqlsaber.prompts.claude import SONNET_4_5
+from sqlsaber.prompts.memory import MEMORY_ADDITION
+from sqlsaber.prompts.openai import GPT_5
 from sqlsaber.tools.registry import tool_registry
 from sqlsaber.tools.sql_tools import SQLTool
 
@@ -168,6 +171,16 @@ class SQLSaberAgent:
 
             @agent.system_prompt(dynamic=True)
             async def sqlsaber_system_prompt(ctx: RunContext) -> str:
+                if "gpt-5" in agent.model.model_name:
+                    base = GPT_5.format(db=self.db_type)
+
+                    if self.database_name:
+                        mem = self.memory_manager.format_memories_for_prompt(
+                            self.database_name
+                        )
+                        mem = mem.strip()
+                        if mem:
+                            return f"{base}\n\n{MEMORY_ADDITION}\n\n{mem}"
                 return self.system_prompt_text(include_memory=True)
         else:
 
@@ -178,37 +191,13 @@ class SQLSaberAgent:
 
     def system_prompt_text(self, include_memory: bool = True) -> str:
         """Return the original SQLSaber system prompt as a single string."""
-        db = self.db_type
-        base = (
-            f"You are a helpful SQL assistant that helps users query their {db} database.\n\n"
-            "Your responsibilities:\n"
-            "1. Understand user's natural language requests, think and convert them to SQL\n"
-            "2. Use the provided tools efficiently to explore database schema\n"
-            "3. Generate appropriate SQL queries\n"
-            "4. Execute queries safely - queries that modify the database are not allowed\n"
-            "5. Format and explain results clearly\n\n"
-            "IMPORTANT - Tool Usage Strategy:\n"
-            "1. ALWAYS start with 'list_tables' to see available tables and row counts. Use this first to discover available tables.\n"
-            "2. Use 'introspect_schema' with a table_pattern to get details ONLY for relevant tables. Use table patterns like 'sample%' or '%experiment%' to filter related tables.\n"
-            "3. Execute SQL queries safely with automatic LIMIT clauses for SELECT statements. Only SELECT queries are permitted for security.\n\n"
-            "Tool-Specific Guidelines:\n"
-            "- introspect_schema: Use 'introspect_schema' with a table_pattern to get details ONLY for relevant tables. Use table patterns like 'sample%' or '%experiment%' to filter related tables.\n"
-            "- execute_sql: Execute SQL queries safely with automatic LIMIT clauses for SELECT statements. Only SELECT queries are permitted for security.\n\n"
-            "Guidelines:\n"
-            "- Use proper JOIN syntax and avoid cartesian products\n"
-            "- Include appropriate WHERE clauses to limit results\n"
-            "- Explain what the query does in simple terms\n"
-            "- Handle errors gracefully and suggest fixes\n"
-            "- Be security conscious - use parameterized queries when needed\n"
-            "- Timestamp columns must be converted to text when you write queries\n"
-            "- Use table patterns like 'sample%' or '%experiment%' to filter related tables"
-        )
+        base = SONNET_4_5.format(db=self.db_type)
 
         if include_memory and self.database_name:
             mem = self.memory_manager.format_memories_for_prompt(self.database_name)
             mem = mem.strip()
             if mem:
-                return f"{base}\n\n{mem}"
+                return f"{base}\n\n{MEMORY_ADDITION}\n\n{mem}\n\n"
         return base
 
     def _register_tools(self, agent: Agent) -> None:

sqlsaber/application/auth_setup.py

@@ -1,6 +1,7 @@
 """Shared auth setup logic for onboarding and CLI."""
 
 import asyncio
+import os
 
 from questionary import Choice
 
@@ -9,6 +10,7 @@ from sqlsaber.config import providers
 from sqlsaber.config.api_keys import APIKeyManager
 from sqlsaber.config.auth import AuthConfigManager, AuthMethod
 from sqlsaber.config.oauth_flow import AnthropicOAuthFlow
+from sqlsaber.config.oauth_tokens import OAuthTokenManager
 from sqlsaber.theme.manager import create_console
 
 console = create_console()
@@ -102,24 +104,49 @@ async def setup_auth(
     Returns:
         Tuple of (success: bool, provider: str | None)
     """
-    # Check if auth is already configured
-    if auth_manager.has_auth_configured():
-        console.print("[success]✓ Authentication already configured![/success]")
-        return True, None
+    oauth_manager = OAuthTokenManager()
 
-    # Select provider
     provider = await select_provider(prompter, default=default_provider)
 
     if provider is None:
         return False, None
 
+    env_var = api_key_manager.get_env_var_name(provider)
+    api_key_in_env = bool(os.getenv(env_var))
+    api_key_in_keyring = api_key_manager.has_stored_api_key(provider)
+    has_oauth = (
+        oauth_manager.has_oauth_token("anthropic")
+        if provider == "anthropic" and allow_oauth
+        else False
+    )
+
+    if api_key_in_env or api_key_in_keyring or has_oauth:
+        parts: list[str] = []
+        if api_key_in_keyring:
+            parts.append("stored API key")
+        if api_key_in_env:
+            parts.append(f"{env_var} environment variable")
+        if has_oauth:
+            parts.append("OAuth token")
+        summary = ", ".join(parts)
+        console.print(
+            f"[info]Existing authentication found for {provider}: {summary}[/info]"
+        )
+
     # For Anthropic, offer OAuth or API key
     if provider == "anthropic" and allow_oauth:
+        api_key_label = "API Key"
+        if api_key_in_keyring or api_key_in_env:
+            api_key_label += " [configured]"
+        oauth_label = "Claude Pro/Max (OAuth)"
+        if has_oauth:
+            oauth_label += " [configured]"
+
         method_choice = await prompter.select(
             "Authentication method:",
             choices=[
-                Choice("API Key", value=AuthMethod.API_KEY),
-                Choice("Claude Pro/Max (OAuth)", value=AuthMethod.CLAUDE_PRO),
+                Choice(api_key_label, value=AuthMethod.API_KEY),
+                Choice(oauth_label, value=AuthMethod.CLAUDE_PRO),
             ],
         )
 
@@ -127,6 +154,28 @@ async def setup_auth(
             return False, None
 
         if method_choice == AuthMethod.CLAUDE_PRO:
+            if has_oauth:
+                reset = await prompter.confirm(
+                    "Anthropic OAuth is already configured. Reset before continuing?",
+                    default=False,
+                )
+                if not reset:
+                    console.print(
+                        "[warning]No changes made to Anthropic OAuth credentials.[/warning]"
+                    )
+                    return True, None
+
+                removal_success = oauth_manager.remove_oauth_token("anthropic")
+                if not removal_success:
+                    console.print(
+                        "[error]Failed to remove existing Anthropic OAuth credentials.[/error]"
+                    )
+                    return False, None
+
+                current_method = auth_manager.get_auth_method()
+                if current_method == AuthMethod.CLAUDE_PRO:
+                    auth_manager.clear_auth_method()
+
             console.print()
             oauth_success = await configure_oauth_anthropic(
                 auth_manager, run_in_thread=run_oauth_in_thread
@@ -136,12 +185,35 @@ async def setup_auth(
                     "[green]✓ Anthropic OAuth configured successfully![/green]"
                 )
                 return True, provider
-            else:
-                console.print("[error]✗ Anthropic OAuth setup failed.[/error]")
-                return False, None
+
+            console.print("[error]✗ Anthropic OAuth setup failed.[/error]")
+            return False, None
 
     # API key flow
-    env_var = api_key_manager.get_env_var_name(provider)
+    if api_key_in_keyring:
+        reset_api_key = await prompter.confirm(
+            f"{provider.title()} API key is stored in your keyring. Reset before continuing?",
+            default=False,
+        )
+        if not reset_api_key:
+            console.print(
+                "[warning]No changes made to stored API key credentials.[/warning]"
+            )
+            return True, None
+        if not api_key_manager.delete_api_key(provider):
+            console.print(
+                "[error]Failed to remove existing API key credentials.[/error]"
+            )
+            return False, None
+        console.print(
+            f"[muted]{provider.title()} API key removed from keyring.[/muted]"
+        )
+        api_key_in_keyring = False
+
+    if api_key_in_env:
+        console.print(
+            f"[muted]{env_var} is set in your environment. Update it there if you need a new value.[/muted]"
+        )
 
     console.print()
     console.print(f"[dim]To use {provider.title()}, you need an API key.[/dim]")

sqlsaber/cli/auth.py

@@ -167,7 +167,9 @@ def reset():
             pass
         except Exception as e:
             console.print(f"Warning: Could not remove API key: {e}", style="warning")
-            logger.warning("auth.reset.api_key_remove_failed", provider=provider, error=str(e))
+            logger.warning(
+                "auth.reset.api_key_remove_failed", provider=provider, error=str(e)
+            )
 
     # Optionally clear global auth method if removing Anthropic OAuth configuration
     if provider == "anthropic" and oauth_present:

sqlsaber/config/api_keys.py

@@ -41,6 +41,29 @@ class APIKeyManager:
         # 3. Prompt user for API key
         return self._prompt_and_store_key(provider, env_var_name, service_name)
 
+    def has_stored_api_key(self, provider: str) -> bool:
+        """Check if an API key is stored for the provider."""
+        service_name = self._get_service_name(provider)
+        try:
+            return keyring.get_password(service_name, provider) is not None
+        except Exception:
+            return False
+
+    def delete_api_key(self, provider: str) -> bool:
+        """Remove stored API key for the provider."""
+        service_name = self._get_service_name(provider)
+        try:
+            keyring.delete_password(service_name, provider)
+            return True
+        except keyring.errors.PasswordDeleteError:
+            return True
+        except Exception as e:
+            console.print(
+                f"Warning: Could not remove API key: {e}",
+                style="warning",
+            )
+            return False
+
     def get_env_var_name(self, provider: str) -> str:
         """Get the expected environment variable name for a provider."""
         # Normalize aliases to canonical provider keys

sqlsaber/config/auth.py

@@ -81,6 +81,12 @@ class AuthConfigManager:
         config["auth_method"] = auth_method.value
         self._save_config(config)
 
+    def clear_auth_method(self) -> None:
+        """Clear any configured authentication method."""
+        config = self._load_config()
+        config["auth_method"] = None
+        self._save_config(config)
+
     def has_auth_configured(self) -> bool:
         """Check if authentication method is configured."""
         return self.get_auth_method() is not None

sqlsaber/config/logging.py

@@ -193,4 +193,3 @@ __all__ = [
     "default_log_dir",
     "default_log_file",
 ]
-

sqlsaber/database/postgresql.py

@@ -135,6 +135,35 @@ class PostgreSQLConnection(BaseDatabaseConnection):
 class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
     """PostgreSQL-specific schema introspection."""
 
+    def _get_excluded_schemas(self) -> list[str]:
+        """Return schemas to exclude during introspection.
+
+        Defaults include PostgreSQL system schemas and TimescaleDB internal
+        partitions schema. Additional schemas can be excluded by setting the
+        environment variable `SQLSABER_PG_EXCLUDE_SCHEMAS` to a comma-separated
+        list of schema names.
+        """
+        import os
+
+        # Base exclusions: system schemas and TimescaleDB internal partitions
+        excluded = [
+            "pg_catalog",
+            "information_schema",
+            "_timescaledb_internal",
+            "_timescaledb_cache",
+            "_timescaledb_config",
+            "_timescaledb_catalog",
+        ]
+
+        extra = os.getenv("SQLSABER_PG_EXCLUDE_SCHEMAS", "")
+        if extra:
+            for item in extra.split(","):
+                name = item.strip()
+                if name and name not in excluded:
+                    excluded.append(name)
+
+        return excluded
+
     def _build_table_filter_clause(self, tables: list) -> tuple[str, list]:
         """Build VALUES clause with bind parameters for table filtering.
 
@@ -160,23 +189,35 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
         """Get tables information for PostgreSQL."""
         pool = await connection.get_pool()
         async with pool.acquire() as conn:
-            # Build WHERE clause for filtering
-            where_conditions = [
-                "table_schema NOT IN ('pg_catalog', 'information_schema')"
-            ]
-            params = []
+            # Build WHERE clause for filtering with bind params
+            where_conditions: list[str] = []
+            params: list[Any] = []
+
+            excluded = self._get_excluded_schemas()
+            if excluded:
+                placeholders = ", ".join(f"${i + 1}" for i in range(len(excluded)))
+                where_conditions.append(f"table_schema NOT IN ({placeholders})")
+                params.extend(excluded)
+            else:
+                # Fallback safety
+                where_conditions.append(
+                    "table_schema NOT IN ('pg_catalog', 'information_schema')"
+                )
 
             if table_pattern:
                 # Support patterns like 'schema.table' or just 'table'
                 if "." in table_pattern:
                     schema_pattern, table_name_pattern = table_pattern.split(".", 1)
+                    s_idx = len(params) + 1
+                    t_idx = len(params) + 2
                     where_conditions.append(
-                        "(table_schema LIKE $1 AND table_name LIKE $2)"
+                        f"(table_schema LIKE ${s_idx} AND table_name LIKE ${t_idx})"
                     )
                     params.extend([schema_pattern, table_name_pattern])
                 else:
+                    p_idx = len(params) + 1
                     where_conditions.append(
-                        "(table_name LIKE $1 OR table_schema || '.' || table_name LIKE $1)"
+                        f"(table_name LIKE ${p_idx} OR table_schema || '.' || table_name LIKE ${p_idx})"
                     )
                     params.append(table_pattern)
 
@@ -310,17 +351,28 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
         """Get list of tables with basic information for PostgreSQL."""
         pool = await connection.get_pool()
         async with pool.acquire() as conn:
-            # Get table names and basic info without row counts for better performance
-            tables_query = """
+            # Exclude system schemas (and TimescaleDB internals) for performance
+            excluded = self._get_excluded_schemas()
+            params: list[Any] = []
+            if excluded:
+                placeholders = ", ".join(f"${i + 1}" for i in range(len(excluded)))
+                where_clause = f"table_schema NOT IN ({placeholders})"
+                params.extend(excluded)
+            else:
+                where_clause = (
+                    "table_schema NOT IN ('pg_catalog', 'information_schema')"
+                )
+
+            tables_query = f"""
                 SELECT
                     table_schema,
                     table_name,
                     table_type
                 FROM information_schema.tables
-                WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
+                WHERE {where_clause}
                 ORDER BY table_schema, table_name;
             """
-            tables = await conn.fetch(tables_query)
+            tables = await conn.fetch(tables_query, *params)
 
             # Convert to expected format
             return [

sqlsaber/prompts/claude.py

@@ -0,0 +1,52 @@
+SONNET_4_5 = """You are a helpful SQL assistant designed to help users query their {db} database using natural language requests.
+
+## Your Core Responsibilities
+
+1. **Understand requests**: Convert natural language queries into appropriate SQL
+2. **Explore schema**: Use provided tools to discover and understand database structure
+3. **Generate queries**: Create safe, efficient SQL queries with proper syntax
+4. **Execute safely**: Run only SELECT queries (no data modification allowed)
+5. **Explain results**: Format outputs clearly and explain what the queries accomplish
+
+## Tool Usage Strategy
+
+You must follow this systematic approach:
+
+1. **Always start with `list_tables`** to discover available tables
+2. **Use `introspect_schema` strategically** with table patterns (like 'sample%' or '%experiment%') to get details only for relevant tables
+3. **Execute SQL queries safely** - all SELECT statements automatically include LIMIT clauses for safety
+
+## Important Guidelines
+
+- Write proper JOIN syntax and avoid cartesian products
+- Include appropriate WHERE clauses to filter results effectively
+- Convert timestamp columns to text format in your queries
+- Use parameterized queries when needed for security
+- Handle errors gracefully and suggest fixes when issues arise
+- Explain each query's purpose in simple non-technical terms
+
+## Response Format
+
+For each user request, structure your response as follows:
+
+Before proceeding with database exploration, work through the problem systematically in <analysis> tags inside your thinking block:
+- Parse the user's natural language request and identify the core question being asked
+- Extract key terms, entities, and concepts that might correspond to database tables or columns
+- Consider what types of data relationships might be involved (e.g., one-to-many, many-to-many)
+- Plan your database exploration approach step by step
+- Design your overall SQL strategy, including potential JOINs, filters, and aggregations
+- Anticipate potential challenges or edge cases specific to this database type
+- Verify your approach makes logical sense for the business question
+
+It's OK for this analysis section to be quite long if the request is complex.
+
+Then, execute the planned database exploration and queries, providing clear explanations of results.
+
+## Example Response Structure
+
+Working through this systematically in my analysis, then exploring tables and executing queries...
+
+Now I need to address your specific request. Before proceeding with database exploration, let me analyze what you're asking for:
+
+Your final response should focus on the database exploration, query execution, and results explanation, without duplicating or rehashing the analytical work done in the thinking block.
+"""

sqlsaber/prompts/memory.py

@@ -0,0 +1,4 @@
+MEMORY_ADDITION = """# Contextual Memory Integration
+Below is any relevant context, prior memories, or database-specific quirks provided from the user.
+Prioritize only information that directly influences query generation or interpretation to optimize clarity and focus.
+"""

sqlsaber/prompts/openai.py

@@ -0,0 +1,40 @@
+GPT_5 = """# Role and Objective
+A helpful SQL assistant that assists users in querying their {db} database.
+
+# Instructions
+- Understand user requests in natural language and convert them into SQL queries.
+- Efficiently utilize provided tools to investigate the database schema.
+- Generate and execute only safe and appropriate SQL queries (only SELECT statements are allowed — no modifications to the database).
+- Clearly format and explain results to the user.
+- Set reasoning_effort = medium due to moderate task complexity; keep tool call outputs concise, provide fuller explanations in the final output.
+
+## Workflow Checklist
+Begin by thinking about what you will do; keep items conceptual, not implementation-level, before substantive work on user queries.
+
+- Analyze the user request and determine intent.
+- List available tables and their row counts using the appropriate tool.
+- Identify relevant tables via schema introspection with filtered patterns.
+- Formulate a safe and appropriate SELECT query with LIMIT clause.
+- Execute the query and validate the result for correctness and safety.
+- Clearly explain the result or guide the user if adjustments are needed.
+
+
+## Tool Usage Strategy
+1. **Start with `list_tables`**: Always begin by listing available tables and row counts to discover what's present in the database. Before any significant tool call, state the purpose and minimal inputs.
+2. **Use `introspect_schema` with a table pattern**: Retrieve schema details only for tables relevant to the user's request, employing patterns like `sample%` or `%experiment%` to filter.
+3. **Execute SQL queries safely**: All SELECT statements must include LIMIT clauses for safety. Only SELECT queries are permitted for security purposes.
+
+## Tool-Specific Guidelines
+- **introspect_schema**: Limit introspection to relevant tables using appropriate patterns (e.g., `sample%`, `%experiment%`).
+- **execute_sql**: Only run SELECT queries, ensuring they have LIMIT clauses. Do not permit any queries that modify the database.
+
+# Guidelines
+- Apply proper JOIN syntax to avoid cartesian products.
+- Use appropriate WHERE clauses to filter results.
+- Explain each query in simple terms for user understanding.
+- Handle errors gracefully and suggest corrections to users.
+- Be security conscious — use parameterized queries when necessary.
+- Convert timestamp columns to text within the SQL queries you generate.
+- Use table patterns (like `sample%` or `%experiment%`) to narrow down contextually relevant tables.
+- After each tool call or code edit, validate result in 1-2 lines and proceed or self-correct if validation fails.
+"""

{sqlsaber-0.32.1.dist-info → sqlsaber-0.34.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlsaber
-Version: 0.32.1
+Version: 0.34.0
 Summary: SQLsaber - Open-source agentic SQL assistant
 License-File: LICENSE
 Requires-Python: >=3.12

{sqlsaber-0.32.1.dist-info → sqlsaber-0.34.0.dist-info}/RECORD

@@ -2,14 +2,14 @@ sqlsaber/__init__.py,sha256=HjS8ULtP4MGpnTL7njVY45NKV9Fi4e_yeYuY-hyXWQc,73
 sqlsaber/__main__.py,sha256=RIHxWeWh2QvLfah-2OkhI5IJxojWfy4fXpMnVEJYvxw,78
 sqlsaber/agents/__init__.py,sha256=qYI6rLY4q5AbF47vXH5RVoM08-yQjymBSaePh4lFIW4,116
 sqlsaber/agents/base.py,sha256=T05UsMZPwAlMhsJFpuuVI1RNDhdiwiEsgCWr9MbPoAU,2654
-sqlsaber/agents/pydantic_ai_agent.py,sha256=cHHwQHJf9TqrBhItWJgnScL31lvyvKLcCBTSjRSwWug,12002
+sqlsaber/agents/pydantic_ai_agent.py,sha256=6_KppII8YcMw74KOGsYI5Dt6AP8WSduK3yAXCawVex4,10643
 sqlsaber/application/__init__.py,sha256=KY_-d5nEdQyAwNOsK5r-f7Tb69c63XbuEkHPeLpJal8,84
-sqlsaber/application/auth_setup.py,sha256=D94dyU9bOVfnNHLnnFJb5PaeWsKPTL21CiS_DLcY93A,5114
+sqlsaber/application/auth_setup.py,sha256=wbi9MaYl6q27LjcSBZmqFC12JtE5hrUHEX1NmD-7UVc,7778
 sqlsaber/application/db_setup.py,sha256=ZSgR9rJJVHttIjsbYQS9GEIyzkM09k5RLrVGdegrfYc,6859
 sqlsaber/application/model_selection.py,sha256=fSC06MZNKinHDR-csMFVYYJFyK8MydKf6pStof74Jp0,3191
 sqlsaber/application/prompts.py,sha256=4rMGcWpYJbNWPMzqVWseUMx0nwvXOkWS6GaTAJ5mhfc,3473
 sqlsaber/cli/__init__.py,sha256=qVSLVJLLJYzoC6aj6y9MFrzZvAwc4_OgxU9DlkQnZ4M,86
-sqlsaber/cli/auth.py,sha256=eCHxNO2IzgW7Og5970Yc9NZO5PPq1b2WpqVqEXDa66w,7021
+sqlsaber/cli/auth.py,sha256=TmAD4BJr2gIjPeW2LA1QkKK5gUZ2OOS6vOmBvB6PC0M,7051
 sqlsaber/cli/commands.py,sha256=WocWlLrxA5kM8URfvIvWFtc0ocfgKWAwoYTxVNZhmM4,10962
 sqlsaber/cli/completers.py,sha256=g-hLDq5fiBx7gg8Bte1Lq8GU-ZxCYVs4dcPsmHPIcK4,6574
 sqlsaber/cli/database.py,sha256=BBGj0eyduh5DDXNLZLDtWfY9kWpeT_ZX0J9R9INZyyU,12421
@@ -22,10 +22,10 @@ sqlsaber/cli/streaming.py,sha256=jicSDLWQ3efitpdc2y4QsasHcEW8ogZ4lHcWmftq9Ao,676
 sqlsaber/cli/theme.py,sha256=D6HIt7rmF00B5ZOCV5lXKzPICE4uppHdraOdVs7k5Nw,4672
 sqlsaber/cli/threads.py,sha256=zYvs1epmRRuQxOofF85eXk1_YHS6co7oq_F33DdNdf0,14643
 sqlsaber/config/__init__.py,sha256=olwC45k8Nc61yK0WmPUk7XHdbsZH9HuUAbwnmKe3IgA,100
-sqlsaber/config/api_keys.py,sha256=dJ7cCSFOM6CRLHxEVgKJXGIOd_wQkRuQO4W88-8ng_w,3672
-sqlsaber/config/auth.py,sha256=b5qB2h1doXyO9Bn8z0CcL8LAR2jF431gGXBGKLgTmtQ,2756
+sqlsaber/config/api_keys.py,sha256=H7xBU1mflngXIlnaDjbTvuNqZsW_92AIve31eDLij34,4513
+sqlsaber/config/auth.py,sha256=G1uulySUclWSId8EIt1hPNmsUNhbfRzfp8VVQftYyG8,2964
 sqlsaber/config/database.py,sha256=Yec6_0wdzq-ADblMNnbgvouYCimYOY_DWHT9oweaISc,11449
-sqlsaber/config/logging.py,sha256=V-DGhKm7XYPtcA6bXL-aQQyTTlyHi2WHTqTTzu2xipw,6174
+sqlsaber/config/logging.py,sha256=vv4oCuQePeYQ7bMs0OLKj8ZSiNcFWbHmWtdC0lTsUyc,6173
 sqlsaber/config/oauth_flow.py,sha256=cDfaJjqr4spNuzxbAlzuJfk6SEe1ojSRAkoOWlvQYy0,11037
 sqlsaber/config/oauth_tokens.py,sha256=KCC2u3lOjdh0M-rd0K1rW0PWk58w7mqpodAhlPVp9NE,6424
 sqlsaber/config/providers.py,sha256=JFjeJv1K5Q93zWSlWq3hAvgch1TlgoF0qFa0KJROkKY,2957
@@ -35,13 +35,17 @@ sqlsaber/database/base.py,sha256=oaipLxlvoylX6oJCITPAWWqRqv09hRELqqEBufsmFic,370
 sqlsaber/database/csv.py,sha256=41wuP40FaGPfj28HMiD0I69uG0JbUxArpoTLC3MG2uc,4464
 sqlsaber/database/duckdb.py,sha256=8HNKdx208aFK_YtwGjLz6LTne0xEmNevD-f9dRWlrFg,11244
 sqlsaber/database/mysql.py,sha256=wMzDQqq4GFbfEdqXtv_sCb4Qbr9GSWqYAvOLeo5UryY,14472
-sqlsaber/database/postgresql.py,sha256=fuf2Wl29NKXvD3mqsR08PDleNQ1PG-fNvWSxT6HDh2M,13223
+sqlsaber/database/postgresql.py,sha256=jNmjDY8fODfjRo0gHC1KU-NNP3K5ZQ9RVq69QwRP4Ws,15214
 sqlsaber/database/resolver.py,sha256=wSCcn__aCqwIfpt_LCjtW2Zgb8RpG5PlmwwZHli1q_U,3628
 sqlsaber/database/schema.py,sha256=CuV0ewoVaERe1gj_fJFJFWAP8aEPgepmn6X6B7bgkfQ,6962
 sqlsaber/database/sqlite.py,sha256=iReEIiSpkhhS1VzITd79ZWqSL3fHMyfe3DRCDpM0DvE,9421
 sqlsaber/memory/__init__.py,sha256=GiWkU6f6YYVV0EvvXDmFWe_CxarmDCql05t70MkTEWs,63
 sqlsaber/memory/manager.py,sha256=p3fybMVfH-E4ApT1ZRZUnQIWSk9dkfUPCyfkmA0HALs,2739
 sqlsaber/memory/storage.py,sha256=ne8szLlGj5NELheqLnI7zu21V8YS4rtpYGGC7tOmi-s,5745
+sqlsaber/prompts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlsaber/prompts/claude.py,sha256=wvitHetuUi9s_Bfy8desgBUigEbI-URqcIS447WtV2k,2757
+sqlsaber/prompts/memory.py,sha256=UciA3JPdNp6Iup20Vy-Nv7PGU7tL2yOVNYkE61r9AL4,275
+sqlsaber/prompts/openai.py,sha256=gPBvJR7WgmWELPZbP4kC53Wm6jDu1zsCmHKmyc5U1uY,2640
 sqlsaber/theme/__init__.py,sha256=qCICX1Cg4B6yCbZ1UrerxglWxcqldRFVSRrSs73na_8,188
 sqlsaber/theme/manager.py,sha256=TPourIKGU-UzHtImgexgtazpuDaFhqUYtVauMblgGAQ,6480
 sqlsaber/threads/__init__.py,sha256=Hh3dIG1tuC8fXprREUpslCIgPYz8_6o7aRLx4yNeO48,139
@@ -51,8 +55,8 @@ sqlsaber/tools/base.py,sha256=NKEEooliPKTJj_Pomwte_wW0Xd9Z5kXNfVdCRfTppuw,883
 sqlsaber/tools/registry.py,sha256=XmBzERq0LJXtg3BZ-r8cEyt8J54NUekgUlTJ_EdSYMk,2204
 sqlsaber/tools/sql_guard.py,sha256=dTDwcZP-N4xPGzcr7MQtKUxKrlDzlc1irr9aH5a4wvk,6182
 sqlsaber/tools/sql_tools.py,sha256=eo-NTxiXGHMopAjujvDDjmv9hf5bQNbiy3nTpxoJ_E8,7369
-sqlsaber-0.32.1.dist-info/METADATA,sha256=ykPTVg8m9G3OgtJ8kHGSADMwNFAdVq7Abni5_74UYA8,5915
-sqlsaber-0.32.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlsaber-0.32.1.dist-info/entry_points.txt,sha256=tw1mB0fjlkXQiOsC0434X6nE-o1cFCuQwt2ZYHv_WAE,91
-sqlsaber-0.32.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sqlsaber-0.32.1.dist-info/RECORD,,
+sqlsaber-0.34.0.dist-info/METADATA,sha256=A5Xu_z5Q2dw-qJSHZX6MR8uiM1mIf941pHbXnl7BPCg,5915
+sqlsaber-0.34.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlsaber-0.34.0.dist-info/entry_points.txt,sha256=tw1mB0fjlkXQiOsC0434X6nE-o1cFCuQwt2ZYHv_WAE,91
+sqlsaber-0.34.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sqlsaber-0.34.0.dist-info/RECORD,,