tinybird 0.0.1.dev255__py3-none-any.whl → 0.0.1.dev257__py3-none-any.whl

tinybird/datafile/common.py

@@ -1744,6 +1744,8 @@ def parse(
         def _f(*args: str, **kwargs: Any):
             __init_engine(f"ENGINE_{v}".upper())
             engine_arg = eval_var(_unquote((" ".join(args)).strip()), skip=skip_eval)
+            if v.lower() == "ttl" and not engine_arg:
+                return
             parser_state.current_node["engine"]["args"].append((v, engine_arg))
 
         return _f

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.dev255'
-__revision__ = '208306e'
+__version__ = '0.0.1.dev257'
+__revision__ = '249ae8d'

tinybird/tb/modules/agent/agent.py

@@ -1,41 +1,23 @@
+import asyncio
 import shlex
 import subprocess
 import sys
-from datetime import datetime
 from functools import partial
 from pathlib import Path
 from typing import Any, Optional
 
 import click
-from pydantic_ai import Agent, Tool
+import humanfriendly
+from pydantic_ai import Agent, RunContext, Tool
+from pydantic_ai.agent import AgentRunResult
 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.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.prompts import agent_system_prompt, resources_prompt
 from tinybird.tb.modules.agent.tools.analyze import analyze_file, analyze_url
 from tinybird.tb.modules.agent.tools.append import append_file, append_url
 from tinybird.tb.modules.agent.tools.build import build
@@ -52,10 +34,10 @@ from tinybird.tb.modules.agent.tools.preview_datafile import preview_datafile
 from tinybird.tb.modules.agent.tools.request_endpoint import request_endpoint
 from tinybird.tb.modules.agent.utils import TinybirdAgentContext, show_input
 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.common import _analyze, _get_tb_client, echo_safe_humanfriendly_tables_format_pretty_table
 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
@@ -72,130 +54,21 @@ class TinybirdAgent:
         workspace_id: str,
         project: Project,
         dangerously_skip_permissions: bool,
+        prompt_mode: bool,
     ):
         self.token = token
         self.user_token = user_token
         self.host = host
-        self.dangerously_skip_permissions = dangerously_skip_permissions
+        self.dangerously_skip_permissions = dangerously_skip_permissions or prompt_mode
         self.project = project
