tinybird 0.0.1.dev267__py3-none-any.whl → 0.0.1.dev269__py3-none-any.whl

tinybird/tb/modules/agent/prompts.py

@@ -51,6 +51,18 @@ Resource dependencies:
 sql_instructions = """
 <sql_instructions>
     - The SQL query must be a valid ClickHouse SQL query that mixes ClickHouse syntax and Tinybird templating syntax (Tornado templating language under the hood).
+    - Do not use CTEs, only if they return a escalar value, use instead subqueries or nodes if possible.
+    - Create multiple nodes to reuse the same query logic instead of using CTEs. Example:
+    <example_cte_query_not_do_this> # This is wrong. Create a node instead of the cte first and then reuse it
+    WITH my_cte AS (
+      SELECT * FROM events WHERE session_id={{String(my_param, "default_value")}}
+    )
+    SELECT * FROM my_cte
+    </example_cte_query_not_do_this>
+    - Reusing a node means to query that node as a table in the query. Example:
+    <example_not_cte_query_do_this> # This is correct. Create a node instead of the cte first and then reuse it
+    SELECT * FROM my_node_1
+    </example_not_cte_query_do_this>
     - SQL queries with parameters must start with "%" character and a newline on top of every query to be able to use the parameters. Examples:
     <invalid_query_with_parameters_no_%_on_top>
     SELECT * FROM events WHERE session_id={{String(my_param, "default_value")}}
@@ -67,21 +79,21 @@ sql_instructions = """
     AND timestamp BETWEEN {{DateTime(start_date, now() - interval 30 day)}} AND {{DateTime(end_date, now())}}
     </invalid_condition_with_now>
     <valid_condition_without_now>
-    {{%if not defined(start_date)%}}
+    {%if not defined(start_date)%}
     timestamp BETWEEN now() - interval 30 day
-    {{%else%}}
+    {%else%}
     timestamp BETWEEN {{DateTime(start_date)}}
-    {{%end%}}
-    {{%if not defined(end_date)%}}
+    {%end%}
+    {%if not defined(end_date)%}
     AND now()
-    {{%else%}}
+    {%else%}
     AND {{DateTime(end_date)}}
-    {{%end%}}
+    {%end%}
     </valid_condition_without_now>
     - Parameters must not be quoted.
     - When you use defined function with a paremeter inside, do NOT add quotes around the parameter:
-    <invalid_defined_function_with_parameter>{{% if defined('my_param') %}}</invalid_defined_function_with_parameter>
-    <valid_defined_function_without_parameter>{{% if defined(my_param) %}}</valid_defined_function_without_parameter>
+    <invalid_defined_function_with_parameter>{% if defined('my_param') %}</invalid_defined_function_with_parameter>
+    <valid_defined_function_without_parameter>{% if defined(my_param) %}</valid_defined_function_without_parameter>
     - Use datasource names as table names when doing SELECT statements.
     - Do not use pipe names as table names.
     - The available datasource names to use in the SQL are the ones present in the existing_resources section or the ones you will create.
@@ -194,6 +206,18 @@ def get_resource_type(path: Path) -> str:
     return "unknown"
 
 
