kiapi 0.1.0__py3-none-any.whl

kiapi/capabilities/acestep/worker_subprocess.py

@@ -0,0 +1,247 @@
+"""ace-step worker subprocess — runs under the ace-step venv (transformers 4.x).
+
+kiapi's main process can't import ``acestep`` (it pins transformers 4.x, which
+conflicts with chat/embedding's transformers 5.x). So ace-step
+generation runs here, in a separate Python launched from the ace-step venv, and
+kiapi talks to it over a tiny line-oriented JSON protocol on stdin/stdout.
+
+This module is NEVER imported by kiapi; it is executed as a script:
+
+    <ace-step-venv>/bin/python -m ... worker_subprocess.py \
+        --preset-name xl-base --project-root <dir> \
+        --checkpoint-dir <dir>/checkpoints --llm-model acestep-5Hz-lm-1.7B
+
+Protocol (one JSON object per line):
+  - stdout, on ready:           @@KIAPI@@{"event":"ready"}
+  - stdin, one request/line:    {"id":"..","task":"text2music","params":{...},"save_dir":".."}
+  - stdout, progress/line:      @@KIAPI@@{"id":"..","event":"progress","fraction":0.5,"label":".."}
+  - stdout, one reply/line:     @@KIAPI@@{"id":"..","ok":true,"path":".."}
+                            or  @@KIAPI@@{"id":"..","ok":false,"error":".."}
+
+ace-step's ``generate_music`` takes a Gradio-style ``progress(fraction, desc=...)``
+callback that fires at real milestones (LLM phases, a self-calibrating diffusion
+estimator, decode, finalize). We pass one that re-emits each call as a
+``progress`` protocol line tagged with the request id; the kiapi side forwards it
+onto the job's :class:`ProgressReporter`. Any number of progress lines may precede
+the single terminal reply for a request.
+
+All library logging is redirected to stderr so fd 1 carries only ``@@KIAPI@@``-
+prefixed protocol lines (kiapi ignores any other stdout noise defensively).
+The generation logic (_build_params + presets) is ported verbatim from
+ace-step-1.5-server's main.py so behavior is identical.
+"""
+
+import argparse
+import json
+import os
+import sys
+import traceback
+from dataclasses import dataclass
+from pathlib import Path
+
+# Keep fd 1 clean for the protocol: send every library print()/log to stderr.
+_PROTO_OUT = sys.__stdout__
+sys.stdout = sys.stderr
+
+SENTINEL = "@@KIAPI@@"
+
+
+def _emit(obj: dict) -> None:
+    _PROTO_OUT.write(SENTINEL + json.dumps(obj, ensure_ascii=False) + "\n")  # type: ignore
+    _PROTO_OUT.flush()  # type: ignore
+
+
+def _make_progress(rid):  # type: ignore
+    def _progress(value=0.0, desc=None, *args, **kwargs):  # type: ignore
+        try:
+            _emit(
+                {
+                    "id": rid,
+                    "event": "progress",
+                    "fraction": float(value),
+                    "label": desc if isinstance(desc, str) else None,
+                }
+            )
+        except Exception:
+            pass
+
+    return _progress
+
+
+# --- model presets (ported from ace-step-1.5-server/main.py) -----------------
+
+
+@dataclass
+class ModelPreset:
+    config_path: str
+    inference_steps: int
+    guidance_scale: float
+    shift: float
+    use_adg: bool
+    dcw_enabled: bool
+
+
+PRESETS: dict[str, ModelPreset] = {
+    "turbo": ModelPreset(
+        config_path="acestep-v15-turbo",
+        inference_steps=8,
+        guidance_scale=1.0,
+        shift=3.0,
+        use_adg=False,
+        dcw_enabled=True,
+    ),
+    "xl-base": ModelPreset(
+        config_path="acestep-v15-xl-base",
+        inference_steps=32,
+        guidance_scale=7.0,
+        shift=3.0,
+        use_adg=False,
+        dcw_enabled=False,
+    ),
+}
+
+
+def _build_params(task: str, p: dict, preset: ModelPreset):  # type: ignore
+    """Map a protocol request into ace-step GenerationParams. Ported verbatim."""
+    from acestep.inference import GenerationParams  # type: ignore
+
+    common = {
+        "inference_steps": p.get("inference_steps") or preset.inference_steps,
+        "guidance_scale": p["guidance_scale"]
+        if p.get("guidance_scale") is not None
+        else preset.guidance_scale,
+        "shift": p["shift"] if p.get("shift") is not None else preset.shift,
+        "use_adg": preset.use_adg,
+        "dcw_enabled": preset.dcw_enabled,
+        "seed": p.get("seed", -1),
+    }
+
+    if task == "text2music":
+        return GenerationParams(
+            task_type="text2music",
+            thinking=True,
+            caption=p["prompt"],
+            lyrics=p.get("lyrics", "[Instrumental]"),
+            vocal_language=p.get("lang", "ja"),
+            duration=p.get("duration", 60),
+            **common,
+        )
+    if task == "cover":
+        return GenerationParams(
+            task_type="cover",
+            thinking=False,
+            caption=p["prompt"],
+            lyrics="[Instrumental]",
+            src_audio=p["src_audio"],
+            audio_cover_strength=p.get("strength", 0.7),
+            duration=p.get("duration"),
+            **common,
+        )
+    if task == "repaint":
+        return GenerationParams(
+            task_type="repaint",
+            thinking=False,
+            caption=p["prompt"],
+            lyrics="[Instrumental]",
+            src_audio=p["src_audio"],
+            repainting_start=p["start"],
+            repainting_end=p.get("end", -1),
+            repaint_strength=p.get("strength", 0.5),
+            **common,
+        )
+    if task == "extract":
+        return GenerationParams(
+            task_type="extract",
+            thinking=False,
+            caption=p["target"],
+            lyrics="[Instrumental]",
+            src_audio=p["src_audio"],
+            **common,
+        )
+    raise ValueError(f"unknown task: {task!r}")
+
+
+# --- handlers ----------------------------------------------------------------
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--preset-name", required=True, choices=list(PRESETS))
+    ap.add_argument("--project-root", required=True)
+    ap.add_argument("--checkpoint-dir", required=True)
+    ap.add_argument("--llm-model", required=True)
+    args = ap.parse_args()
+
+    preset = PRESETS[args.preset_name]
+
+    # Pin where ace-step finds the checkpoints (highest-priority lever in its
+    # get_checkpoints_dir resolution), so kiapi's checkpoint_dir is authoritative
+    # regardless of project_root layout. Must be set before importing acestep.
+    os.environ.setdefault("ACESTEP_CHECKPOINTS_DIR", args.checkpoint_dir)
+
+    from acestep.handler import AceStepHandler  # type: ignore
+    from acestep.inference import GenerationConfig, generate_music
+    from acestep.llm_inference import LLMHandler  # type: ignore
+
+    # Load the shared LLM + this preset's DiT (mirrors the original server).
+    llm = LLMHandler()
+    msg, ok = llm.initialize(
+        checkpoint_dir=args.checkpoint_dir,
+        lm_model_path=args.llm_model,
+        backend="mlx",
+        device="auto",
+        offload_to_cpu=False,
+        dtype=None,
+    )
+    if not ok:
+        _emit({"event": "error", "error": f"LLM init failed: {msg}"})
+        sys.exit(1)
+
+    dit = AceStepHandler()
+    msg, ok = dit.initialize_service(
+        project_root=args.project_root,
+        config_path=preset.config_path,
+        device="auto",
+        offload_to_cpu=False,
+    )
+    if not ok:
+        _emit({"event": "error", "error": f"DiT init failed: {msg}"})
+        sys.exit(1)
+
+    _emit({"event": "ready", "preset": args.preset_name})
+
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            req = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        rid = req.get("id")
+        try:
+            params = _build_params(req["task"], req["params"], preset)
+            config = GenerationConfig(batch_size=1, audio_format="wav")
+            result = generate_music(
+                dit,
+                llm,
+                params=params,
+                config=config,
+                save_dir=req["save_dir"],
+                progress=_make_progress(rid),
+            )
+            if not getattr(result, "success", False):
+                raise RuntimeError(
+                    getattr(result, "status_message", "generation failed")
+                )
+            path = result.audios[0].get("path", "")
+            if not path or not Path(path).exists():
+                raise RuntimeError("generation finished but no audio file was produced")
+            _emit({"id": rid, "ok": True, "path": path})
+        except Exception as exc:
+            traceback.print_exc()
+            _emit({"id": rid, "ok": False, "error": f"{type(exc).__name__}: {exc}"})
+
+
+if __name__ == "__main__":
+    main()

