Args:
        folder: Model folder type (checkpoints, loras, vae, etc.)
        limit: Maximum number of results to return (default: 25, max: 100)
        offset: Starting index for pagination (default: 0)
    

    Args:
        limit: Maximum number of results to return (default: 25, max: 100)
        offset: Starting index for pagination (default: 0)
    

    Returns a dict with keys: input, input_order, is_input_list, output,
    output_is_list, output_name, name, display_name, description, python_module,
    category, output_node, search_aliases, plus optional flags like deprecated,
    experimental, and api_node when set on the node.
    

    This is distinct from ``comfyui_create_workflow``'s built-in template names
    (txt2img, img2img, etc.) which are hard-coded in the MCP for graph generation.

    Returns a paginated envelope: ``{items, total, offset, limit, has_more}``.
    Each item is ``{"package": str, "templates": [...]}`` from the server.
    

    Returns a paginated envelope: ``{items, total, offset, limit, has_more}``.
    Each item is the extension's URL/path string.
    

    Returns the raw ``/features`` response — typically a dict of
    {feature_name: bool}. Useful for capability-based branching, e.g.
    checking ``supports_preview_metadata`` before requesting preview-format
    images via ``comfyui_get_image``.
    

    Returns a paginated envelope: ``{items, total, offset, limit, has_more}``.
    

    Args:
        folder: Model folder type (checkpoints, loras, vae, etc.)
        filename: Name of the model file
    

    Scans for nodes that could execute arbitrary code, run shell commands,
    or access the file system. Useful for building a dangerous node blacklist.

    Returns:
        Dictionary with dangerous and suspicious node counts and lists
    

    Returns a whitelist-filtered subset of system stats useful for making
    generation decisions: GPU VRAM, queue depth, and ComfyUI version.
    Sensitive fields (hostname, OS, CPU details, file paths, Python version,
    network interfaces) are deliberately excluded.

    Returns:
        Dictionary with keys: comfyui_version, devices (list of GPU info),
        queue (running/pending counts).
    

    The presets are static data baked into this MCP — they reflect
    community best-practice defaults, not anything the connected ComfyUI
    server reports. At least one of ``model_name`` or ``model_family``
    must be supplied; if both are given, ``model_family`` takes
    precedence and ``model_name`` is ignored.

    Args:
        model_name (required if ``model_family`` is omitted): Model
            filename to auto-detect the family from (e.g.
            ``sd_xl_base_1.0.safetensors`` → ``sdxl``). Used as a
            fallback when ``model_family`` is empty.
        model_family (required if ``model_name`` is omitted): Explicit
            family identifier. Valid values: ``sd15``, ``sdxl``,
            ``flux``, ``sd3``, ``cascade`` (aliases like ``sd1.5``,
            ``stable-diffusion-xl``, ``flux.1``, ``sd3.5``,
            ``stable-cascade`` are also accepted).

    Returns:
        Dict ``{"family": "<id>", "recommended": {<settings>}}`` where
        ``recommended`` always contains the keys ``sampler`` (str),
        ``scheduler`` (str), ``steps`` (int), ``cfg`` (float),
        ``resolution`` (str like ``"1024x1024"``), ``clip_skip`` (int),
        and ``notes`` (str). Callers that only need the settings can
        read ``result["recommended"]`` directly.
    

    The guide is static data baked into this MCP — it gives stylistic
    and structural advice tuned to each family (prompt structure,
    weighting syntax conventions, recommended quality tags, negative
    prompt tips). It does not reflect the connected ComfyUI server's
    installed models or state.

    Args:
        model_family (required): Family identifier. Valid values:
            ``sd15``, ``sdxl``, ``flux``, ``sd3``, ``cascade`` (aliases
            like ``sd1.5``, ``stable-diffusion-xl``, ``flux.1``,
            ``sd3.5``, ``stable-cascade`` are also accepted).

    Returns:
        Dict ``{"family": "<id>", "guide": {<advice>}}`` where ``guide``
        always contains the keys ``prompt_structure`` (str),
        ``weight_syntax`` (str), ``quality_tags`` (list[str]), and
        ``negative_prompt_tips`` (str). Callers that only need the
        advice can read ``result["guide"]`` directly.
    

    Uses server-side `/history?offset=N&max_items=M` so callers can page
    arbitrarily far back. The tool requests one extra entry per page so it
    can set ``has_more`` without an additional round-trip.

    Args:
        limit: Maximum number of results to return (default: 25, max: 100)
        offset: Zero-based starting index (default: 0)

    Returns:
        Envelope with keys ``items``, ``count`` (items in this page),
        ``offset``, ``limit``, ``has_more``, and ``total``.

        ``total`` is set only when we can prove the true count:

        - ``offset + count`` on the last page when ``count > 0``
          (the upstream returned at most ``limit`` entries, so we've seen
          everything from ``offset`` onward).
        - ``0`` when ``offset == 0`` and the upstream returned nothing
          (history is genuinely empty).
        - ``None`` otherwise (``has_more`` is True, OR we paged past the
          end and got back an empty result — in the latter case the true
          count is somewhere in ``[0, offset]`` and we can't tell which).

        ``has_more`` is the canonical end-of-history signal.
    

    Returns a flat unified job object with top-level keys: prompt_id, status
    (pending/in_progress/completed/failed/cancelled), timing fields (created_at,
    started_at, completed_at, execution_duration), outputs (when completed),
    and error (when failed). Use this to check on a job that may be queued,
    running, or already finished.

    Note: this replaces the previous /history/{prompt_id} envelope shape
    (`{prompt_id: {...}}`); callers should index fields directly on the
    returned object.
    

    Returns {"jobs": [...], "pagination": {"offset", "limit", "total", "has_more"}}.
    Each job includes prompt_id, status (pending/in_progress/completed/failed/cancelled),
    timing, and outputs (when completed).
    

    Without prompt_id: global interrupt — stops whatever is running now.
    With prompt_id: targeted — only interrupts if that prompt is the
    running one. ComfyUI silently no-ops if prompt_id is queued but
    not yet running.
    

    Args:
        clear_running: Stop the currently running workflow
        clear_pending: Remove pending workflows from the queue
    

    Returns status (queued/running/completed/error/unknown), queue position,
    and output files when available. Step progress and current node are only
    available when using wait=True on run_workflow/generate_image (WebSocket).

    Args:
        prompt_id: The prompt_id returned by run_workflow or generate_image.
    

    Returns:
        Base64-encoded image data with content type prefix, or a direct image URL.
        When response_format='data_uri' and preview_format is set, ComfyUI re-encodes
        the image server-side as a smaller webp or jpeg thumbnail.
    

    Args:
        limit: Maximum number of results to return (default: 25, max: 100)
        offset: Starting index for pagination (default: 0)

    Returns:
        JSON envelope with paginated list of objects with 'filename' and
        'subfolder' keys. Pass these values to comfyui_get_image to retrieve files.
    

    ComfyUI embeds the full workflow JSON and prompt data in PNG text chunks.
    This enables extracting the exact settings used to generate an image
    for inspection or re-execution.

    Args:
        filename: Name of the PNG file to extract metadata from
        subfolder: Subfolder within ComfyUI's output directory (default: empty)

    Returns:
        Dict with 'workflow' (parsed JSON or None), 'prompt' (parsed JSON or None),
        and 'message' (human-readable status).
    

    See also: comfyui_run_workflow_stream for a streaming variant that emits
    per-node progress events while the workflow executes.

    Args:
        workflow: JSON string of a ComfyUI workflow (API format).
                  Each key is a node ID, each value has 'class_type' and 'inputs'.
        wait: If True, block until execution completes and return structured result
              with status, outputs, and elapsed time. If False (default), return
              immediately with just the prompt_id.
    

    Uses ComfyUI's websocket stream endpoint internally to capture per-event
    execution updates (for example, `progress`, `executing`, `executed`).
    Events are filtered by `prompt_id` when that field is present in the
    websocket payload.

    See also: comfyui_run_workflow for a non-streaming variant. Use this
    streaming version when you need real-time per-node progress events
    (intended for tooling that surfaces progress to a user); use the
    non-streaming variant for fire-and-forget submission or when you only
    need the final result.

    Args:
        workflow: JSON string of a ComfyUI workflow (API format).
    

    The input image must already be uploaded to ComfyUI via comfyui_upload_image.
    

    Both the input image and mask must already be uploaded via
    comfyui_upload_image/comfyui_upload_mask.
    White regions in the mask indicate areas to regenerate.
    

    The input image must already be uploaded to ComfyUI via comfyui_upload_image.
    The scale factor is determined by the upscale model (e.g. RealESRGAN_x4plus = 4x).
    

    Available templates: ``txt2img``, ``img2img``, ``upscale``, ``inpaint``,
    ``txt2vid_animatediff``, ``txt2vid_wan``, ``controlnet_canny``,
    ``controlnet_depth``, ``controlnet_openpose``, ``ip_adapter``,
    ``lora_stack``, ``face_restore``, ``flux_txt2img``, ``sdxl_txt2img``.

    Args:
        template (required): Template name from the list above.
        params (optional): JSON string of parameter overrides. Defaults to
            an empty string, meaning "use template defaults". Pass either
            ``""`` or ``"{}"`` for no overrides. Common keys:
            ``prompt``, ``negative_prompt``, ``width``, ``height``,
            ``steps``, ``cfg``, ``model``, ``denoise``, ``controlnet_model``,
            ``control_strength``, ``lora_name``, ``lora_strength``.

    Example:
        ``comfyui_create_workflow(template="txt2img",
        params='{"prompt": "a sunset", "width": 768, "steps": 30}')``
    

    Operations execute sequentially in array order. If any operation fails,
    the call raises ``ValueError`` and the input workflow is left
    unmodified (atomic — operations are applied to a deep copy).

    Args:
        workflow (required): JSON string of the workflow to modify.
        operations (required): JSON string of an array of operation objects.

    Operation reference:

    - ``add_node`` — append a new node. Fields:
      ``{"op": "add_node", "class_type": "<NodeType>",
         "node_id": "<id>" (optional, auto-assigned if omitted),
         "inputs": {...} (optional default inputs)}``
    - ``remove_node`` — drop a node. Fields:
      ``{"op": "remove_node", "node_id": "<id>"}``
    - ``set_input`` — set or replace a single input value. Fields:
      ``{"op": "set_input", "node_id": "<id>",
         "input_name": "<key>", "value": <any>}``
    - ``connect`` — wire one node's output into another's input. Fields:
      ``{"op": "connect", "from_node": "<id>", "from_output": <int>,
         "to_node": "<id>", "to_input": "<key>"}``
    - ``disconnect`` — clear an existing input connection. Fields:
      ``{"op": "disconnect", "node_id": "<id>", "input_name": "<key>"}``

    Example:
        ``operations='[{"op": "set_input", "node_id": "3",
        "input_name": "steps", "value": 50},
        {"op": "add_node", "class_type": "LoraLoader"}]'``
    

    Unlike ``comfyui_summarize_workflow`` (which formats a human-readable
    text or Mermaid summary), this tool returns the raw analysis as a dict
    so callers can read individual fields directly without parsing prose.

    Args:
        workflow (required): JSON string of the workflow to analyze. The
            workflow JSON is a dict keyed by node ID; each value has
            ``class_type`` and ``inputs``.

    Returns:
        Dict with keys:

        - ``node_count`` (int): number of nodes in the workflow.
        - ``class_types`` (list[str]): every ``class_type`` in topological
          order.
        - ``flow`` (list[dict]): per-node info — ``node_id``, ``class_type``,
          ``display_name``, ``inputs`` — in topological order.
        - ``models`` (list[dict]): single-field loader values, e.g.
          ``[{"name": "v1-5-pruned.safetensors", "type": "checkpoints"}]``.
        - ``parameters`` (dict): flat key/value of common sampler/latent
          parameters extracted from the graph (``steps``, ``cfg``, ``width``,
          ``height``, etc.).
        - ``pipeline`` (str): coarse type — one of ``txt2img``,
          ``img2img``, ``upscale``, ``img2img -> upscale``,
          ``txt2img -> upscale``, or ``unknown``.
        - ``prompt_nodes`` (list[str]): ids of ``CLIPTextEncode`` nodes
          that are NOT wired into any sampler's ``negative`` input
          (the analyzer treats every non-negative CLIPTextEncode as
          a positive prompt — it does not separately verify that it
          is wired into a sampler's positive input).
        - ``negative_nodes`` (list[str]): ids of ``CLIPTextEncode`` nodes
          wired into a sampler's ``negative`` input.

    Display-name enrichment is best-effort via ComfyUI's ``/object_info``
    endpoint; if the server is unreachable, ``display_name`` falls back to
    the bare ``class_type``.
    

    Checks: node structure, connection references, installed node types,
    available models, dangerous nodes, and suspicious inputs.

    Args:
        workflow (required): JSON string of the workflow to validate.

    Returns:
        Dict with keys:

        - ``valid`` (bool): True only if there are zero entries in ``errors``.
        - ``errors`` (list[str]): blocking issues — invalid structure,
          connections that reference nonexistent nodes, ``class_type``
          not installed on the connected server, missing required
          inputs, security blocks, etc. Each entry is a human-readable
          string identifying the offending node id and what's wrong.
        - ``warnings`` (list[str]): non-blocking concerns — missing model
          files, dangerous node names, suspicious input patterns
          (e.g. ``__import__``), or a server-unreachable note when the
          installed-class_type check has to be skipped.
        - ``node_count`` (int): number of nodes in the workflow.
        - ``pipeline`` (str): coarse type — one of ``txt2img``,
          ``img2img``, ``upscale``, ``img2img -> upscale``,
          ``txt2img -> upscale``, or ``unknown``. (For the full
          structural breakdown, use ``comfyui_analyze_workflow``.)
    

    Returns:
        JSON with search results including name, download URL, size, and stats.
        Use comfyui_download_model with the URL to install a model.
    

    Returns:
        JSON with download task status. Use comfyui_get_download_tasks to check progress.
    

    Returns:
        JSON with list of download tasks including progress, speed, and status.
    

    Args:
        task_id: ID of the download task to cancel
    

    Args:
        query: Search term to match against installed node pack metadata.
        limit: Maximum number of results to return (default: 10, max: 25)
        offset: Starting index for pagination (default: 0)

    Returns:
        JSON with matching node packs including name, description, author,
        install status, version, and ID.
    

    Args:
        node_id: Node pack ID from the registry (use search_custom_nodes to find IDs).
        version: Specific version to install (empty string = latest).
        restart: If True, restart ComfyUI after install and run a security audit
                 on all installed nodes. If False, manual restart is needed.

    Returns:
        Status message. If restart=True, includes security audit results.
    

    Args:
        node_id: Node pack ID to uninstall.
        restart: If True, restart ComfyUI after uninstall.

    Returns:
        Status message.
    

    Args:
        node_id: Node pack ID to update.
        restart: If True, restart ComfyUI after update and run a security audit
                 on all installed nodes.

    Returns:
        Status message. If restart=True, includes security audit results.
    

    Returns:
        JSON with queue status: total tasks, completed, in progress, and
        whether the queue is currently processing.