since-cutoff

List the public API changes of one PyPI package since a model's training cutoff. Use it before writing code against a library version that may have been released after your training cutoff (check the lockfile or requirements for the version), or when code fails on a name, import or parameter of that library. Pass `symbol` to see only the functions or classes you are about to use. For all dependencies of a project in one call, use project_changes. Compares the newest final release on or before the cutoff (or `from_version`) with `to_version` (default: the latest final release on PyPI). Read-only: downloads the two releases' wheels from PyPI (80 MB at most each, by default) and reads their sources statically. No package code runs and no model is called. The first call for a package takes a few seconds, up to a minute or two for very large packages; the result is cached, and later calls take about a second. One of `model`, `cutoff` or `from_version` is required. Returns Markdown: a "# <package> <old> -> <new>" heading; bullets with both versions and their release dates and the number of breaking changes and new deprecations by kind; then sections "Dependencies switched" (the package requires another library instead of one it required, such as `httpx2` instead of `httpx`, and its signatures take that library's objects), "Removed or moved", "Parameters removed", "Parameters now required", "Changed kind", "Now keyword-only or positional-only" and "Deprecated", one line per change with what to use instead when the diff knows it (the new import, the new signature, a parameter probably renamed in place, what the old version's deprecation text said), and names that merely look similar, labelled as not confirmed. A change reachable under several import paths is listed once. If the package had no release by the cutoff, a short note says its whole API was released after your reported training cutoff.

Look up a model's training cutoff: library releases after it may be missing from its training data. Use it to find or confirm your own cutoff. The other two tools do not need it first: they take `model` and look the cutoff up themselves. Read-only and quick (about a second): no model is called. The cutoffs come from the models.dev catalogue, fetched at most once a day and cached; without network access a cached or bundled copy is used. Returns one short paragraph of plain text: "<id> (<provider>, <name>): training cutoff YYYY-MM-DD. Released YYYY-MM-DD. Source: models.dev", then the api_changes and project_changes calls to make with that id. An unknown id is a tool error that lists close matches.

Check every dependency of a Python project for API changes since a training cutoff. Use it at the start of work on a project, or before adding code that uses its dependencies: one call covers every direct dependency at the version the project pins. For a single package, a single symbol, or a version the project does not pin, api_changes is faster. Reads the project's lockfile (uv.lock, poetry.lock, pdm.lock, pylock.toml, Pipfile.lock), requirements*.txt, pyproject.toml or .venv, and for each direct dependency compares the release that existed at the cutoff with the pinned one. Changes to names the project's code uses, in packages it imports, come first. Read-only: nothing in the project is written. Reads PyPI metadata, downloads the wheels of the dependencies that changed and reads them statically; no package code runs and no model is called. The first call on a project with many dependencies can take several minutes (large packages such as transformers take longest); results are cached, so later calls take seconds. Running `since-cutoff scan` in the project once fills the same cache. Reports progress while it works if the client asks for it. One of `model` or `cutoff` is required. Returns Markdown: a heading with the number of dependencies checked and where their versions came from; bullets with the cutoff, how many of the changed APIs the project's code uses, and how many dependencies changed, were first released after the cutoff, are unchanged, or could not be checked; then "## Your code uses these changed APIs": each changed API the code uses, with what changed, "old form" (the code uses it as the release at the cutoff allowed) or "uses this API", the files that use it (at most 3), the note to follow with its tag ([diff]: from the static diff; [library]: the replacement is named in the library's own deprecation text), the runtime caveat when the pinned source still accepts a removed name, and similar names, not confirmed as replacements; then one "## <pack…