Inspect or reload library plugins.

Recommend libraries for a scenario or generate/merge sampling prompts.

WHEN TO USE THIS TOOL:

• IMMEDIATELY after analyze_scenario, before execute_step

• When you encounter "No keyword with name" errors

• To discover which libraries provide needed functionality

This tool analyzes scenario text and suggests relevant libraries, saving you from guessing which libraries to import.

Analyze a natural-language scenario into structured intent and create a session.

WORKFLOW: This is the single front door — your FIRST tool call for any test scenario. It CREATES the session, so do NOT also call manage_session(action="init") for the same scenario (that causes redundant session churn). Reuse the returned session_id in every later call.

What this tool does:

1. Creates a new session with unique session_id (or reuses provided one)

2. Analyzes scenario to detect context (web/api/mobile/desktop)

3. Auto-configures libraries based on scenario text

4. Returns session_id for use in ALL subsequent tool calls

CRITICAL: Save the session_id from the response and use it in all other tool calls.

Discover Robot Framework keywords using multiple strategies.

WHEN TO USE THIS TOOL:

• ALWAYS before calling execute_step with an unfamiliar keyword

• When you're unsure of exact keyword name or spelling

• To discover what keywords are available in imported libraries

• When error says "No keyword with name 'X' found"

Manage session lifecycle: initialize, configure libraries/variables, and organize tests.

For a NEW scenario, prefer analyze_scenario — it is the front door that CREATES the session (and auto-configures libraries). Use manage_session for explicit session ops on an existing session (importing extra libraries/resources/variables, multi-test structure). Do NOT call action="init" right after analyze_scenario — the session already exists; that only causes redundant churn.

Workflows: Single test: analyze_scenario -> execute_step (repeat) -> build_test_suite Multi-test: analyze_scenario -> set_suite_setup -> start_test -> execute_step (repeat) -> end_test -> start_test -> ... -> build_test_suite (action="init" is the explicit alternative when you are NOT starting from analyze_scenario, e.g. driving a bare session directly.)

Actions and parameters (session_id is always required):

init             - Create session and load libraries (explicit entry; for a new
                   scenario prefer analyze_scenario instead).
                   Params: libraries (list of library names),
                           variables (dict or list to pre-set).

import_library   - Add a library to an existing session.
                   Params: library_name, args (constructor args), alias.

import_resource  - Import a Robot Framework resource file.
                   Params: resource_path, args.

set_variables    - Set variables in the session.
                   Params: variables (dict {"NAME": "value"} or list ["NAME=value"]),
                           scope ("test" | "suite" | "global", default "suite").

import_variables - Load variables from a Python variable file.
                   Params: variable_file_path, args (passed to get_variables()).

start_test       - Begin a named test (enables multi-test mode). Local mode only.
                   Params: test_name (required),
                           test_documentation, test_tags,
                           test_setup (dict {"keyword": "...", "arguments": [...]}),
                           test_teardown (same format as test_setup).
                   Alias: start_task.

end_test         - End the current test. Local mode only.
                   Params: test_status ("pass" or "fail", default "pass"),
                           test_message (optional error description).
                   NOTE: test_status and test_message are session tracking metadata.
                   They do NOT affect the .robot file generated by build_test_suite.
                   Alias: end_task.

