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

sqlsaber/agents/anthropic.py

@@ -1,7 +1,8 @@
 """Anthropic-specific SQL agent implementation."""
 
+import asyncio
 import json
-from typing import Any, AsyncIterator, Dict, List, Optional
+from typing import Any, AsyncIterator, Dict, List
 
 from anthropic import AsyncAnthropic
 
@@ -21,7 +22,7 @@ class AnthropicSQLAgent(BaseSQLAgent):
     """SQL Agent using Anthropic SDK directly."""
 
     def __init__(
-        self, db_connection: BaseDatabaseConnection, database_name: Optional[str] = None
+        self, db_connection: BaseDatabaseConnection, database_name: str | None = None
     ):
         super().__init__(db_connection)
 
@@ -82,6 +83,44 @@ class AnthropicSQLAgent(BaseSQLAgent):
                     "required": ["query"],
                 },
             },
+            {
+                "name": "plot_data",
+                "description": "Create a plot of query results.",
+                "input_schema": {
+                    "type": "object",
+                    "properties": {
+                        "y_values": {
+                            "type": "array",
+                            "items": {"type": ["number", "null"]},
+                            "description": "Y-axis data points (required)",
+                        },
+                        "x_values": {
+                            "type": "array",
+                            "items": {"type": ["number", "null"]},
+                            "description": "X-axis data points (optional, will use indices if not provided)",
+                        },
+                        "plot_type": {
+                            "type": "string",
+                            "enum": ["line", "scatter", "histogram"],
+                            "description": "Type of plot to create (default: line)",
+                            "default": "line",
+                        },
+                        "title": {
+                            "type": "string",
+                            "description": "Title for the plot",
+                        },
+                        "x_label": {
+                            "type": "string",
+                            "description": "Label for X-axis",
+                        },
+                        "y_label": {
+                            "type": "string",
+                            "description": "Label for Y-axis",
+                        },
+                    },
+                    "required": ["y_values"],
+                },
+            },
         ]
 
         # Build system prompt with memories if available
@@ -96,13 +135,15 @@ Your responsibilities:
 1. Understand user's natural language requests, think and convert them to SQL
 2. Use the provided tools efficiently to explore database schema
 3. Generate appropriate SQL queries
-4. Execute queries safely (only SELECT queries unless explicitly allowed)
+4. Execute queries safely - queries that modify the database are not allowed
 5. Format and explain results clearly
+6. Create visualizations when requested or when they would be helpful
 
 IMPORTANT - Schema Discovery Strategy:
 1. ALWAYS start with 'list_tables' to see available tables and row counts
 2. Based on the user's query, identify which specific tables are relevant
 3. Use 'introspect_schema' with a table_pattern to get details ONLY for relevant tables
+4. Timestamp columns must be converted to text when you write queries
 
 Guidelines:
 - Use list_tables first, then introspect_schema for specific tables only
@@ -124,7 +165,7 @@ Guidelines:
 
         return base_prompt
 
-    def add_memory(self, content: str) -> Optional[str]:
+    def add_memory(self, content: str) -> str | None:
         """Add a memory for the current database."""
         if not self.database_name:
             return None
@@ -134,7 +175,7 @@ Guidelines:
         self.system_prompt = self._build_system_prompt()
         return memory.id
 
-    async def execute_sql(self, query: str, limit: Optional[int] = 100) -> str:
+    async def execute_sql(self, query: str, limit: int | None = None) -> str:
         """Execute a SQL query against the database with streaming support."""
         # Call parent implementation for core functionality
         result = await super().execute_sql(query, limit)
@@ -163,10 +204,18 @@ Guidelines:
         return await super().process_tool_call(tool_name, tool_input)
 
     async def _process_stream_events(
-        self, stream, content_blocks: List[Dict], tool_use_blocks: List[Dict]
+        self,
+        stream,
+        content_blocks: List[Dict],
+        tool_use_blocks: List[Dict],
+        cancellation_token: asyncio.Event | None = None,
     ) -> AsyncIterator[StreamEvent]:
         """Process stream events and yield appropriate StreamEvents."""
         async for event in stream:
+            # Only check cancellation if token is provided
+            if cancellation_token is not None and cancellation_token.is_set():
+                return
+
             if event.type == "content_block_start":
                 if hasattr(event.content_block, "type"):
                     if event.content_block.type == "tool_use":
@@ -213,11 +262,17 @@ Guidelines:
         return "stop"
 
     async def _process_tool_results(
-        self, response: StreamingResponse
+        self,
+        response: StreamingResponse,
+        cancellation_token: asyncio.Event | None = None,
     ) -> AsyncIterator[StreamEvent]:
         """Process tool results and yield appropriate events."""
         tool_results = []
         for block in response.content:
+            # Only check cancellation if token is provided
+            if cancellation_token is not None and cancellation_token.is_set():
+                return
+
             if block.get("type") == "tool_use":
                 yield StreamEvent(
                     "tool_use",
@@ -249,13 +304,25 @@ Guidelines:
                             "result": tool_result,
                         },
                     )
+                elif block["name"] == "plot_data":
+                    yield StreamEvent(
+                        "plot_result",
+                        {
+                            "tool_name": block["name"],
+                            "input": block["input"],
+                            "result": tool_result,
+                        },
+                    )
 
                 tool_results.append(build_tool_result_block(block["id"], tool_result))
 
         yield StreamEvent("tool_result_data", tool_results)
 
     async def query_stream(
-        self, user_query: str, use_history: bool = True
+        self,
+        user_query: str,
+        use_history: bool = True,
+        cancellation_token: asyncio.Event | None = None,
     ) -> AsyncIterator[StreamEvent]:
         """Process a user query and stream responses."""
         # Initialize for tracking state
@@ -273,7 +340,11 @@ Guidelines:
         try:
             # Create initial stream and get response
             response = None
-            async for event in self._create_and_process_stream(messages):
+            async for event in self._create_and_process_stream(
+                messages, cancellation_token
+            ):
+                if cancellation_token is not None and cancellation_token.is_set():
+                    return
                 if event.type == "response_ready":
                     response = event.data
                 else:
@@ -283,14 +354,21 @@ Guidelines:
 
             # Process tool calls if needed
             while response is not None and response.stop_reason == "tool_use":
+                # Check for cancellation at the start of tool cycle
+                if cancellation_token is not None and cancellation_token.is_set():
+                    return
+
                 # Add assistant's response to conversation
                 collected_content.append(
                     {"role": "assistant", "content": response.content}
                 )
 
-                # Process tool results
+                # Process tool results - DO NOT check cancellation during tool execution
+                # as this would break the tool_use -> tool_result API contract
                 tool_results = []
-                async for event in self._process_tool_results(response):
+                async for event in self._process_tool_results(
+                    response, None
+                ):  # Pass None to disable cancellation checks
                     if event.type == "tool_result_data":
                         tool_results = event.data
                     else:
@@ -298,6 +376,12 @@ Guidelines:
 
                 # Continue conversation with tool results
                 collected_content.append({"role": "user", "content": tool_results})
+                if use_history:
+                    self.conversation_history.extend(collected_content)
+
+                # Check for cancellation AFTER tool results are complete
+                if cancellation_token is not None and cancellation_token.is_set():
+                    return
 
                 # Signal that we're processing the tool results
                 yield StreamEvent("processing", "Analyzing results...")
@@ -305,8 +389,10 @@ Guidelines:
                 # Get next response
                 response = None
                 async for event in self._create_and_process_stream(
-                    messages + collected_content
+                    messages + collected_content, cancellation_token
                 ):
+                    if cancellation_token is not None and cancellation_token.is_set():
+                        return
                     if event.type == "response_ready":
                         response = event.data
                     else:
@@ -314,21 +400,19 @@ Guidelines:
 
             # Update conversation history if using history
             if use_history:
-                self.conversation_history.append(
-                    {"role": "user", "content": user_query}
-                )
-                self.conversation_history.extend(collected_content)
                 # Add final assistant response
                 if response is not None:
                     self.conversation_history.append(
                         {"role": "assistant", "content": response.content}
                     )
 
