sqlsaber 0.6.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

sqlsaber/config/settings.py

@@ -5,11 +5,13 @@ import os
 import platform
 import stat
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any
 
 import platformdirs
 
 from sqlsaber.config.api_keys import APIKeyManager
+from sqlsaber.config.auth import AuthConfigManager, AuthMethod
+from sqlsaber.config.oauth_flow import AnthropicOAuthFlow
 
 
 class ModelConfigManager:
@@ -40,7 +42,7 @@ class ModelConfigManager:
         except (OSError, PermissionError):
             pass
 
-    def _load_config(self) -> Dict[str, Any]:
+    def _load_config(self) -> dict[str, Any]:
         """Load configuration from file."""
         if not self.config_file.exists():
             return {"model": self.DEFAULT_MODEL}
@@ -55,7 +57,7 @@ class ModelConfigManager:
         except (json.JSONDecodeError, IOError):
             return {"model": self.DEFAULT_MODEL}
 
-    def _save_config(self, config: Dict[str, Any]) -> None:
+    def _save_config(self, config: dict[str, Any]) -> None:
         """Save configuration to file."""
         with open(self.config_file, "w") as f:
             json.dump(config, f, indent=2)
@@ -81,35 +83,44 @@ class Config:
         self.model_config_manager = ModelConfigManager()
         self.model_name = self.model_config_manager.get_model()
         self.api_key_manager = APIKeyManager()
-        self.api_key = self._get_api_key()
+        self.auth_config_manager = AuthConfigManager()
+        self.oauth_flow = AnthropicOAuthFlow()
+
+        # Get authentication credentials based on configured method
+        self.auth_method = self.auth_config_manager.get_auth_method()
+        self.api_key = None
+        self.oauth_token = None
+
+        if self.auth_method == AuthMethod.CLAUDE_PRO:
+            # Try to get OAuth token and refresh if needed
+            try:
+                token = self.oauth_flow.refresh_token_if_needed()
+                if token:
+                    self.oauth_token = token.access_token
+            except Exception:
+                # OAuth token unavailable, will need to re-authenticate
+                pass
+        else:
+            # Use API key authentication (default or explicitly configured)
+            self.api_key = self._get_api_key()
 
-    def _get_api_key(self) -> Optional[str]:
+    def _get_api_key(self) -> str | None:
         """Get API key for the model provider using cascading logic."""
         model = self.model_name
-
-        if model.startswith("openai:"):
-            return self.api_key_manager.get_api_key("openai")
-        elif model.startswith("anthropic:"):
+        if model.startswith("anthropic:"):
             return self.api_key_manager.get_api_key("anthropic")
-        else:
-            # For other providers, use generic key
-            return self.api_key_manager.get_api_key("generic")
 
     def set_model(self, model: str) -> None:
         """Set the model and update configuration."""
         self.model_config_manager.set_model(model)
         self.model_name = model
-        # Update API key for new model
-        self.api_key = self._get_api_key()
 
     def validate(self):
         """Validate that necessary configuration is present."""
-        if not self.api_key:
-            model = self.model_name
-            provider = "generic"
-            if model.startswith("openai:"):
-                provider = "OpenAI"
-            elif model.startswith("anthropic:"):
-                provider = "Anthropic"
-
-            raise ValueError(f"{provider} API key not found.")
+        if self.auth_method == AuthMethod.CLAUDE_PRO and not self.oauth_token:
+            raise ValueError(
+                "OAuth token not available. Run 'saber auth setup' to authenticate with Claude Pro."
+            )
+        else:
+            if not self.api_key:
+                raise ValueError("Anthropic API key not found.")

sqlsaber/database/connection.py

@@ -1,7 +1,7 @@
 """Database connection management."""
 
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional
+from typing import Any
 from urllib.parse import urlparse, parse_qs
 import ssl
 from pathlib import Path
@@ -30,7 +30,7 @@ class BaseDatabaseConnection(ABC):
         pass
 
     @abstractmethod