add_data_row     - Add a data row to the current data-driven (template) test.
                   Requires an active test with template set via start_test.
                   Params: args (list of values matching the template keyword's [Arguments]).
                   Alias: data_row.
                   Example:
                     manage_session(action="start_test", test_name="Cart Test",
                                  template="Add And Verify Product")
                     manage_session(action="add_data_row", args=["Backpack", "1", "$29.99"])
                     manage_session(action="add_data_row", args=["Bike Light", "2", "$39.98"])
                     manage_session(action="end_test")
                   The data rows appear under [Template] in the generated .robot file.

list_tests       - List all tests in the session with their status and step counts.
                   Params: (none).

set_suite_setup    - Set a suite-level setup keyword (appears in *** Settings ***).
                     Params: keyword (required), args (keyword arguments).

set_suite_teardown - Set a suite-level teardown keyword (appears in *** Settings ***).
                     Params: keyword (required), args (keyword arguments).

Returns: Dict with success, session_id, and action-specific details. On failure: error and guidance fields are present.

Examples: Initialize session with libraries: manage_session(action="init", session_id="s1", libraries=["Browser", "BuiltIn", "Collections"])

Set suite-level variables:
    manage_session(action="set_variables", session_id="s1",
                   variables={"BASE_URL": "https://example.com", "TIMEOUT": "30"})

Import a library with constructor arguments:
    manage_session(action="import_library", session_id="s1",
                   library_name="Browser", args=["chromium"])

Load a Python variable file:
    manage_session(action="import_variables", session_id="s1",
                   variable_file_path="config/variables.py",
                   args=["production", "secret_key"])

Start a named test (multi-test mode):
    manage_session(action="start_test", session_id="s1",
                   test_name="Login Test", test_tags=["smoke"],
                   test_setup={"keyword": "Open Browser", "arguments": ["chromium"]})

End the current test:
    manage_session(action="end_test", session_id="s1")

Set suite setup (for generated .robot file):
    manage_session(action="set_suite_setup", session_id="s1",
                   keyword="New Browser", args=["chromium"])

Set suite teardown:
    manage_session(action="set_suite_teardown", session_id="s1",
                   keyword="Close Browser")

Execute structured flow (if/for/try) within a session.

Retrieve aggregated session state for debugging and visibility.

Execute a single Robot Framework keyword (or Evaluate) within a session.

Generate a Robot Framework test suite from previously executed steps.

Verify that specified Robot Framework libraries can be imported/installed.

Recommended as step 3 after analyze_scenario and recommend_libraries; use the recommended names to avoid unnecessary checks.

Execute multiple RF keywords in one call with recovery and variable chaining.

Reduces N MCP round-trips to 1. Steps run sequentially; each step's return value is available to later steps via ${STEP_N} references in arguments. Both 0-based (${STEP_0} = first step) and 1-based (${STEP_1} = first step) indexing are accepted. When ambiguous, 1-based is preferred.

Resume a failed batch from its failure point, optionally inserting fix steps.

After execute_batch returns status=FAIL with a batch_id, call this to:

1. Re-run the failed step (with optional fix_steps injected before it)

2. Continue executing remaining steps from the original batch

Get keyword/library docs or parse a signature. Call this before execute_step when you know the keyword name but not its arguments.

Modes: "keyword" (default — document one keyword), "library" (list a library's keywords), "session" (resolve against the live session namespace), "parse" (parse a signature string). Pass session_id to scope the lookup to that session's libraries.

Set explicit library search order for keyword resolution.

Provide locator/selector guidance for Browser, SeleniumLibrary, AppiumLibrary, PlatynUI.BareMetal, or RequestsLibrary.

For API testing, call with library="requests" (or "api") to get a RequestsLibrary request/response cookbook — session setup, response-field access (${resp.json()["field"]}), the $resp-in-Evaluate rule, Status Should Be, JSON body/headers, the Cookie token header, and expected_status= for non-2xx — BEFORE writing Evaluate-based assertions.

For VISUAL validation, call with library="visual" (or "screenshot") to learn WHEN a screenshot beats the DOM/ARIA tree (canvas/image text, layout/overlap, obscured elements, color, charts) and the dual read-back pattern — useful for any UI library (Browser/Selenium/Appium/PlatynUI) when a multimodal model drives rf-mcp.

Capture a screenshot of the current UI for VISUAL validation (change: visual-inspection-guidance).

Token-cheap by DEFAULT: saves the screenshot to disk and returns the PATH as text — a multimodal agent WITH file access reads that file on demand for checks the DOM/ARIA can't do (canvas/image text, layout/overlap, obscured elements, color, charts). Call get_locator_guidance(library="visual") for when to use it.

Set return_image=true ONLY if your model is multimodal AND cannot read the saved file (e.g. a hosted/remote MCP): the response then includes an image content block. This requires ROBOTMCP_SCREENSHOT_MODE to allow images (image|auto); text-only deployments (mode=file, the default) always return just the path so a text-only model is never sent unsupported image content.

Works across Browser/SeleniumLibrary/AppiumLibrary/PlatynUI (uses the session's screenshot keyword). Degrades cleanly if capture fails.

Validate or execute a Robot Framework suite.

Inspect or control attach bridge configuration.

Execute a high-level intent that auto-resolves to the correct library keyword.

Valid intents: navigate, click, fill, hover, select, assert_visible, extract, wait_for.

Also accepted but DEPRECATED:

• extract_text — equivalent to extract with mode="text". The extract verb is the canonical mode-aware getter (text / attribute / count / value / url / title) and additionally surfaces extracted_value at the top level of the response. extract_text will be removed in a future release; prefer intent="extract" for new code.

The intent is resolved based on the session's active library (Browser/SeleniumLibrary/AppiumLibrary).