Skip to content

v4.7.0

Choose a tag to compare

@github-actions github-actions released this 07 Nov 06:31
· 47 commits to main since this release

The published specification was invalid, and nothing checked

Three descriptions in openapi.yaml held a comma inside a YAML flow mapping,
which parses as a second key. The document was therefore invalid, and every
client generator refused it outright — not a route, the whole file. It had been
that way through several releases, with every guard green, because nothing in
the build had ever asked a parser.

Reading the document did not find it. Generating a client from it found it in
one run, which is the lesson worth keeping: a generator is the first reader
of a specification that does not forgive.

The document is now linted on every push, and a second defect came out with the
first: only six of fifty-six responses declared a schema, and those six were
wrong. All fifty-six now carry a named schema, reconstructed from the reference
examples and the handler types, including the citation shape that only the
reference's second example showed. Three arrays that said "array of
something" without saying of what — a notebook's tags, an import's errors, a
notebook's collaborators — now say it; a generator turned each of them into an
untyped blob the caller had to inspect at runtime.

The UTCP manual is generated from that specification, so it inherited
everything: all 56 operations now describe what they answer, and the manual no
longer points at definitions it does not carry.

The Rust client covers the whole API, and is generated

The crate started with seven methods written by hand, which meant a route added
tomorrow reached no Rust caller and no guard noticed. The entire surface — 56
operations, 119 types, plus the synchronous twin — is now generated from the
specification and formatted before it is written, so the drift guard never
cries wolf.

Generation exposed four defects a hand-written client makes by accident. A
field we send and a field we receive want opposite defaults, because sending an
empty string asks the server for a notebook named empty string. Closing a
struct against future fields is right for what we receive and wrong for what
the caller sends — it stopped them building the request at all. An integer the
specification marks as possibly absent was becoming an untyped value, and
therefore zero on reading: exactly the trap this crate documents, where a
null offset attributes a quotation to the top of a long document. And the two
routes that answer with their own document rather than the envelope failed on
a missing success field.

The minimum supported Rust version is 1.88, verified by building with it rather
than claimed.

A Ruby client, from the same specification

gems/notebooklm publishes to RubyGems as notebooklm: the same 56
operations, generated the same way, with every response shape documented field
by field. The Ruby shelf for the consumer product was empty — no gem at all —
and the gem that fills it has no runtime dependencies, and none in its
tests either: the stub server they run against is built out of TCPServer,
which exercises the real HTTP path where a mocking library would replace the
part worth testing.

Ruby needs fewer helpers than Rust, and the gem ships none: keyword arguments
with defaults already read like a builder. What it does guarantee is the
honesty the generated types buy in Rust — an absent scalar reads as nil, never
as zero or an empty string; an absent nested shape reads as an empty shape, so
a chain holds without a guard at every hop; a field the server adds later stays
reachable, so an unknown shape is never a wall; and a refusal keeps the
server's own wording, separate from a request that never arrived.

Publishing uses RubyGems trusted publishing, which — unlike npm and crates.io —
needs no bootstrap token at all: a pending publisher can be configured before
the first version exists. So there is no gem token anywhere.

Eight capabilities to take from the Go tool

The Go command-line tool is ahead of us on sources and notes. Its eight
capabilities worth having are now in the roadmap, each naming the file to read
in its MIT-licensed source rather than a vague aspiration: content-addressed
sync with receipts, automatic splitting of oversized sources, source matching
by name, citation resolution, note rendering, label ingestion, flashcard export
and research sourcing.

Two articles

Driving it from Ruby,
and generating a client for any language in ten seconds
— measured across Python, Go and Ruby, with an honest account of what a
generated client does not give you.



Install / upgrade: npm i -g @roomi-fields/notebooklm-mcp@4.7.0

Full changelog: https://github.com/roomi-fields/notebooklm-mcp/blob/main/CHANGELOG.md