+        except asyncio.CancelledError:
+            return
         except Exception as e:
             yield StreamEvent("error", str(e))
 
     async def _create_and_process_stream(
-        self, messages: List[Dict]
+        self, messages: List[Dict], cancellation_token: asyncio.Event | None = None
     ) -> AsyncIterator[StreamEvent]:
         """Create a stream and yield events while building response."""
         stream = await self.client.messages.create(
@@ -344,8 +428,11 @@ Guidelines:
         tool_use_blocks = []
 
         async for event in self._process_stream_events(
-            stream, content_blocks, tool_use_blocks
+            stream, content_blocks, tool_use_blocks, cancellation_token
         ):
+            # Only check cancellation if token is provided
+            if cancellation_token is not None and cancellation_token.is_set():
+                return
             yield event
 
         # Finalize tool blocks and create response

sqlsaber/agents/base.py

@@ -1,9 +1,12 @@
 """Abstract base class for SQL agents."""
 
+import asyncio
 import json
 from abc import ABC, abstractmethod
 from typing import Any, AsyncIterator, Dict, List, Optional
 
+from uniplot import histogram, plot
+
 from sqlsaber.database.connection import (
     BaseDatabaseConnection,
     CSVConnection,
@@ -25,9 +28,18 @@ class BaseSQLAgent(ABC):
 
     @abstractmethod
     async def query_stream(
-        self, user_query: str, use_history: bool = True
+        self,
+        user_query: str,
+        use_history: bool = True,
+        cancellation_token: asyncio.Event | None = None,
     ) -> AsyncIterator[StreamEvent]:
-        """Process a user query and stream responses."""
+        """Process a user query and stream responses.
+
+        Args:
+            user_query: The user's query to process
+            use_history: Whether to include conversation history
+            cancellation_token: Optional event to signal cancellation
+        """
         pass
 
     def clear_history(self):
@@ -84,7 +96,7 @@ class BaseSQLAgent(ABC):
         except Exception as e:
             return json.dumps({"error": f"Error listing tables: {str(e)}"})
 
-    async def execute_sql(self, query: str, limit: Optional[int] = 100) -> str:
+    async def execute_sql(self, query: str, limit: Optional[int] = None) -> str:
         """Execute a SQL query against the database."""
         try:
             # Security check - only allow SELECT queries unless write is enabled
@@ -146,6 +158,15 @@ class BaseSQLAgent(ABC):
             return await self.execute_sql(
                 tool_input["query"], tool_input.get("limit", 100)
             )
+        elif tool_name == "plot_data":
+            return await self.plot_data(
+                y_values=tool_input["y_values"],
+                x_values=tool_input.get("x_values"),
+                plot_type=tool_input.get("plot_type", "line"),
+                title=tool_input.get("title"),
+                x_label=tool_input.get("x_label"),
+                y_label=tool_input.get("y_label"),
+            )
         else:
             return json.dumps({"error": f"Unknown tool: {tool_name}"})
 
@@ -182,3 +203,84 @@ class BaseSQLAgent(ABC):
         if query_upper.startswith("SELECT") and "LIMIT" not in query_upper:
             return f"{query.rstrip(';')} LIMIT {limit};"
         return query
+
+    async def plot_data(
+        self,
+        y_values: List[float],
+        x_values: Optional[List[float]] = None,
+        plot_type: str = "line",
+        title: Optional[str] = None,
+        x_label: Optional[str] = None,
+        y_label: Optional[str] = None,
+    ) -> str:
+        """Create a terminal plot using uniplot.
+
+        Args:
+            y_values: Y-axis data points
+            x_values: X-axis data points (optional)
+            plot_type: Type of plot - "line", "scatter", or "histogram"
+            title: Plot title
+            x_label: X-axis label
+            y_label: Y-axis label
+
+        Returns:
+            JSON string with success status and plot details
+        """
+        try:
+            # Validate inputs
+            if not y_values:
+                return json.dumps({"error": "No data provided for plotting"})
+
+            # Convert to floats if needed
+            try:
+                y_values = [float(v) if v is not None else None for v in y_values]
+                if x_values:
+                    x_values = [float(v) if v is not None else None for v in x_values]
+            except (ValueError, TypeError) as e:
+                return json.dumps({"error": f"Invalid data format: {str(e)}"})
+
+            # Create the plot
+            if plot_type == "histogram":
+                # For histogram, we only need y_values
+                histogram(
+                    y_values,
+                    title=title,
+                    bins=min(20, len(set(y_values))),  # Adaptive bin count
+                )
+                plot_info = {
+                    "type": "histogram",
+                    "data_points": len(y_values),
+                    "title": title or "Histogram",
+                }
+            elif plot_type in ["line", "scatter"]:
+                # For line/scatter plots
+                plot_kwargs = {
+                    "ys": y_values,
+                    "title": title,
+                    "lines": plot_type == "line",
+                }
+
+                if x_values:
+                    plot_kwargs["xs"] = x_values
+                if x_label:
+                    plot_kwargs["x_unit"] = x_label
+                if y_label:
+                    plot_kwargs["y_unit"] = y_label
+
+                plot(**plot_kwargs)
+
+                plot_info = {
+                    "type": plot_type,
+                    "data_points": len(y_values),
+                    "title": title or f"{plot_type.capitalize()} Plot",
+                    "has_x_values": x_values is not None,
+                }
+            else:
+                return json.dumps({"error": f"Unsupported plot type: {plot_type}"})
+
+            return json.dumps(
+                {"success": True, "plot_rendered": True, "plot_info": plot_info}
+            )
+
+        except Exception as e:
+            return json.dumps({"error": f"Error creating plot: {str(e)}"})

sqlsaber/cli/display.py

@@ -62,12 +62,20 @@ class DisplayManager:
         )
 
         # Create table with columns from first result
-        columns = list(results[0].keys())
-        table = self._create_table(columns)
+        all_columns = list(results[0].keys())
+        display_columns = all_columns[:15]  # Limit to first 15 columns
+
+        # Show warning if columns were truncated
+        if len(all_columns) > 15:
+            self.console.print(
+                f"[yellow]Note: Showing first 15 of {len(all_columns)} columns[/yellow]"
+            )
+
+        table = self._create_table(display_columns)
 
         # Add rows (show first 20 rows)
         for row in results[:20]:
-            table.add_row(*[str(row[key]) for key in columns])
+            table.add_row(*[str(row[key]) for key in display_columns])
 
         self.console.print(table)
 
@@ -205,3 +213,33 @@ class DisplayManager:
             self.show_error("Failed to parse schema data")
         except Exception as e:
             self.show_error(f"Error displaying schema information: {str(e)}")
+
+    def show_plot(self, plot_data: dict):
+        """Display plot information and status."""
+        try:
+            # Parse the result if it's a string
+            if isinstance(plot_data.get("result"), str):
+                result = json.loads(plot_data["result"])
+            else:
+                result = plot_data.get("result", {})
+
+            # Check if there was an error
+            if "error" in result:
+                self.show_error(f"Plot error: {result['error']}")
+                return
+
+            # If plot was successful, show plot info
+            if result.get("success") and result.get("plot_rendered"):
+                plot_info = result.get("plot_info", {})
+                self.console.print(
+                    f"\n[bold green]✓ Plot rendered:[/bold green] {plot_info.get('title', 'Plot')}"
+                )
+                self.console.print(
+                    f"[dim]  Type: {plot_info.get('type', 'unknown')}, "
+                    f"Data points: {plot_info.get('data_points', 0)}[/dim]"
+                )
+
+        except json.JSONDecodeError:
+            self.show_error("Failed to parse plot result")
+        except Exception as e:
+            self.show_error(f"Error displaying plot: {str(e)}")

sqlsaber/cli/interactive.py

@@ -1,6 +1,10 @@
 """Interactive mode handling for the CLI."""
 
+import asyncio
+from typing import Optional
+
 import questionary
+from prompt_toolkit.completion import Completer, Completion
 from rich.console import Console
 from rich.panel import Panel
 
@@ -9,6 +13,34 @@ from sqlsaber.cli.display import DisplayManager
 from sqlsaber.cli.streaming import StreamingQueryHandler
 
 
+class SlashCommandCompleter(Completer):
+    """Custom completer for slash commands."""
+
+    def get_completions(self, document, complete_event):
+        """Get completions for slash commands."""
+        # Only provide completions if the line starts with "/"
+        text = document.text
+        if text.startswith("/"):
+            # Get the partial command after the slash
+            partial_cmd = text[1:]
+
+            # Define available commands with descriptions
+            commands = [
+                ("clear", "Clear conversation history"),
+                ("exit", "Exit the interactive session"),
+                ("quit", "Exit the interactive session"),
+            ]
+
+            # Yield completions that match the partial command
+            for cmd, description in commands:
+                if cmd.startswith(partial_cmd):
+                    yield Completion(
+                        cmd,
+                        start_position=-len(partial_cmd),
+                        display_meta=description,
+                    )
+
+
 class InteractiveSession:
     """Manages interactive CLI sessions."""
 
@@ -17,6 +49,8 @@ class InteractiveSession:
         self.agent = agent
         self.display = DisplayManager(console)
         self.streaming_handler = StreamingQueryHandler(console)
+        self.current_task: Optional[asyncio.Task] = None
+        self.cancellation_token: Optional[asyncio.Event] = None
 
     def show_welcome_message(self):
         """Display welcome message for interactive mode."""
@@ -28,7 +62,7 @@ class InteractiveSession:
             Panel.fit(
                 "[bold green]SQLSaber - Use the agent Luke![/bold green]\n\n"
                 "[bold]Your agentic SQL assistant.[/bold]\n\n\n"
-                "[dim]Use 'clear' to reset conversation, 'exit' or 'quit' to leave.[/dim]\n\n"
+                "[dim]Use '/clear' to reset conversation, '/exit' or '/quit' to leave.[/dim]\n\n"
                 "[dim]Start a message with '#' to add something to agent's memory for this database.[/dim]",
                 border_style="green",
             )
@@ -38,8 +72,31 @@ class InteractiveSession:
         )
         self.console.print(
             "[dim]Press Esc-Enter or Meta-Enter to submit your query.[/dim]\n"
+            "[dim]Press Ctrl+C during query execution to interrupt and return to prompt.[/dim]\n"
         )
 