kiapi/capabilities/audiogen/README.ja.md

@@ -0,0 +1,49 @@
+# audiogen
+
+[English](README.md) | **日本語**
+
+[AudioGen](https://huggingface.co/facebook/audiogen-medium) で、効果音生成機能を提供します。
+
+## API
+
+| Endpoint | Name | Description |
+|---|---|---|
+| `POST /v1/audio/audiogen/generate` | 効果音生成 | プロンプトから効果音を生成。**16 kHz モノラル WAV 最大10秒**。 |
+| `GET /v1/audio/audiogen/models` | モデル一覧 | 利用可能なモデルの一覧を返す。 |
+| `GET /v1/audio/audiogen/openapi.json` | OpenAPI | 詳細な入出力仕様、使い方、TIPS を返す。 |
+
+## API Docs
+
+- [OpenAPI JSON](https://kiarina.github.io/kiapi/v1/audio/audiogen/openapi.json)
+- [Swagger UI](https://kiarina.github.io/kiapi/v1/audio/audiogen/docs.html)
+- [ReDoc](https://kiarina.github.io/kiapi/v1/audio/audiogen/redoc.html)
+
+## Dependencies
+
+| Package | License | Description |
+|---|---|---|
+| [mlx-audiocraft](https://github.com/theashishmaurya/mlx-audiocraft) | MIT | Meta AudioCraft の AudioGen を MLX へ移植。 |
+
+## Models
+
+| Model | License | Terms | Size | Description |
+|---|---|---|---:|---|
+| [facebook/audiogen-medium](https://huggingface.co/facebook/audiogen-medium) | CC-BY-NC-4.0 | 不要 | 3.6 GB | **非商用ライセンス**。16 kHz モノラル、約 0.5 倍速（5 秒のクリップで約 10 秒の計算）。 |
+
+## Quickstart
+
+### generate — 効果音生成
+
+```bash
+jq -n \
+--arg prompt "heavy rain on a tin roof, distant thunder" \
+'{
+  mode: "sync",
+  prompt: $prompt,
+  duration: 5
+}' |
+curl -sS -X POST http://localhost:${PORT:-8000}/v1/audio/audiogen/generate \
+-H 'Content-Type: application/json' \
+--data-binary @- \
+-o sfx.wav
+```

kiapi/capabilities/audiogen/README.md

@@ -0,0 +1,48 @@
+# audiogen
+
+**English** | [日本語](README.ja.md)
+
+[AudioGen](https://huggingface.co/facebook/audiogen-medium) provides sound effect generation functionality.
+
+## API
+
+| Endpoint | Name | Description |
+|---|---|---|
+| `POST /v1/audio/audiogen/generate` | Sound effect generation | Generate sound effects from prompts. **16 kHz monaural WAV up to 10 seconds**. |
+| `GET /v1/audio/audiogen/models` | Model list | Returns a list of available models. |
+| `GET /v1/audio/audiogen/openapi.json` | OpenAPI | Returns detailed input/output specifications, usage, and TIPS. |
+
+## API Docs
+
+- [OpenAPI JSON](https://kiarina.github.io/kiapi/v1/audio/audiogen/openapi.json)
+- [Swagger UI](https://kiarina.github.io/kiapi/v1/audio/audiogen/docs.html)
+- [ReDoc](https://kiarina.github.io/kiapi/v1/audio/audiogen/redoc.html)
+
+## Dependencies
+
+| Package | License | Description |
+|---|---|---|
+| [mlx-audiocraft](https://github.com/theashishmaurya/mlx-audiocraft) | MIT | Porting Meta AudioCraft's AudioGen to MLX. |
+
+## Models
+
+| Model | License | Terms | Size | Description |
+|---|---|---|---:|---|
+| [facebook/audiogen-medium](https://huggingface.co/facebook/audiogen-medium) | CC-BY-NC-4.0 | Not required | 3.6 GB | **Non-Commercial License**. 16 kHz monaural, approximately 0.5x speed (approximately 10 seconds calculation for a 5 second clip). |
+
+## Quickstart
+
+### generate — sound effect generation
+```bash
+jq -n \
+--arg prompt "heavy rain on a tin roof, distant thunder" \
+'{
+  mode: "sync",
+  prompt: $prompt,
+  duration: 5
+}' |
+curl -sS -X POST http://localhost:${PORT:-8000}/v1/audio/audiogen/generate \
+-H 'Content-Type: application/json' \
+--data-binary @- \
+-o sfx.wav
+```

kiapi/capabilities/audiogen/__init__.py

@@ -0,0 +1,25 @@
+"""audiogen family — text→sound-effect via AudioGen (mlx-audiocraft).
+
+Integrates mlx-audiocraft-server. Endpoint: ``POST /v1/audio/audiogen/generate``;
+sync/async via `mode`, artifacts in the Files API. ``weight_gb`` measured on
+device (model card ~3.6 GB). The variant ``medium`` is the only AudioGen size;
+the family name (audiogen) is the AudioGen model family, distinct from the
+mlx-audiocraft library (which also hosts MusicGen).
+"""
+
+from kiapi.capabilities import ValidationError
+
+from ._helpers.register import register
+from ._helpers.validate_generate import validate_generate
+from ._operations.handle_generate import handle_generate
+from ._settings import settings_manager
+from ._views.generate_request import GenerateRequest
+
+__all__ = [
+    "GenerateRequest",
+    "ValidationError",
+    "handle_generate",
+    "register",
+    "settings_manager",
+    "validate_generate",
+]

kiapi/capabilities/audiogen/_constants/description.py

@@ -0,0 +1,60 @@
+DESCRIPTION = """Sound-effect / ambient audio generation from text.
+
+AudioGen turns a text prompt into short non-musical audio events: environmental
+sounds, foley, impacts, ambience, machinery, footsteps, room tone, and similar
+SFX. Output is always 16 kHz mono WAV. It is not a music model — for songs,
+vocals, cover, repaint, or stem extraction use the ACE-Step family instead.
+
+## Upstream docs
+- [AudioGen medium](https://huggingface.co/facebook/audiogen-medium) — the
+  upstream model card
+- [mlx-audiocraft](https://github.com/theashishmaurya/mlx-audiocraft) — MLX port
+  of Meta AudioCraft
+
+## Models
+- **medium** (default) — `facebook/audiogen-medium`, 1.5B parameters, native up
+  to 10 seconds. The model is CC-BY-NC-4.0, so check the license before use.
+
+Discover variants at `GET /v1/audio/audiogen/models`.
+
+## Prompt Tips
+Be concrete and additive. Name the source, action, material, distance, space, and
+energy:
+- **good**: "heavy rain on a tin roof, distant thunder, wide outdoor ambience"
+- **good**: "slow footsteps on wet gravel, close microphone, quiet night street"
+- **less useful**: "rain" or "scary sound"
+
+Sampling tweaks matter less than wording. Start with `duration`, `seed`, and
+`cfg_coef`; only adjust `top_k`, `top_p`, and `temperature` when exploring
+variation.
+
+## Reproducibility
+Set `seed` to reproduce a clip with the same prompt and sampling parameters.
+Leave it null to explore alternatives; the resolved seed is recorded in the Job
+`result.params`.
+
+## Performance
+- First request after activate/idle may spend tens of seconds loading weights.
+- After loading, the model stays resident until idle TTL or memory budget pressure
+  frees it.
+- On M4 Max, generation is roughly half realtime: a 5 second clip takes about
+  10 seconds of compute.
+
+## Examples
+
+### Generate raw WAV (sync)
+```sh
+curl -sS http://localhost:${PORT:-8000}/v1/audio/audiogen/generate \\
+  -H 'Content-Type: application/json' \\
+  -d '{"mode":"sync","prompt":"keyboard typing, office ambience","duration":5}' \\
+  -o sfx.wav
+```
+
+### Generate as async job
+```sh
+curl -sS http://localhost:${PORT:-8000}/v1/audio/audiogen/generate \\
+  -H 'Content-Type: application/json' \\
+  -d '{"mode":"async","prompt":"ocean waves crashing on rocks","duration":5,"seed":42}'
+# -> {"job_id": "..."}; poll GET /v1/jobs/{job_id}
+```
+"""

kiapi/capabilities/audiogen/_helpers/attach_audiogen_progress.py

@@ -0,0 +1,27 @@
+"""Register a token-generation progress callback on an AudioGen model.
+
+Called right before ``model.generate(..., progress=True)`` in the audiogen
+generation helper. ``mlx_audiocraft``'s ``AudioGen`` exposes a single progress
+slot via ``set_custom_progress_callback`` and invokes it once per autoregressive
+decode step with ``(generated_tokens, tokens_to_generate)`` (see
+``genmodel._generate_tokens`` / ``lm.generate``).
+
+The callback holds no per-job state — it reads the job's ambient
+:class:`ProgressReporter` (see core/job) each step — so a single instance can stay
+registered on the resident model and serve every job (silently no-op when no job
+is bound). Unlike mflux's callback registry this is a single slot, so re-setting
+it on each call is naturally idempotent.
+"""
+
+from typing import Any
+
+from kiapi.core.job import ProgressReporter
+
+
+def attach_audiogen_progress(model: Any, *, label: str = "generating") -> None:
+    def _callback(generated_tokens: int, tokens_to_generate: int) -> None:
+        ProgressReporter.current().step(
+            int(generated_tokens), int(tokens_to_generate), label
+        )
+
+    model.set_custom_progress_callback(_callback)

kiapi/capabilities/audiogen/_helpers/register.py

@@ -0,0 +1,42 @@
+"""Register audiogen's models + OpenAPI description in the global registries."""
+
+from kiapi.core.capability import CapabilitySpec, capability_spec_registry
+from kiapi.core.model import ModelSpec, model_registry
+from kiapi.core.setup import HfSnapshotResource
+
+from .._constants.description import DESCRIPTION
+from .._models import audiogen
+
+
+def register() -> None:
+    capability_spec_registry.register(
+        CapabilitySpec(
+            name="audiogen",
+            domain="audio",
+            title="kiapi AudioGen API",
+            summary="Generate short sound effects from text prompts.",
+            description=DESCRIPTION,
+            openapi_path="/v1/audio/audiogen/openapi.json",
+            docs_path="/v1/audio/audiogen/docs",
+            redoc_path="/v1/audio/audiogen/redoc",
+            path_prefixes=("/v1/audio/audiogen",),
+        )
+    )
+
+    model_registry.register(
+        ModelSpec(
+            name="medium",
+            family="audiogen",
+            domain="audio",
+            repo="facebook/audiogen-medium",
+            module=audiogen,
+            weight_gb=7.1,  # measured on device (model card weights ~3.6 GB)
+            peak_headroom_gb=2.0,
+            framework="mlx",
+            priority=0,
+            default=True,
+            setup_resources=(
+                HfSnapshotResource(repo="facebook/audiogen-medium", disk_gb=3.6),
+            ),
+        )
+    )

kiapi/capabilities/audiogen/_helpers/validate_generate.py

@@ -0,0 +1,14 @@
+from kiapi.capabilities import ValidationError
+
+from .._settings import settings_manager
+from .._views.generate_request import GenerateRequest
+
+
+def validate_generate(req: GenerateRequest, *, variant: str) -> None:
+    del variant
+
+    settings = settings_manager.get_settings()
+    if req.duration > settings.max_duration:
+        raise ValidationError(
+            f"duration {req.duration}s exceeds max {settings.max_duration}s"
+        )

kiapi/capabilities/audiogen/_models/audiogen.py

@@ -0,0 +1,98 @@
+"""Handler for AudioGen (text → sound effect; ``facebook/audiogen-medium``).
+
+Owns the load + generate flow, ported from mlx-audiocraft-server's
+generation.run_generation. Generates a 16 kHz mono WAV, stores it in the global
+file store, and returns the artifact metadata (the job's ``result``).
+"""
+
+import time
+from types import SimpleNamespace
+from typing import Any
+
+from kiapi.core.file import FileStore
+from kiapi.core.model import ModelSpec
+from kiapi.core.workdir import create_work_dir
+
+from .._helpers.attach_audiogen_progress import attach_audiogen_progress
+from .._views.generate_params import GenerateParams
+
+FEATURES = {"text"}
+
+
+def load(spec: ModelSpec) -> SimpleNamespace:
+    from mlx_audiocraft import AudioGen  # type: ignore
+
+    model = AudioGen.get_pretrained(spec.repo)
+    return SimpleNamespace(model=model)
+
+
+def warmup(payload: SimpleNamespace) -> None:
+    """Prime weights + MLX kernels with a tiny generation (artifact discarded)."""
+    model = payload.model
+    model.set_generation_params(duration=1.0)
+    model.generate(["click"])
+
+
+def run(
+    payload: SimpleNamespace,
+    params: GenerateParams,
+    files: FileStore,
+) -> dict[str, Any]:
+    """Blocking generation on the resident model. Returns artifact metadata."""
+    import mlx.core as mx
+    import numpy as np
+    import soundfile as sf  # type: ignore
+
+    model = payload.model
+
+    mx.random.seed(params.seed)
+
+    model.set_generation_params(
+        duration=params.duration,
+        top_k=params.top_k,
+        top_p=params.top_p,
+        temperature=params.temperature,
+        cfg_coef=params.cfg_coef,
+    )
+
+    attach_audiogen_progress(model)
+
+    t0 = time.time()
+    wavs = model.generate([params.prompt], progress=True)  # [B, C, T] mlx array
+    total_s = round(time.time() - t0, 2)
+
+    # [B, C, T] -> [T, C] (soundfile wants samples-major); squeeze mono to 1-D.
+    arr = np.array(wavs[0])  # [C, T]
+    arr = arr.T  # [T, C]
+    if arr.shape[1] == 1:
+        arr = arr[:, 0]
+
+    sample_rate = int(model.sample_rate)
+    tmp_dir = create_work_dir("audio/audiogen")
+    tmp_wav = tmp_dir / "se.wav"
+    sf.write(str(tmp_wav), arr, sample_rate)
+    if not tmp_wav.exists():
+        raise RuntimeError("generation finished but no audio file was produced")
+
+    duration_s = round(arr.shape[0] / sample_rate, 3)
+    meta = {
+        "model": params.model,
+        "prompt": params.prompt,
+        "params": params.model_dump(),
+        "duration_s": duration_s,
+        "sample_rate": sample_rate,
+        "timings": {"total_s": total_s},
+    }
+    rec = files.put_path(
+        tmp_wav,
+        filename=f"se_{int(time.time())}.wav",
+        content_type="audio/wav",
+        meta=meta,
+        move=True,
+    )
+
+    return {
+        "file_id": rec.file_id,
+        "audio_bytes": rec.size,
+        **meta,
+    }

kiapi/capabilities/audiogen/_operations/handle_generate.py

@@ -0,0 +1,27 @@
+"""Sound-effect service entry: resolve → acquire (memory budget) → generate.
+
+Body of the se job's worker-thread thunk. The handler writes its WAV artifact to
+the global file store and returns metadata; the job's ``artifacts`` is the
+produced file_id.
+"""
+
+from kiapi.core.app import AppContext
+from kiapi.core.file import FileID
+from kiapi.core.job import JobResult
+from kiapi.core.model import model_registry
+
+from .._settings import settings_manager
+from .._views.generate_request import GenerateRequest
+from .resolve_generate_params import resolve_generate_params
+
+
+def handle_generate(
+    ctx: AppContext, req: GenerateRequest
+) -> tuple[JobResult, list[FileID]]:
+    spec = model_registry.resolve("audiogen", req.model)
+    ctx.ensure_model_ready(spec)
+    settings = settings_manager.get_settings()
+    params = resolve_generate_params(settings, req, variant=spec.name)
+    payload = ctx.memory_manager.acquire(spec)
+    result = spec.module.run(payload, params, ctx.file_store)
+    return result, [result["file_id"]]

kiapi/capabilities/audiogen/_operations/resolve_generate_params.py

@@ -0,0 +1,25 @@
+"""Merge an AudioGen request with settings defaults into GenerateParams."""
+
+import random
+
+from .._settings import AudiogenSettings
+from .._views.generate_params import GenerateParams
+from .._views.generate_request import GenerateRequest
+
+
+def resolve_generate_params(
+    settings: AudiogenSettings,
+    req: GenerateRequest,
+    *,
+    variant: str,
+) -> GenerateParams:
+    return GenerateParams(
+        model=variant,
+        prompt=req.prompt,
+        duration=req.duration,
+        seed=req.seed if req.seed is not None else random.randint(0, 2**31 - 1),
+        top_k=req.top_k,
+        top_p=req.top_p,
+        temperature=req.temperature,
+        cfg_coef=req.cfg_coef,
+    )