tinybird 0.0.1.dev239__tar.gz → 0.0.1.dev240__tar.gz

{tinybird-0.0.1.dev239 → tinybird-0.0.1.dev240}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tinybird
-Version: 0.0.1.dev239
+Version: 0.0.1.dev240
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/forward/commands
 Author: Tinybird
@@ -8,7 +8,7 @@ Author-email: support@tinybird.co
 Requires-Python: >=3.9, <3.14
 Description-Content-Type: text/x-rst
 Requires-Dist: aiofiles==24.1.0
-Requires-Dist: anthropic==0.42.0
+Requires-Dist: anthropic==0.55.0
 Requires-Dist: boto3
 Requires-Dist: click<8.2,>=8.1.6
 Requires-Dist: clickhouse-toolset==0.34.dev0
@@ -20,7 +20,8 @@ Requires-Dist: docker==7.1.0
 Requires-Dist: GitPython~=3.1.32
 Requires-Dist: humanfriendly~=8.2
 Requires-Dist: prompt_toolkit==3.0.48
-Requires-Dist: pydantic~=2.8.0
+Requires-Dist: pydantic~=2.11.7
+Requires-Dist: pydantic-ai-slim[anthropic]~=0.3.1
 Requires-Dist: pyperclip==1.8.2
 Requires-Dist: pyyaml<6.1,>=6.0
 Requires-Dist: requests<3,>=2.28.1

{tinybird-0.0.1.dev239 → tinybird-0.0.1.dev240}/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.dev239'
-__revision__ = '960f37b'
+__version__ = '0.0.1.dev240'
+__revision__ = '268407c'

tinybird-0.0.1.dev240/tinybird/tb/modules/agent/__init__.py

@@ -0,0 +1,3 @@
+from .agent import run_agent
+
+__all__ = ["run_agent"]

tinybird-0.0.1.dev240/tinybird/tb/modules/agent/agent.py

