echoact 0.1.0__py3-none-any.whl

echoact/mcp/server.py

@@ -0,0 +1,340 @@
+"""The MCP server: eight tools, each one REST call, and nothing else.
+
+F-59 is unusually strict about this and it is worth restating, because the
+temptation to be helpful here is what would break it: each tool maps onto
+one REST operation and adds no capability REST does not already expose.
+N-24 makes the REST contract canonical and MCP a projection of it, so a
+behaviour difference between the two is a defect -- which is why these
+tools pass the service's JSON through rather than re-modelling it.  A
+second model of the same data is a second thing to keep in step, and it
+would not stay in step.
+
+The revision this implements, 2026-07-28, is stateless and has no
+connection-establishing handshake, so:
+
+* Nothing is cached between calls and no session is opened.  The
+  connection is read once at start-up because it is configuration, not
+  state.
+* Cross-call state travels as a server-minted job identifier passed as an
+  ordinary tool argument -- which is what ``job_id`` is.
+* Result references are MCP resource URIs, and they are identifiers
+  rather than addresses.  ``echoact://job/<id>/audio`` names a thing; it
+  carries no host, no filesystem path, and no credential, and resolving
+  it requires this process's own credential.  §2.11 forbids the
+  alternatives by name.
+* Resource reads are cacheable on this revision, so every reference
+  carries a freshness hint no longer than the result's remaining lifetime
+  and is marked private, so no shared intermediary may hold one owner's
+  audio.  The hint travels on the reference the tool returns.  The
+  protocol's own ``ttlMs``/``cacheScope`` on a read default to 0 and
+  private in this SDK, which is stricter than the requirement rather than
+  looser, so the two agree and neither has to be argued about.
+
+Diagnostics go to stderr.  The revision deprecates the protocol's own
+logging and §2.11 says so explicitly.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Annotated, Any
+
+from ..errors import Code, EchoActError
+from ..policy import BOUNDED_WAIT_CEILING_S, MCP_PROTOCOL_REVISION
+from ..util import ids
+from .client import RestClient, describe
+from .config import Connection
+
+SERVER_NAME = "echoact"
+RESOURCE_SCHEME = "echoact"
+
+INSTRUCTIONS = """\
+EchoAct generates Korean and English speech locally, on this machine.
+
+One generation runs at a time across the whole application, including the
+person sitting at it, so contention is normal: a busy answer carries a
+retry_after_s and giving up is a reasonable response to it.
+
+Call estimate_speech before create_speech for anything long: it validates,
+counts segments, gives the expected length, and says whether the slot is
+free, without creating a job or loading a model.
+
+create_speech needs an idempotency_key. Reuse the same key when you retry
+and you will get the same job back rather than a second rendering.
+"""
+
+
+def _stderr(message: str) -> None:
+    print(f"[echoact-mcp] {message}", file=sys.stderr, flush=True)
+
+
+def audio_uri(job_id: str, segment_id: str | None = None) -> str:
+    if segment_id:
+        return f"{RESOURCE_SCHEME}://job/{job_id}/segment/{segment_id}"
+    return f"{RESOURCE_SCHEME}://job/{job_id}/audio"
+
+
+def _ttl_ms(result: dict[str, Any], now: float | None = None) -> int:
+    """A freshness hint that cannot outlive the result.
+
+    F-60 caps the hint at the remaining lifetime in 4.1.  A retained
+    result has no expiry, and a hint that never goes stale would still be
+    wrong -- the owner may delete it -- so it is capped at the one-hour
+    figure the same section uses for a one-off.
+    """
+    moment = ids.now() if now is None else now
+    expires = result.get("expires_at")
+    if expires is None:
+        return 3_600_000
+    remaining = float(expires) - moment
+    return max(0, int(remaining * 1000))
+
+
+def build(connection: Connection, *, client: RestClient | None = None):
+    """Construct the server.  Takes a client so a test can supply one."""
+    from fastmcp import FastMCP
+
+    rest = client or RestClient(connection)
+    mcp = FastMCP(
+        name=SERVER_NAME,
+        instructions=INSTRUCTIONS,
+        version="0.1.0",
+    )
+
+    def call(fn):
+        """Run one REST call, and turn a failure into a described result.
+
+        A tool that raised would give the client an exception where F-57
+        promises a code, whether a retry can succeed, and a request
+        identifier.  So failures come back as data.
+        """
+        try:
+            return fn()
+        except EchoActError as exc:
+            if exc.code in {Code.APP_NOT_RUNNING, Code.SERVICE_OFF, Code.MCP_DISABLED}:
+                _stderr(f"{exc.code.value}: {exc.message}")
+            return describe(exc)
+
+    # -- discovery ------------------------------------------------------
+
+    @mcp.tool
+    def list_models() -> dict[str, Any]:
+        """Models, voices, languages, speaking styles and input limits.
+
+        Every voice carries a description as well as an identifier,
+        because an identifier alone gives a caller that is not a person
+        nothing to choose on (F-53).
+        """
+        return call(lambda: rest.get("/models"))
+
+    @mcp.tool
+    def estimate_speech(
+        text: Annotated[str, "The text to be spoken."],
+        model_id: Annotated[str, "From list_models."],
+        voice_id: Annotated[str, "A voice belonging to that model."],
+        gender: Annotated[str, "female or male; must match the voice's own."],
+        language: Annotated[str, "auto, ko or en."] = "auto",
+        style: Annotated[str, "natural, calm, bright or narration."] = "natural",
+        tempo: Annotated[float, "0.70 to 1.50."] = 1.0,
+    ) -> dict[str, Any]:
+        """Validate and estimate without creating a job or loading a model.
+
+        Answers with the segment count, the expected audio length and
+        synthesis time, and whether the single generation slot is free.
+        The figures are approximate by construction: they come from the
+        model's recorded throughput, not from a trial run (F-88).
+        """
+        body = {
+            "text": text,
+            "kind": "speech",
+            "voice": _voice_body(model_id, voice_id, gender, language, style, tempo),
+        }
+        return call(lambda: rest.post("/estimate", body))
+
+    # -- generation -----------------------------------------------------
+
+    @mcp.tool
+    def create_speech(
+        text: Annotated[str, "The text to be spoken. Files and URLs are not accepted."],
+        idempotency_key: Annotated[
+            str, "Required. Reuse it on a retry to get the same job back rather than a second one."
+        ],
+        model_id: Annotated[str, "From list_models."],
+        voice_id: Annotated[str, "A voice belonging to that model."],
+        gender: Annotated[str, "female or male; must match the voice's own."],
+        language: Annotated[str, "auto, ko or en."] = "auto",
+        style: Annotated[str, "natural, calm, bright or narration."] = "natural",
+        tempo: Annotated[float, "0.70 to 1.50."] = 1.0,
+        wait_seconds: Annotated[
+            float | None,
+            "Wait up to this long for the job to finish before answering. "
+            "The job is untouched either way; if the bound passes you get the job id.",
+        ] = None,
+        retain: Annotated[bool, "Keep the result in EchoAct's library."] = False,
+    ) -> dict[str, Any]:
+        """Start generating speech.
+
+        Returns the job's state.  If it finished inside ``wait_seconds``
+        the answer is terminal; otherwise it carries the job id and the
+        job continues untouched.  Waiting never covers model preparation.
+
+        File and URL inputs are not accepted: N-18 keeps arbitrary paths
+        and external URLs out of what an integration can ask EchoAct to
+        read.
+        """
+        body: dict[str, Any] = {
+            "kind": "speech",
+            "idempotency_key": idempotency_key,
+            "text": text,
+            "retain": retain,
+            "voice": _voice_body(model_id, voice_id, gender, language, style, tempo),
+        }
+        if wait_seconds is not None:
+            body["wait_s"] = max(0.0, min(float(wait_seconds), BOUNDED_WAIT_CEILING_S))
+        return call(lambda: rest.post("/jobs", body))
+
+    @mcp.tool
+    def get_speech_job(job_id: Annotated[str, "From create_speech."]) -> dict[str, Any]:
+        """State, progress and any error for one of your own jobs."""
+        return call(lambda: rest.get(f"/jobs/{job_id}"))
+
+    @mcp.tool
+    def cancel_speech_job(job_id: Annotated[str, "From create_speech."]) -> dict[str, Any]:
+        """Cancel one of your own jobs.
+
+        Cancelling twice adds nothing, and cancelling a job that already
+        finished returns its final state rather than changing it.  This is
+        not the same as cancelling the MCP request itself.
+        """
+        return call(lambda: rest.post(f"/jobs/{job_id}/cancel"))
+
+    @mcp.tool
+    def list_speech_segments(job_id: Annotated[str, "From create_speech."]) -> dict[str, Any]:
+        """Ready segments, with their source-text range and their times.
+
+        Ranges are Unicode code point offsets into the text you supplied,
+        start inclusive and end exclusive, and times are milliseconds from
+        the start of the audio.
+        """
+        return call(lambda: rest.get(f"/jobs/{job_id}/segments"))
+
+    @mcp.tool
+    def get_speech_result(
+        job_id: Annotated[str, "From create_speech."],
+        segment_id: Annotated[str | None, "From list_speech_segments, for one segment."] = None,
+    ) -> dict[str, Any]:
+        """A reference to the finished audio, and what it is.
+
+        The audio is not embedded here.  You get a resource URI to read
+        over this same session, plus the format, rate, size, length and
+        expiry.  The URI is an identifier, not an address: it holds no
+        path and no credential, and only this server can resolve it.
+        """
+
+        def fetch() -> dict[str, Any]:
+            result = rest.get(f"/jobs/{job_id}/result")
+            uri = audio_uri(job_id, segment_id)
+            ttl = _ttl_ms(result)
+            return {
+                **result,
+                "resource": {
+                    "uri": uri,
+                    "mime_type": "audio/wav",
+                    # F-60: no longer than the remaining lifetime, and
+                    # private so no shared cache may hold one owner's audio.
+                    "ttl_ms": ttl,
+                    "cache_scope": "private",
+                },
+            }
+
+        return call(fetch)
+
+    @mcp.tool
+    def list_speech_history(
+        limit: Annotated[int | None, "Up to 100."] = None,
+        model: Annotated[str | None, "Filter by model id."] = None,
+        state: Annotated[str | None, "Filter by job state."] = None,
+    ) -> dict[str, Any]:
+        """Your own retained jobs, if your credential may read history.
+
+        A summary without body text is what you get; the source text of a
+        retained job needs its own permission and its own request.
+        """
+        return call(lambda: rest.get("/jobs", limit=limit, model=model, state=state))
+
+    # -- resources ------------------------------------------------------
+
+    @mcp.resource(
+        f"{RESOURCE_SCHEME}://job/{{job_id}}/audio",
+        name="Finished audio",
+        mime_type="audio/wav",
+        description="The complete WAV for a job, resolved on your behalf.",
+    )
+    def job_audio(job_id: str) -> bytes:
+        payload, _ = rest.get_bytes(f"/jobs/{job_id}/audio")
+        return payload
+
+    @mcp.resource(
+        f"{RESOURCE_SCHEME}://job/{{job_id}}/segment/{{segment_id}}",
+        name="Segment audio",
+        mime_type="audio/wav",
+        description="One ready segment's WAV, resolved on your behalf.",
+    )
+    def segment_audio(job_id: str, segment_id: str) -> bytes:
+        payload, _ = rest.get_bytes(f"/jobs/{job_id}/segments/{segment_id}/audio")
+        return payload
+
+    return mcp
+
+
+def _voice_body(
+    model_id: str,
+    voice_id: str,
+    gender: str,
+    language: str,
+    style: str,
+    tempo: float,
+) -> dict[str, Any]:
+    """The settings, stated in full, exactly as the REST contract wants them.
+
+    Nothing here falls back to the owner's current selection, and that is
+    the service's decision rather than this module's: an automated
+    caller's output must not depend on what the person at the keyboard
+    last clicked.  So the tools require the three fields that identify a
+    voice and let ``list_models`` be the place a caller learns them --
+    which is also why they are required *parameters* rather than a
+    runtime error, since a tool schema can say so and an error cannot.
+    """
+    return {
+        "model_id": model_id,
+        "voice_id": voice_id,
+        "gender": gender,
+        "language": language,
+        "style": style,
+        "tempo": tempo,
+    }
+
+
+def preflight(rest: RestClient) -> dict[str, Any]:
+    """Check that this process can be useful before serving anything.
+
+    F-52 requires an app that is not running, a REST service that is off,
+    and a disabled MCP integration to be reported to the client as
+    distinct, non-retrying errors -- and requires this process never to
+    launch the app.  Doing it here means the client is told once, clearly,
+    rather than on every tool call.
+    """
+    status = rest.get("/status")
+    if not status.get("mcp_enabled", True):
+        raise EchoActError(
+            Code.MCP_DISABLED,
+            "MCP is turned off in EchoAct. Enable it under Settings; "
+            "this server cannot enable it.",
+        )
+    revision = status.get("mcp_protocol_revision")
+    if revision and revision != MCP_PROTOCOL_REVISION:
+        _stderr(
+            f"EchoAct reports MCP revision {revision}; this server implements "
+            f"{MCP_PROTOCOL_REVISION}."
+        )
+    return status

echoact/models/catalog.py

@@ -0,0 +1,273 @@
+"""The shipped manifest (F-84): one model, Supertonic 3.
+
+A.3 fixes the lineup at a single model, and F-04 keeps the selection
+machinery anyway so that a second one is data rather than structure.  This
+file is that data.
+
+It is a Python literal on purpose.  F-84 says manifest changes ship with the
+application and are never applied as a silent remote update; a manifest that
+could be fetched would let whoever served it redefine which bytes count as
+sound for weights already on this disk.  Changing anything here is a release.
+
+The digests below were computed over the files of
+``Supertone/supertonic-3`` at the pinned revision, on disk, with SHA-256 --
+not copied from a listing.  ``tests/test_manifest.py`` re-derives them from
+the real weights when they are present, because F-84 makes a mismatch mean
+"corrupted": an invented digest would turn every honest copy into a fake
+corruption report, which is worse than shipping no manifest at all.
+
+The licence text is quoted from the ``LICENSE`` file of that same revision.
+N-11 treats the pass-through clause as a release blocker, so it is recorded
+as an obligation the product must carry to its own users, not as a notice.
+"""
+
+from __future__ import annotations
+
+from typing import Final
+
+from ..domain import Gender, Language
+from ..policy import CPU_PERCENT_MIN, MEMORY_FLOOR_BYTES
+from .manifest import (
+    LicenseTerms,
+    Manifest,
+    MinimumBudget,
+    ModelEntry,
+    ModelFile,
+    VoiceEntry,
+)
+
+SUPERTONIC_3_ID: Final = "supertonic-3"
+
+#: Attachment A of the BigScience OpenRAIL-M licence, quoted from the
+#: ``LICENSE`` file at the pinned revision, in its own order and wording.
+#: N-11 requires these to reach the end user unchanged, and a paraphrase is
+#: what a reader would hold us to instead of the real term.
+_USE_RESTRICTIONS: Final[tuple[str, ...]] = (
+    "(a) In any way that violates any applicable national, federal, state, local or "
+    "international law or regulation;",
+    "(b) For the purpose of exploiting, harming or attempting to exploit or harm minors in "
+    "any way;",
+    "(c) To generate or disseminate verifiably false information and/or content with the "
+    "purpose of harming others;",
+    "(d) To generate or disseminate personal identifiable information that can be used to "
+    "harm an individual;",
+    "(e) To generate or disseminate information and/or content (e.g. images, code, posts, "
+    "articles), and place the information and/or content in any context (e.g. bot generating "
+    "tweets) without expressly and intelligibly disclaiming that the information and/or "
+    "content is machine generated;",
+    "(f) To defame, disparage or otherwise harass others;",
+    "(g) To impersonate or attempt to impersonate (e.g. deepfakes) others without their "
+    "consent;",
+    "(h) For fully automated decision making that adversely impacts an individual’s legal "
+    "rights or otherwise creates or modifies a binding, enforceable obligation;",
+    "(i) For any use intended to or which has the effect of discriminating against or harming "
+    "individuals or groups based on online or offline social behavior or known or predicted "
+    "personal or personality characteristics;",
+    "(j) To exploit any of the vulnerabilities of a specific group of persons based on their "
+    "age, social, physical or mental characteristics, in order to materially distort the "
+    "behavior of a person pertaining to that group in a manner that causes or is likely to "
+    "cause that person or another person physical or psychological harm;",
+    "(k) For any use intended to or which has the effect of discriminating against individuals "
+    "or groups based on legally protected characteristics or categories;",
+    "(l) To provide medical advice and medical results interpretation;",
+    "(m) To generate or disseminate information for the purpose to be used for administration "
+    "of justice, law enforcement, immigration or asylum processes, such as predicting an "
+    "individual will commit fraud/crime commitment (e.g. by text profiling, drawing causal "
+    "relationships between assertions made in documents, indiscriminate and "
+    "arbitrarily-targeted use).",
+)
+
+SUPERTONIC_3_LICENSE: Final = LicenseTerms(
+    name="BigScience OpenRAIL-M",
+    restrictions=_USE_RESTRICTIONS,
+    # Paragraph 5, quoted.  This sentence is why N-11 calls shipping the
+    # model without carrying the restrictions through a release blocker.
+    pass_through_obligation=(
+        "Paragraph 5, Use-based restrictions: “You shall require all of Your users who use "
+        "the Model or a Derivative of the Model to comply with the terms of this paragraph "
+        "(paragraph 5).” The restrictions in Attachment A therefore bind everyone who uses "
+        "EchoAct's speech generation, not only whoever installed it."
+    ),
+    acceptance_required=True,
+    notes=(
+        "Full title as it appears in the file: “BigScience Open RAIL-M License, dated "
+        "August 18, 2022”.",
+        "Paragraph 6, the Output: “Except as set forth herein, Licensor claims no rights in "
+        "the Output You generate using the Model. You are accountable for the Output you "
+        "generate and its subsequent uses. No use of the output can contravene any provision "
+        "as stated in the License.”",
+        "Paragraph 7, Updates and Runtime Restrictions: the licensor “reserves the right to "
+        "restrict (remotely or otherwise) usage of the Model” and asks that You “undertake "
+        "reasonable efforts to use the latest version of the Model”. EchoAct implements no "
+        "remote control and checks for updates only on the user's action (N-01, F-75); A.4 "
+        "leaves reading this clause against a deliberately offline product to a lawyer.",
+        "Being able to run the model locally is not a right to redistribute it (N-11); the "
+        "weights are downloaded from the source repository, never bundled.",
+    ),
+    source_file="LICENSE",
+)
+
+#: Every voice description ends with this.  A.4 records that nobody has
+#: listened to this model in either language yet, so a description that
+#: claimed a character would be invented.  F-53 still needs a caller to have
+#: something to choose on, so the descriptions carry what is verifiable and
+#: say plainly that the rest is unknown.
+_UNREVIEWED: Final = (
+    "Its voice character has not been reviewed yet, so nothing is claimed here about tone, "
+    "age or intended use (N-08)."
+)
+
+
+def _voice(voice_id: str, gender: Gender, index: int, count: int) -> VoiceEntry:
+    """One built-in style, described only as far as it has been verified."""
+    word = "male" if gender is Gender.MALE else "female"
+    return VoiceEntry(
+        voice_id=voice_id,
+        gender=gender,
+        display_name=f"{word.capitalize()} {index}",
+        description=(
+            f"Built-in Supertonic 3 style {voice_id}: {word} voice {index} of {count}. "
+            f"Reads both Korean and English, since a voice is not specific to one language "
+            f"(F-06). {_UNREVIEWED}"
+        ),
+        characterised=False,
+    )
+
+
+SUPERTONIC_3_VOICES: Final[tuple[VoiceEntry, ...]] = (
+    _voice("M1", Gender.MALE, 1, 5),
+    _voice("M2", Gender.MALE, 2, 5),
+    _voice("M3", Gender.MALE, 3, 5),
+    _voice("M4", Gender.MALE, 4, 5),
+    _voice("M5", Gender.MALE, 5, 5),
+    _voice("F1", Gender.FEMALE, 1, 5),
+    _voice("F2", Gender.FEMALE, 2, 5),
+    _voice("F3", Gender.FEMALE, 3, 5),
+    _voice("F4", Gender.FEMALE, 4, 5),
+    _voice("F5", Gender.FEMALE, 5, 5),
+)
+
+#: The four ONNX graphs and two tables the runtime loads, plus one style
+#: file per voice.  Nothing else in the repository is needed to synthesise,
+#: so nothing else is downloaded: F-73 sizes this cache and N-01 keeps the
+#: network traffic to what preparation actually requires.
+SUPERTONIC_3_FILES: Final[tuple[ModelFile, ...]] = (
+    ModelFile(
+        "onnx/duration_predictor.onnx",
+        "c3eb91414d5ff8a7a239b7fe9e34e7e2bf8a8140d8375ffb14718b1c639325db",
+        3_700_147,
+    ),
+    ModelFile(
+        "onnx/text_encoder.onnx",
+        "c7befd5ea8c3119769e8a6c1486c4edc6a3bc8365c67621c881bbb774b9902ff",
+        36_416_150,
+    ),
+    ModelFile(
+        "onnx/vector_estimator.onnx",
+        "883ac868ea0275ef0e991524dc64f16b3c0376efd7c320af6b53f5b780d7c61c",
+        256_534_781,
+    ),
+    ModelFile(
+        "onnx/vocoder.onnx",
+        "085de76dd8e8d5836d6ca66826601f615939218f90e519f70ee8a36ed2a4c4ba",
+        101_424_195,
+    ),
+    ModelFile(
+        "onnx/tts.json",
+        "42078d3aef1cd43ab43021f3c54f47d2d75ceb4e75f627f118890128b06a0d09",
+        8_253,
+    ),
+    ModelFile(
+        "onnx/unicode_indexer.json",
+        "9bf7346e43883a81f8645c81224f786d43c5b57f3641f6e7671a7d6c493cb24f",
+        277_676,
+    ),
+    ModelFile(
+        "voice_styles/M1.json",
+        "e35604687f5d23694b8e91593a93eec0e4eca6c0b02bb8ed69139ab2ea6b0a5b",
+        291_748,
+    ),
+    ModelFile(
+        "voice_styles/M2.json",
+        "b76cbf62bac707c710cf0ae5aba5e31eea1a6339a9734bfae33ab98499534a50",
+        292_055,
+    ),
+    ModelFile(
+        "voice_styles/M3.json",
+        "ea1ac35ccb91b0d7ecad533a2fbd0eec10c91513d8951e3b25fbba99954e159b",
+        290_198,
+    ),
+    ModelFile(
+        "voice_styles/M4.json",
+        "ca8eefad4fcd989c9379032ff3e50738adc547eeb5e221b82593a6d7b3bac303",
+        291_522,
+    ),
+    ModelFile(
+        "voice_styles/M5.json",
+        "dd22b92740314321f8ae11c5e87f8dd60d060f15dd3a632b5adf77f471f77af2",
+        291_469,
+    ),
+    ModelFile(
+        "voice_styles/F1.json",
+        "bbdec6ee00231c2c742ad05483df5334cab3b52fda3ba38e6a07059c4563dbc2",
+        292_046,
+    ),
+    ModelFile(
+        "voice_styles/F2.json",
+        "7c722c6a72707b1a77f035d67f0d1351ba187738e06f7683e8c72b1df3477fc6",
+        292_423,
+    ),
+    ModelFile(
+        "voice_styles/F3.json",
+        "12f6ef2573baa2defa1128069cb59f203e3ab67c92af77b42df8a0e3a2f7c6ab",
+        290_794,
+    ),
+    ModelFile(
+        "voice_styles/F4.json",
+        "c2fa764c1225a76dfc3e2c73e8aa4f70d9ee48793860eb34c295fff01c2e032b",
+        291_808,
+    ),
+    ModelFile(
+        "voice_styles/F5.json",
+        "45966e73316415626cf41a7d1c6f3b4c70dbc1ba2bee5c1978ef0ce33244fc8d",
+        291_479,
+    ),
+)
+
+SUPERTONIC_3: Final = ModelEntry(
+    model_id=SUPERTONIC_3_ID,
+    display_name="Supertonic 3",
+    repo_id="Supertone/supertonic-3",
+    revision="724fb5abbf5502583fb520898d45929e62f02c0b",
+    files=SUPERTONIC_3_FILES,
+    license=SUPERTONIC_3_LICENSE,
+    # A.5 measured 44,100 Hz mono, which F-82 then forbids resampling away.
+    sample_rate=44_100,
+    # The engine advertises 31 languages; the product supports two (F-05),
+    # and this list is what F-53 answers and what a request is checked
+    # against.  Claiming the other 29 would promise pronunciation nobody has
+    # tested and N-08 has not reviewed even for these two.
+    languages=(Language.KO, Language.EN),
+    # F-23's floor is also this model's approved minimum: A.5 measured 0.57
+    # GB of working memory, so 2 GiB is comfortable rather than tight.  At
+    # F-20's lowest CPU setting the baseline is about one thread, which A.5
+    # measured at a real-time factor under 0.36 -- still faster than
+    # playback, so the model is approved down to the bottom of the range.
+    minimum_budget=MinimumBudget(memory_bytes=MEMORY_FLOOR_BYTES, cpu_percent=CPU_PERCENT_MIN),
+    voices=SUPERTONIC_3_VOICES,
+    engine_model_name="supertonic-3",
+)
+
+#: The lineup this build ships.  F-04: one model, chosen through the same
+#: machinery a longer list would use.
+MANIFEST: Final = Manifest((SUPERTONIC_3,))
+
+DEFAULT_MODEL_ID: Final = SUPERTONIC_3_ID
+
+__all__ = [
+    "DEFAULT_MODEL_ID",
+    "MANIFEST",
+    "SUPERTONIC_3",
+    "SUPERTONIC_3_ID",
+    "SUPERTONIC_3_LICENSE",
+]