tinybird 0.0.1.dev254__tar.gz → 0.0.1.dev256__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tinybird
-Version: 0.0.1.dev254
+Version: 0.0.1.dev256
 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.dev256}/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.dev256}/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.dev256'
+__revision__ = '78e1011'

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

@@ -26,13 +26,14 @@ from tinybird.prompts import (
 from tinybird.tb.client import TinyB
 from tinybird.tb.modules.agent.animations import ThinkingAnimation
 from tinybird.tb.modules.agent.banner import display_banner
-from tinybird.tb.modules.agent.memory import clear_history
+from tinybird.tb.modules.agent.memory import clear_history, clear_messages, load_messages, save_messages
 from tinybird.tb.modules.agent.models import create_model, model_costs
 from tinybird.tb.modules.agent.prompts import (
     datafile_instructions,
     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
@@ -53,7 +55,7 @@ from tinybird.tb.modules.build_common import process as build_process
 from tinybird.tb.modules.common import _analyze, _get_tb_client
 from tinybird.tb.modules.config import CLIConfig
 from tinybird.tb.modules.deployment_common import create_deployment
-from tinybird.tb.modules.exceptions import CLIBuildException, CLIMockException
+from tinybird.tb.modules.exceptions import CLIBuildException, CLIDeploymentException, CLIMockException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 from tinybird.tb.modules.local_common import get_tinybird_local_client
 from tinybird.tb.modules.login_common import login
@@ -76,7 +78,8 @@ class TinybirdAgent:
         self.host = host
         self.dangerously_skip_permissions = dangerously_skip_permissions
         self.project = project
-        self.messages: list[ModelMessage] = []
+        # we load the last 5 messages to manage token usage
+        self.messages: list[ModelMessage] = load_messages()[-5:]
         self.agent = Agent(
             model=create_model(user_token, host, workspace_id),
             deps_type=TinybirdAgentContext,
@@ -121,6 +124,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 +176,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 +187,23 @@ Kafka: {kafka_connection_example}
 S3: {s3_connection_example}
 GCS: {gcs_connection_example}
 
+# When executing a query or requesting/testing 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.
+
+# 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
+- Use append if user explicitly asks for it
+- Do not append data if user requests to test an endpoint
+
+# How to use `mock` tool:
+- Use `mock` tool as part of the creation of a new landing datasource if the user did not provided a file or an external url
+- Use `mock` tool if user explicitly asks for it
+- Do not use `mock` tool if user requests to test an endpoint.
+
 # Info
 Today is {datetime.now().strftime("%Y-%m-%d")}
 """,
@@ -208,6 +230,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 +256,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,
@@ -250,6 +279,7 @@ Today is {datetime.now().strftime("%Y-%m-%d")}
         )
         new_messages = result.new_messages()
         self.messages.extend(new_messages)
+        save_messages(new_messages)
         thinking_animation.stop()
         usage = result.usage()
         request_tokens = usage.request_tokens or 0
@@ -293,9 +323,12 @@ def run_agent(
                 login(host, auth_host="https://cloud.tinybird.co", workspace=None, interactive=False, method="browser")
                 click.echo()
                 cli_config = CLIConfig.get_project_config()
+                config = {**config, **cli_config.to_dict()}
                 token = cli_config.get_token()
                 user_token = cli_config.get_user_token()
                 host = cli_config.get_host()
+                workspace_id = cli_config.get("id", "")
+                workspace_name = cli_config.get("name", "")
 
             if not token or not host or not user_token:
                 click.echo(
@@ -339,6 +372,7 @@ def run_agent(
                     break
                 elif user_input.lower() == "/clear":
                     clear_history()
+                    clear_messages()
                     continue
                 elif user_input.lower() == "/login":
                     click.echo()
@@ -381,26 +415,25 @@ def build_project(config: dict[str, Any], project: Project, silent: bool = True,
 
 def deploy_project(config: dict[str, Any], project: Project) -> None:
     client = _get_tb_client(config["token"], config["host"])
-    create_deployment(
-        project=project,
-        client=client,
-        config=config,
-        wait=True,
-        auto=True,
-        allow_destructive_operations=False,
-    )
+    try:
+        create_deployment(
+            project=project,
+            client=client,
+            config=config,
+            wait=True,
+            auto=True,
+            allow_destructive_operations=False,
+        )
+    except SystemExit as e:
+        raise CLIDeploymentException(e.args[0])
 
 
 def deploy_check_project(config: dict[str, Any], project: Project) -> None:
     client = _get_tb_client(config["token"], config["host"])
-    create_deployment(
-        project=project,
-        client=client,
-        config=config,
-        check=True,
-        wait=True,
-        auto=True,
-    )
+    try:
+        create_deployment(project=project, client=client, config=config, check=True, wait=True, auto=True)
+    except SystemExit as e:
+        raise CLIDeploymentException(e.args[0])
 
 
 def append_data(config: dict[str, Any], datasource_name: str, path: str) -> None:
@@ -444,12 +477,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 +499,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.dev256/tinybird/tb/modules/agent/memory.py

@@ -0,0 +1,103 @@
+import json
+from pathlib import Path
+from typing import Optional
+
+import click
+from prompt_toolkit.history import FileHistory
+from pydantic_ai.messages import ModelMessage, ModelMessagesTypeAdapter
+from pydantic_core import to_jsonable_python
+
+from tinybird.tb.modules.feedback_manager import FeedbackManager
+
+
+def get_history_file_path():
+    """Get the history file path based on current working directory"""
+    # Get current working directory
+    cwd = Path.cwd()
+
+    # Get user's home directory
+    home = Path.home()
+
+    # Calculate relative path from home to current directory
+    try:
+        relative_path = cwd.relative_to(home)
+    except ValueError:
+        # If current directory is not under home, use absolute path components
+        relative_path = Path(*cwd.parts[1:]) if cwd.is_absolute() else cwd
+
+    # Create history directory structure
+    history_dir = home / ".tinybird" / "projects" / relative_path
+    history_dir.mkdir(parents=True, exist_ok=True)
+
+    # Return history file path
+    return history_dir / "history.txt"
+
+
+def load_history() -> Optional[FileHistory]:
+    try:
+        history_file = get_history_file_path()
+        return FileHistory(str(history_file))
+    except Exception:
+        return None
+
+
+def clear_history():
+    """Clear the history file"""
+    history_file = get_history_file_path()
+    history_file.unlink(missing_ok=True)
+
+
+def clear_messages():
+    """Clear the messages file"""
+    messages_file = get_messages_file_path()
+    messages_file.unlink(missing_ok=True)
+
+
+def get_messages_file_path():
+    """Get the history file path based on current working directory"""
+    # Get current working directory
+    cwd = Path.cwd()
+
+    # Get user's home directory
+    home = Path.home()
+
+    # Calculate relative path from home to current directory
+    try:
+        relative_path = cwd.relative_to(home)
+    except ValueError:
+        # If current directory is not under home, use absolute path components
+        relative_path = Path(*cwd.parts[1:]) if cwd.is_absolute() else cwd
+
+    # Create history directory structure
+    history_dir = home / ".tinybird" / "projects" / relative_path
+    history_dir.mkdir(parents=True, exist_ok=True)
+
+    # Return history file path
+    return history_dir / "messages.json"
+
+
+def load_messages() -> list[ModelMessage]:
+    try:
+        messages_file = get_messages_file_path()
+        messages_file.touch()
+        if not messages_file.exists():
+            messages_file.touch(exist_ok=True)
+            messages_file.write_text("[]")
+            return []
+        with open(messages_file, "r") as f:
+            messages_json = json.loads(f.read() or "[]")
+            return ModelMessagesTypeAdapter.validate_python(messages_json)
+    except Exception as e:
+        click.echo(FeedbackManager.error(message=f"Could not load previous messages: {e}"))
+        messages_file.unlink(missing_ok=True)
+        return []
+
+
+def save_messages(new_messages: list[ModelMessage]):
+    messages_file = get_messages_file_path()
+    messages_file.touch(exist_ok=True)
+    messages = load_messages()
+    messages.extend(new_messages)
+    messages_json = to_jsonable_python(messages)
+    with open(messages_file, "w") as f:
+        f.write(json.dumps(messages_json))

{tinybird-0.0.1.dev254 → tinybird-0.0.1.dev256}/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.dev256}/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.dev254 → tinybird-0.0.1.dev256}/tinybird/tb/modules/agent/tools/deploy.py

@@ -30,7 +30,5 @@ def deploy(ctx: RunContext[TinybirdAgentContext]) -> str:
         ctx.deps.thinking_animation.start()
         return "Project deployed successfully"
     except Exception as e:
-        ctx.deps.thinking_animation.stop()
-        click.echo(FeedbackManager.error(message=e))
         ctx.deps.thinking_animation.start()
         return f"Error depoying project: {e}"

{tinybird-0.0.1.dev254 → tinybird-0.0.1.dev256}/tinybird/tb/modules/agent/tools/deploy_check.py

@@ -2,7 +2,6 @@ import click
 from pydantic_ai import RunContext
 
 from tinybird.tb.modules.agent.utils import TinybirdAgentContext, show_confirmation, show_input
-from tinybird.tb.modules.feedback_manager import FeedbackManager
 
 
 def deploy_check(ctx: RunContext[TinybirdAgentContext]) -> str:
@@ -28,7 +27,5 @@ def deploy_check(ctx: RunContext[TinybirdAgentContext]) -> str:
         ctx.deps.thinking_animation.start()
         return "Project can be deployed"
     except Exception as e:
-        ctx.deps.thinking_animation.stop()
-        click.echo(FeedbackManager.error(message=e))
         ctx.deps.thinking_animation.start()
         return f"Project cannot be deployed: {e}"