+    async def _execute_query_with_cancellation(self, user_query: str):
+        """Execute a query with cancellation support."""
+        # Create cancellation token
+        self.cancellation_token = asyncio.Event()
+
+        # Create the query task
+        query_task = asyncio.create_task(
+            self.streaming_handler.execute_streaming_query(
+                user_query, self.agent, self.cancellation_token
+            )
+        )
+        self.current_task = query_task
+
+        try:
+            # Simply await the query task
+            # Ctrl+C will be handled by the KeyboardInterrupt exception in run()
+            await query_task
+
+        finally:
+            self.current_task = None
+            self.cancellation_token = None
+
     async def run(self):
         """Run the interactive session loop."""
         self.show_welcome_message()
@@ -51,12 +108,16 @@ class InteractiveSession:
                     qmark="",
                     multiline=True,
                     instruction="",
+                    completer=SlashCommandCompleter(),
                 ).ask_async()
 
-                if user_query.lower() in ["exit", "quit", "q"]:
+                if not user_query:
+                    continue
+
+                if user_query in ["/exit", "/quit"]:
                     break
 
-                if user_query.lower() == "clear":
+                if user_query == "/clear":
                     self.agent.clear_history()
                     self.console.print("[green]Conversation history cleared.[/green]\n")
                     continue
