Diagnose issues with a specific DAG run - get run details and failed tasks.

USE THIS TOOL WHEN troubleshooting a failed or problematic DAG run. Returns all the information you need to understand what went wrong.

This is the preferred tool when:

• User asks "Why did this DAG run fail?"

• User asks "What's wrong with run X?"

• You need to investigate task failures in a specific run

Returns combined data:

• DAG run metadata (state, start/end times, trigger type)

• All task instances for this run with their states

• Highlighted failed/upstream_failed tasks with details

• Summary of task states

Args: dag_id: The ID of the DAG dag_run_id: The ID of the DAG run (e.g., "manual__2024-01-01T00:00:00+00:00")

Returns: JSON with diagnostic information about the DAG run

Comprehensive investigation of a DAG - get all relevant info in one call.

USE THIS TOOL WHEN you need to understand a DAG completely. Instead of making multiple calls, this returns everything about a DAG in a single response.

This is the preferred first tool when:

• User asks "Tell me about DAG X" or "What is this DAG?"

• You need to understand a DAG's structure before diagnosing issues

• You want to know the schedule, tasks, and source code together

Returns combined data:

• DAG metadata (schedule, owners, tags, paused status)

• All tasks with their operators and dependencies

• DAG source code

• Any import errors or warnings for this DAG

Args: dag_id: The ID of the DAG to explore

Returns: JSON with comprehensive DAG information

Get Airflow instance configuration and settings.

Use this tool when the user asks about:

• "What's the Airflow configuration?" or "Show me Airflow settings"

• "What's the executor type?" or "How is Airflow configured?"

• "What's the parallelism setting?"

• Database connection, logging, or scheduler settings

• Finding specific configuration values

Returns all Airflow configuration organized by sections:

• [core]: Basic Airflow settings (executor, dags_folder, parallelism)

• [database]: Database connection and settings

• [webserver]: Web UI configuration (port, workers, auth)

• [scheduler]: Scheduler behavior and intervals

• [logging]: Log locations and formatting

• [api]: REST API configuration

• [operators]: Default operator settings

• And many more sections...

Each setting includes:

• key: Configuration parameter name

• value: Current value

• source: Where the value came from (default, env var, config file)

Returns: JSON with complete Airflow configuration organized by sections

Get version information for the Airflow instance.

Use this tool when the user asks about:

• "What version of Airflow is running?" or "Show me the Airflow version"

• "What's the Airflow version?" or "Which Airflow release is this?"

• "What version is installed?" or "Check Airflow version"

• "Is this Airflow 2 or 3?" or "What's the version number?"

Returns version information including:

• version: The Airflow version string (e.g., "2.8.0", "3.0.0")

• git_version: Git commit hash if available

This is useful for:

• Determining API compatibility

• Checking if features are available in this version

• Troubleshooting version-specific issues

• Verifying upgrade success

Returns: JSON with Airflow version information

Get detailed information about a specific Apache Airflow DAG.

Use this tool when the user asks about:

• "Show me details for DAG X" or "What are the details of DAG Y?"

• "Tell me about DAG Z" or "Get information for this specific DAG"

• "What's the schedule for DAG X?" or "When does this DAG run?"

• "Is DAG Y paused?" or "Show me the configuration of DAG Z"

• "Who owns this DAG?" or "What are the tags for this workflow?"

Returns complete DAG information including:

• dag_id: Unique identifier for the DAG

• is_paused: Whether the DAG is currently paused

• is_active: Whether the DAG is active

• is_subdag: Whether this is a SubDAG

• fileloc: File path where the DAG is defined

• file_token: Unique token for the DAG file

• owners: List of DAG owners

• description: Human-readable description of what the DAG does

• schedule_interval: Cron expression or timedelta for scheduling

• tags: List of tags/labels for categorization

• max_active_runs: Maximum number of concurrent runs

• max_active_tasks: Maximum number of concurrent tasks

• has_task_concurrency_limits: Whether task concurrency limits are set

• has_import_errors: Whether the DAG has import errors

• next_dagrun: When the next DAG run is scheduled

• next_dagrun_create_after: Earliest time for next DAG run creation

Args: dag_id: The ID of the DAG to get details for

Returns: JSON with complete details about the specified DAG

Get detailed information about a specific DAG run execution.

Use this tool when the user asks about:

• "Show me details for DAG run X" or "What's the status of run Y?"

• "When did this run start/finish?" or "How long did run Z take?"

• "Why did this run fail?" or "Get execution details for run X"

