yolo-learn.vercel.app

{
  "name": "list_flows",
  "kind": "answer",
  "impl": "imperative",
  "description": "List taught clinic flows AND remembered public sites. Each remembered origin is also its own WebMCP tool (remembered_<host>). Call that tool instead of fetching; pass refresh=true only to re-read.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "check_flow_health",
  "kind": "answer",
  "impl": "imperative",
  "description": "Compare a taught flow against the demo site as it looks right now. Returns every change in plain English, which changes heal by themselves, and the questions that need an answer from the user. Omit the arguments to check every flow at once.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "flowId": {
        "type": "string",
        "description": "Flow id from list_flows"
      },
      "flowName": {
        "type": "string",
        "description": "Flow name, if you do not have the id"
      }
    }
  }
}

{
  "name": "run_flow",
  "kind": "act",
  "impl": "imperative",
  "description": "Run a taught flow on the demo site. Every step is animated on screen and the user must approve the final submit before anything is sent. Values you do not supply fall back to what the user demonstrated.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "flowId": {
        "type": "string",
        "description": "Flow id from list_flows"
      },
      "flowName": {
        "type": "string",
        "description": "Flow name, if you do not have the id"
      },
      "params": {
        "type": "object",
        "description": "Parameter values, keyed as listed by list_flows"
      }
    }
  }
}

{
  "name": "heal_flow",
  "kind": "act",
  "impl": "imperative",
  "description": "Repair a drifted flow so it matches the site as it looks now. Renames, reorders, removals and reworded buttons are healed from the site itself. Pass the user's answers for anything check_flow_health asked about.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "flowId": {
        "type": "string",
        "description": "Flow id from list_flows"
      },
      "flowName": {
        "type": "string",
        "description": "Flow name, if you do not have the id"
      },
      "answers": {
        "type": "array",
        "description": "One entry per question from check_flow_health",
        "items": {
          "type": "object",
          "properties": {
            "questionId": {
              "type": "string"
            },
            "answer": {
              "type": "string"
            }
          },
          "required": [
            "questionId",
            "answer"
          ]
        }
      }
    }
  }
}

{
  "name": "get_run_status",
  "kind": "answer",
  "impl": "imperative",
  "description": "Report the run in progress, or the last one that finished, in this tab. Call this when a run_flow call never returned: a page navigation or a reload destroys the promise you were waiting on, but not the run itself. It picks up where it stopped and the outcome lands here and in the flow's history. Also tells you whether it is currently waiting on the human at an approval gate.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "audit_page",
  "kind": "act",
  "impl": "imperative",
  "description": "Run three specialist passes over the page currently on screen and return their findings. The bug scout checks structure and semantics, the workflow checker asks whether the task can actually be completed, and the theme critic measures contrast and target sizes. Every finding cites the rule that produced it and says whether that rule is a published standard or a preference of this app's. Anything not computable is returned as unknown rather than as a pass. A second call on the same page shape returns a diff against the first.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "lenses": {
        "type": "array",
        "description": "Which passes to run. Defaults to all three.",
        "items": {
          "type": "string",
          "enum": [
            "bugs",
            "workflow",
            "theme"
          ]
        }
      }
    }
  }
}

{
  "name": "audit_url",
  "kind": "act",
  "impl": "imperative",
  "description": "Audit any public web page by URL. The page is fetched server-side, because a browser cannot read another origin, then measured in this browser in a sandboxed frame with scripts disabled. Returns the same three lenses as audit_page. Two limits worth passing on to the user: no JavaScript from the target runs, so a client-rendered site will look nearly empty, and private or reserved addresses are refused.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "url": {
        "type": "string",
        "description": "An http or https URL of a public page"
      }
    },
    "required": [
      "url"
    ]
  }
}

{
  "name": "recall_url",
  "kind": "answer",
  "impl": "imperative",
  "description": "Ask whether a real site's task is already known, WITHOUT fetching it. Call this before learn_url on any URL. A hit returns the stored steps and fields immediately and costs no page read at all, which is the whole point: an agent that re-reads a site's DOM on every visit pays that cost forever. Keyed by origin and a fingerprint of the task's shape, so ordinary content churn does not invalidate it.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "url": {
        "type": "string",
        "description": "An http or https URL"
      }
    },
    "required": [
      "url"
    ]
  }
}

{
  "name": "learn_url",
  "kind": "act",
  "impl": "imperative",
  "description": "Read a task on a real public site, then remember it so the next visit does not re-read. Call recall_url first. STRICTLY READ-ONLY (GET only, never submits). Pass pages as the URLs the user already opened, in order, to learn after they navigated by hand. No browser extension.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "url": {
        "type": "string",
        "description": "An http or https URL of a public page"
      },
      "pages": {
        "type": "array",
        "items": {
          "type": "string"
        },
        "description": "URLs the user opened, in order. Use this after they navigated by hand."
      },
      "force": {
        "type": "boolean",
        "description": "Re-read even if known, to detect a changed shape"
      }
    }
  }
}

{
  "name": "learn_markup",
  "kind": "act",
  "impl": "imperative",
  "description": "Learn a task from HTML the user (or you) already rendered in a real browser, including a logged-in page. Pass the page url and the painted markup. Cookies stay in that browser; password and card fields are stripped. Use this when learn_url cannot see fields because they exist only after login.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "url": {
        "type": "string",
        "description": "The http(s) URL of the tab the markup came from"
      },
      "html": {
        "type": "string",
        "description": "document.documentElement.outerHTML from that tab"
      }
    },
    "required": [
      "url",
      "html"
    ]
  }
}

{
  "name": "get_site_info",
  "kind": "answer",
  "impl": "imperative",
  "description": "Report the demo site's current version and its changelog, so you can explain what changed.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "recall_page",
  "kind": "answer",
  "impl": "imperative",
  "description": "Ask whether this page is already known. Call this FIRST on any page, before learn_site. Returns one of three states: miss (nothing known here, go and learn it), hit (already known and the page still matches what was stored, so run it immediately with nothing to re-read and nothing to ask), or stale (known but the page changed, so heal it first). This is a cache lookup keyed by origin and a fingerprint of the page's structure, so a hit is free.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "learn_site",
  "kind": "act",
  "impl": "imperative",
  "description": "Learn the task on the current page autonomously, with no human demonstration. Reads the form the way a screen reader would - labels, field names, required flags, option lists - walks the wizard with throwaway values, and mints a tool for what it found. Every field it discovers becomes a parameter you supply at call time; it never invents a person's details. It will not press a button unless that button clearly means \"next\", so it cannot submit anything. Safe to call on a page that is already known: it checks first and returns the existing flow rather than learning a duplicate. Pass force to re-read deliberately.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "force": {
        "type": "boolean",
        "description": "Re-read even if this page is already known, instead of returning what is stored"
      }
    }
  }
}

{
  "name": "start_teaching",
  "kind": "act",
  "impl": "imperative",
  "description": "Put the page into teach mode so the user can demonstrate a task by hand, and remember the values they enter. Prefer learn_site when you only need the shape of the task; use this when the user wants their own details replayed on every run. Either way the app mints a tool immediately, in this same session.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "flowName": {
        "type": "string",
        "description": "Short snake_case name, for example book_appointment"
      }
    }
  }
}