@@ -85,12 +146,24 @@ class InteractiveSession:
                             )
                         continue
 
-                    await self.streaming_handler.execute_streaming_query(
-                        user_query, self.agent
-                    )
+                    # Execute query with cancellation support
+                    await self._execute_query_with_cancellation(user_query)
                     self.display.show_newline()  # Empty line for readability
 
             except KeyboardInterrupt:
-                self.console.print("\n[yellow]Use 'exit' or 'quit' to leave.[/yellow]")
+                # Handle Ctrl+C - cancel current task if running
+                if self.current_task and not self.current_task.done():
+                    if self.cancellation_token is not None:
+                        self.cancellation_token.set()
+                    self.current_task.cancel()
+                    try:
+                        await self.current_task
+                    except asyncio.CancelledError:
+                        pass
+                    self.console.print("\n[yellow]Query interrupted[/yellow]")
+                else:
+                    self.console.print(
+                        "\n[yellow]Use '/exit' or '/quit' to leave.[/yellow]"
+                    )
             except Exception as e:
                 self.console.print(f"[bold red]Error:[/bold red] {str(e)}")

sqlsaber/cli/streaming.py

@@ -1,5 +1,7 @@
 """Streaming query handling for the CLI."""
 
+import asyncio
+
 from rich.console import Console
 
 from sqlsaber.agents.base import BaseSQLAgent