-    async def execute_query(self, query: str, *args) -> List[Dict[str, Any]]:
+    async def execute_query(self, query: str, *args) -> list[dict[str, Any]]:
         """Execute a query and return results as list of dicts.
 
         All queries run in a transaction that is rolled back at the end,
@@ -44,10 +44,10 @@ class PostgreSQLConnection(BaseDatabaseConnection):
 
     def __init__(self, connection_string: str):
         super().__init__(connection_string)
-        self._pool: Optional[asyncpg.Pool] = None
+        self._pool: asyncpg.Pool | None = None
         self._ssl_context = self._create_ssl_context()
 
-    def _create_ssl_context(self) -> Optional[ssl.SSLContext]:
+    def _create_ssl_context(self) -> ssl.SSLContext | None:
         """Create SSL context from connection string parameters."""
         parsed = urlparse(self.connection_string)
         if not parsed.query:
@@ -112,7 +112,7 @@ class PostgreSQLConnection(BaseDatabaseConnection):
             await self._pool.close()
             self._pool = None
 
-    async def execute_query(self, query: str, *args) -> List[Dict[str, Any]]:
+    async def execute_query(self, query: str, *args) -> list[dict[str, Any]]:
         """Execute a query and return results as list of dicts.
 
         All queries run in a transaction that is rolled back at the end,
@@ -137,7 +137,7 @@ class MySQLConnection(BaseDatabaseConnection):
 
     def __init__(self, connection_string: str):
         super().__init__(connection_string)
-        self._pool: Optional[aiomysql.Pool] = None
+        self._pool: aiomysql.Pool | None = None
         self._parse_connection_string()
 
     def _parse_connection_string(self):
@@ -217,7 +217,7 @@ class MySQLConnection(BaseDatabaseConnection):
             await self._pool.wait_closed()
             self._pool = None
 
-    async def execute_query(self, query: str, *args) -> List[Dict[str, Any]]:
+    async def execute_query(self, query: str, *args) -> list[dict[str, Any]]:
         """Execute a query and return results as list of dicts.
 
         All queries run in a transaction that is rolled back at the end,
@@ -253,7 +253,7 @@ class SQLiteConnection(BaseDatabaseConnection):
         """SQLite connections are created per query, no persistent pool to close."""
         pass
 
-    async def execute_query(self, query: str, *args) -> List[Dict[str, Any]]:
+    async def execute_query(self, query: str, *args) -> list[dict[str, Any]]:
         """Execute a query and return results as list of dicts.
 
         All queries run in a transaction that is rolled back at the end,
@@ -380,7 +380,7 @@ class CSVConnection(BaseDatabaseConnection):
         except Exception as e:
             raise ValueError(f"Error loading CSV file '{self.csv_path}': {str(e)}")
 
-    async def execute_query(self, query: str, *args) -> List[Dict[str, Any]]:
+    async def execute_query(self, query: str, *args) -> list[dict[str, Any]]:
         """Execute a query and return results as list of dicts.
 
         All queries run in a transaction that is rolled back at the end,

sqlsaber/database/schema.py

@@ -2,7 +2,7 @@
 
 import time
 from abc import ABC, abstractmethod
-from typing import Any, Dict, Optional, Tuple
+from typing import Any
 
 import aiosqlite
 
@@ -21,8 +21,8 @@ class BaseSchemaIntrospector(ABC):
 
     @abstractmethod
     async def get_tables_info(
-        self, connection, table_pattern: Optional[str] = None
-    ) -> Dict[str, Any]:
+        self, connection, table_pattern: str | None = None
+    ) -> dict[str, Any]:
         """Get tables information for the specific database type."""
         pass
 
@@ -42,7 +42,7 @@ class BaseSchemaIntrospector(ABC):
         pass
 
     @abstractmethod
-    async def list_tables_info(self, connection) -> Dict[str, Any]:
+    async def list_tables_info(self, connection) -> dict[str, Any]:
         """Get list of tables with basic information."""
         pass
 
@@ -51,8 +51,8 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
     """PostgreSQL-specific schema introspection."""
 
     async def get_tables_info(
-        self, connection, table_pattern: Optional[str] = None
-    ) -> Dict[str, Any]:
+        self, connection, table_pattern: str | None = None
+    ) -> dict[str, Any]:
         """Get tables information for PostgreSQL."""
         pool = await connection.get_pool()
         async with pool.acquire() as conn:
@@ -182,7 +182,7 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
             """
             return await conn.fetch(pk_query)
 
-    async def list_tables_info(self, connection) -> Dict[str, Any]:
+    async def list_tables_info(self, connection) -> dict[str, Any]:
         """Get list of tables with basic information for PostgreSQL."""
         pool = await connection.get_pool()
         async with pool.acquire() as conn:
@@ -214,8 +214,8 @@ class MySQLSchemaIntrospector(BaseSchemaIntrospector):
     """MySQL-specific schema introspection."""
 
     async def get_tables_info(
-        self, connection, table_pattern: Optional[str] = None
-    ) -> Dict[str, Any]:
+        self, connection, table_pattern: str | None = None
+    ) -> dict[str, Any]:
         """Get tables information for MySQL."""
         pool = await connection.get_pool()
         async with pool.acquire() as conn:
@@ -353,7 +353,7 @@ class MySQLSchemaIntrospector(BaseSchemaIntrospector):
                 await cursor.execute(pk_query)
                 return await cursor.fetchall()
 
-    async def list_tables_info(self, connection) -> Dict[str, Any]:
+    async def list_tables_info(self, connection) -> dict[str, Any]:
         """Get list of tables with basic information for MySQL."""
         pool = await connection.get_pool()
         async with pool.acquire() as conn:
@@ -392,8 +392,8 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
             return await cursor.fetchall()
 
     async def get_tables_info(
-        self, connection, table_pattern: Optional[str] = None
-    ) -> Dict[str, Any]:
+        self, connection, table_pattern: str | None = None
+    ) -> dict[str, Any]:
         """Get tables information for SQLite."""
         where_conditions = ["type IN ('table', 'view')", "name NOT LIKE 'sqlite_%'"]
         params = ()
@@ -496,7 +496,7 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
 
         return primary_keys
 
-    async def list_tables_info(self, connection) -> Dict[str, Any]:
+    async def list_tables_info(self, connection) -> dict[str, Any]:
         """Get list of tables with basic information for SQLite."""
         # First get the table names
         tables_query = """
@@ -548,7 +548,7 @@ class SchemaManager:
     def __init__(self, db_connection: BaseDatabaseConnection, cache_ttl: int = 900):
         self.db = db_connection
         self.cache_ttl = cache_ttl  # Default 15 minutes
-        self._schema_cache: Dict[str, Tuple[float, Dict[str, Any]]] = {}
+        self._schema_cache: dict[str, tuple[float, dict[str, Any]]] = {}
 
         # Select appropriate introspector based on connection type
         if isinstance(db_connection, PostgreSQLConnection):
@@ -567,8 +567,8 @@ class SchemaManager:
         self._schema_cache.clear()
 
     async def get_schema_info(
-        self, table_pattern: Optional[str] = None
-    ) -> Dict[str, SchemaInfo]:
+        self, table_pattern: str | None = None
+    ) -> dict[str, SchemaInfo]:
         """Get database schema information, optionally filtered by table pattern.
 
         Args:
@@ -587,7 +587,7 @@ class SchemaManager:
         self._schema_cache[cache_key] = (time.time(), schema_info)
         return schema_info
 
-    def _get_cached_schema(self, cache_key: str) -> Optional[Dict[str, SchemaInfo]]:
+    def _get_cached_schema(self, cache_key: str) -> dict[str, SchemaInfo] | None:
         """Get schema from cache if available and not expired."""
         if cache_key in self._schema_cache:
             cached_time, cached_data = self._schema_cache[cache_key]
@@ -596,8 +596,8 @@ class SchemaManager:
         return None
 
     async def _fetch_schema_from_db(
-        self, table_pattern: Optional[str]
-    ) -> Dict[str, SchemaInfo]:
+        self, table_pattern: str | None
+    ) -> dict[str, SchemaInfo]:
         """Fetch schema information from database."""
         # Get all schema components
         tables = await self.introspector.get_tables_info(self.db, table_pattern)
@@ -613,7 +613,7 @@ class SchemaManager:
 
         return schema_info
 
-    def _build_table_structure(self, tables: list) -> Dict[str, Dict]:
+    def _build_table_structure(self, tables: list) -> dict[str, dict]:
         """Build basic table structure from table info."""
         schema_info = {}
         for table in tables:
@@ -632,7 +632,7 @@ class SchemaManager:
         return schema_info
 
     def _add_columns_to_schema(
-        self, schema_info: Dict[str, Dict], columns: list
+        self, schema_info: dict[str, dict], columns: list
     ) -> None:
         """Add column information to schema."""
         for col in columns:
@@ -656,7 +656,7 @@ class SchemaManager:
                 schema_info[full_name]["columns"][col["column_name"]] = col_info
 
     def _add_primary_keys_to_schema(
-        self, schema_info: Dict[str, Dict], primary_keys: list
+        self, schema_info: dict[str, dict], primary_keys: list
     ) -> None:
         """Add primary key information to schema."""
         for pk in primary_keys:
@@ -665,7 +665,7 @@ class SchemaManager:
                 schema_info[full_name]["primary_keys"].append(pk["column_name"])
 
     def _add_foreign_keys_to_schema(
-        self, schema_info: Dict[str, Dict], foreign_keys: list
+        self, schema_info: dict[str, dict], foreign_keys: list
     ) -> None:
         """Add foreign key information to schema."""
         for fk in foreign_keys:
@@ -681,8 +681,15 @@ class SchemaManager:
                     }
                 )
 
-    async def list_tables(self) -> Dict[str, Any]:
+    async def list_tables(self) -> dict[str, Any]:
         """Get a list of all tables with basic information like row counts."""
+        # Check cache first
+        cache_key = "list_tables"
+        cached_data = self._get_cached_tables(cache_key)
+        if cached_data is not None:
+            return cached_data
+
+        # Fetch from database if not cached
         tables = await self.introspector.list_tables_info(self.db)
 
         # Format the result
@@ -699,4 +706,14 @@ class SchemaManager:
                 }
             )
 
+        # Cache the result
+        self._schema_cache[cache_key] = (time.time(), result)
         return result
+
+    def _get_cached_tables(self, cache_key: str) -> dict[str, Any] | None:
+        """Get table list from cache if available and not expired."""
+        if cache_key in self._schema_cache:
+            cached_time, cached_data = self._schema_cache[cache_key]
+            if time.time() - cached_time < self.cache_ttl:
+                return cached_data
+        return None

sqlsaber/mcp/mcp.py

@@ -1,7 +1,6 @@
 """FastMCP server implementation for SQLSaber."""
 
 import json
-from typing import Optional
 
 from fastmcp import FastMCP
 
@@ -32,7 +31,7 @@ mcp = FastMCP(name="SQL Assistant", instructions=INSTRUCTIONS)
 config_manager = DatabaseConfigManager()
 
 
-async def _create_agent_for_database(database_name: str) -> Optional[MCPSQLAgent]:
+async def _create_agent_for_database(database_name: str) -> MCPSQLAgent | None:
     """Create a MCPSQLAgent for the specified database."""
     try:
         # Look up configured database connection
@@ -92,7 +91,7 @@ async def list_tables(database: str) -> str:
 
 
 @mcp.tool
-async def introspect_schema(database: str, table_pattern: Optional[str] = None) -> str:
+async def introspect_schema(database: str, table_pattern: str | None = None) -> str:
     """
     Introspect database schema to understand table structures. Use optional pattern to filter tables (e.g., 'public.users', 'user%', '%order%').
     """
@@ -112,7 +111,7 @@ async def introspect_schema(database: str, table_pattern: Optional[str] = None)
 
 
 @mcp.tool
-async def execute_sql(database: str, query: str, limit: Optional[int] = 100) -> str:
+async def execute_sql(database: str, query: str, limit: int | None = 100) -> str:
     """Execute a SQL query against the specified database."""
     try:
         agent = await _create_agent_for_database(database)

sqlsaber/memory/manager.py

@@ -1,7 +1,5 @@
 """Memory manager for handling database-specific context and memories."""
 
-from typing import List, Optional
-
 from sqlsaber.memory.storage import Memory, MemoryStorage
 
 
@@ -15,7 +13,7 @@ class MemoryManager:
         """Add a new memory for the specified database."""
         return self.storage.add_memory(database_name, content)
 
-    def get_memories(self, database_name: str) -> List[Memory]:
+    def get_memories(self, database_name: str) -> list[Memory]:
         """Get all memories for the specified database."""
         return self.storage.get_memories(database_name)
 
@@ -27,7 +25,7 @@ class MemoryManager:
         """Clear all memories for the specified database."""
         return self.storage.clear_memories(database_name)
 
-    def get_memory_by_id(self, database_name: str, memory_id: str) -> Optional[Memory]:
+    def get_memory_by_id(self, database_name: str, memory_id: str) -> Memory | None:
         """Get a specific memory by ID."""
         return self.storage.get_memory_by_id(database_name, memory_id)
 
@@ -72,6 +70,6 @@ Use this context to better understand the user's needs and provide more relevant
             ],
         }
 