• "What was the configuration for this run?" or "Show me run metadata"

• "What's the state of DAG run X?" or "Did run Y succeed?"

Returns detailed information about a specific DAG run execution including:

• dag_run_id: Unique identifier for this execution

• dag_id: Which DAG this run belongs to

• state: Current state (running, success, failed, queued, etc.)

• execution_date: When this run was scheduled to execute

• start_date: When execution actually started

• end_date: When execution completed (if finished)

• duration: How long the run took (in seconds)

• run_type: Type of run (manual, scheduled, backfill, etc.)

• conf: Configuration parameters passed to this run

• external_trigger: Whether this was triggered externally

• data_interval_start: Start of the data interval

• data_interval_end: End of the data interval

• last_scheduling_decision: Last scheduling decision timestamp

• note: Optional note attached to the run

Args: dag_id: The ID of the DAG (e.g., "example_dag") dag_run_id: The ID of the DAG run (e.g., "manual__2024-01-01T00:00:00+00:00")

Returns: JSON with complete details about the specified DAG run

Get the source code for a specific Apache Airflow DAG.

Use this tool when the user asks about:

• "Show me the code for DAG X" or "What's the source of DAG Y?"

• "How is DAG Z implemented?" or "What does the DAG file look like?"

• "Can I see the Python code for this workflow?"

• "What tasks are defined in the DAG code?"

Returns the DAG source file contents including:

• content: The actual Python source code of the DAG file

• file_token: Unique identifier for the source file

Args: dag_id: The ID of the DAG to get source code for

Returns: JSON with DAG source code and metadata

Get statistics about DAG runs (success/failure counts by state).

Use this tool when the user asks about:

• "What's the overall health of my DAGs?" or "Show me DAG statistics"

• "How many DAG runs succeeded/failed?" or "What's the success rate?"

• "Give me a summary of DAG run states"

• "How many runs are currently running/queued?"

• "Show me stats for specific DAGs"

Returns statistics showing counts of DAG runs grouped by state:

• success: Number of successful runs

• failed: Number of failed runs

• running: Number of currently running runs

• queued: Number of queued runs

• And other possible states

Args: dag_ids: Optional list of DAG IDs to filter by. If not provided, returns stats for all DAGs.

Returns: JSON with DAG run statistics organized by DAG and state

Get detailed information about a specific resource pool.

Use this tool when the user asks about:

• "Show me details for pool X" or "What's the status of pool Y?"

• "How many slots are available in pool Z?" or "Is pool X full?"

• "What's using pool Y?" or "How many tasks are running in pool X?"

• "Get information about the default_pool" or "Show me pool details"

Pools are used to limit parallelism for specific sets of tasks. This returns detailed real-time information about a specific pool's capacity and utilization.

Returns detailed pool information including:

• name: Name of the pool

• slots: Total number of available slots in the pool

• occupied_slots: Number of currently occupied slots (running + queued)

• running_slots: Number of slots with currently running tasks

• queued_slots: Number of slots with queued tasks waiting to run

• open_slots: Number of available slots (slots - occupied_slots)

• description: Human-readable description of the pool's purpose

Args: pool_name: The name of the pool to get details for (e.g., "default_pool")

Returns: JSON with complete details about the specified pool

Get overall Airflow system health - import errors, warnings, and DAG stats.

USE THIS TOOL WHEN you need a quick health check of the Airflow system. Returns a consolidated view of potential issues across the entire system.

This is the preferred tool when:

• User asks "Are there any problems with Airflow?"

• User asks "Show me the system health" or "Any errors?"

• You want to do a morning health check

• You're starting an investigation and want to see the big picture

Returns combined data:

• Import errors (DAG files that failed to parse)

• DAG warnings (deprecations, configuration issues)

• DAG statistics (run counts by state) if available

• Version information

Returns: JSON with system health overview

Get detailed information about a specific task definition in a DAG.

Use this tool when the user asks about:

• "Show me details for task X in DAG Y" or "What does task Z do?"

• "What operator does task A use?" or "What's the configuration of task B?"

• "Tell me about task C" or "Get task definition for D"

• "What are the dependencies of task E?" or "Which tasks does F depend on?"

Returns task definition information including:

• task_id: Unique identifier for the task

• task_display_name: Human-readable display name

• owner: Who owns this task

• start_date: When this task becomes active

• end_date: When this task becomes inactive (if set)

• trigger_rule: When this task should run (all_success, one_failed, etc.)

• depends_on_past: Whether task depends on previous run's success