@@ -13,7 +15,12 @@ class StreamingQueryHandler:
         self.console = console
         self.display = DisplayManager(console)
 
-    async def execute_streaming_query(self, user_query: str, agent: BaseSQLAgent):
+    async def execute_streaming_query(
+        self,
+        user_query: str,
+        agent: BaseSQLAgent,
+        cancellation_token: asyncio.Event | None = None,
+    ):
         """Execute a query with streaming display."""
 
         has_content = False
@@ -24,7 +31,12 @@ class StreamingQueryHandler:
         status.start()
 
         try:
-            async for event in agent.query_stream(user_query):
+            async for event in agent.query_stream(
+                user_query, cancellation_token=cancellation_token
+            ):
+                if cancellation_token is not None and cancellation_token.is_set():
+                    break
+
                 if event.type == "tool_use":
                     # Stop any ongoing status, but don't mark has_content yet
                     self._stop_status(status)
@@ -63,6 +75,11 @@ class StreamingQueryHandler:
                         self.display.show_schema_info(event.data["result"])
                         has_content = True
 
+                elif event.type == "plot_result":
+                    # Handle plot results
+                    self.display.show_plot(event.data)
+                    has_content = True
+
                 elif event.type == "processing":
                     # Show status when processing tool results
                     if explanation_started:
@@ -78,6 +95,13 @@ class StreamingQueryHandler:
                         has_content = True
                     self.display.show_error(event.data)
 
+        except asyncio.CancelledError:
+            # Handle cancellation gracefully
+            self._stop_status(status)
+            if explanation_started:
+                self.display.show_newline()
+            self.console.print("[yellow]Query interrupted[/yellow]")
+            return
         finally:
             # Make sure status is stopped
             self._stop_status(status)

sqlsaber/models/events.py

@@ -7,7 +7,7 @@ class StreamEvent:
     """Event emitted during streaming processing."""
 
     def __init__(self, event_type: str, data: Any = None):
-        # 'tool_use', 'text', 'query_result', 'error', 'processing'
+        # 'tool_use', 'text', 'query_result', 'plot_result', 'error', 'processing'
         self.type = event_type
         self.data = data
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlsaber
-Version: 0.4.1
+Version: 0.6.0
 Summary: SQLSaber - Agentic SQL assistant like Claude Code
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -16,6 +16,7 @@ Requires-Dist: platformdirs>=4.0.0
 Requires-Dist: questionary>=2.1.0
 Requires-Dist: rich>=13.7.0
 Requires-Dist: typer>=0.16.0
+Requires-Dist: uniplot>=0.21.2
 Description-Content-Type: text/markdown
 
 # SQLSaber

{sqlsaber-0.4.1.dist-info → sqlsaber-0.6.0.dist-info}/RECORD

@@ -1,18 +1,18 @@
 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=xAjKeQSnaut-P5VBeBISbQeqdP41epDjX6MJb2ZUXWg,14060
-sqlsaber/agents/base.py,sha256=IuVyCaA7VsA92odfQS2_lYNzwIZwPxK55mL_xRewgwQ,6943
+sqlsaber/agents/anthropic.py,sha256=FLVET2HvFmsEuFln9Hu4SaBs-Tnk-GestOgnDnUp3ps,17885
+sqlsaber/agents/base.py,sha256=DAnezHl5RLYoef8XQ-n3KA9PowdrMbQrkjdGKPPnFsI,10570
 sqlsaber/agents/mcp.py,sha256=FKtXgDrPZ2-xqUYCw2baI5JzrWekXaC5fjkYW1_Mg50,827
 sqlsaber/agents/streaming.py,sha256=_EO390-FHUrL1fRCNfibtE9QuJz3LGQygbwG3CB2ViY,533
 sqlsaber/cli/__init__.py,sha256=qVSLVJLLJYzoC6aj6y9MFrzZvAwc4_OgxU9DlkQnZ4M,86
 sqlsaber/cli/commands.py,sha256=Dw24W0jij-8t1lpk99C4PBTgzFSag6vU-FZcjAYGG54,5074
 sqlsaber/cli/database.py,sha256=DUfyvNBDp47oFM_VAC_hXHQy_qyE7JbXtowflJpwwH8,12643