+explore_data_instructions = """
+# When executing a query:
+- Avoid using the `*` wildcard to avoid returning too much data.
+# When executing a query or calling an endpoint:
+- You need to be sure that the selected resource is updated to the last version in the environment you are working on.
+- Use `diff_resource` tool to compare the content of the resource to compare the differences between environments.
+- Project local file is the source of truth.
+- If the resource is not present or updated to the last version in Tinybird Local, it means you need to build the project. 
+- If the resource is not present or updated to the last version in Tinybird Cloud, it means you need to deploy the project.
+- If exploring an endpoint, the response is empty. You can query the tables to understand what data is available.
+"""
+
 endpoint_optimization_instructions = """
 <endpoint_optimization_instructions>
 ## Endpoint Optimization Instructions
@@ -626,34 +650,32 @@ You are an interactive CLI tool that helps users with data engineering tasks. Us
 
 # Tools
 You have access to the following tools:
-1. `preview_datafile` - Preview the content of a datafile (datasource, endpoint, materialized, sink, copy, connection).
-2. `create_datafile` - Create a file in the project folder. Confirmation will be asked by the tool before creating the file.
-3. `plan` - Plan the creation or update of resources.
-4. `build` - Build the project.
-5. `deploy` - Deploy the project to Tinybird Cloud.
-6. `deploy_check` - Check if the project can be deployed to Tinybird Cloud before deploying it.
-7. `mock` - Create mock data for a landing datasource in Tinybird Cloud or Local.
-8. `analyze_file` - Analyze the content of a fixture file present in the project folder.
-9. `analyze_url` - Analyze the content of an external url.
+1. `create_datafile` - Create a datafile (datasource, endpoint, materialized, sink, copy, connection) in the project folder. Confirmation will be asked by the tool before creating the file.
+2. `plan` - Plan the creation or update of resources.
+3. `build` - Build the project.
+4. `deploy` - Deploy the project to Tinybird Cloud.
+5. `deploy_check` - Check if the project can be deployed to Tinybird Cloud before deploying it.
+6. `mock` - Create mock data for a landing datasource in Tinybird Cloud or Local.
+7. `analyze_file` - Analyze the content of a fixture file present in the project folder.
+8. `analyze_url` - Analyze the content of an external url.
 9. `append_file` - Append a file present in the project to a datasource in Tinybird Cloud or Local.
 10. `append_url` - Append an external url to a datasource in Tinybird Cloud or Local.
 11. `get_endpoint_stats` - Get metrics of the requests to an endpoint.
 12. `get_openapi_definition` - Get the OpenAPI definition for an endpoint in Tinybird Cloud or Local.
-13. `execute_query` - Execute a query against Tinybird Cloud or Local.
-13. `request_endpoint` - Request an endpoint against Tinybird Cloud or Local.
-14. `diff_resource` - Diff the content of a resource in Tinybird Cloud vs Tinybird Local vs Project local file.
-15. `create_tests` - Create tests for an endpoint.
-16. `rename_datafile_or_fixture` - Rename a datafile or fixture.
+13. `explore_data` - Execute a query or request an endpoint against Tinybird Cloud or Local.
+14. `manage_tests` - Create, update or run tests for an endpoint.
+15. `run_command` - Run a command using the Tinybird CLI.
+16. `diff_resource` - Diff the content of a resource in Tinybird Cloud vs Tinybird Local vs Project local file.
+17. `rename_datafile_or_fixture` - Rename a datafile or fixture.
 
 # When creating or updating datafiles:
 1. Use `plan` tool to plan the creation, update or rename of resources.
 2. If the user confirms the plan, go from 3 to 7 steps until all the resources are created, updated or skipped.
-3. Use `preview_datafile` tool to preview the content of a datafile.
-4. Without asking, use the `create_datafile` tool to create the datafile, because it will ask for confirmation before creating the file.
-5. Check the result of the `create_datafile` tool to see if the datafile was created successfully.
-6. If the datafile was created successfully, report the result to the user.
-7. If the datafile was not created, finish the process and just wait for a new user prompt.
-8. If the datafile was created successfully, but the built failed, try to fix the error and repeat the process.
+3. Without asking, use the `create_datafile` tool to create the datafile, because it will ask for confirmation before creating the file.
+4. Check the result of the `create_datafile` tool to see if the datafile was created successfully.
+5. If the datafile was created successfully, report the result to the user.
+6. If the datafile was not created, finish the process and just wait for a new user prompt.
+7. If the datafile was created successfully, but the built failed, try to fix the error and repeat the process.
 
 # When creating a landing datasource given a .ndjson file:
 - If the user does not specify anything about the desired schema, create a schema like this (sorting key not needed in this case)
@@ -706,14 +728,7 @@ Kafka: {kafka_connection_example}
 S3: {s3_connection_example}
 GCS: {gcs_connection_example}
 
-# When executing a query or calling an endpoint:
-- You need to be sure that the selected resource is updated to the last version in the environment you are working on.
-- Use `diff_resource` tool to compare the content of the resource to compare the differences between environments.
-- Project local file is the source of truth.
-- If the resource is not present or updated to the last version in Tinybird Local, it means you need to build the project. 
-- If the resource is not present or updated to the last version in Tinybird Cloud, it means you need to deploy the project.
-- If exploring an endpoint, the response is empty. You can query the tables to understand what data is available.
-
+{explore_data_instructions}
 
 # How to use apppend tools:
 - Use append as part of the creation of a new landing datasource if the user provided a file or an external url

tinybird/tb/modules/agent/testing_agent.py

@@ -26,6 +26,7 @@ class TestingAgent:
         self.token = token
         self.user_token = user_token
         self.host = host
+        self.workspace_id = workspace_id
         self.dangerously_skip_permissions = dangerously_skip_permissions or prompt_mode
         self.project = project
         self.thinking_animation = thinking_animation
@@ -56,7 +57,13 @@ You can do the following:
             return tests_files_prompt(self.project)
 
     def run(self, task: str, deps: TinybirdAgentContext, usage: Usage):
-        result = self.agent.run_sync(task, deps=deps, usage=usage, message_history=self.messages)
+        result = self.agent.run_sync(
+            task,
+            deps=deps,
+            usage=usage,
+            message_history=self.messages,
+            model=create_model(self.user_token, self.host, self.workspace_id, run_id=deps.run_id),
+        )
         new_messages = result.new_messages()
         self.messages.extend(new_messages)
         return result

tinybird/tb/modules/agent/tools/append.py

@@ -10,6 +10,7 @@ from tinybird.tb.modules.agent.utils import (
     show_confirmation,
     show_input,
 )
+from tinybird.tb.modules.common import echo_safe_humanfriendly_tables_format_pretty_table
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
 
@@ -113,20 +114,29 @@ def append_url(
         return f"Error appending URL {fixture_url} to {datasource_name} in Tinybird {cloud_or_local}: {error_message}"
 
 
-def handle_quarantine_error(ctx: RunContext[TinybirdAgentContext], error_message: str, datasource_name: str) -> str:
+def handle_quarantine_error(
+    ctx: RunContext[TinybirdAgentContext], error_message: str, datasource_name: str, cloud: bool = False
+) -> str:
     try:
         if "in quarantine" in error_message:
+            cloud_or_local = "Cloud" if cloud else "Local"
             click.echo(FeedbackManager.highlight(message=f"» Looking for errors in {datasource_name}_quarantine..."))
-            query = (
-                f"select * from {datasource_name}_quarantine order by insertion_date desc limit 5 FORMAT CSVWithNames"
+            query = f"select * from {datasource_name}_quarantine order by insertion_date desc limit 5 FORMAT JSON"
+            result = ctx.deps.execute_query_cloud(query=query) if cloud else ctx.deps.execute_query_local(query=query)
+            quarantine_data = result["data"] or []
+            quarantine_meta = result["meta"] or []
+            column_names = [c["name"] for c in quarantine_meta]
+            echo_safe_humanfriendly_tables_format_pretty_table(
+                data=[d.values() for d in quarantine_data], column_names=column_names
             )
-            quarantine_data = ctx.deps.execute_query_local(query=query)
             error_message = (
                 error_message
-                + f"\nThese are the first 5 rows of the quarantine table for datasource '{datasource_name}':\n{quarantine_data}. Use again `mock` tool but add this issue to the context."
+                + f"\nThese are the first 5 rows of the quarantine table for datasource '{datasource_name}' in {cloud_or_local}:\n{quarantine_data}"
             )
 
     except Exception as quarantine_error:
-        error_message = error_message + f"\nError accessing to {datasource_name}_quarantine: {quarantine_error}"
+        error_message = (
+            error_message + f"\nError accessing to {datasource_name}_quarantine in {cloud_or_local}: {quarantine_error}"
+        )
 
     return error_message

tinybird/tb/modules/agent/tools/create_datafile.py

@@ -16,17 +16,30 @@ from tinybird.tb.modules.exceptions import CLIBuildException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
 
-def create_datafile(ctx: RunContext[TinybirdAgentContext], resource: Datafile) -> str:
-    """Given a resource representation, create a file in the project folder
+def create_datafile(
+    ctx: RunContext[TinybirdAgentContext], name: str, type: str, description: str, content: str, pathname: str
+) -> str:
+    """Given a resource representation, create or update a datafile in the project folder
 
     Args:
-        resource (Datafile): The resource to create. Required.
+        name (str): The name of the datafile. Required.
+        type (str): The type of the datafile. Options: datasource, endpoint, materialized, sink, copy, connection. Required.
+        description (str): The description of the datafile. Required.
+        content (str): The content of the datafile. Required.
+        pathname (str): The pathname of the datafile where the file will be created or it is already located. If it is a new datafile, always include the parent folder depending on the type of the datafile. Required.
 
     Returns:
         str: If the resource was created or not.
     """
     try:
         ctx.deps.thinking_animation.stop()