• wait_for_downstream: Whether to wait for downstream tasks

• retries: Number of retry attempts

• retry_delay: Time between retries

• execution_timeout: Maximum execution time

• operator_name: Type of operator (PythonOperator, BashOperator, etc.)

• pool: Resource pool assignment

• queue: Queue for executor

• downstream_task_ids: List of tasks that depend on this task

• upstream_task_ids: List of tasks this task depends on

Args: dag_id: The ID of the DAG containing the task task_id: The ID of the task to get details for

Returns: JSON with complete task definition details

Get detailed information about a specific task instance execution.

Use this tool when the user asks about:

• "Show me details for task X in DAG run Y" or "What's the status of task Z?"

• "Why did task A fail?" or "When did task B start/finish?"

• "What's the duration of task C?" or "Show me task execution details"

• "Get logs for task D" or "What operator does task E use?"

Returns detailed task instance information including:

• task_id: Name of the task

• state: Current state (success, failed, running, queued, etc.)

• start_date: When the task started

• end_date: When the task finished

• duration: How long the task ran

• try_number: Which attempt this is

• max_tries: Maximum retry attempts

• operator: What operator type (PythonOperator, BashOperator, etc.)

• executor_config: Executor configuration

• pool: Resource pool assignment

Args: dag_id: The ID of the DAG dag_run_id: The ID of the DAG run (e.g., "manual__2024-01-01T00:00:00+00:00") task_id: The ID of the task within the DAG

Returns: JSON with complete task instance details

Get logs for a specific task instance execution.

Use this tool when the user asks about:

• "Show me the logs for task X" or "Get logs for task Y"

• "What did task Z output?" or "Show me task execution logs"

• "Why did task A fail?" (to see error messages in logs)

• "What happened during task B execution?"

• "Show me the stdout/stderr for task C"

• "Debug task D" or "Troubleshoot task E"

Returns the actual log output from the task execution, which includes:

• Task execution output (stdout/stderr)

• Error messages and stack traces (if task failed)

• Timing information

• Any logged messages from the task code

This is essential for debugging failed tasks or understanding what happened during task execution.

Args: dag_id: The ID of the DAG (e.g., "example_dag") dag_run_id: The ID of the DAG run (e.g., "manual__2024-01-01T00:00:00+00:00") task_id: The ID of the task within the DAG (e.g., "extract_data") try_number: The task try/attempt number, 1-indexed (default: 1). Use higher numbers to get logs from retry attempts. map_index: For mapped tasks, which map index to get logs for. Use -1 for non-mapped tasks (default: -1).

Returns: JSON with the task logs content

Get asset events that triggered a specific DAG run.

Use this tool when the user asks about:

• "What triggered this DAG run?"

• "Which asset events caused this run to start?"

• "Why did DAG X start running?"

• "Show me the upstream triggers for this run"

• "What data changes triggered this pipeline run?"

This is useful for understanding causation in data-aware scheduling. When a DAG is scheduled based on asset updates, this tool shows which specific asset events triggered the run.

Returns information including:

• dag_id: The DAG that was triggered

• dag_run_id: The specific run

• triggered_by_events: List of asset events that caused this run

• event_count: Number of triggering events

Each event includes:

• asset_uri or dataset_uri: The asset that was updated

• source_dag_id: The DAG that produced the event

• source_run_id: The run that produced the event

• timestamp: When the event occurred

Args: dag_id: The ID of the DAG dag_run_id: The ID of the DAG run (e.g., "scheduled__2024-01-01T00:00:00+00:00")

Returns: JSON with the asset events that triggered this DAG run

Get a specific Airflow variable by key.

Use this tool when the user asks about:

• "What's the value of variable X?" or "Show me variable Y"

• "Get variable Z" or "What does variable A contain?"

• "What's stored in variable B?" or "Look up variable C"

Variables are key-value pairs stored in Airflow's metadata database that can be accessed by DAGs at runtime. They're commonly used for configuration values, API keys, or other settings that need to be shared across DAGs.

Returns variable information including:

• key: The variable's key/name

• value: The variable's value (may be masked if marked as sensitive)

• description: Optional description of the variable's purpose

Args: variable_key: The key/name of the variable to retrieve

Returns: JSON with the variable's key, value, and metadata

List asset/dataset events with optional filtering.

Use this tool when the user asks about:

• "What asset events were produced by DAG X?"

• "Show me dataset events from run Y"

• "Debug why downstream DAG wasn't triggered"

