tinybird 0.0.1.dev254__tar.gz → 0.0.1.dev255__tar.gz

{tinybird-0.0.1.dev254 → tinybird-0.0.1.dev255}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tinybird
-Version: 0.0.1.dev254
+Version: 0.0.1.dev255
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/forward/commands
 Author: Tinybird

{tinybird-0.0.1.dev254 → tinybird-0.0.1.dev255}/tinybird/prompts.py

@@ -689,7 +689,6 @@ materialized_pipe_instructions = """
 - TYPE MATERIALIZED is the type of the pipe and it is mandatory for materialized pipes.
 - The content of the .pipe file must follow the materialized_pipe_content format.
 - Use State modifier for the aggregated columns in the pipe.
-- Keep the SQL query simple and avoid using complex queries with joins, subqueries, etc.
 </materialized_pipe_instructions>
 <materialized_pipe_content>
 NODE daily_sales
@@ -812,11 +811,11 @@ TYPE endpoint
 """
 
 pipe_instructions = """
+Follow these instructions when creating or updating any type of .pipe file:
 <pipe_file_instructions>
     - The pipe names must be unique.
     - Nodes do NOT use the same name as the Pipe they belong to. So if the pipe name is "my_pipe", the nodes must be named different like "my_pipe_node_1", "my_pipe_node_2", etc.
     - Node names MUST be different from the resource names in the project.
-    - Avoid more than one node per pipe unless it is really necessary or requested by the user.
     - No indentation is allowed for property names: DESCRIPTION, NODE, SQL, TYPE, etc.
     - Allowed TYPE values are: endpoint, copy, materialized, sink.
     - Add always the output node in the TYPE section or in the last node of the pipe.

{tinybird-0.0.1.dev254 → tinybird-0.0.1.dev255}/tinybird/tb/__cli__.py

@@ -4,5 +4,5 @@ __description__ = 'Tinybird Command Line Tool'
 __url__ = 'https://www.tinybird.co/docs/forward/commands'
 __author__ = 'Tinybird'
 __author_email__ = 'support@tinybird.co'
-__version__ = '0.0.1.dev254'
-__revision__ = '269e345'
+__version__ = '0.0.1.dev255'
+__revision__ = '208306e'

{tinybird-0.0.1.dev254 → tinybird-0.0.1.dev255}/tinybird/tb/modules/agent/agent.py

@@ -33,6 +33,7 @@ from tinybird.tb.modules.agent.prompts import (
     endpoint_optimization_instructions,
     plan_instructions,
     resources_prompt,
+    sql_agent_instructions,
     sql_instructions,
 )
 from tinybird.tb.modules.agent.tools.analyze import analyze_file, analyze_url
@@ -41,6 +42,7 @@ from tinybird.tb.modules.agent.tools.build import build
 from tinybird.tb.modules.agent.tools.create_datafile import create_datafile
 from tinybird.tb.modules.agent.tools.deploy import deploy
 from tinybird.tb.modules.agent.tools.deploy_check import deploy_check
+from tinybird.tb.modules.agent.tools.diff_resource import diff_resource
 from tinybird.tb.modules.agent.tools.execute_query import execute_query
 from tinybird.tb.modules.agent.tools.get_endpoint_stats import get_endpoint_stats
 from tinybird.tb.modules.agent.tools.get_openapi_definition import get_openapi_definition
@@ -121,6 +123,7 @@ You have access to the following tools:
 12. `get_openapi_definition` - Get the OpenAPI definition for all endpoints that are built/deployed to 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.
 
 # When creating or updating datafiles:
 1. Use `plan` tool to plan the creation or update of resources.
@@ -172,6 +175,7 @@ IMPORTANT: Every time you finish a plan and start a new resource creation or upd
 {copy_pipe_instructions}
 
 # Working with SQL queries:
+{sql_agent_instructions}
 {sql_instructions}
 
 # Working with connections files:
@@ -182,6 +186,13 @@ Kafka: {kafka_connection_example}
 S3: {s3_connection_example}
 GCS: {gcs_connection_example}
 
+# When executing a query or requesting 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.
+
 # Info
 Today is {datetime.now().strftime("%Y-%m-%d")}
 """,