+        resource = Datafile(
+            type=type.lower(),
+            name=name,
+            content=content,
+            description=description,
+            pathname=pathname,
+        )
         resource.pathname = resource.pathname.removeprefix("/")
         path = Path(ctx.deps.folder) / resource.pathname
         content = resource.content
@@ -63,7 +76,7 @@ def create_datafile(ctx: RunContext[TinybirdAgentContext], resource: Datafile) -
         ctx.deps.thinking_animation.stop()
         click.echo(FeedbackManager.error(message=e))
         ctx.deps.thinking_animation.start()
-        return f"Error building project: {e}"
+        return f"Error building project: {e}. If the error is related to another resource, fix it and try again."
     except Exception as e:
         ctx.deps.thinking_animation.stop()
         click.echo(FeedbackManager.error(message=e))

tinybird/tb/modules/agent/tools/execute_query.py

@@ -1,3 +1,9 @@
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
 import click
 import humanfriendly
 from pydantic_ai import RunContext
@@ -20,55 +26,115 @@ forbidden_commands = [
     "information_schema.tables",
 ]
 
+forbidden_commands_start_with = [
+    "describe",
+]
+
 
-def execute_query(ctx: RunContext[TinybirdAgentContext], query: str, task: str, cloud: bool = False):
-    """Execute a query:
+def execute_query(
+    ctx: RunContext[TinybirdAgentContext],
+    query: str,
+    task: str,
+    cloud: bool = False,
+    script: Optional[str] = None,
+    export_format: Optional[str] = None,
+):
+    """Execute a query and return the result as a table, chart or exported file.
 
     Args:
         query (str): The query to execute. Required.
         task (str): The purpose of the query. Required.
         cloud (bool): Whether to execute the query on cloud or local. Optional.