• "What assets did this pipeline produce?"

• "List recent asset update events"

Asset events are produced when a task updates an asset/dataset. These events can trigger downstream DAGs that depend on those assets (data-aware scheduling).

Returns event information including:

• uri: The asset that was updated

• source_dag_id: The DAG that produced this event

• source_run_id: The DAG run that produced this event

• source_task_id: The task that produced this event

• timestamp: When the event was created

Args: source_dag_id: Filter events by the DAG that produced them source_run_id: Filter events by the DAG run that produced them source_task_id: Filter events by the task that produced them limit: Maximum number of events to return (default: 100)

Returns: JSON with list of asset events

Get data assets and datasets tracked by Airflow (data lineage).

Use this tool when the user asks about:

• "What datasets exist?" or "List all assets"

• "What data does this DAG produce/consume?"

• "Show me data dependencies" or "What's the data lineage?"

• "Which DAGs use dataset X?"

• Data freshness or update events

Assets represent datasets or files that DAGs produce or consume. This enables data-driven scheduling where DAGs wait for data availability.

Returns asset information including:

• uri: Unique identifier for the asset (e.g., s3://bucket/path)

• id: Internal asset ID

• created_at: When this asset was first registered

• updated_at: When this asset was last updated

• consuming_dags: Which DAGs depend on this asset

• producing_tasks: Which tasks create/update this asset

Returns: JSON with list of all assets and their producing/consuming relationships

Get connection configurations for external systems (databases, APIs, services).

Use this tool when the user asks about:

• "What connections are configured?" or "List all connections"

• "How do I connect to database X?"

• "What's the connection string for Y?"

• "Which databases/services are available?"

• Finding connection details by name or type

Connections store credentials and connection info for external systems that DAGs interact with (databases, S3, APIs, etc.).

Returns connection metadata including:

• connection_id: Unique name for this connection

• conn_type: Type (postgres, mysql, s3, http, etc.)

• description: Human-readable description

• host: Server hostname or IP

• port: Port number

• schema: Database schema or path

• login: Username (passwords excluded for security)

• extra: Additional connection parameters as JSON

IMPORTANT: Passwords are NEVER returned for security reasons.

Returns: JSON with list of all connections (credentials excluded)

Get execution history and status of DAG runs (workflow executions).

Use this tool when the user asks about:

• "What DAG runs have executed?" or "Show me recent runs"

• "Which runs failed/succeeded?"

• "What's the status of my workflows?"

• "When did DAG X last run?"

• Execution times, durations, or states

• Finding runs by date or status

Returns execution metadata including:

• dag_run_id: Unique identifier for this execution

• dag_id: Which DAG this run belongs to

• state: Current state (running, success, failed, queued)

• execution_date: When this run was scheduled to execute

• start_date: When execution actually started

• end_date: When execution completed (if finished)

• run_type: manual, scheduled, or backfill

• conf: Configuration passed to this run

Returns: JSON with list of DAG runs across all DAGs, sorted by most recent

Get information about all Apache Airflow DAGs (Directed Acyclic Graphs).

Use this tool when the user asks about:

• "What DAGs are available?" or "List all DAGs"

• "Show me the workflows" or "What pipelines exist?"

• "Which DAGs are paused/active?"

• DAG schedules, descriptions, or tags

• Finding a specific DAG by name

Returns comprehensive DAG metadata including:

• dag_id: Unique identifier for the DAG

• is_paused: Whether the DAG is currently paused

• is_active: Whether the DAG is active

• schedule_interval: How often the DAG runs

• description: Human-readable description

• tags: Labels/categories for the DAG

• owners: Who maintains the DAG

• file_token: Location of the DAG file

Returns: JSON with list of all DAGs and their complete metadata

Get warnings and issues detected in DAG definitions.

Use this tool when the user asks about:

• "Are there any DAG warnings?" or "Show me DAG issues"

• "What problems exist with my DAGs?" or "Any DAG errors?"

• "Check DAG health" or "Show me DAG validation warnings"

• "What's wrong with my workflows?"

Returns warnings about DAG configuration issues including:

• dag_id: Which DAG has the warning

• warning_type: Type of warning (e.g., deprecation, configuration issue)

• message: Description of the warning

• timestamp: When the warning was detected

Returns: JSON with list of DAG warnings and their details

Get import errors from DAG files that failed to parse or load.

Use this tool when the user asks about:

• "Are there any import errors?" or "Show me import errors"

• "Why isn't my DAG showing up?" or "DAG not appearing in Airflow"

• "What DAG files have errors?" or "Show me broken DAGs"

• "Check for syntax errors" or "Are there any parsing errors?"

• "Why is my DAG file failing to load?"

Import errors occur when DAG files have problems that prevent Airflow from parsing them, such as:

• Python syntax errors

• Missing imports or dependencies

• Module not found errors

• Invalid DAG definitions

• Runtime errors during file parsing

Returns import error details including:

• import_error_id: Unique identifier for the error

• timestamp: When the error was detected

• filename: Path to the DAG file with the error

• stack_trace: Complete error message and traceback

Returns: JSON with list of import errors and their stack traces

Get information about installed Airflow plugins.

Use this tool when the user asks about:

• "What plugins are installed?" or "List all plugins"

• "Show me the plugins" or "Which plugins are enabled?"

• "Is plugin X installed?" or "Do we have any custom plugins?"

• "What's in the plugins directory?"

Plugins extend Airflow functionality by adding custom operators, hooks, views, menu items, or other components. This returns information about all plugins discovered by Airflow's plugin system.

Returns information about installed plugins including:

• name: Name of the plugin

• hooks: Custom hooks provided by the plugin

• executors: Custom executors provided by the plugin

• macros: Custom macros provided by the plugin

• flask_blueprints: Flask blueprints for custom UI pages

• appbuilder_views: Flask-AppBuilder views for admin interface

• appbuilder_menu_items: Custom menu items in the UI

Returns: JSON with list of all installed plugins and their components

Get resource pools for managing task concurrency and resource allocation.

Use this tool when the user asks about:

• "What pools are configured?" or "List all pools"

• "Show me the resource pools" or "What pools exist?"

• "How many slots does pool X have?" or "What's the pool capacity?"

• "Which pools are available?" or "What's the pool configuration?"

Pools are used to limit parallelism for specific sets of tasks. Each pool has a certain number of slots, and tasks assigned to a pool will only run if there are available slots. This is useful for limiting concurrent access to resources like databases or external APIs.

Returns pool information including:

• name: Name of the pool

• slots: Total number of available slots in the pool

• occupied_slots: Number of currently occupied slots

• running_slots: Number of slots with running tasks

• queued_slots: Number of slots with queued tasks

• open_slots: Number of available slots (slots - occupied_slots)

• description: Human-readable description of the pool's purpose

Returns: JSON with list of all pools and their current utilization

Get information about installed Airflow provider packages.

Use this tool when the user asks about:

• "What providers are installed?" or "List all providers"

• "What integrations are available?" or "Show me installed packages"

• "Do we have the AWS provider?" or "Is the Snowflake provider installed?"

• "What version of provider X is installed?"

Returns information about installed provider packages including:

• package_name: Name of the provider package (e.g., "apache-airflow-providers-amazon")

• version: Version of the provider package

• description: What the provider does

• provider_info: Details about operators, hooks, and sensors included

Returns: JSON with list of all installed provider packages and their details

Get all tasks defined in a specific DAG.

Use this tool when the user asks about:

• "What tasks are in DAG X?" or "List all tasks for DAG Y"

• "Show me the tasks in this workflow" or "What's in the DAG?"

• "What are the steps in DAG Z?" or "Show me the task structure"

• "What does this DAG do?" or "Explain the workflow steps"

Returns information about all tasks in the DAG including:

• task_id: Unique identifier for the task

• task_display_name: Human-readable display name

• owner: Who owns this task

• operator_name: Type of operator (PythonOperator, BashOperator, etc.)

• start_date: When this task becomes active

• end_date: When this task becomes inactive (if set)

• trigger_rule: When this task should run

• retries: Number of retry attempts

• pool: Resource pool assignment

• downstream_task_ids: List of tasks that depend on this task

• upstream_task_ids: List of tasks this task depends on

Args: dag_id: The ID of the DAG to list tasks for

Returns: JSON with list of all tasks in the DAG and their configurations

Get all Airflow variables (key-value configuration pairs).

Use this tool when the user asks about:

• "What variables are configured?" or "List all variables"

• "Show me the variables" or "What variables exist?"

• "What configuration variables are available?"

• "Show me all variable keys"

Variables are key-value pairs stored in Airflow's metadata database that can be accessed by DAGs at runtime. They're commonly used for configuration values, environment-specific settings, or other data that needs to be shared across DAGs without hardcoding in the DAG files.

Returns variable information including:

• key: The variable's key/name

• value: The variable's value (may be masked if marked as sensitive)

• description: Optional description of the variable's purpose

IMPORTANT: Sensitive variables (like passwords, API keys) may have their values masked in the response for security reasons.

Returns: JSON with list of all variables and their values

Pause a DAG to prevent new scheduled runs from starting.

Use this tool when the user asks to:

• "Pause DAG X" or "Stop DAG Y from running"

• "Disable DAG Z" or "Prevent new runs of DAG X"

• "Turn off DAG scheduling" or "Suspend DAG execution"

When a DAG is paused:

• No new scheduled runs will be created

• Currently running tasks will complete

• Manual triggers are still possible

• The DAG remains visible in the UI with a paused indicator

IMPORTANT: This is a write operation that modifies Airflow state. The DAG will remain paused until explicitly unpaused.

Args: dag_id: The ID of the DAG to pause (e.g., "example_dag")

Returns: JSON with updated DAG details showing is_paused=True

Trigger a new DAG run (start a workflow execution manually).

Use this tool when the user asks to:

• "Run DAG X" or "Start DAG Y" or "Execute DAG Z"

• "Trigger a run of DAG X" or "Kick off DAG Y"

• "Run this workflow" or "Start this pipeline"

• "Execute DAG X with config Y" or "Trigger DAG with parameters"

• "Start a manual run" or "Manually execute this DAG"

This creates a new DAG run that will be picked up by the scheduler and executed. You can optionally pass configuration parameters that will be available to the DAG during execution via the conf context variable.

IMPORTANT: This is a write operation that modifies Airflow state by creating a new DAG run. Use with caution.

Returns information about the newly triggered DAG run including:

• dag_run_id: Unique identifier for the new execution

• dag_id: Which DAG was triggered

• state: Initial state (typically 'queued')

• execution_date: When this run is scheduled to execute

• start_date: When execution started (may be null if queued)

• run_type: Type of run (will be 'manual')

• conf: Configuration passed to the run

• external_trigger: Set to true for manual triggers

Args: dag_id: The ID of the DAG to trigger (e.g., "example_dag") conf: Optional configuration dictionary to pass to the DAG run. This will be available in the DAG via context['dag_run'].conf

Returns: JSON with details about the newly triggered DAG run

Trigger a DAG run and wait for it to complete before returning.

Use this tool when the user asks to:

• "Run DAG X and wait for it to finish" or "Execute DAG Y and tell me when it's done"

• "Trigger DAG Z and wait for completion" or "Run this pipeline synchronously"

• "Start DAG X and let me know the result" or "Execute and monitor DAG Y"

• "Run DAG X and show me if it succeeds or fails"

This is a BLOCKING operation that will:

1. Trigger the specified DAG

2. Poll for status automatically (interval scales with timeout)

3. Return once the DAG run reaches a terminal state (success, failed, upstream_failed)

4. Include details about any failed tasks if the run was not successful

IMPORTANT: This tool blocks until the DAG completes or times out. For long-running DAGs, consider using trigger_dag instead and checking status separately with get_dag_run.

Default timeout is 60 minutes. Adjust the timeout parameter for longer DAGs.

Returns information about the completed DAG run including:

• dag_id: Which DAG was run

• dag_run_id: Unique identifier for this execution

• state: Final state (success, failed, upstream_failed)

• start_date: When execution started

• end_date: When execution completed

• elapsed_seconds: How long we waited

• timed_out: Whether we hit the timeout before completion

• failed_tasks: List of failed task details (only if state != success)

Args: dag_id: The ID of the DAG to trigger (e.g., "example_dag") conf: Optional configuration dictionary to pass to the DAG run. This will be available in the DAG via context['dag_run'].conf timeout: Maximum time to wait in seconds (default: 3600.0 / 60 minutes)

Returns: JSON with final DAG run status and any failed task details

Unpause a DAG to allow scheduled runs to resume.

Use this tool when the user asks to:

• "Unpause DAG X" or "Resume DAG Y"

• "Enable DAG Z" or "Start DAG scheduling again"

• "Turn on DAG X" or "Activate DAG Y"

When a DAG is unpaused:

• The scheduler will create new runs based on the schedule

• Any missed runs (depending on catchup setting) may be created

• The DAG will appear active in the UI

IMPORTANT: This is a write operation that modifies Airflow state. New DAG runs will be scheduled according to the DAG's schedule_interval.

Args: dag_id: The ID of the DAG to unpause (e.g., "example_dag")

Returns: JSON with updated DAG details showing is_paused=False