-    def list_databases_with_memories(self) -> List[str]:
+    def list_databases_with_memories(self) -> list[str]:
         """List all databases that have memories."""
         return self.storage.list_databases_with_memories()

sqlsaber/memory/storage.py

@@ -8,7 +8,6 @@ import time
 import uuid
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Dict, List, Optional
 
 import platformdirs
 
@@ -21,7 +20,7 @@ class Memory:
     content: str
     timestamp: float
 
-    def to_dict(self) -> Dict:
+    def to_dict(self) -> dict:
         """Convert memory to dictionary for JSON serialization."""
         return {
             "id": self.id,
@@ -30,7 +29,7 @@ class Memory:
         }
 
     @classmethod
-    def from_dict(cls, data: Dict) -> "Memory":
+    def from_dict(cls, data: dict) -> "Memory":
         """Create Memory from dictionary."""
         return cls(
             id=data["id"],
@@ -79,7 +78,7 @@ class MemoryStorage:
         """Get the memory file path for a specific database."""
         return self.memory_dir / f"{database_name}.json"
 
-    def _load_memories(self, database_name: str) -> List[Memory]:
+    def _load_memories(self, database_name: str) -> list[Memory]:
         """Load memories for a specific database."""
         memory_file = self._get_memory_file(database_name)
 
@@ -96,7 +95,7 @@ class MemoryStorage:
         except (json.JSONDecodeError, IOError, KeyError):
             return []
 
-    def _save_memories(self, database_name: str, memories: List[Memory]) -> None:
+    def _save_memories(self, database_name: str, memories: list[Memory]) -> None:
         """Save memories for a specific database."""
         memory_file = self._get_memory_file(database_name)
 
@@ -125,7 +124,7 @@ class MemoryStorage:
 
         return memory
 
-    def get_memories(self, database_name: str) -> List[Memory]:
+    def get_memories(self, database_name: str) -> list[Memory]:
         """Get all memories for the specified database."""
         return self._load_memories(database_name)
 
@@ -152,7 +151,7 @@ class MemoryStorage:
 
         return count
 
-    def get_memory_by_id(self, database_name: str, memory_id: str) -> Optional[Memory]:
+    def get_memory_by_id(self, database_name: str, memory_id: str) -> Memory | None:
         """Get a specific memory by ID."""
         memories = self._load_memories(database_name)
         return next((m for m in memories if m.id == memory_id), None)
@@ -161,7 +160,7 @@ class MemoryStorage:
         """Check if database has any memories."""
         return len(self._load_memories(database_name)) > 0
 
-    def list_databases_with_memories(self) -> List[str]:
+    def list_databases_with_memories(self) -> list[str]:
         """List all databases that have memories."""
         databases = []
 

sqlsaber/models/events.py

@@ -1,6 +1,6 @@
 """Event models for streaming and responses."""
 
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 
 class StreamEvent:
@@ -17,10 +17,10 @@ class SQLResponse:
 
     def __init__(
         self,
-        query: Optional[str] = None,
+        query: str | None = None,
         explanation: str = "",
-        results: Optional[List[Dict[str, Any]]] = None,
-        error: Optional[str] = None,
+        results: list[dict[str, Any]] | None = None,
+        error: str | None = None,
     ):
         self.query = query
         self.explanation = explanation

sqlsaber/models/types.py

@@ -1,6 +1,6 @@
 """Type definitions for SQLSaber."""
 
-from typing import Any, Dict, List, Optional, TypedDict
+from typing import Any, TypedDict
 
 
 class ColumnInfo(TypedDict):
@@ -8,17 +8,17 @@ class ColumnInfo(TypedDict):
 
     data_type: str
     nullable: bool
-    default: Optional[str]
-    max_length: Optional[int]
-    precision: Optional[int]
-    scale: Optional[int]
+    default: str | None
+    max_length: int | None
+    precision: int | None
+    scale: int | None
 
 
 class ForeignKeyInfo(TypedDict):
     """Type definition for foreign key information."""
 
     column: str
-    references: Dict[str, str]  # {"table": "schema.table", "column": "column_name"}
+    references: dict[str, str]  # {"table": "schema.table", "column": "column_name"}
 
 
 class SchemaInfo(TypedDict):
@@ -27,9 +27,9 @@ class SchemaInfo(TypedDict):
     schema: str
     name: str
     type: str
-    columns: Dict[str, ColumnInfo]
-    primary_keys: List[str]
-    foreign_keys: List[ForeignKeyInfo]
+    columns: dict[str, ColumnInfo]
+    primary_keys: list[str]
+    foreign_keys: list[ForeignKeyInfo]
 
 
 class ToolDefinition(TypedDict):
@@ -37,4 +37,4 @@ class ToolDefinition(TypedDict):
 
     name: str
     description: str
-    input_schema: Dict[str, Any]
+    input_schema: dict[str, Any]

{sqlsaber-0.6.0.dist-info → sqlsaber-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlsaber
-Version: 0.6.0
+Version: 0.8.0
 Summary: SQLSaber - Agentic SQL assistant like Claude Code
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -212,23 +212,24 @@ The MCP server uses your existing SQLSaber database configurations, so make sure
 
 ## How It Works
 
-SQLSaber uses an intelligent three-step process optimized for minimal token usage:
+SQLSaber uses a multi-step process to gather the right context, provide it to the model, and execute SQL queries to get the right answers:
+
+![](./sqlsaber.svg)
 
 ### 🔍 Discovery Phase
 
 1. **List Tables Tool**: Quickly discovers available tables with row counts
-2. **Pattern Matching**: Identifies relevant tables based on your query using SQL LIKE patterns
+2. **Pattern Matching**: Identifies relevant tables based on your query
 
 ### 📋 Schema Analysis
 
-3. **Smart Introspection**: Analyzes only the specific table structures needed for your query
-4. **Selective Loading**: Fetches schema information only for relevant tables
+3. **Smart Schema Introspection**: Analyzes only the specific table structures needed for your query
 
 ### ⚡ Execution Phase
 
-5. **SQL Generation**: Creates optimized SQL queries based on natural language input
-6. **Safe Execution**: Runs queries with built-in protections against destructive operations
-7. **Result Formatting**: Presents results with syntax highlighting and explanations
+4. **SQL Generation**: Creates optimized SQL queries based on natural language input
+5. **Safe Execution**: Runs read-only queries with built-in protections against destructive operations
+6. **Result Formatting**: Presents results with explanations in tables and optionally, visualizes using plots
 
 ## Contributing
 

sqlsaber-0.8.0.dist-info/RECORD

@@ -0,0 +1,46 @@
+sqlsaber/__init__.py,sha256=QCFi8xTVMohelfi7zOV1-6oLCcGoiXoOcKQY-HNBCk8,66
+sqlsaber/__main__.py,sha256=RIHxWeWh2QvLfah-2OkhI5IJxojWfy4fXpMnVEJYvxw,78
+sqlsaber/agents/__init__.py,sha256=LWeSeEUE4BhkyAYFF3TE-fx8TtLud3oyEtyB8ojFJgo,167
+sqlsaber/agents/anthropic.py,sha256=CBHneR5NJhu155d0-D1mSGOcTH7kmbXZSLv2mVQotSM,22128
+sqlsaber/agents/base.py,sha256=Cl5ZV4dfgjslOAq8jbrnt5kX-NM_8QmjacWzb0hvbzs,10527
+sqlsaber/agents/mcp.py,sha256=FKtXgDrPZ2-xqUYCw2baI5JzrWekXaC5fjkYW1_Mg50,827
+sqlsaber/agents/streaming.py,sha256=LaSeMTlxuJFRArJVqDly5-_KgcePiCCKPKfMxfB4oGs,521
+sqlsaber/cli/__init__.py,sha256=qVSLVJLLJYzoC6aj6y9MFrzZvAwc4_OgxU9DlkQnZ4M,86
+sqlsaber/cli/auth.py,sha256=tm3f-qIuNS0nQbU2DEI7ezWG092mayNW1GuoiwdV8hI,5047
+sqlsaber/cli/commands.py,sha256=Ob505FV1kfaRKoW_agon4Q82772QmLjxISfvbXGOHE4,5256
+sqlsaber/cli/completers.py,sha256=HsUPjaZweLSeYCWkAcgMl8FylQ1xjWBWYTEL_9F6xfU,6430
+sqlsaber/cli/database.py,sha256=mWpMPcISUokYIiAMU4M_g8YeI-Fz5YU_R3PYs-GigCw,12588
+sqlsaber/cli/display.py,sha256=XcBkjdG7RoM_ijHgv0VWqWleT5CCTm0Hcp1sJoE1FKE,9979
+sqlsaber/cli/interactive.py,sha256=sQQXO8RcbVwxIBArNUlv-8ePhLn3UUdx6zUl44l8tow,7395
+sqlsaber/cli/memory.py,sha256=OFspjaZ2RaYrBdSDVOD-9_6T8NbqedHEn5FztGkLUlc,7621
+sqlsaber/cli/models.py,sha256=7bvIykGPTJu3-3tpPinr44GBkPIQhoeKI3d3Kgn3jOI,7783
+sqlsaber/cli/streaming.py,sha256=WfhFd5ntq2HStpJZwWJ0C5uyXKc3aU14eo8HdjzW1o0,3767
+sqlsaber/clients/__init__.py,sha256=jcMoVsT92U6nQrfotCp1h0ggskJPAcgeYarqQl1qEBg,171
+sqlsaber/clients/anthropic.py,sha256=umRmuzpmJdYO7hO3biAZXO9T_sb6Vv010o6zqn03is8,9947
+sqlsaber/clients/base.py,sha256=RLFJ3NV75Z6keiu9mnh9zrMZK1HwdeUby0e3oeJMtyw,935
+sqlsaber/clients/exceptions.py,sha256=6OoCSxvuA13I3dML2Zngygl9MdaObISh1UHvBB3yUq0,3408
+sqlsaber/clients/models.py,sha256=fOvnkW8NQSdn8Oqfk3-5dP4TylLh7C9wOvuNQYw184A,7016
+sqlsaber/clients/streaming.py,sha256=CwdoocLAyW_GjZm2XcLb33Sa99w5fyb7dU-27FFpePQ,8319
+sqlsaber/config/__init__.py,sha256=olwC45k8Nc61yK0WmPUk7XHdbsZH9HuUAbwnmKe3IgA,100
+sqlsaber/config/api_keys.py,sha256=wnWlYy26AkkevZ1Vln6avYRBDLPRzfrHkj-fPojkxaQ,3624
+sqlsaber/config/auth.py,sha256=b5qB2h1doXyO9Bn8z0CcL8LAR2jF431gGXBGKLgTmtQ,2756
+sqlsaber/config/database.py,sha256=c6q3l4EvoBch1ckYHA70hf6L7fSOY-sItnLCpvJiPrA,11357
+sqlsaber/config/oauth_flow.py,sha256=A3bSXaBLzuAfXV2ZPA94m9NV33c2MyL6M4ii9oEkswQ,10291
+sqlsaber/config/oauth_tokens.py,sha256=C9z35hyx-PvSAYdC1LNf3rg9_wsEIY56hkEczelbad0,6015
+sqlsaber/config/settings.py,sha256=H2NrTaB7Vy5YWhg6k1g94XiQHZq0LZOQEd1ILtx7GHw,4567
+sqlsaber/database/__init__.py,sha256=a_gtKRJnZVO8-fEZI7g3Z8YnGa6Nio-5Y50PgVp07ss,176
+sqlsaber/database/connection.py,sha256=sZVGNMzMwiM11GrsLLPwR8A5ugzJ5O0TCdkrt0KVRuI,15123
+sqlsaber/database/schema.py,sha256=B4emtbaNiqjz6aGBUQYYwARsTMqBilvWSurNg_zKu9U,28600
+sqlsaber/mcp/__init__.py,sha256=COdWq7wauPBp5Ew8tfZItFzbcLDSEkHBJSMhxzy8C9c,112
+sqlsaber/mcp/mcp.py,sha256=YH4crygqb5_Y94nsns6d-26FZCTlDPOh3tf-ghihzDM,4440
+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/models/__init__.py,sha256=RJ7p3WtuSwwpFQ1Iw4_DHV2zzCtHqIzsjJzxv8kUjUE,287
+sqlsaber/models/events.py,sha256=89SXKb5GGpH01yTr2kPEBhzp9xv35RFIYuFdAZSIPoE,721
+sqlsaber/models/types.py,sha256=w-zk81V2dtveuteej36_o1fDK3So428j3P2rAejU62U,862
+sqlsaber-0.8.0.dist-info/METADATA,sha256=jksWiXSR2Qy0O2KgeYm6pCY5boEBM1kO6lJuYSHV6_Y,5986
+sqlsaber-0.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlsaber-0.8.0.dist-info/entry_points.txt,sha256=jmFo96Ylm0zIKXJBwhv_P5wQ7SXP9qdaBcnTp8iCEe8,195
+sqlsaber-0.8.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sqlsaber-0.8.0.dist-info/RECORD,,