+        script (str): Python script using plotext to render the query results as a chart. The script will have access to 'data' (list of dicts), 'meta' (list of column info dicts), 'terminal_width' and 'terminal_height' variables. Always use plt.theme("clear") for transparent background and plt.plot_size(terminal_width, terminal_height) for proper sizing. For bar charts, use the simple versions: plt.simple_bar(), plt.simple_multiple_bar(), and plt.simple_stacked_bar(). Optional.
+        export_format (str): The format to export the query results to. Options: csv, json, ndjson. Optional.
 
     Returns:
         str: The result of the query.
     """
+
     try:
         for forbidden_command in forbidden_commands:
             if forbidden_command in query.lower():
                 return f"Error executing query: {forbidden_command} is not allowed."
 
+        for forbidden_command in forbidden_commands_start_with:
+            if query.lower().startswith(forbidden_command):
+                return f"Error executing query: {forbidden_command} is not allowed."
+
         cloud_or_local = "cloud" if cloud else "local"
         ctx.deps.thinking_animation.stop()
 
         click.echo(FeedbackManager.highlight(message=f"» Executing query to {cloud_or_local}:\n{query}\n"))
 
         is_templating = query.strip().startswith("%")
-        query_format = "FORMAT JSON"
+        query_format = "JSON"
+        if export_format == "csv":
+            query_format = "CSVWithNames"
+        elif export_format == "ndjson":
+            query_format = "JSONEachRow"
+        elif export_format == "json":
+            query_format = "JSON"
+
         if is_templating:
             query = query.strip()
-            query = f"%\nSELECT * FROM ({query}) {query_format}"
+            query = f"%\nSELECT * FROM ({query}) FORMAT {query_format}"
         else:
-            query = f"SELECT * FROM ({query}) {query_format}"
+            query = f"SELECT * FROM ({query}) FORMAT {query_format}"
 
         execute_query = ctx.deps.execute_query_cloud if cloud else ctx.deps.execute_query_local
         result = execute_query(query=query)
+        if export_format:
+            file_extension = f".{export_format}"
+            filename = f"export_{export_format}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+            if not filename.endswith(file_extension):
+                filename = f"{filename}{file_extension}"
+
+            file_path = Path(ctx.deps.folder) / filename
+
+            # Ensure directory exists
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Write raw ClickHouse formatted data directly to file
+            with open(file_path, "w", encoding="utf-8") as f:
+                if export_format == "json":
+                    content = json.dumps(result)
+                else:
+                    content = str(result)
+                f.write(content)
+            ctx.deps.thinking_animation.start()
+            return f"Successfully exported data to {file_path} ({export_format.upper()} format)"
+
         stats = result["statistics"]
         seconds = stats["elapsed"]
         rows_read = humanfriendly.format_number(stats["rows_read"])
         bytes_read = humanfriendly.format_size(stats["bytes_read"])
 
         click.echo(FeedbackManager.info_query_stats(seconds=seconds, rows=rows_read, bytes=bytes_read))
+        click.echo()
 
         if not result["data"]:
             click.echo(FeedbackManager.info_no_rows())
         else:
-            echo_safe_humanfriendly_tables_format_pretty_table(
-                data=[d.values() for d in result["data"][:10]], column_names=result["data"][0].keys()
-            )
-            click.echo("Showing first 10 results\n")
+            if script:
+                try:
+                    # Execute the LLM-generated plotext script
+                    chart_output = _execute_plotext_script(script, result["data"], result["meta"])
+                    click.echo(chart_output)
+                except Exception as script_error:
+                    click.echo(
+                        FeedbackManager.error(message=f"There was an error rendering the chart.\n{script_error}")
+                    )
+                    ctx.deps.thinking_animation.start()
+                    return f"After executing the query: {query}, there was an error rendering the chart: {script_error}. Fix the script and render the chart again."
+            else:
+                echo_safe_humanfriendly_tables_format_pretty_table(
+                    data=[d.values() for d in result["data"]], column_names=result["data"][0].keys()
+                )
+                click.echo("Showing first 10 results\n")
+
         ctx.deps.thinking_animation.start()
-        result["data"] = result["data"][:10]
-        return f"Result for task '{task}' in {cloud_or_local} environment: {result}. The user is being shown the full result in the console but this message only contains the first 10 rows."
+        display_format = "chart" if script else "table"
+        return f"Result for task '{task}' in {cloud_or_local} environment: {result}. The user is being shown the result as a {display_format} in the console, so do not render that again."
     except Exception as e:
         error = str(e)
         ctx.deps.thinking_animation.stop()
@@ -78,3 +144,64 @@ def execute_query(ctx: RunContext[TinybirdAgentContext], query: str, task: str,
             return f"Error executing query: {error}. Please run the query against Tinybird local instead of cloud."
         else:
             return f"Error executing query: {error}. Please try again."
+
+
+def _execute_plotext_script(script: str, data: List[Dict[str, Any]], meta: List[Dict[str, str]]) -> str:
+    """Execute a plotext script with the provided data using exec().
+
+    Args:
+        script: Python script using plotext
+        data: Query result data
+        meta: Query result metadata
+
+    Returns:
+        Chart output as string
+    """
+    import io
+    from contextlib import redirect_stdout
+
+    try:
+        # Capture stdout
+        output = io.StringIO()
+
+        # Prepare globals with data and required imports
+        script_globals = {
+            "data": data,
+            "meta": meta,
+            "__builtins__": __builtins__,
+        }
+
+        # Import required modules into the script namespace
+        exec("import plotext as plt", script_globals)
+        exec("import json", script_globals)
+        exec("from datetime import datetime", script_globals)
+        exec("import re", script_globals)
+        exec("import os", script_globals)
+
+        # Clear any previous plot data to prevent chart reuse
+        exec("plt.clear_data()", script_globals)
+
+        # Get terminal dimensions and make them available
+        try:
+            terminal_size = os.get_terminal_size()
+            terminal_width = terminal_size.columns
+            terminal_height = max(20, terminal_size.lines // 3)  # Use 1/3 of terminal height, min 20
+        except:
+            terminal_width = 80
+            terminal_height = 20
+
+        script_globals["terminal_width"] = terminal_width
+        script_globals["terminal_height"] = terminal_height
+
+        # Execute the user script with stdout capture
+        with redirect_stdout(output):
+            exec(script, script_globals)
+
+        # Clean up after rendering to prevent state leakage
+        exec("plt.clear_data()", script_globals)
+        exec("plt.clear_figure()", script_globals)
+
+        return output.getvalue()
+
+    except Exception as e:
+        raise Exception(f"Script execution error: {str(e)}")

tinybird/tb/modules/agent/tools/mock.py

@@ -1,36 +1,34 @@
-from typing import Optional
-
 import click
 from pydantic_ai import RunContext
 
-from tinybird.tb.modules.agent.utils import AgentRunCancelled, TinybirdAgentContext, show_confirmation, show_input
+from tinybird.tb.modules.agent.utils import (
+    AgentRunCancelled,
+    TinybirdAgentContext,
+    show_confirmation,
+    show_input,
+)
+from tinybird.tb.modules.common import echo_safe_humanfriendly_tables_format_pretty_table
 from tinybird.tb.modules.datafile.fixture import persist_fixture
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
 
 def mock(
-    ctx: RunContext[TinybirdAgentContext],
-    datasource_name: str,
-    data_format: str,
-    rows: int,
-    context: Optional[str] = None,
-    cloud: bool = False,
+    ctx: RunContext[TinybirdAgentContext], datasource_name: str, data_format: str, rows: int, description: str
 ) -> str:
     """Create mock data for a datasource
 
     Args:
-        datasource_name: Name of the datasource to create mock data for
-        data_format: Format of the mock data to create. Options: ndjson, csv
-        rows: Number of rows to create. If not provided, the default is 10
-        context: Extra context to be used to generate the mock data. Optional.
-        cloud: Whether to generate the mock data in the cloud or local environment. Optional.
+        datasource_name (str): Name of the datasource to create mock data for. Required.
+        data_format (str): Format of the mock data to create. Options: ndjson, csv. Required.
+        rows (int): Number of rows to create. If not provided, the default is 10. Required.
+        description (str): Extra details about how to generate the mock data (nested json if any, sample row to help with the generation, etc). You can use this to fix issues with the mock data generation. Required.
 
     Returns:
         str: Message indicating the success or failure of the mock data generation
     """
     try:
         ctx.deps.thinking_animation.stop()
-        cloud_or_local = "Cloud" if cloud else "Local"
+        cloud_or_local = "Local"
         confirmation = show_confirmation(
             title=f"Generate mock data for datasource '{datasource_name}' in Tinybird {cloud_or_local}?",
             skip_confirmation=ctx.deps.dangerously_skip_permissions,
@@ -42,12 +40,11 @@ def mock(
             return f"User did not confirm mock data for datasource '{datasource_name}' in Tinybird {cloud_or_local} and gave the following feedback: {feedback}"
 
         click.echo(FeedbackManager.highlight(message=f"» Generating mock data for {datasource_name}..."))
-        data = ctx.deps.mock_data(datasource_name=datasource_name, data_format=data_format, rows=rows, context=context)
+        data = ctx.deps.mock_data(
+            datasource_name=datasource_name, data_format=data_format, rows=rows, context=description
+        )
         fixture_path = persist_fixture(datasource_name, data, ctx.deps.folder, format=data_format)
-        if cloud:
-            ctx.deps.append_data_cloud(datasource_name=datasource_name, path=str(fixture_path))
-        else:
-            ctx.deps.append_data_local(datasource_name=datasource_name, path=str(fixture_path))
+        ctx.deps.append_data_local(datasource_name=datasource_name, path=str(fixture_path))
         click.echo(FeedbackManager.success(message=f"✓ Data generated for {datasource_name}"))
         ctx.deps.thinking_animation.start()
         return f"Mock data generated successfully for datasource '{datasource_name}' in Tinybird {cloud_or_local}"
@@ -62,8 +59,19 @@ def mock(
                 click.echo(
                     FeedbackManager.highlight(message=f"» Looking for errors in {datasource_name}_quarantine...")
                 )
-                query = f"select * from {datasource_name}_quarantine order by insertion_date desc limit 5 FORMAT CSVWithNames"
-                quarantine_data = ctx.deps.execute_query_local(query=query)
+                query = f"select * from {datasource_name}_quarantine order by insertion_date desc limit 5 FORMAT JSON"
+                quarantine_result = ctx.deps.execute_query_local(query=query)
+                quarantine_data = quarantine_result["data"] or []
+                quarantine_meta = quarantine_result["meta"] or []
+                column_names = [c["name"] for c in quarantine_meta]
+                echo_safe_humanfriendly_tables_format_pretty_table(
+                    data=[d.values() for d in quarantine_data], column_names=column_names
+                )
+                click.echo(
+                    FeedbackManager.info(
+                        message=f"These are the first 5 rows of the quarantine table for datasource '{datasource_name}':"
+                    )
+                )
                 error_message = (
                     error_message
                     + f"\nThese are the first 5 rows of the quarantine table for datasource '{datasource_name}':\n{quarantine_data}. Use again `mock` tool but add this issue to the context."

tinybird/tb/modules/agent/tools/request_endpoint.py

@@ -4,7 +4,7 @@ import click
 import humanfriendly
 from pydantic_ai import RunContext
 
-from tinybird.tb.modules.agent.utils import TinybirdAgentContext
+from tinybird.tb.modules.agent.utils import TinybirdAgentContext, limit_result_output
 from tinybird.tb.modules.common import echo_safe_humanfriendly_tables_format_pretty_table
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
@@ -37,6 +37,10 @@ def request_endpoint(
 
         request_endpoint = ctx.deps.request_endpoint_cloud if cloud else ctx.deps.request_endpoint_local
         result = request_endpoint(endpoint_name=endpoint_name, params=params)
+
+        # Apply output limiting using the utility function
+        result, truncated_columns = limit_result_output(result)
+
         stats = result["statistics"]
         seconds = stats["elapsed"]
         rows_read = humanfriendly.format_number(stats["rows_read"])
@@ -49,11 +53,20 @@ def request_endpoint(
             click.echo(FeedbackManager.info_no_rows())
         else:
             echo_safe_humanfriendly_tables_format_pretty_table(
-                data=[d.values() for d in result["data"][:10]], column_names=result["data"][0].keys()
+                data=[d.values() for d in result["data"]], column_names=result["data"][0].keys()
             )
             click.echo("Showing first 10 results\n")
+
+        # Prepare return message with truncation info
+        truncation_info = ""
+        if truncated_columns:
+            truncated_list = ", ".join(sorted(truncated_columns))
+            truncation_info = (
+                f" Note: The following columns had values truncated due to length > 200 characters: {truncated_list}."
+            )
+
         ctx.deps.thinking_animation.start()
-        return f"Result for endpoint {endpoint_name} with params {params} in {cloud_or_local} environment: {result}. Do not show result is already shown in the console."
+        return f"Result for endpoint {endpoint_name} with params {params} in {cloud_or_local} environment: {result}. Do not show result is already shown in the console.{truncation_info}"
     except Exception as e:
         error = str(e)
         ctx.deps.thinking_animation.stop()

tinybird/tb/modules/agent/tools/run_command.py

@@ -15,8 +15,10 @@ def run_command(ctx: RunContext[TinybirdAgentContext], command: str):
     """
     try:
         ctx.deps.thinking_animation.stop()