@@ -208,6 +219,7 @@ Today is {datetime.now().strftime("%Y-%m-%d")}
                 ),
                 Tool(execute_query, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
                 Tool(request_endpoint, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
+                Tool(diff_resource, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
             ],
         )
 
@@ -233,10 +245,16 @@ Today is {datetime.now().strftime("%Y-%m-%d")}
                 mock_data=partial(mock_data, project=project, config=config),
                 append_data=partial(append_data, config=config),
                 analyze_fixture=partial(analyze_fixture, config=config),
-                execute_cloud_query=partial(execute_cloud_query, config=config),
-                execute_local_query=partial(execute_local_query, config=config),
+                execute_query_cloud=partial(execute_query_cloud, config=config),
+                execute_query_local=partial(execute_query_local, config=config),
                 request_endpoint_cloud=partial(request_endpoint_cloud, config=config),
                 request_endpoint_local=partial(request_endpoint_local, config=config),
+                get_datasource_datafile_cloud=partial(get_datasource_datafile_cloud, config=config),
+                get_datasource_datafile_local=partial(get_datasource_datafile_local, config=config),
+                get_pipe_datafile_cloud=partial(get_pipe_datafile_cloud, config=config),
+                get_pipe_datafile_local=partial(get_pipe_datafile_local, config=config),
+                get_connection_datafile_cloud=partial(get_connection_datafile_cloud, config=config),
+                get_connection_datafile_local=partial(get_connection_datafile_local, config=config),
                 get_project_files=project.get_project_files,
                 folder=folder,
                 thinking_animation=thinking_animation,
@@ -444,12 +462,12 @@ def analyze_fixture(config: dict[str, Any], fixture_path: str, format: str = "js
     return meta
 
 
-def execute_cloud_query(config: dict[str, Any], query: str, pipe_name: Optional[str] = None) -> dict[str, Any]:
+def execute_query_cloud(config: dict[str, Any], query: str, pipe_name: Optional[str] = None) -> dict[str, Any]:
     client = _get_tb_client(config["token"], config["host"])
     return client.query(sql=query, pipeline=pipe_name)
 
 
-def execute_local_query(config: dict[str, Any], query: str, pipe_name: Optional[str] = None) -> dict[str, Any]:
+def execute_query_local(config: dict[str, Any], query: str, pipe_name: Optional[str] = None) -> dict[str, Any]:
     local_client = get_tinybird_local_client(config, test=False, silent=True)
     return local_client.query(sql=query, pipeline=pipe_name)
 
@@ -466,3 +484,51 @@ def request_endpoint_local(
 ) -> dict[str, Any]:
     local_client = get_tinybird_local_client(config, test=False, silent=True)
     return local_client.pipe_data(endpoint_name, format="json", params=params)
+
+
+def get_datasource_datafile_cloud(config: dict[str, Any], datasource_name: str) -> str:
+    try:
+        client = _get_tb_client(config["token"], config["host"])
+        return client.datasource_file(datasource_name)
+    except Exception:
+        return "Datasource not found"
+
+
+def get_datasource_datafile_local(config: dict[str, Any], datasource_name: str) -> str:
+    try:
+        local_client = get_tinybird_local_client(config, test=False, silent=True)
+        return local_client.datasource_file(datasource_name)
+    except Exception:
+        return "Datasource not found"
+
+
+def get_pipe_datafile_cloud(config: dict[str, Any], pipe_name: str) -> str:
+    try:
+        client = _get_tb_client(config["token"], config["host"])
+        return client.pipe_file(pipe_name)
+    except Exception:
+        return "Pipe not found"
+
+
+def get_pipe_datafile_local(config: dict[str, Any], pipe_name: str) -> str:
+    try:
+        local_client = get_tinybird_local_client(config, test=False, silent=True)
+        return local_client.pipe_file(pipe_name)
+    except Exception:
+        return "Pipe not found"
+
+
+def get_connection_datafile_cloud(config: dict[str, Any], connection_name: str) -> str:
+    try:
+        client = _get_tb_client(config["token"], config["host"])
+        return client.connection_file(connection_name)
+    except Exception:
+        return "Connection not found"
+
+
+def get_connection_datafile_local(config: dict[str, Any], connection_name: str) -> str:
+    try:
+        local_client = get_tinybird_local_client(config, test=False, silent=True)
+        return local_client.connection_file(connection_name)
+    except Exception:
+        return "Connection not found"

{tinybird-0.0.1.dev254 → tinybird-0.0.1.dev255}/tinybird/tb/modules/agent/prompts.py

@@ -1,4 +1,7 @@
 from pathlib import Path
+from typing import Any
+
+from pydantic_ai import format_as_xml
 
 from tinybird.tb.modules.project import Project
 
@@ -73,9 +76,10 @@ sql_instructions = """
     - Use node names as table names only when nodes are present in the same file.
     - Do not reference the current node name in the SQL.
     - SQL queries only accept SELECT statements with conditions, aggregations, joins, etc.
-    - Do NOT use CREATE TABLE, INSERT INTO, CREATE DATABASE, etc.
+    - Do NOT use CREATE TABLE, INSERT INTO, CREATE DATABASE, SHOW TABLES, etc.
     - Use ONLY SELECT statements in the SQL section.
     - INSERT INTO is not supported in SQL section.
+    - Do NOT query system.<table_name> tables.
     - When using functions try always ClickHouse functions first, then SQL functions.
     - Parameters are never quoted in any case.
     - Use the following syntax in the SQL section for the iceberg table function: iceberg('s3://bucket/path/to/table', {{tb_secret('aws_access_key_id')}}, {{tb_secret('aws_secret_access_key')}})
@@ -101,38 +105,32 @@ def resources_prompt(project: Project) -> str:
 
     resources_content = "# Existing resources in the project:\n"
     if files:
-        paths = [Path(file_path) for file_path in files]
-
-        resources_content += "\n".join(
-            [
-                f"""
-    <resource>
-        <path>{file_path.relative_to(project.folder)}</path>
-        <type>{get_resource_type(file_path)}</type>
-        <name>{file_path.stem}</name>
-        <content>{file_path.read_text()}</content>
-    </resource>
-    """
-                for file_path in paths
-            ]
-        )
+        resources: list[dict[str, Any]] = []
+        for filename in files:
+            file_path = Path(filename)
+            resource = {
+                "path": str(file_path.relative_to(project.folder)),
+                "type": get_resource_type(file_path),
+                "name": file_path.stem,
+                "content": file_path.read_text(),
+            }
+            resources.append(resource)
+        resources_content = format_as_xml(resources, root_tag="resources", item_tag="resource")
     else:
         resources_content += "No resources found"
 
     fixture_content = "# Fixture files in the project:\n"
     if fixture_files:
-        paths = [Path(file_path) for file_path in fixture_files]
-        fixture_content += "\n".join(
-            [
-                f"""
-    <fixture>
-        <path>{file_path.relative_to(project.folder)}</path>
-        <name>{file_path.stem}</name>
-    </fixture>
-    """
-                for file_path in paths
-            ]
-        )
+        fixtures: list[dict[str, Any]] = []
+        for filename in fixture_files:
+            file_path = Path(filename)
+            fixture = {
+                "path": str(file_path.relative_to(project.folder)),
+                "name": file_path.stem,
+            }
+            fixtures.append(fixture)
+        fixture_content = format_as_xml(fixtures, root_tag="fixtures", item_tag="fixture")
+
     else:
         fixture_content += "No fixture files found"
 
@@ -384,3 +382,115 @@ SQL >
 5. **JOIN carefully** - Consider alternatives and optimize when necessary
 </endpoint_optimization_instructions>
 """
+
+
+sql_agent_instructions = """
+# SQL Best Practices Rules
+
+## Core Principles
+1. **The best data is the data you don't write** - Don't save unnecessary data
+2. **The second best data is the one you don't read** - Filter as early as possible
+3. **Sequential reads are much faster** - Use proper indexes and sorting keys
+4. **The less data you process after read, the better** - Select only needed columns
+5. **Perform complex operations later in the processing pipeline** - Filter before joins/aggregations
+
+## SQL Query Rules
+
+### 1. Filter Placement Rules
+- **ALWAYS** apply WHERE filters before ORDER BY clauses
+- **ALWAYS** apply WHERE filters before GROUP BY operations
+- **ALWAYS** filter data at the earliest possible point in the query
+- **NEVER** sort data before filtering it
+
+### 2. Column Selection Rules
+- **NEVER** use SELECT * in production queries
+- **ALWAYS** specify only the columns you need
+- **ALWAYS** minimize the number of columns retrieved to reduce memory usage
+
+### 3. Sorting and Index Rules
+- **ALWAYS** filter by ENGINE_SORTING_KEY columns first (typically date/time columns)
+- **ALWAYS** order filtering conditions from most to least selective
+- **ALWAYS** use columns in ENGINE_SORTING_KEY for WHERE clauses when possible
+- **NEVER** use functions on indexed columns in WHERE clauses (e.g., avoid DATE_FORMAT, EXTRACT)
+
+### 4. Join Optimization Rules
+- **ALWAYS** pre-filter data before JOIN operations
+- **NEVER** join tables with more than 1 million rows without filtering
+- **ALWAYS** filter the right-side table in joins using subqueries
+- **PREFERRED** pattern for large joins:
+  ```sql
+  -- Good: Pre-filter right table
+  FROM left_table AS left
+  INNER JOIN (
+    SELECT id, column FROM right_table 
+    WHERE id IN (SELECT id FROM left_table)
+  ) AS right ON left.id = right.id
+  ```
+
+### 5. Aggregation Rules
+- **NEVER** use nested aggregate functions (e.g., MAX(AVG(column)))
+- **ALWAYS** use subqueries instead of nested aggregates
+- **ALWAYS** filter data before GROUP BY operations
+- **ALWAYS** perform aggregations as late as possible in the query
+
+### 6. Complex Operations Order
+- **ALWAYS** follow this operation order:
+  1. Filter (WHERE)
+  2. Select only needed columns
+  3. Join (if necessary)
+  4. Group/Aggregate (if necessary)
+  5. Sort (ORDER BY)
+  6. Limit
+
+### 7. Aggregate Function Rules
+- **ALWAYS** use -Merge combinators (countMerge, avgMerge, etc.) when querying AggregateFunction columns
+- **ALWAYS** apply -Merge functions as late as possible in the pipeline
+- **NEVER** select AggregateFunction columns without the appropriate -Merge combinator
+
+### 8. Performance Rules
+- **AVOID** full table scans - always include WHERE clauses
+- **AVOID** reading more than 1GB of data in a single query
+- **AVOID** operations that load large datasets into memory
+- **MINIMIZE** the number of rows processed at each step
+
+### 9. Memory Optimization Rules
+- **REDUCE** column count when hitting memory limits
+- **AVOID** cross JOINs that generate excessive rows
+- **FILTER** before massive GROUP BY operations
+- **CHUNK** large populate operations (they run in 1M row chunks)
+
+### 10. Query Pattern Examples
+
+**BAD Pattern - Filtering after sorting:**
+```sql
+SELECT * FROM table ORDER BY date WHERE condition = true
+```
+
+**GOOD Pattern - Filtering before sorting:**
+```sql
+SELECT column1, column2 FROM table WHERE condition = true ORDER BY date
+```
+
+**BAD Pattern - Nested aggregates:**
+```sql
+SELECT MAX(AVG(amount)) FROM table
+```
+
+**GOOD Pattern - Using subquery:**
+```sql
+SELECT MAX(avg_amount) FROM (SELECT AVG(amount) as avg_amount FROM table)
+```
+
+**BAD Pattern - Unfiltered join:**
+```sql
+SELECT * FROM small_table JOIN huge_table ON small_table.id = huge_table.id
+```
+
+**GOOD Pattern - Pre-filtered join:**
+```sql
+SELECT needed_columns 
+FROM small_table 
+JOIN (SELECT id, col FROM huge_table WHERE id IN (SELECT id FROM small_table)) filtered 
+ON small_table.id = filtered.id
+```
+"""

{tinybird-0.0.1.dev254 → tinybird-0.0.1.dev255}/tinybird/tb/modules/agent/tools/append.py

@@ -41,10 +41,12 @@ def append_file(ctx: RunContext[TinybirdAgentContext], datasource_name: str, fix
         ctx.deps.thinking_animation.start()
         return f"Data appended to {datasource_name}"
     except Exception as e:
+        error_message = str(e)
         ctx.deps.thinking_animation.stop()
-        click.echo(FeedbackManager.error(message=e))
+        click.echo(FeedbackManager.error(message=error_message))
+        error_message = handle_quarantine_error(ctx, error_message, datasource_name)
         ctx.deps.thinking_animation.start()
-        return f"Error appending fixture {fixture_pathname} to {datasource_name}: {e}"
+        return f"Error appending fixture {fixture_pathname} to {datasource_name}: {error_message}"
 
 
 def append_url(ctx: RunContext[TinybirdAgentContext], datasource_name: str, fixture_url: str) -> str:
@@ -81,7 +83,28 @@ def append_url(ctx: RunContext[TinybirdAgentContext], datasource_name: str, fixt
         ctx.deps.thinking_animation.start()
         return f"Data appended to {datasource_name}"
     except Exception as e:
+        error_message = str(e)
         ctx.deps.thinking_animation.stop()
-        click.echo(FeedbackManager.error(message=e))
+        click.echo(FeedbackManager.error(message=error_message))
+        error_message = handle_quarantine_error(ctx, error_message, datasource_name)
         ctx.deps.thinking_animation.start()
-        return f"Error appending URL {fixture_url} to {datasource_name}: {e}"
+        return f"Error appending URL {fixture_url} to {datasource_name}: {error_message}"
+
+
+def handle_quarantine_error(ctx: RunContext[TinybirdAgentContext], error_message: str, datasource_name: str) -> str:
+    try:
+        if "in quarantine" in error_message:
+            click.echo(FeedbackManager.highlight(message=f"\n» 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)
+            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."
+            )
+
+    except Exception as quarantine_error:
+        error_message = error_message + f"\nError accessing to {datasource_name}_quarantine: {quarantine_error}"
+
+    return error_message

tinybird-0.0.1.dev255/tinybird/tb/modules/agent/tools/diff_resource.py

@@ -0,0 +1,51 @@
+from pathlib import Path
+
+import click
+from pydantic_ai import RunContext
+
+from tinybird.tb.modules.agent.utils import Datafile, TinybirdAgentContext
+from tinybird.tb.modules.feedback_manager import FeedbackManager
+
+
+def diff_resource(ctx: RunContext[TinybirdAgentContext], resource: Datafile) -> str:
+    """Diff the content of a resource in Tinybird Cloud vs Tinybird Local vs Project local file
+
+    Args:
+        resource (Datafile): The resource to diff. Required.
+
+    Returns:
+        Datafile: The diff of the resource.
+    """
+    try:
+        ctx.deps.thinking_animation.stop()
+        click.echo(
+            FeedbackManager.highlight(message=f"\n» Comparing content of {resource.pathname} with Tinybird Cloud")
+        )
+        resource.pathname = resource.pathname.removeprefix("/")
+        project_file_path = Path(ctx.deps.folder) / resource.pathname
+        if not project_file_path.exists():
+            raise Exception(f"Resource {resource.pathname} not found in project")
+
+        project_file_content = project_file_path.read_text()
+        if resource.type == "datasource":
+            cloud_content = ctx.deps.get_datasource_datafile_cloud(datasource_name=resource.name)
+            local_content = ctx.deps.get_datasource_datafile_local(datasource_name=resource.name)
+        elif resource.type == "connection":
+            cloud_content = ctx.deps.get_connection_datafile_cloud(connection_name=resource.name)
+            local_content = ctx.deps.get_connection_datafile_local(connection_name=resource.name)
+        elif resource.type in ["endpoint", "materialized", "sink", "copy"]:
+            cloud_content = ctx.deps.get_pipe_datafile_cloud(pipe_name=resource.name)
+            local_content = ctx.deps.get_pipe_datafile_local(pipe_name=resource.name)
+        else:
+            raise Exception(f"{resource.type} is not a valid extension")
+
+        needs_to_build = project_file_content != local_content
+        needs_to_deploy = project_file_content != cloud_content
+        ctx.deps.thinking_animation.start()
+        diff = f"# Diff of resource {resource.name}:\n"
+        diff += f"## Tinybird Cloud: {'Deploy needed. Resource does not exist or needs to be updated. Run `deploy` tool to deploy the resource.' if needs_to_deploy else 'Nothing to deploy.'}\n"
+        diff += f"## Tinybird Local: {'Build needed. Resource does not exist or needs to be updated. Run `build` tool to build the resource.' if needs_to_build else 'Nothing to build.'}\n"
+        return diff
+    except Exception as e:
+        ctx.deps.thinking_animation.start()
+        return f"Could not diff resource {resource.pathname}: {e}"

{tinybird-0.0.1.dev254 → tinybird-0.0.1.dev255}/tinybird/tb/modules/agent/tools/execute_query.py

@@ -3,7 +3,7 @@ import humanfriendly
 from pydantic_ai import RunContext
 
 from tinybird.tb.modules.agent.utils import TinybirdAgentContext
-from tinybird.tb.modules.common import echo_safe_humanfriendly_tables_format_smart_table
+from tinybird.tb.modules.common import echo_safe_humanfriendly_tables_format_pretty_table
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
 
@@ -32,7 +32,7 @@ def execute_query(ctx: RunContext[TinybirdAgentContext], query: str, task: str,
         else:
             query = f"SELECT * FROM ({query}) {query_format}"
 
-        execute_query = ctx.deps.execute_cloud_query if cloud else ctx.deps.execute_local_query
+        execute_query = ctx.deps.execute_query_cloud if cloud else ctx.deps.execute_query_local
         result = execute_query(query=query)
         stats = result["statistics"]
         seconds = stats["elapsed"]
@@ -44,9 +44,10 @@ def execute_query(ctx: RunContext[TinybirdAgentContext], query: str, task: str,
         if not result["data"]:
             click.echo(FeedbackManager.info_no_rows())
         else:
-            echo_safe_humanfriendly_tables_format_smart_table(
-                data=[d.values() for d in result["data"]], column_names=result["data"][0].keys()
+            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")
         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."

{tinybird-0.0.1.dev254 → tinybird-0.0.1.dev255}/tinybird/tb/modules/agent/tools/get_endpoint_stats.py

@@ -42,7 +42,7 @@ def get_endpoint_stats(
     FORMAT JSON
     """
 
-    execute_query = ctx.deps.execute_cloud_query if cloud else ctx.deps.execute_local_query
+    execute_query = ctx.deps.execute_query_cloud if cloud else ctx.deps.execute_query_local
 
     result = execute_query(query=query)
     click.echo(FeedbackManager.success(message="✓ Done!"))

{tinybird-0.0.1.dev254 → tinybird-0.0.1.dev255}/tinybird/tb/modules/agent/tools/mock.py

@@ -60,7 +60,7 @@ def mock(
                     FeedbackManager.highlight(message=f"\n» 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_local_query(query=query)
+                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."

{tinybird-0.0.1.dev254 → tinybird-0.0.1.dev255}/tinybird/tb/modules/agent/tools/preview_datafile.py

@@ -16,7 +16,7 @@ def preview_datafile(name: str, type: str, description: str, content: str, pathn
     """
 
     return Datafile(
-        type=type,
+        type=type.lower(),
         name=name,
         content=content,
         description=description,

{tinybird-0.0.1.dev254 → tinybird-0.0.1.dev255}/tinybird/tb/modules/agent/tools/request_endpoint.py

@@ -5,7 +5,7 @@ import humanfriendly
 from pydantic_ai import RunContext
 
 from tinybird.tb.modules.agent.utils import TinybirdAgentContext
-from tinybird.tb.modules.common import echo_safe_humanfriendly_tables_format_smart_table
+from tinybird.tb.modules.common import echo_safe_humanfriendly_tables_format_pretty_table
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
 
@@ -48,10 +48,10 @@ def request_endpoint(
         if not result["data"]:
             click.echo(FeedbackManager.info_no_rows())
         else:
-            echo_safe_humanfriendly_tables_format_smart_table(
-                data=[d.values() for d in result["data"][:5]], column_names=result["data"][0].keys()
+            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 5 results\n")
+            click.echo("Showing first 10 results\n")
         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."
     except Exception as e:

{tinybird-0.0.1.dev254 → tinybird-0.0.1.dev255}/tinybird/tb/modules/agent/utils.py

@@ -41,10 +41,16 @@ class TinybirdAgentContext(BaseModel):
     mock_data: Callable[..., list[dict[str, Any]]]
     append_data: Callable[..., None]
     analyze_fixture: Callable[..., dict[str, Any]]
-    execute_cloud_query: Callable[..., dict[str, Any]]
-    execute_local_query: Callable[..., dict[str, Any]]
+    execute_query_cloud: Callable[..., dict[str, Any]]
+    execute_query_local: Callable[..., dict[str, Any]]
     request_endpoint_cloud: Callable[..., dict[str, Any]]
     request_endpoint_local: Callable[..., dict[str, Any]]
+    get_datasource_datafile_cloud: Callable[..., str]
+    get_datasource_datafile_local: Callable[..., str]
+    get_pipe_datafile_cloud: Callable[..., str]
+    get_pipe_datafile_local: Callable[..., str]
+    get_connection_datafile_cloud: Callable[..., str]
+    get_connection_datafile_local: Callable[..., str]
     dangerously_skip_permissions: bool
     token: str
     user_token: str

{tinybird-0.0.1.dev254 → tinybird-0.0.1.dev255}/tinybird/tb/modules/common.py

@@ -124,6 +124,23 @@ def echo_safe_humanfriendly_tables_format_smart_table(data: Iterable[Any], colum
             raise exc
 
 
+def echo_safe_humanfriendly_tables_format_pretty_table(data: Iterable[Any], column_names: List[str]) -> None:
+    """
+    There is a bug in the humanfriendly library: it breaks to render the small table for small terminals
+    (`format_robust_table`) if we call format_smart_table with an empty dataset. This catches the error and prints
+    what we would call an empty "robust_table".
+    """
+    try:
+        click.echo(humanfriendly.tables.format_pretty_table(data, column_names=column_names))
+    except ValueError as exc:
+        if str(exc) == "max() arg is an empty sequence":
+            click.echo("------------")
+            click.echo("Empty")
+            click.echo("------------")
+        else:
+            raise exc
+
+
 def echo_safe_format_table(data: Iterable[Any], columns) -> None:
     """
     There is a bug in the humanfriendly library: it breaks to render the small table for small terminals

{tinybird-0.0.1.dev254 → tinybird-0.0.1.dev255}/tinybird.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tinybird
-Version: 0.0.1.dev254
+Version: 0.0.1.dev255
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/forward/commands
 Author: Tinybird

{tinybird-0.0.1.dev254 → tinybird-0.0.1.dev255}/tinybird.egg-info/SOURCES.txt

@@ -93,6 +93,7 @@ tinybird/tb/modules/agent/tools/build.py
 tinybird/tb/modules/agent/tools/create_datafile.py
 tinybird/tb/modules/agent/tools/deploy.py
 tinybird/tb/modules/agent/tools/deploy_check.py
+tinybird/tb/modules/agent/tools/diff_resource.py
 tinybird/tb/modules/agent/tools/execute_query.py
 tinybird/tb/modules/agent/tools/explore.py
 tinybird/tb/modules/agent/tools/get_endpoint_stats.py