-sqlsaber/cli/display.py,sha256=5J4AgJADmMwKi9Aq5u6_MKRO1TA6unS4F4RUfml_sfU,7651
-sqlsaber/cli/interactive.py,sha256=Kqe7kN9mhUiY_5z1Ki6apZ9ahs8uzhHp3xMZGiyTXpY,3912
+sqlsaber/cli/display.py,sha256=lZW7BI2LusU5lJhov7u9kKWwfsqcXGSfjrw-kNO3FQA,9200
+sqlsaber/cli/interactive.py,sha256=RNEWyCM1gLLUsXaXaCFzXu0PFDVuAK8NBOOYYFTHTUE,6716
 sqlsaber/cli/memory.py,sha256=LW4ZF2V6Gw6hviUFGZ4ym9ostFCwucgBTIMZ3EANO-I,7671
 sqlsaber/cli/models.py,sha256=3IcXeeU15IQvemSv-V-RQzVytJ3wuQ4YmWk89nTDcSE,7813
-sqlsaber/cli/streaming.py,sha256=5QGAYTAvg9mzQLxDEVtdDH-TIbGfYYzMOLoOYPrHPu0,3788
+sqlsaber/cli/streaming.py,sha256=2vLCYqqziQTO52erfgvnEk_hM3BoDM1TMBAXgT7KKfo,4548
 sqlsaber/config/__init__.py,sha256=olwC45k8Nc61yK0WmPUk7XHdbsZH9HuUAbwnmKe3IgA,100
 sqlsaber/config/api_keys.py,sha256=kLdoExF_My9ojmdhO5Ca7-ZeowsO0v1GVa_QT5jjUPo,3658
 sqlsaber/config/database.py,sha256=vKFOxPjVakjQhj1uoLcfzhS9ZFr6Z2F5b4MmYALQZoA,11421
@@ -26,10 +26,10 @@ sqlsaber/memory/__init__.py,sha256=GiWkU6f6YYVV0EvvXDmFWe_CxarmDCql05t70MkTEWs,6
 sqlsaber/memory/manager.py,sha256=ML2NEO5Z4Aw36sEI9eOvWVnjl-qT2VOTojViJAj7Seo,2777
 sqlsaber/memory/storage.py,sha256=DvZBsSPaAfk_DqrNEn86uMD-TQsWUI6rQLfNw6PSCB8,5788
 sqlsaber/models/__init__.py,sha256=RJ7p3WtuSwwpFQ1Iw4_DHV2zzCtHqIzsjJzxv8kUjUE,287
-sqlsaber/models/events.py,sha256=55m41tDwMsFxnKKA5_VLJz8iV-V4Sq3LDfta4VoutJI,737
+sqlsaber/models/events.py,sha256=q2FackB60J9-7vegYIjzElLwKebIh7nxnV5AFoZc67c,752
 sqlsaber/models/types.py,sha256=3U_30n91EB3IglBTHipwiW4MqmmaA2qfshfraMZyPps,896
-sqlsaber-0.4.1.dist-info/METADATA,sha256=Jf17BrqK-2LdClq-VdYzhQ5jCsIN44rqsAsQ9kU4ClM,5938
-sqlsaber-0.4.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlsaber-0.4.1.dist-info/entry_points.txt,sha256=jmFo96Ylm0zIKXJBwhv_P5wQ7SXP9qdaBcnTp8iCEe8,195
-sqlsaber-0.4.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sqlsaber-0.4.1.dist-info/RECORD,,
+sqlsaber-0.6.0.dist-info/METADATA,sha256=Mvou6xXxA8T2Cfwq4y1bd0DYW46zBs4Qw7oXWNfihfE,5969
+sqlsaber-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlsaber-0.6.0.dist-info/entry_points.txt,sha256=jmFo96Ylm0zIKXJBwhv_P5wQ7SXP9qdaBcnTp8iCEe8,195
+sqlsaber-0.6.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sqlsaber-0.6.0.dist-info/RECORD,,