-        self.messages: list[ModelMessage] = []
+        if prompt_mode:
+            self.messages: list[ModelMessage] = load_messages()[-5:]
+        else:
+            self.messages = []
         self.agent = Agent(
             model=create_model(user_token, host, workspace_id),
             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. Do not use emojis.
-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. `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.
-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.
-9. `append_file` - Append a file present in the project to a datasource.
-10. `append_url` - Append an external url to a datasource.
-11. `get_endpoint_stats` - Get metrics of the requests to an endpoint.
-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.
-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.
-
-# 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:
-SCHEMA >
-    `data` String `json:$`
-
-- Use always json paths with .ndjson files.
-
-# When user wants to optimize an endpoint:
-{endpoint_optimization_instructions}
-
-IMPORTANT: If the user cancels some of the steps or there is an error in file creation, DO NOT continue with the plan. Stop the process and wait for the user before using any other tool.
-IMPORTANT: Every time you finish a plan and start a new resource creation or update process, create a new plan before starting with the changes.
-
-# Using deployment tools:
-- Use `deploy_check` tool to check if the project can be deployed to Tinybird Cloud before deploying it.
-- Use `deploy` tool to deploy the project to Tinybird Cloud.
-- Only use deployment tools if user explicitly asks for it.
-
-# 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_agent_instructions}
-{sql_instructions}
-
-# Working with connections files:
-{connection_instructions}
-
-# Connection examples:
-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")}
-""",
+            system_prompt=agent_system_prompt,
             tools=[
                 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),
@@ -221,76 +94,131 @@ Today is {datetime.now().strftime("%Y-%m-%d")}
                 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),
             ],
+            # history_processors=[self._keep_recent_messages],
         )
 
-    def _keep_recent_messages(self) -> list[ModelMessage]:
+        @self.agent.instructions
+        def get_local_host(ctx: RunContext[TinybirdAgentContext]) -> str:
+            return f"Tinybird Local host: {ctx.deps.local_host}"
+
+        @self.agent.instructions
+        def get_cloud_host(ctx: RunContext[TinybirdAgentContext]) -> str:
+            return f"Tinybird Cloud host: {ctx.deps.host}"
+
+        @self.agent.instructions
+        def get_local_token(ctx: RunContext[TinybirdAgentContext]) -> str:
+            return f"Tinybird Local token: {ctx.deps.local_token}"
+
+        @self.agent.instructions
+        def get_cloud_token(ctx: RunContext[TinybirdAgentContext]) -> str:
+            return f"Tinybird Cloud token: {ctx.deps.token}"
+
+        @self.agent.instructions
+        def get_project_files(ctx: RunContext[TinybirdAgentContext]) -> str:
+            return resources_prompt(self.project)
+
+        self.thinking_animation = ThinkingAnimation()
+
+    def _keep_recent_messages(self, messages: list[ModelMessage]) -> list[ModelMessage]:
         """Keep only the last 5 messages to manage token usage."""
-        return self.messages[-5:] if len(self.messages) > 5 else self.messages
+        return messages[-5:] if len(messages) > 5 else messages
 
-    def run(self, user_prompt: str, config: dict[str, Any], project: Project) -> None:
-        user_prompt = f"{user_prompt}\n\n{resources_prompt(project)}"
+    def _build_agent_deps(self, config: dict[str, Any]) -> TinybirdAgentContext:
         client = TinyB(token=self.token, host=self.host)
+        project = self.project
         folder = self.project.folder
-        click.echo()
-        thinking_animation = ThinkingAnimation(message="Chirping", delay=0.15)
-        thinking_animation.start()
+        local_client = get_tinybird_local_client(config, test=False, silent=False)
+        return TinybirdAgentContext(
+            # context does not support the whole client, so we need to pass only the functions we need
+            explore_data=client.explore_data,
+            build_project=partial(build_project, project=project, config=config),
+            deploy_project=partial(deploy_project, project=project, config=config),
+            deploy_check_project=partial(deploy_check_project, project=project, config=config),
+            mock_data=partial(mock_data, project=project, config=config),
+            append_data_local=partial(append_data_local, config=config),
+            append_data_cloud=partial(append_data_cloud, config=config),
+            analyze_fixture=partial(analyze_fixture, 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=self.thinking_animation,
+            workspace_name=self.project.workspace_name,
+            dangerously_skip_permissions=self.dangerously_skip_permissions,
+            token=self.token,
+            user_token=self.user_token,
+            host=self.host,
+            local_host=local_client.host,
+            local_token=local_client.token,
+        )
+
+    def run(self, user_prompt: str, config: dict[str, Any]) -> None:
+        user_prompt = f"{user_prompt}\n\n{resources_prompt(self.project)}"
+        self.thinking_animation.start()
         result = self.agent.run_sync(
             user_prompt,
-            deps=TinybirdAgentContext(
-                # context does not support the whole client, so we need to pass only the functions we need
-                explore_data=client.explore_data,
-                build_project=partial(build_project, project=project, config=config),
-                deploy_project=partial(deploy_project, project=project, config=config),
-                deploy_check_project=partial(deploy_check_project, project=project, config=config),
-                mock_data=partial(mock_data, project=project, config=config),
-                append_data=partial(append_data, config=config),
-                analyze_fixture=partial(analyze_fixture, 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,
-                workspace_name=self.project.workspace_name,
-                dangerously_skip_permissions=self.dangerously_skip_permissions,
-                token=self.token,
-                user_token=self.user_token,
-                host=self.host,
-            ),
+            deps=self._build_agent_deps(config),
             message_history=self.messages,
         )
         new_messages = result.new_messages()
         self.messages.extend(new_messages)
-        thinking_animation.stop()
-        usage = result.usage()
-        request_tokens = usage.request_tokens or 0
-        response_tokens = usage.response_tokens or 0
-        total_tokens = usage.total_tokens or 0
-        cost = (
-            request_tokens * model_costs["input_cost_per_token"]
-            + response_tokens * model_costs["output_cost_per_token"]
-        )
+        save_messages(new_messages)
+        self.thinking_animation.stop()
         click.echo(result.output)
-        click.echo("\n")
-
+        self._echo_usage(config, result)
+
+    async def run_iter(self, user_prompt: str, config: dict[str, Any]) -> None:
+        user_prompt = f"{user_prompt}\n\n"
+        self.thinking_animation.start()
+        deps = self._build_agent_deps(config)
+
+        async with self.agent.iter(user_prompt, deps=deps, message_history=self.messages) as agent_run:
+            async for node in agent_run:
+                if hasattr(node, "model_response"):
+                    for _i, part in enumerate(node.model_response.parts):
+                        if hasattr(part, "content") and not agent_run.result:
+                            animation_running = self.thinking_animation.running
+                            if animation_running:
+                                self.thinking_animation.stop()
+                            click.echo(FeedbackManager.info(message=part.content))
+                            if animation_running:
+                                self.thinking_animation.start()
+
+        if agent_run.result is not None:
+            new_messages = agent_run.result.new_messages()
+            self.messages.extend(new_messages)
+            save_messages(new_messages)
+            self.thinking_animation.stop()
+            self._echo_usage(config, agent_run.result)
+
+    def _echo_usage(self, config: dict[str, Any], result: AgentRunResult) -> None:
         if "@tinybird.co" in config.get("user_email", ""):
+            usage = result.usage()
+            request_tokens = usage.request_tokens or 0
+            response_tokens = usage.response_tokens or 0
+            total_tokens = usage.total_tokens or 0
+            cost = (
+                request_tokens * model_costs["input_cost_per_token"]
+                + response_tokens * model_costs["output_cost_per_token"]
+            )
             click.echo(f"Input tokens: {request_tokens}")
             click.echo(f"Output tokens: {response_tokens}")
             click.echo(f"Total tokens: {total_tokens}")
             click.echo(f"Cost: ${cost:.6f}")
-            click.echo("\n")
 
 
 def run_agent(
     config: dict[str, Any], project: Project, dangerously_skip_permissions: bool, prompt: Optional[str] = None
 ):
+    click.echo(FeedbackManager.highlight(message="» Initializing Tinybird Code..."))
     token = config.get("token", None)
     host = config.get("host", None)
     user_token = config.get("user_token", None)
@@ -307,13 +235,14 @@ def run_agent(
                 default=True,
             )
             if yes:
-                click.echo()
                 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(
@@ -321,23 +250,22 @@ def run_agent(
                 )
                 return
 
-                # In print mode, always skip permissions to avoid interactive prompts
-        skip_permissions = dangerously_skip_permissions or (prompt is not None)
-        agent = TinybirdAgent(token, user_token, host, workspace_id, project, skip_permissions)
+        build_project(config, project, test=False, silent=True)
+
+        # In prompt mode, always skip permissions to avoid interactive prompts
+        prompt_mode = prompt is not None
+        agent = TinybirdAgent(token, user_token, host, workspace_id, project, dangerously_skip_permissions, prompt_mode)
 
         # Print mode: run once with the provided prompt and exit
         if prompt:
-            agent.run(prompt, config, project)
+            agent.run(prompt, config)
             return
 
         # Interactive mode: show banner and enter interactive loop
         display_banner()
-        click.echo()
         click.echo(FeedbackManager.info(message="Describe what you want to create and I'll help you build it"))
         click.echo(FeedbackManager.info(message="Run /help for more commands"))
 
-        click.echo()
-
     except Exception as e:
         click.echo(FeedbackManager.error(message=f"Failed to initialize agent: {e}"))
         return
@@ -350,31 +278,48 @@ def run_agent(
                 if user_input.startswith("tb "):
                     cmd_parts = shlex.split(user_input)
                     subprocess.run(cmd_parts)
-                    click.echo()
                     continue
-                if user_input.lower() in ["/exit", "/quit"]:
+                if user_input.lower() in ["/exit", "/quit", "exit", "quit"]:
                     click.echo(FeedbackManager.info(message="Goodbye!"))
                     break
-                elif user_input.lower() == "/clear":
+                elif user_input.lower() in ["/clear", "clear"]:
                     clear_history()
+                    click.echo(FeedbackManager.info(message="Message history cleared!"))
+                    clear_messages()
+                    continue
+                elif user_input.lower().startswith("select ") or user_input.lower().startswith("with "):
+                    query = f"SELECT * FROM ({user_input.strip()}) FORMAT JSON"
+                    result = execute_query_local(config, query=query)
+                    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))
+
+                    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")
                     continue
                 elif user_input.lower() == "/login":
-                    click.echo()
                     subprocess.run(["tb", "login"], check=True)
-                    click.echo()
+
                     continue
                 elif user_input.lower() == "/help":
-                    click.echo()
                     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("• Connect to external services: '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, config, project)
+                    asyncio.run(agent.run_iter(user_input, config))
 
             except KeyboardInterrupt:
                 click.echo(FeedbackManager.info(message="Goodbye!"))
@@ -399,33 +344,37 @@ 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:
+def append_data_local(config: dict[str, Any], datasource_name: str, path: str) -> None:
     client = get_tinybird_local_client(config, test=False, silent=False)
     append_mock_data(client, datasource_name, path)
 
 
+def append_data_cloud(config: dict[str, Any], datasource_name: str, path: str) -> None:
+    client = _get_tb_client(config["token"], config["host"])
+    append_mock_data(client, datasource_name, path)
+
+
 def mock_data(
     config: dict[str, Any],
     project: Project,

tinybird/tb/modules/agent/memory.py

@@ -1,7 +1,13 @@
+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():
@@ -39,3 +45,59 @@ 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))