@@ -0,0 +1,212 @@
+import sys
+from datetime import datetime
+
+import click
+from prompt_toolkit import prompt
+from prompt_toolkit.cursor_shapes import CursorShape
+from prompt_toolkit.styles import Style
+from pydantic_ai import Agent, Tool
+from pydantic_ai.messages import ModelMessage
+
+from tinybird.prompts import (
+    connection_instructions,
+    copy_pipe_instructions,
+    datasource_example,
+    datasource_instructions,
+    gcs_connection_example,
+    kafka_connection_example,
+    materialized_pipe_instructions,
+    pipe_example,
+    pipe_instructions,
+    s3_connection_example,
+    sink_pipe_instructions,
+)
+from tinybird.tb.modules.agent.banner import display_banner
+from tinybird.tb.modules.agent.client import TinybirdClient
+from tinybird.tb.modules.agent.memory import clear_history, load_history
+from tinybird.tb.modules.agent.models import create_model
+from tinybird.tb.modules.agent.prompts import datafile_instructions, plan_instructions, sql_instructions
+from tinybird.tb.modules.agent.tools.create_datafile import create_datafile
+from tinybird.tb.modules.agent.tools.explore import explore_data
+from tinybird.tb.modules.agent.tools.plan import plan
+from tinybird.tb.modules.agent.tools.preview_datafile import preview_datafile
+from tinybird.tb.modules.agent.utils import TinybirdAgentContext
+from tinybird.tb.modules.feedback_manager import FeedbackManager
+
+
+class TinybirdAgent:
+    def __init__(self, token: str, host: str, folder: str):
+        self.token = token
+        self.host = host
+        self.folder = folder
+        self.messages: list[ModelMessage] = []
+        self.agent = Agent(
+            model=create_model(token, host),
+            deps_type=TinybirdAgentContext,
+            system_prompt=f"""
+You are a Tinybird Code, an agentic CLI that can help users to work with Tinybird.
+
+You are an interactive CLI tool that helps users with data engineering tasks. Use the instructions below and the tools available to you to assist the user.
+
+# Tone and style
+You should be concise, direct, and to the point. 
+Remember that your output will be displayed on a command line interface. Your responses can use Github-flavored markdown for formatting.
+Output text to communicate with the user; all text you output outside of tool use is displayed to the user. Only use tools to complete tasks. Never use tools like Bash or code comments as means to communicate with the user during the session.
+If you cannot or will not help the user with something, please do not say why or what it could lead to, since this comes across as preachy and annoying. Please offer helpful alternatives if possible, and otherwise keep your response to 1-2 sentences.
+IMPORTANT: You should minimize output tokens as much as possible while maintaining helpfulness, quality, and accuracy. Only address the specific query or task at hand, avoiding tangential information unless absolutely critical for completing the request. If you can answer in 1-3 sentences or a short paragraph, please do.
+IMPORTANT: You should NOT answer with unnecessary preamble or postamble (such as explaining your code or summarizing your action), unless the user asks you to.
+IMPORTANT: Keep your responses short, since they will be displayed on a command line interface. You MUST answer concisely with fewer than 4 lines (not including tool use or code generation), unless user asks for detail. Answer the user's question directly, without elaboration, explanation, or details. One word answers are best. Avoid introductions, conclusions, and explanations. You MUST avoid text before/after your response, such as "The answer is <answer>.", "Here is the content of the file..." or "Based on the information provided, the answer is..." or "Here is what I will do next...". Here are some examples to demonstrate appropriate verbosity:
+
+# Proactiveness
+You are allowed to be proactive, but only when the user asks you to do something. You should strive to strike a balance between:
+Doing the right thing when asked, including taking actions and follow-up actions
+Not surprising the user with actions you take without asking
+For example, if the user asks you how to approach something, you should do your best to answer their question first, and not immediately jump into taking actions.
+Do not add additional code explanation summary unless requested by the user. After working on a file, just stop, rather than providing an explanation of what you did.
+
+# Code style
+IMPORTANT: DO NOT ADD ANY COMMENTS unless asked by the user.
+
+# Tools
+You have access to the following tools:
+1. `explore_data` - Explore data in the current workspace
+2. `preview_datafile` - Preview the content of a datafile (datasource, endpoint, materialized, sink, copy, connection).
+3. `create_datafile` - Create a file in the project folder. Confirmation will be asked by the tool before creating the file.
+4. `plan` - Plan the creation or update of resources.
+
+
+# When creating or updating datafiles:
+1. Use `plan` tool to plan the creation or update 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 successfully, finish the process and just wait for a new user prompt.
+
+IMPORTANT: If the user cancels some of the steps or there is an error, DO NOT continue with the plan. Stop the process and wait for the user before using any other tool.
+
+# When planning the creation or update of resources:
+{plan_instructions}
+{datafile_instructions}
+
+# Working with datasource files:
+{datasource_instructions}
+{datasource_example}
+
+# Working with any type of pipe file:
+{pipe_instructions}
+{pipe_example}
+
+# Working with materialized pipe files:
+{materialized_pipe_instructions}
+
+# Working with sink pipe files:
+{sink_pipe_instructions}
+
+# Working with copy pipe files:
+{copy_pipe_instructions}
+
+# Working with SQL queries:
+{sql_instructions}
+
+# Working with connections files:
+{connection_instructions}
+
+# Connection examples:
+Kafka: {kafka_connection_example}
+S3: {s3_connection_example}
+GCS: {gcs_connection_example}
+
+# Info
+Today is {datetime.now().strftime("%Y-%m-%d")}
+""",
+            tools=[
+                Tool(explore_data, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
+                Tool(preview_datafile, docstring_format="google", require_parameter_descriptions=True, takes_ctx=False),
+                Tool(create_datafile, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
+                Tool(plan, docstring_format="google", require_parameter_descriptions=True, takes_ctx=False),
+            ],
+        )
+
+    def _keep_recent_messages(self) -> list[ModelMessage]:
+        """Keep only the last 5 messages to manage token usage."""
+        return self.messages[-5:] if len(self.messages) > 5 else self.messages
+
+    def run(self, user_prompt: str) -> None:
+        result = self.agent.run_sync(
+            user_prompt,
+            deps=TinybirdAgentContext(
+                client=TinybirdClient(token=self.token, host=self.host),
+                folder=self.folder,
+            ),
+            message_history=self.messages,
+        )
+        new_messages = result.new_messages()
+        self.messages.extend(new_messages)
+        click.echo("\n")
+        click.echo(result.output)
+        click.echo("\n")
+
+
+def run_agent(token: str, host: str, folder: str):
+    display_banner()
+
+    try:
+        agent = TinybirdAgent(token, host, folder)
+        click.echo()
+        click.echo(FeedbackManager.success(message="Welcome to Tinybird Code"))
+        click.echo(FeedbackManager.info(message="Describe what you want to create and I'll help you build it"))
+        click.echo(FeedbackManager.info(message="Commands: 'exit', 'quit', 'help', or Ctrl+C to exit"))
+        click.echo()
+
+    except Exception as e:
+        click.echo(FeedbackManager.error(message=f"Failed to initialize agent: {e}"))
+        return
+
+    # Interactive loop
+    try:
+        while True:
+            try:
+                user_input = prompt(
+                    [("class:prompt", "tb » ")],
+                    history=load_history(),
+                    cursor=CursorShape.BLOCK,
+                    style=Style.from_dict(
+                        {
+                            "prompt": "#40a8a8 bold",
+                            "": "",  # Normal color for user input
+                        }
+                    ),
+                )
+
+                if user_input.lower() in ["exit", "quit"]:
+                    click.echo(FeedbackManager.info(message="Goodbye!"))
+                    break
+                elif user_input.lower() == "clear":
+                    clear_history()
+                    continue
+                elif user_input.lower() == "help":
+                    click.echo()
+                    click.echo(FeedbackManager.info(message="Tinybird Code Help:"))
+                    click.echo("• Describe what you want to create: 'Create a user analytics system'")
+                    click.echo("• Ask for specific resources: 'Create a pipe to aggregate daily clicks'")
+                    click.echo("• Request data sources: 'Set up a Kafka connection for events'")
+                    click.echo("• Type 'exit' or 'quit' to leave")
+                    click.echo()
+                    continue
+                elif user_input.strip() == "":
+                    continue
+                else:
+                    agent.run(user_input)
+
+            except KeyboardInterrupt:
+                click.echo(FeedbackManager.info(message="Goodbye!"))
+                break
+            except EOFError:
+                click.echo(FeedbackManager.info(message="Goodbye!"))
+                break
+
+    except Exception as e:
+        click.echo(FeedbackManager.error(message=f"Error: {e}"))
+        sys.exit(1)

tinybird-0.0.1.dev240/tinybird/tb/modules/agent/banner.py

@@ -0,0 +1,55 @@
+import click
+
+
+def display_banner():
+    reset = "\033[0m"
+
+    click.echo("\n")
+    # The Tinybird Code ASCII art banner
+    banner = [
+        "  ████████╗██╗███╗   ██╗██╗   ██╗██████╗ ██╗██████╗ ██████╗     ██████╗ ██████╗ ██████╗ ███████╗",
+        "  ╚══██╔══╝██║████╗  ██║╚██╗ ██╔╝██╔══██╗██║██╔══██╗██╔══██╗   ██╔════╝██╔═══██╗██╔══██╗██╔════╝",
+        "     ██║   ██║██╔██╗ ██║ ╚████╔╝ ██████╔╝██║██████╔╝██║  ██║   ██║     ██║   ██║██║  ██║█████╗  ",
+        "     ██║   ██║██║╚██╗██║  ╚██╔╝  ██╔══██╗██║██╔══██╗██║  ██║   ██║     ██║   ██║██║  ██║██╔══╝  ",
+        "     ██║   ██║██║ ╚████║   ██║   ██████╔╝██║██║  ██║██████╔╝   ╚██████╗╚██████╔╝██████╔╝███████╗",
+        "     ╚═╝   ╚═╝╚═╝  ╚═══╝   ╚═╝   ╚═════╝ ╚═╝╚═╝  ╚═╝╚═════╝     ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝",
+    ]
+
+    def interpolate_color(start_rgb, end_rgb, factor):
+        """Interpolate between two RGB colors"""
+        return [int(start_rgb[i] + (end_rgb[i] - start_rgb[i]) * factor) for i in range(3)]
+
+    def rgb_to_ansi(r, g, b):
+        """Convert RGB values to ANSI escape code"""
+        return f"\033[38;2;{r};{g};{b}m"
+
+    # Define start and end colors for smooth gradient
+    start_color = [0, 128, 128]  # Deep teal
+    end_color = [100, 200, 180]  # Light turquoise
+
+    # Print each line with a very smooth horizontal gradient
+    for line in banner:
+        colored_line = ""
+        # Count non-space characters for gradient calculation
+        non_space_chars = sum(1 for char in line if char != " ")
+        char_count = 0
+
+        for char in line:
+            if char == " ":
+                colored_line += char
+                continue
+
+            # Calculate smooth gradient position (0.0 to 1.0)
+            if non_space_chars > 1:
+                gradient_position = char_count / (non_space_chars - 1)
+            else:
+                gradient_position = 0
+
+            # Interpolate color
+            current_rgb = interpolate_color(start_color, end_color, gradient_position)
+            color_code = rgb_to_ansi(*current_rgb)
+
+            colored_line += f"{color_code}{char}"
+            char_count += 1
+
+        click.echo(colored_line + reset)

tinybird-0.0.1.dev240/tinybird/tb/modules/agent/client.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+import httpx
+
+
+@dataclass
+class TinybirdClient:
+    def __init__(self, host: str, token: str):
+        self.host = host
+        self.token = token
+        self.client = httpx.Client(
+            timeout=30.0,
+            headers={"Accept": "application/json", "User-Agent": "Python/APIClient"},
+        )
+        self.insights: list[str] = []
+
+    def __aenter__(self):
+        return self
+
+    def __aexit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def close(self):
+        """Close the underlying HTTP client."""
+        self.client.close()
+
+    def _get(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> str:
+        if params is None:
+            params = {}
+        params["token"] = self.token
+        url = f"{self.host}{endpoint}"
+        response = self.client.get(url, params=params)
+        try:
+            response.raise_for_status()
+        except Exception as e:
+            raise Exception(response.json().get("error", str(e))) from e
+        return response.text
+
+    def explore_data(self, prompt: str) -> str:
+        params = {"prompt": prompt, "host": self.host, "origin": "cli"}
+        return self._get("/v1/agents/explore", params)

tinybird-0.0.1.dev240/tinybird/tb/modules/agent/memory.py

@@ -0,0 +1,41 @@
+from pathlib import Path
+from typing import Optional
+
+from prompt_toolkit.history import FileHistory
+
+
+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)

tinybird-0.0.1.dev240/tinybird/tb/modules/agent/models.py

@@ -0,0 +1,20 @@
+from anthropic import AsyncAnthropic
+from httpx import AsyncClient
+from pydantic_ai.models.anthropic import AnthropicModel, AnthropicModelName
+from pydantic_ai.providers.anthropic import AnthropicProvider
+
+
+def create_model(
+    token: str,
+    base_url: str = "https://api.wadus3.aws.tinybird.co",
+    model: AnthropicModelName = "claude-4-sonnet-20250514",
+):
+    client = AsyncAnthropic(
+        base_url=base_url,
+        http_client=AsyncClient(params={"token": token}),
+        auth_token=token,
+    )
+    return AnthropicModel(
+        model_name=model,
+        provider=AnthropicProvider(anthropic_client=client),
+    )

tinybird-0.0.1.dev240/tinybird/tb/modules/agent/prompts.py

@@ -0,0 +1,83 @@
+plan_instructions = """
+When asked to create a plan, you MUST respond with this EXACT format and NOTHING ELSE:
+
+PLAN_DESCRIPTION: [One sentence describing what will be built]
+
+STEPS:
+1. CREATE_DATASOURCE: [name] - [description] - DEPENDS_ON: none
+2. CREATE_ENDPOINT: [name] - [description] - DEPENDS_ON: [resource_name]
+3. CREATE_MATERIALIZED_PIPE: [name] - [description] - DEPENDS_ON: [resource_name]
+4. CREATE_MATERIALIZED_DATASOURCE: [name] - [description] - DEPENDS_ON: [resource_name]
+5. CREATE_SINK: [name] - [description] - DEPENDS_ON: [resource_name]
+6. CREATE_COPY: [name] - [description] - DEPENDS_ON: [resource_name]
+7. CREATE_CONNECTION: [name] - [description] - DEPENDS_ON: none
+
+You can skip steps where resources will not be created or updated.
+
+ESTIMATED_RESOURCES: [total number of steps]
+
+RESOURCE_DEPENDENCIES:
+[resource_name]: [resource_name]
+"""
+
+
+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).
+    - 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")}}
+    </invalid_query_with_parameters_no_%_on_top>
+    <valid_query_with_parameters_with_%_on_top>
+    %
+    SELECT * FROM events WHERE session_id={{String(my_param, "default_value")}}
+    </valid_query_with_parameters_with_%_on_top>
+    - The Parameter functions like this one {{String(my_param_name,default_value)}} can be one of the following: String, DateTime, Date, Float32, Float64, Int, Integer, UInt8, UInt16, UInt32, UInt64, UInt128, UInt256, Int8, Int16, Int32, Int64, Int128, Int256
+    - Parameter names must be different from column names. Pass always the param name and a default value to the function.
+    - Use ALWAYS hardcoded values for default values for parameters.
+    - Code inside the template {{template_expression}} follows the rules of Tornado templating language so no module is allowed to be imported. So for example you can't use now() as default value for a DateTime parameter. You need an if else block like this:
+    <invalid_condition_with_now>
+    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)%}}
+    timestamp BETWEEN now() - interval 30 day
+    {{%else%}}
+    timestamp BETWEEN {{DateTime(start_date)}}
+    {{%end%}}
+    {{%if not defined(end_date)%}}
+    AND now()
+    {{%else%}}
+    AND {{DateTime(end_date)}}
+    {{%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>
+    - 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.
+    - 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.
+    - Use ONLY SELECT statements in the SQL section.
+    - INSERT INTO is not supported in SQL section.
+    - 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')}})
+    - Use the following syntax in the SQL section for the postgres table function: postgresql('host:port', 'database', 'table', {{tb_secret('db_username')}}, {{tb_secret('db_password')}}), 'schema')
+</sql_instructions>
+"""
+
+datafile_instructions = """
+<datafile_instructions>
+- Endpoint files will be created under the `/endpoints` folder.
+- Materialized pipe files will be created under the `/materialized` folder.
+- Sink pipe files will be created under the `/sinks` folder.
+- Copy pipe files will be created under the `/copies` folder.
+- Connection files will be created under the `/connections` folder.
+- Datasource files will be created under the `/datasources` folder.
+</datafile_instructions>
+"""

tinybird-0.0.1.dev240/tinybird/tb/modules/agent/tools/create_datafile.py

@@ -0,0 +1,62 @@
+from pathlib import Path
+
+import click
+from pydantic_ai import RunContext
+
+from tinybird.tb.modules.agent.utils import Datafile, TinybirdAgentContext, show_options
+
+
+def get_resource_confirmation(resource: Datafile) -> bool:
+    """Get user confirmation for creating a resource"""
+    while True:
+        result = show_options(
+            options=[f"Yes, create {resource.type} '{resource.name}'", "No, and tell Tinybird Code what to do"],
+            title=f"What would you like to do with {resource.type} '{resource.name}'?",
+        )
+
+        if result is None:  # Cancelled
+            return False
+
+        if result.startswith("Yes"):
+            return True
+        elif result.startswith("No"):
+            return False
+
+        return False
+
+
+def create_datafile(ctx: RunContext[TinybirdAgentContext], resource: Datafile) -> str:
+    """Given a resource representation, create a file in the project folder
+
+    Args:
+        resource (Datafile): The resource to create. Required.
+
+    Returns:
+        str: If the resource was created or not.
+    """
+    try:
+        click.echo()
+        click.echo(resource.content)
+        confirmation = get_resource_confirmation(resource)
+
+        if not confirmation:
+            return f"Resource {resource.pathname} was not created. User cancelled creation."
+
+        resource.pathname = resource.pathname.removeprefix("/")
+
+        path = Path(ctx.deps.folder) / resource.pathname
+
+        folder_path = path.parent
+
+        if not folder_path.exists():
+            folder_path.mkdir()
+
+        if not path.exists():
+            path.touch()
+
+        path.write_text(resource.content)
+
+        return f"Created {resource.pathname}"
+
+    except Exception as e:
+        return f"Error creating {resource.pathname}: {e}"

tinybird-0.0.1.dev240/tinybird/tb/modules/agent/tools/explore.py

@@ -0,0 +1,15 @@
+from pydantic_ai import RunContext
+
+from tinybird.tb.modules.agent.utils import TinybirdAgentContext
+
+
+def explore_data(ctx: RunContext[TinybirdAgentContext], prompt: str):
+    """Explore production data in the current workspace
+
+    Args:
+        prompt (str): The prompt to explore data with. Required.
+
+    Returns:
+        str: The result of the exploration.
+    """
+    return ctx.deps.client.explore_data(prompt)

tinybird-0.0.1.dev240/tinybird/tb/modules/agent/tools/plan.py

@@ -0,0 +1,45 @@
+import click
+
+from tinybird.tb.modules.agent.utils import show_options
+
+
+def get_plan_confirmation() -> bool:
+    """Get user confirmation for implementing a plan"""
+    while True:
+        result = show_options(
+            options=["Yes, implement the plan", "No, and tell Tinybird Code what to do"],
+            title="Do you want to implement the plan?",
+        )
+
+        if result is None:  # Cancelled
+            return False
+
+        if result.startswith("Yes"):
+            return True
+        elif result.startswith("No"):
+            return False
+
+        return False
+
+
+def plan(plan: str) -> str:
+    """Given a plan, ask the user for confirmation to implement it
+
+    Args:
+        plan (str): The plan to implement. Required.
+
+    Returns:
+        str: If the plan was implemented or not.
+    """
+    try:
+        click.echo()
+        click.echo(plan)
+        confirmation = get_plan_confirmation()
+
+        if not confirmation:
+            return "Plan was not implemented. User cancelled implementation."
+
+        return "User confirmed the plan. Implementing..."
+
+    except Exception as e:
+        return f"Error implementing the plan: {e}"

tinybird-0.0.1.dev240/tinybird/tb/modules/agent/tools/preview_datafile.py

@@ -0,0 +1,24 @@
+from tinybird.tb.modules.agent.utils import Datafile
+
+
+def preview_datafile(name: str, type: str, description: str, content: str, pathname: str) -> Datafile:
+    """Preview the content of a datafile before creating it
+
+    Args:
+        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. Required.
+
+    Returns:
+        Datafile: The datafile preview.
+    """
+
+    return Datafile(
+        type=type,
+        name=name,
+        content=content,
+        description=description,
+        pathname=pathname,
+    )