+        is_deploy = " deploy " in command.lower()
         confirmation = show_confirmation(
-            title=f"Run command: {command}?", skip_confirmation=ctx.deps.dangerously_skip_permissions
+            title=f"Run command: {command}?",
+            skip_confirmation=ctx.deps.dangerously_skip_permissions and not is_deploy,
         )
 
         if confirmation == "review":

tinybird/tb/modules/agent/utils.py

@@ -36,6 +36,7 @@ except ImportError:
 
 class TinybirdAgentContext(BaseModel):
     folder: str
+    workspace_id: str
     workspace_name: str
     thinking_animation: Any
     get_project_files: Callable[[], List[str]]
@@ -66,6 +67,7 @@ class TinybirdAgentContext(BaseModel):
     host: str
     local_host: str
     local_token: str
+    run_id: Optional[str] = None
 
 
 default_style = PromptStyle.from_dict(
@@ -792,3 +794,43 @@ def _is_path_inside_project(file_path: Path, project_path: Path) -> bool:
         return True
     except ValueError:
         return False
+
+
+def limit_result_output(
+    result: dict[str, Any], max_rows: int = 10, max_column_length: int = 200
+) -> tuple[dict[str, Any], set[str]]:
+    """
+    Limit result output by truncating column values and limiting number of rows.
+    Modifies the result dict in place and returns truncation info.
+
+    Args:
+        result: Result dictionary containing 'data' key with list of row dictionaries
+        max_rows: Maximum number of rows to return
+        max_column_length: Maximum length for column values before truncation
+
+    Returns:
+        Tuple of (modified_result, truncated_columns_set)
+    """
+    truncated_columns: set[str] = set()
+
+    # Handle case where data doesn't exist or is empty
+    if not result.get("data"):
+        return result, truncated_columns
+
+    result_data = result["data"]
+
+    # Limit to max_rows
+    limited_data = result_data[:max_rows]
+
+    # Truncate column values and track which columns were truncated
+    for row in limited_data:
+        for column, value in row.items():
+            value_str = str(value)
+            if len(value_str) > max_column_length:
+                row[column] = value_str[:max_column_length] + "..."
+                truncated_columns.add(column)
+
+    # Update the result dict with limited data
+    result["data"] = limited_data
+
+    return result, truncated_columns