nous-genai 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

nous/genai/_internal/capability_rules.py

@@ -63,7 +63,6 @@ _TTS_PREFIX: Final[str] = "tts-"
 _TTS_SUFFIX: Final[str] = "-tts"
 _VOICE_SUFFIXES: Final[tuple[str, ...]] = ("-voice", "_voice")
 _ADVANCED_VOICE_MODEL: Final[str] = "advanced-voice"
-_SUNO_PREFIX: Final[str] = "suno-"
 _CHIRP_PREFIX: Final[str] = "chirp-"
 
 _WHISPER_PREFIX: Final[str] = "whisper-"
@@ -223,7 +222,6 @@ def is_tts_model(model_id: str) -> bool:
     mid_l = _norm(model_id)
     return (
         mid_l.startswith(_TTS_PREFIX)
-        or mid_l.startswith(_SUNO_PREFIX)
         or mid_l.startswith(_CHIRP_PREFIX)
         or mid_l.endswith(_TTS_SUFFIX)
         or mid_l.endswith(_VOICE_SUFFIXES)

nous/genai/cli.py

@@ -109,6 +109,15 @@ def main(argv: list[str] | None = None) -> None:
     parser.add_argument("--video-path", help="Input video file path")
     parser.add_argument("--output-path", help="Write output to file (text/json/binary)")
     parser.add_argument("--ouput-path", dest="output_path", help=argparse.SUPPRESS)
+    parser.add_argument(
+        "--job-id",
+        help="Resume/poll a provider job id (tuzi-web only for now); ignores --prompt/--*-path",
+    )
+    parser.add_argument(
+        "--no-wait",
+        action="store_true",
+        help="Do not wait for job completion (returns job_id if supported)",
+    )
     parser.add_argument(
         "--timeout-ms",
         type=int,
@@ -184,7 +193,25 @@ def main(argv: list[str] | None = None) -> None:
         except BrokenPipeError:
             return
 
+    client = Client()
     provider, model_id = _split_model(args.model)
+    _apply_protocol_override(client, provider=provider, protocol=args.protocol)
+
+    cap = client.capabilities(args.model)
+    output = _infer_output_spec(provider=provider, model_id=model_id, cap=cap)
+
+    if args.job_id:
+        _run_job(
+            client,
+            provider=provider,
+            model_id=model_id,
+            job_id=str(args.job_id),
+            output=output,
+            output_path=args.output_path,
+            timeout_ms=timeout_ms,
+        )
+        return
+
     prompt = args.prompt
     if prompt is None and args.prompt_path:
         try:
@@ -192,11 +219,6 @@ def main(argv: list[str] | None = None) -> None:
                 prompt = f.read()
         except OSError as e:
             raise SystemExit(f"cannot read --prompt-path: {e}") from None
-    client = Client()
-    _apply_protocol_override(client, provider=provider, protocol=args.protocol)
-
-    cap = client.capabilities(args.model)
-    output = _infer_output_spec(provider=provider, model_id=model_id, cap=cap)
 
     parts = _build_input_parts(
         prompt=prompt,
@@ -212,7 +234,7 @@ def main(argv: list[str] | None = None) -> None:
         model=args.model,
         input=[Message(role="user", content=parts)],
         output=output,
-        wait=True,
+        wait=not bool(getattr(args, "no_wait", False)),
     )
     if timeout_ms is not None:
         req = replace(req, params=replace(req.params, timeout_ms=timeout_ms))
@@ -229,21 +251,37 @@ def main(argv: list[str] | None = None) -> None:
             if resp.job and resp.job.job_id:
                 print(resp.job.job_id)
                 if resp.status == "running":
-                    effective_timeout_ms = timeout_ms
-                    if effective_timeout_ms is None:
-                        effective_timeout_ms = getattr(
-                            client, "_default_timeout_ms", None
+                    status_note = ""
+                    if resp.job.last_status:
+                        status_note += f" upstream_status={resp.job.last_status}"
+                    if resp.job.last_detail:
+                        d = resp.job.last_detail
+                        if len(d) > 200:
+                            d = d[:200] + "..."
+                        status_note += f" fail_reason={d}"
+                    if not req.wait:
+                        print(
+                            "[INFO] 已提交任务（未等待完成）；已返回 job_id。"
+                            f"可用 --job-id {resp.job.job_id} 继续轮询/下载。",
+                            file=sys.stderr,
+                        )
+                    else:
+                        effective_timeout_ms = timeout_ms
+                        if effective_timeout_ms is None:
+                            effective_timeout_ms = getattr(
+                                client, "_default_timeout_ms", None
+                            )
+                        timeout_note = (
+                            f"{effective_timeout_ms}ms"
+                            if isinstance(effective_timeout_ms, int)
+                            else "timeout"
+                        )
+                        print(
+                            f"[INFO] 任务仍在运行（等待 {elapsed_s:.1f}s，可能已超时 {timeout_note}）；已返回 job_id。"
+                            f"可用 --job-id {resp.job.job_id} 继续轮询/下载，或增大 --timeout-ms 重试。"
+                            f"{status_note}",
+                            file=sys.stderr,
                         )
-                    timeout_note = (
-                        f"{effective_timeout_ms}ms"
-                        if isinstance(effective_timeout_ms, int)
-                        else "timeout"
-                    )
-                    print(
-                        f"[INFO] 任务仍在运行（等待 {elapsed_s:.1f}s，可能已超时 {timeout_note}）；已返回 job_id。"
-                        "可增大 --timeout-ms 或设置 NOUS_GENAI_TIMEOUT_MS 后重试。",
-                        file=sys.stderr,
-                    )
                     if args.output_path:
                         print(
                             f"[INFO] 未写入输出文件：{args.output_path}",
@@ -275,6 +313,122 @@ _DEFAULT_VIDEO_URL = (
 )
 
 
+def _run_job(
+    client: Client,
+    *,
+    provider: str,
+    model_id: str,
+    job_id: str,
+    output: OutputSpec,
+    output_path: str | None,
+    timeout_ms: int | None,
+) -> None:
+    provider = provider.strip().lower()
+    if provider != "tuzi-web":
+        raise SystemExit("--job-id only supported for provider=tuzi-web for now")
+
+    job_id = job_id.strip()
+    if not job_id:
+        raise SystemExit("--job-id must be non-empty")
+
+    adapter = client._adapter(provider)
+    from .providers import TuziAdapter
+
+    if not isinstance(adapter, TuziAdapter):
+        raise SystemExit("tuzi-web adapter not configured")
+
+    effective_timeout_ms = timeout_ms
+    if effective_timeout_ms is None:
+        effective_timeout_ms = getattr(client, "_default_timeout_ms", None)
+    if effective_timeout_ms is None:
+        effective_timeout_ms = 120_000
+
+    modalities = set(output.modalities)
+    mid_l = model_id.lower().strip()
+    is_chirp_music = (
+        modalities == {"audio"} and mid_l.startswith("chirp-") and mid_l != "chirp-v3"
+    )
+    if not is_chirp_music:
+        raise SystemExit("--job-id only supports tuzi-web chirp-* audio tasks for now")
+
+    def fn():
+        try:
+            host = adapter._base_host()
+            probe = adapter._suno_feed(
+                host=host,
+                ids=job_id,
+                timeout_ms=min(10_000, int(effective_timeout_ms)),
+            )
+            clips = probe.get("clips")
+            clip_found = bool(
+                isinstance(clips, list)
+                and any(
+                    isinstance(c, dict)
+                    and isinstance(c.get("id"), str)
+                    and c.get("id") == job_id
+                    for c in clips
+                )
+            )
+            if clip_found:
+                return adapter._suno_wait_feed_audio(
+                    clip_id=job_id,
+                    model_id=model_id,
+                    timeout_ms=effective_timeout_ms,
+                    wait=True,
+                )
+        except Exception:
+            pass
+        return adapter._suno_wait_fetch_audio(
+            task_id=job_id,
+            model_id=model_id,
+            timeout_ms=effective_timeout_ms,
+            wait=True,
+        )
+
+    show_progress = sys.stderr.isatty()
+    resp, elapsed_s = _run_with_spinner(fn, enabled=show_progress, label="等待任务完成")
+
+    if resp.status != "completed":
+        if resp.job and resp.job.job_id:
+            print(resp.job.job_id)
+            if resp.status == "running":
+                status_note = ""
+                if resp.job.last_status:
+                    status_note += f" upstream_status={resp.job.last_status}"
+                if resp.job.last_detail:
+                    d = resp.job.last_detail
+                    if len(d) > 200:
+                        d = d[:200] + "..."
+                    status_note += f" fail_reason={d}"
+                timeout_note = (
+                    f"{effective_timeout_ms}ms"
+                    if isinstance(effective_timeout_ms, int)
+                    else "timeout"
+                )
+                print(
+                    f"[INFO] 任务仍在运行（等待 {elapsed_s:.1f}s，可能已超时 {timeout_note}）；已返回 job_id。"
+                    f"可稍后重试 --job-id。{status_note}",
+                    file=sys.stderr,
+                )
+                if output_path:
+                    print(f"[INFO] 未写入输出文件：{output_path}", file=sys.stderr)
+        else:
+            raise SystemExit(f"[FAIL]: request status={resp.status}")
+        return
+
+    if not resp.output:
+        raise SystemExit("[FAIL]: missing output")
+    _write_response(
+        resp.output[0].content,
+        output=output,
+        output_path=output_path,
+        timeout_ms=timeout_ms,
+        download_auth=_download_auth(client, provider=provider),
+    )
+    if show_progress:
+        print(f"[INFO] 完成，用时 {elapsed_s:.1f}s", file=sys.stderr)
+
+
 def _run_probe(args: argparse.Namespace, *, timeout_ms: int | None) -> int:
     from .client import _normalize_provider
     from .reference import get_sdk_supported_models_for_provider

nous/genai/providers/tuzi.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import json
 import re
 import time
+import urllib.parse
 from dataclasses import dataclass, replace
 from typing import Any, Iterator
 from uuid import uuid4
@@ -53,32 +54,6 @@ _AUDIO_URL_RE = re.compile(
     re.IGNORECASE,
 )
 
-_SUNO_WORKFLOW_MODELS = frozenset(
-    {
-        "suno-all-stems",
-        "suno-continue",
-        "suno-continue-uploaded",
-        "suno-infill",
-        "suno-infill-uploaded",
-        "suno-midi",
-        "suno-overpainting",
-        "suno-remix",
-        "suno-remix-uploaded",
-        "suno-rewrite",
-        "suno-tags",
-        "suno-vocal-stems",
-        "suno_act_midi",
-        "suno_act_mp4",
-        "suno_act_stems",
-        "suno_act_tags",
-        "suno_act_timing",
-        "suno_act_wav",
-        "suno_concat",
-        "suno_persona_create",
-        "suno_uploads",
-    }
-)
-
 
 def _extract_first_url(pattern: re.Pattern[str], text: str) -> str | None:
     m = pattern.search(text)
@@ -135,6 +110,10 @@ class TuziAdapter:
 
     def capabilities(self, model_id: str) -> Capability:
         mid_l = model_id.lower().strip()
+        if mid_l.startswith(("suno-", "suno_")):
+            raise invalid_request_error(
+                "suno model ids are not supported; use chirp-* (e.g. chirp-v3-5)"
+            )
         if mid_l in {"kling_image", "seededit"}:
             return Capability(
                 input_modalities={"text", "image"},
@@ -144,27 +123,7 @@ class TuziAdapter:
                 supports_tools=False,
                 supports_json_schema=False,
             )
-        if mid_l in _SUNO_WORKFLOW_MODELS:
-            return Capability(
-                input_modalities={"text"},
-                output_modalities={"audio"},
-                supports_stream=False,
-                supports_job=True,
-                supports_tools=False,
-                supports_json_schema=False,
-            )
-        if mid_l == "suno_lyrics":
-            return Capability(
-                input_modalities={"text"},
-                output_modalities={"text"},
-                supports_stream=False,
-                supports_job=True,
-                supports_tools=False,
-                supports_json_schema=False,
-            )
-        if mid_l == "suno_music" or (
-            mid_l.startswith("chirp-") and mid_l != "chirp-v3"
-        ):
+        if mid_l.startswith("chirp-") and mid_l != "chirp-v3":
             return Capability(
                 input_modalities={"text"},
                 output_modalities={"audio"},
@@ -191,6 +150,11 @@ class TuziAdapter:
         mid_l = model_id.lower().strip()
         modalities = set(request.output.modalities)
 
+        if mid_l.startswith(("suno-", "suno_")):
+            raise invalid_request_error(
+                "suno model ids are not supported; use chirp-* (e.g. chirp-v3-5)"
+            )
+
         if modalities == {"video"} and mid_l.startswith("pika-"):
             raise not_supported_error(
                 "tuzi pika endpoints are not available on api.tu-zi.com (returns HTML)"
@@ -231,27 +195,14 @@ class TuziAdapter:
                 return self._kling_text2image(request, model_id=model_id)
             return self._seededit(request, model_id=model_id)
 
-        if modalities == {"text"} and mid_l == "suno_lyrics":
-            if stream:
-                raise invalid_request_error(
-                    "suno lyrics generation does not support streaming"
-                )
-            return self._suno_lyrics(request)
-
-        if modalities == {"audio"} and mid_l in _SUNO_WORKFLOW_MODELS:
-            if stream:
-                raise invalid_request_error(
-                    "suno workflow endpoints do not support streaming"
-                )
-            return self._suno_workflow(request, model_id=model_id)
-
-        if modalities == {"audio"} and (
-            mid_l == "suno_music"
-            or (mid_l.startswith("chirp-") and mid_l != "chirp-v3")
+        if (
+            modalities == {"audio"}
+            and mid_l.startswith("chirp-")
+            and mid_l != "chirp-v3"
         ):
             if stream:
                 raise invalid_request_error(
-                    "suno music generation does not support streaming"
+                    "chirp music generation does not support streaming"
                 )
             return self._suno_music(request, model_id=model_id)
 
@@ -633,41 +584,30 @@ class TuziAdapter:
             job=JobInfo(job_id=task_id, poll_after_ms=1_000),
         )
 
-    def _suno_lyrics(self, request: GenerateRequest) -> GenerateResponse:
-        prompt = self._single_text_prompt(request)
-        host = self._base_host()
-        obj = request_json(
-            method="POST",
-            url=f"{host}/suno/submit/lyrics",
-            headers=self._bearer_headers(),
-            json_body={"prompt": prompt},
-            timeout_ms=max(request.params.timeout_ms or 60_000, 60_000),
-            proxy_url=self.proxy_url,
-        )
-        task_id = obj.get("data")
-        if not isinstance(task_id, str) or not task_id:
-            raise provider_error("suno lyrics submit missing task id")
-        return self._suno_wait_fetch_text(
-            task_id=task_id,
-            model_id="suno_lyrics",
-            timeout_ms=request.params.timeout_ms,
-            wait=request.wait,
-        )
-
     def _suno_music(
         self, request: GenerateRequest, *, model_id: str
     ) -> GenerateResponse:
         prompt = self._single_text_prompt(request)
         host = self._base_host()
-        mv = model_id if model_id.lower().startswith("chirp-") else "chirp-v3-5"
-        body: dict[str, object] = {
-            "prompt": prompt,
-            "tags": "",
-            "mv": mv,
-            "title": "suno",
-            "infill_start_s": None,
-            "infill_end_s": None,
-        }
+        mid_l = model_id.lower().strip()
+        if not (mid_l.startswith("chirp-") and mid_l != "chirp-v3"):
+            raise invalid_request_error(
+                f"unsupported music model_id: {model_id} (use chirp-*, e.g. chirp-v3-5)"
+            )
+        body: dict[str, object] = {"prompt": prompt, "mv": model_id}
+        opts = request.provider_options.get("tuzi-web")
+        if isinstance(opts, dict):
+            for k, v in opts.items():
+                if k in body:
+                    raise invalid_request_error(f"provider_options cannot override {k}")
+                if (
+                    k == "tags"
+                    and isinstance(v, list)
+                    and all(isinstance(x, str) and x.strip() for x in v)
+                ):
+                    body["tags"] = ",".join([x.strip() for x in v])
+                    continue
+                body[k] = v
         obj = request_json(
             method="POST",
             url=f"{host}/suno/submit/music",
@@ -676,87 +616,97 @@ class TuziAdapter:
             timeout_ms=max(request.params.timeout_ms or 60_000, 60_000),
             proxy_url=self.proxy_url,
         )
-        task_id = obj.get("data")
-        if not isinstance(task_id, str) or not task_id:
-            raise provider_error("suno music submit missing task id")
-        return self._suno_wait_fetch_audio(
-            task_id=task_id,
-            model_id=model_id,
-            timeout_ms=request.params.timeout_ms,
-            wait=request.wait,
-        )
 
-    def _suno_workflow_endpoint(self, model_id: str) -> str:
-        mid_l = model_id.lower().strip()
-        if mid_l == "suno_concat":
-            return "/suno/submit/concat"
-        if mid_l == "suno_uploads":
-            return "/suno/submit/upload"
-        if mid_l == "suno_persona_create":
-            return "/suno/submit/persona-create"
-        if mid_l.startswith("suno_act_"):
-            suffix = mid_l[len("suno_act_") :]
-            if not suffix:
-                raise invalid_request_error("invalid suno_act model id")
-            return f"/suno/submit/act-{suffix}"
-        if mid_l.startswith("suno-"):
-            suffix = mid_l[len("suno-") :]
-            if not suffix:
-                raise invalid_request_error("invalid suno model id")
-            return f"/suno/submit/{suffix}"
-        raise invalid_request_error(f"unsupported suno workflow model: {model_id}")
-
-    def _suno_workflow(
-        self, request: GenerateRequest, *, model_id: str
-    ) -> GenerateResponse:
-        host = self._base_host()
-        endpoint = self._suno_workflow_endpoint(model_id)
+        clip_id: str | None = None
+        audio_url: str | None = None
+        data = obj.get("data")
+        sources: list[dict[str, object]] = [obj]
+        if isinstance(data, dict):
+            sources.append(data)
+        for src in sources:
+            clips = src.get("clips")
+            if not isinstance(clips, list):
+                continue
+            for clip in clips:
+                if not isinstance(clip, dict):
+                    continue
+                if clip_id is None:
+                    cid = clip.get("id")
+                    if isinstance(cid, str) and cid.strip():
+                        clip_id = cid.strip()
+                if audio_url is None:
+                    au = clip.get("audio_url")
+                    if isinstance(au, str) and au.strip():
+                        audio_url = au.strip()
+                if clip_id is not None and audio_url is not None:
+                    break
+            if clip_id is not None:
+                break
 
-        body: dict[str, object] = {}
-        opts = request.provider_options.get("tuzi-web")
-        if isinstance(opts, dict):
-            body.update(opts)
+        if request.wait and audio_url:
+            part = Part(
+                type="audio",
+                mime_type="audio/mpeg",
+                source=PartSourceUrl(url=audio_url),
+            )
+            return GenerateResponse(
+                id=f"sdk_{uuid4().hex}",
+                provider="tuzi-web",
+                model=f"tuzi-web:{model_id}",
+                status="completed",
+                output=[Message(role="assistant", content=[part])],
+            )
 
-        prompt = self._text_prompt_or_none(request)
-        if prompt and "prompt" not in body:
-            body["prompt"] = prompt
+        task_id: str | None = None
+        if isinstance(data, str) and data.strip():
+            task_id = data.strip()
+        for src in sources:
+            if task_id is not None:
+                break
+            for key in ("task_id", "id"):
+                v = src.get(key)
+                if isinstance(v, str) and v.strip():
+                    task_id = v.strip()
+                    break
+        if task_id is not None:
+            return self._suno_wait_fetch_audio(
+                task_id=task_id,
+                model_id=model_id,
+                timeout_ms=request.params.timeout_ms,
+                wait=request.wait,
+            )
 
-        obj = request_json(
-            method="POST",
-            url=f"{host}{endpoint}",
-            headers=self._bearer_headers(),
-            json_body=body,
-            timeout_ms=max(request.params.timeout_ms or 60_000, 60_000),
-            proxy_url=self.proxy_url,
-        )
-        task_id = obj.get("data")
-        if not isinstance(task_id, str) or not task_id:
-            raise provider_error("suno submit missing task id")
-        return self._suno_wait_fetch_any(
-            task_id=task_id,
-            model_id=model_id,
-            timeout_ms=request.params.timeout_ms,
-            wait=request.wait,
+        if clip_id is not None:
+            return self._suno_wait_feed_audio(
+                clip_id=clip_id,
+                model_id=model_id,
+                timeout_ms=request.params.timeout_ms,
+                wait=request.wait,
+            )
+
+        keys = (
+            ",".join(sorted([k for k in obj.keys() if isinstance(k, str)])) or "<none>"
         )
+        raise provider_error(f"suno music submit missing clip id (keys={keys})")
 
-    def _suno_fetch(
-        self, *, host: str, task_id: str, timeout_ms: int | None
+    def _suno_feed(
+        self, *, host: str, ids: str, timeout_ms: int | None
     ) -> dict[str, object]:
+        qs = urllib.parse.urlencode({"ids": ids})
         obj = request_json(
             method="GET",
-            url=f"{host}/suno/fetch/{task_id}",
+            url=f"{host}/suno/feed?{qs}",
             headers=self._bearer_headers(),
             json_body=None,
             timeout_ms=timeout_ms,
             proxy_url=self.proxy_url,
         )
-        data = obj.get("data")
-        if not isinstance(data, dict):
-            raise provider_error("suno fetch missing data")
-        return data
+        if not isinstance(obj, dict):
+            raise provider_error("suno feed invalid response", retryable=True)
+        return obj
 
-    def _suno_wait_fetch_text(
-        self, *, task_id: str, model_id: str, timeout_ms: int | None, wait: bool
+    def _suno_wait_feed_audio(
+        self, *, clip_id: str, model_id: str, timeout_ms: int | None, wait: bool
     ) -> GenerateResponse:
         if not wait:
             return GenerateResponse(
@@ -764,102 +714,51 @@ class TuziAdapter:
                 provider="tuzi-web",
                 model=f"tuzi-web:{model_id}",
                 status="running",
-                job=JobInfo(job_id=task_id, poll_after_ms=2_000),
-            )
-        host = self._base_host()
-        budget_ms = 60_000 if timeout_ms is None else timeout_ms
-        deadline = time.time() + max(1, budget_ms) / 1000.0
-        while True:
-            remaining_ms = int((deadline - time.time()) * 1000)
-            if remaining_ms <= 0:
-                break
-            data = self._suno_fetch(
-                host=host, task_id=task_id, timeout_ms=min(30_000, remaining_ms)
+                job=JobInfo(job_id=clip_id, poll_after_ms=2_000),
             )
-            status = data.get("status")
-            if status == "SUCCESS":
-                inner = data.get("data")
-                if isinstance(inner, dict):
-                    text = inner.get("text")
-                    if isinstance(text, str):
-                        return GenerateResponse(
-                            id=f"sdk_{uuid4().hex}",
-                            provider="tuzi-web",
-                            model=f"tuzi-web:{model_id}",
-                            status="completed",
-                            output=[
-                                Message(
-                                    role="assistant", content=[Part.from_text(text)]
-                                )
-                            ],
-                        )
-                raise provider_error("suno lyrics succeeded but missing text")
-            if status == "FAIL":
-                raise provider_error(f"suno task failed: {data.get('fail_reason')}")
-            time.sleep(min(2.0, max(0.0, deadline - time.time())))
 
-        return GenerateResponse(
-            id=f"sdk_{uuid4().hex}",
-            provider="tuzi-web",
-            model=f"tuzi-web:{model_id}",
-            status="running",
-            job=JobInfo(job_id=task_id, poll_after_ms=2_000),
-        )
-
-    def _suno_wait_fetch_audio(
-        self, *, task_id: str, model_id: str, timeout_ms: int | None, wait: bool
-    ) -> GenerateResponse:
-        if not wait:
-            return GenerateResponse(
-                id=f"sdk_{uuid4().hex}",
-                provider="tuzi-web",
-                model=f"tuzi-web:{model_id}",
-                status="running",
-                job=JobInfo(job_id=task_id, poll_after_ms=2_000),
-            )
         host = self._base_host()
         budget_ms = 120_000 if timeout_ms is None else timeout_ms
         deadline = time.time() + max(1, budget_ms) / 1000.0
+        last_status: str | None = None
+        last_detail: str | None = None
         while True:
             remaining_ms = int((deadline - time.time()) * 1000)
             if remaining_ms <= 0:
                 break
-            data = self._suno_fetch(
-                host=host, task_id=task_id, timeout_ms=min(30_000, remaining_ms)
+
+            data = self._suno_feed(
+                host=host, ids=clip_id, timeout_ms=min(30_000, remaining_ms)
             )
-            status = data.get("status")
-            if status == "SUCCESS":
-                inner = data.get("data")
-                urls: list[str] = []
-                if isinstance(inner, dict):
-                    u = inner.get("audio_url")
-                    if isinstance(u, str) and u:
-                        urls.append(u)
-                    clips = inner.get("clips")
-                    if isinstance(clips, list):
-                        for clip in clips:
-                            if not isinstance(clip, dict):
-                                continue
-                            u = clip.get("audio_url")
-                            if isinstance(u, str) and u:
-                                urls.append(u)
-                elif isinstance(inner, list):
-                    for clip in inner:
-                        if not isinstance(clip, dict):
-                            continue
-                        u = clip.get("audio_url")
-                        if isinstance(u, str) and u:
-                            urls.append(u)
-                if not urls:
-                    blob = json.dumps(inner, ensure_ascii=False)
-                    u = _extract_first_url(_AUDIO_URL_RE, blob)
-                    if u:
-                        urls.append(u)
-                if urls:
+            clips = data.get("clips")
+            clip: dict[str, object] | None = None
+            if isinstance(clips, list):
+                for c in clips:
+                    if not isinstance(c, dict):
+                        continue
+                    cid = c.get("id")
+                    if isinstance(cid, str) and cid.strip() == clip_id:
+                        clip = c
+                        break
+                if clip is None and clips and isinstance(clips[0], dict):
+                    clip = clips[0]
+
+            if clip is not None:
+                raw_status = clip.get("status")
+                status = (
+                    raw_status.strip().upper() if isinstance(raw_status, str) else ""
+                )
+                if status:
+                    last_status = status
+                elif raw_status is not None:
+                    last_status = str(raw_status)
+
+                au = clip.get("audio_url")
+                if isinstance(au, str) and au.strip():
                     part = Part(
                         type="audio",
                         mime_type="audio/mpeg",
-                        source=PartSourceUrl(url=urls[0]),
+                        source=PartSourceUrl(url=au.strip()),
                     )
                     return GenerateResponse(
                         id=f"sdk_{uuid4().hex}",
@@ -868,9 +767,23 @@ class TuziAdapter:
                         status="completed",
                         output=[Message(role="assistant", content=[part])],
                     )
-                raise provider_error("suno music succeeded but missing audio url")
-            if status == "FAIL":
-                raise provider_error(f"suno task failed: {data.get('fail_reason')}")
+
+                if status in {"FAIL", "FAILED", "ERROR"}:
+                    meta = clip.get("metadata")
+                    if isinstance(meta, dict):
+                        err = meta.get("error_message")
+                        if isinstance(err, str) and err:
+                            last_detail = err
+                    raise provider_error(
+                        f"suno feed task failed: {last_detail or ''}".strip()
+                    )
+
+                meta = clip.get("metadata")
+                if isinstance(meta, dict):
+                    err = meta.get("error_message")
+                    if isinstance(err, str) and err:
+                        last_detail = err
+
             time.sleep(min(2.0, max(0.0, deadline - time.time())))
 
         return GenerateResponse(
@@ -878,10 +791,31 @@ class TuziAdapter:
             provider="tuzi-web",
             model=f"tuzi-web:{model_id}",
             status="running",
-            job=JobInfo(job_id=task_id, poll_after_ms=2_000),
+            job=JobInfo(
+                job_id=clip_id,
+                poll_after_ms=2_000,
+                last_status=last_status,
+                last_detail=last_detail,
+            ),
         )
 
-    def _suno_wait_fetch_any(
+    def _suno_fetch(
+        self, *, host: str, task_id: str, timeout_ms: int | None
+    ) -> dict[str, object]:
+        obj = request_json(
+            method="GET",
+            url=f"{host}/suno/fetch/{task_id}",
+            headers=self._bearer_headers(),
+            json_body=None,
+            timeout_ms=timeout_ms,
+            proxy_url=self.proxy_url,
+        )
+        data = obj.get("data")
+        if not isinstance(data, dict):
+            raise provider_error("suno fetch missing data")
+        return data
+
+    def _suno_wait_fetch_audio(
         self, *, task_id: str, model_id: str, timeout_ms: int | None, wait: bool
     ) -> GenerateResponse:
         if not wait:
@@ -895,6 +829,8 @@ class TuziAdapter:
         host = self._base_host()
         budget_ms = 120_000 if timeout_ms is None else timeout_ms
         deadline = time.time() + max(1, budget_ms) / 1000.0
+        last_status: str | None = None
+        last_detail: str | None = None
         while True:
             remaining_ms = int((deadline - time.time()) * 1000)
             if remaining_ms <= 0:
@@ -902,63 +838,57 @@ class TuziAdapter:
             data = self._suno_fetch(
                 host=host, task_id=task_id, timeout_ms=min(30_000, remaining_ms)
             )
-            status = data.get("status")
-            if status == "SUCCESS":
-                inner = data.get("data")
-                parts: list[Part] = []
-                blob = json.dumps(inner, ensure_ascii=False)
-
-                audio_urls: list[str] = []
-                if isinstance(inner, dict):
-                    clips = inner.get("clips")
+            raw_status = data.get("status")
+            status = raw_status.strip().upper() if isinstance(raw_status, str) else ""
+            if status:
+                last_status = status
+            elif raw_status is not None:
+                last_status = str(raw_status)
+            fail_reason = data.get("fail_reason")
+            if isinstance(fail_reason, str) and fail_reason:
+                last_detail = fail_reason
+
+            def _collect_urls(obj: object) -> list[str]:
+                urls: list[str] = []
+                if isinstance(obj, dict):
+                    u = obj.get("audio_url")
+                    if isinstance(u, str) and u.strip():
+                        urls.append(u.strip())
+                    clips = obj.get("clips")
                     if isinstance(clips, list):
                         for clip in clips:
-                            if not isinstance(clip, dict):
-                                continue
-                            u = clip.get("audio_url")
-                            if isinstance(u, str) and u:
-                                audio_urls.append(u)
-
-                    text = inner.get("text")
-                    if isinstance(text, str) and text:
-                        parts.append(Part.from_text(text))
-
-                if not audio_urls:
-                    u = _extract_first_url(_AUDIO_URL_RE, blob)
-                    if u:
-                        audio_urls.append(u)
-                for u in audio_urls:
-                    parts.append(
-                        Part(
-                            type="audio",
-                            mime_type="audio/mpeg",
-                            source=PartSourceUrl(url=u),
-                        )
-                    )
-
-                mp4 = _extract_first_url(_MP4_URL_RE, blob)
-                if mp4:
-                    parts.append(
-                        Part(
-                            type="video",
-                            mime_type="video/mp4",
-                            source=PartSourceUrl(url=mp4),
-                        )
-                    )
-
-                if not parts:
-                    parts.append(
-                        Part.from_text(blob if blob and blob != "null" else "{}")
-                    )
-
+                            urls.extend(_collect_urls(clip))
+                elif isinstance(obj, list):
+                    for item in obj:
+                        urls.extend(_collect_urls(item))
+                return urls
+
+            inner = data.get("data")
+            urls = _collect_urls(data) + _collect_urls(inner)
+            if not urls:
+                blob = json.dumps(
+                    inner if inner is not None else data, ensure_ascii=False
+                )
+                u = _extract_first_url(_AUDIO_URL_RE, blob)
+                if u:
+                    urls.append(u)
+            if urls:
+                part = Part(
+                    type="audio",
+                    mime_type="audio/mpeg",
+                    source=PartSourceUrl(url=urls[0]),
+                )
                 return GenerateResponse(
                     id=f"sdk_{uuid4().hex}",
                     provider="tuzi-web",
                     model=f"tuzi-web:{model_id}",
                     status="completed",
-                    output=[Message(role="assistant", content=parts)],
+                    output=[Message(role="assistant", content=[part])],
                 )
-            if status == "FAIL":
+
+            if status in {"SUCCESS", "SUCCEEDED", "COMPLETE", "COMPLETED", "DONE"}:
+                raise provider_error("suno music succeeded but missing audio url")
+            if status in {"FAIL", "FAILED", "ERROR"}:
                 raise provider_error(f"suno task failed: {data.get('fail_reason')}")
             time.sleep(min(2.0, max(0.0, deadline - time.time())))
 
@@ -967,7 +897,12 @@ class TuziAdapter:
             provider="tuzi-web",
             model=f"tuzi-web:{model_id}",
             status="running",
-            job=JobInfo(job_id=task_id, poll_after_ms=2_000),
+            job=JobInfo(
+                job_id=task_id,
+                poll_after_ms=2_000,
+                last_status=last_status,
+                last_detail=last_detail,
+            ),
         )
 
     def _deepsearch(

nous/genai/reference/model_catalog_data/tuzi_web.py

@@ -126,9 +126,9 @@ MODELS: list[str] = [
     "chirp-auk",
     "chirp-bluejay",
     "chirp-crow",
+    "chirp-v3-0",
+    "chirp-v3-5",
     "chirp-v4",
-    "suno-v3",
-    "suno_lyrics",
     "sonar-medium-chat",
     "sonar-medium-online",
     "sonar-small-chat",

nous/genai/types.py

@@ -339,6 +339,8 @@ class JobInfo:
     job_id: str
     poll_after_ms: int = 1_000
     expires_at: str | None = None
+    last_status: str | None = None
+    last_detail: str | None = None
 
 
 @dataclass(frozen=True, slots=True)

{nous_genai-0.1.0.dist-info → nous_genai-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nous-genai
-Version: 0.1.0
+Version: 0.1.2
 Summary: Single-endpoint GenAI SDK (multi-provider, multimodal)
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/gravtice/nous-genai
@@ -168,6 +168,11 @@ If you need to write to file, see `examples/demo.py` (`_write_binary()`), or reu
 uv run genai --model openai:gpt-4o-mini --prompt "Hello"
 uv run genai model available --all
 
+# Tuzi Chirp music
+uv run genai --model tuzi-web:chirp-v3-5 --prompt "Lo-fi hiphop beat, 30s" --no-wait
+# ...later
+uv run genai --model tuzi-web:chirp-v3-5 --job-id "<job_id>" --output-path demo_suno.mp3 --timeout-ms 600000
+
 # MCP Server
 uv run genai-mcp-server                    # Streamable HTTP: /mcp, SSE: /sse
 uv run genai-mcp-cli tools                 # Debug CLI

{nous_genai-0.1.0.dist-info → nous_genai-0.1.2.dist-info}/RECORD

@@ -2,13 +2,13 @@ nous/__init__.py,sha256=Hh6QnLL0rRIVOTu33-Yt8GxHSNGfckYHTIsNP5prvEE,32
 nous/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 nous/genai/__init__.py,sha256=VY43n2cxXUP8ozW5vkW3P_WyEkGWYQY17NVHJHdRY24,1037
 nous/genai/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
-nous/genai/cli.py,sha256=f_e1Ss1ehVw-lfVaF9wEuquP5e0Fib2FfSnr0zmnTrQ,42733
+nous/genai/cli.py,sha256=H6cIhkMzaxnT7GeA9zWBpk8ePzhPwQupyxh5YnrIdZY,48227
 nous/genai/client.py,sha256=uKwttxMSkXCa1w8i7g3Mqs0L6ZCZZvMk7HdTXPfzoV0,26249
 nous/genai/mcp_cli.py,sha256=bhAhL4r9x3Xkzb_7NypfUELAHqdIiC23LQbSAGZIPAE,10356
 nous/genai/mcp_server.py,sha256=1NlJnAIV4LhMUDJ4BmH60KU7Jrx-bfivgIbcIaofPVU,40507
-nous/genai/types.py,sha256=g589VUakFeMEIN3-AwHHKP6PCcMDlD6svKZcrBeu0Ts,13011
+nous/genai/types.py,sha256=ndAO2SsVTyoQEKt06A7UGt4fixeY1hw7nS30nIqdTh0,13081
 nous/genai/_internal/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
-nous/genai/_internal/capability_rules.py,sha256=uCYeBDbJZx-S4Bib66oi_v3nZXS7dG84X0eEDifMjbY,13299
+nous/genai/_internal/capability_rules.py,sha256=aYoVSRVP4FK32Pgi7Qrs86J2Kj4g_GTPSgI9dqsSlts,13222
 nous/genai/_internal/config.py,sha256=JfT8uhU_QSNfPEKPU614pB_jRJbMBnVkbHnOm7UeYoc,3243
 nous/genai/_internal/errors.py,sha256=JZ2GIdFjae1I9ar7BCXmy01VenTrgvn4WfhbFNVF4i4,1639
 nous/genai/_internal/http.py,sha256=XcO13YOs28N-Tq8WKi0a4REIHgWQxXBgzPxDM_MBSo0,30236
@@ -18,7 +18,7 @@ nous/genai/providers/aliyun.py,sha256=FOAhQOlHmJC3Nm5cagPbf6JQ94XtM-TKFVCH51PPSL
 nous/genai/providers/anthropic.py,sha256=MShEm1lAw3dpbCPcsRz9eqWHt_x20EBswe4cJ4-ZgHo,17920
 nous/genai/providers/gemini.py,sha256=Kb-oe7zVYlm--EGla1yZ0BavUx11GkAO1d0dtyLSC3A,58320
 nous/genai/providers/openai.py,sha256=HxhR3pABZMLPtECAq4rUwuDSsBM4bb7AF66AVYLjUIU,75303
-nous/genai/providers/tuzi.py,sha256=arkU5UBtcwb4bNOEEMcNW9hww8NNzXxc1-d7TAv_2Hg,44761
+nous/genai/providers/tuzi.py,sha256=TVZpppT-MWcsmq5sCW6WDMF-usaKYkTAos7UVWakllM,42229
 nous/genai/providers/volcengine.py,sha256=hZVO9jIBLqKSqwZsysOoO_FtrLGGUvJVbfLDKzXITQc,9962
 nous/genai/reference/__init__.py,sha256=nfMsgNMUF1CHw3qslPA5Zniy8rBds9eISBpkCshbbJE,409
 nous/genai/reference/catalog.py,sha256=FeF3iabPNgNdWFR40ffAYTPHXfuEY4zT8G9asrlBD14,6633
@@ -33,13 +33,13 @@ nous/genai/reference/model_catalog_data/openai.py,sha256=siwx-htP7kPtlcDPzl6ommo
 nous/genai/reference/model_catalog_data/tuzi_anthropic.py,sha256=8jLckkoU0zwjoaTsAcdK03yY0u6iikK9p32HnL55mOk,519
 nous/genai/reference/model_catalog_data/tuzi_google.py,sha256=3S4mJfN1VtsNkTxbb42AeKc-oF84KRPTILA39QOpCew,540
 nous/genai/reference/model_catalog_data/tuzi_openai.py,sha256=K_w802dimRfQmmlgc4P2eI6ohvqAsQt2GoWb0K57BX0,1632
-nous/genai/reference/model_catalog_data/tuzi_web.py,sha256=wKYo9yndsi5yQA44HB2omQKz6esHvOqZKjMizOvFdbc,3081
+nous/genai/reference/model_catalog_data/tuzi_web.py,sha256=BrTBuKGt6aEPtgSRl-82xJcGes7Z8onPLHe2bdrZh4A,3083
 nous/genai/reference/model_catalog_data/volcengine.py,sha256=GxDELF9z8sbYyOEu-SpYluCal0tTAfFFLkS9-vXt1hg,3657
 nous/genai/tools/__init__.py,sha256=YWNhBKZ4t6diXI5SlCHA5OAIhLLOOA3vwQ6jClJsO2o,292
 nous/genai/tools/output_parser.py,sha256=epHW-fLBatrjMTl2nMvh_vFWFEmP8Xj2pZ5fosaZxTc,3968
-nous_genai-0.1.0.dist-info/licenses/LICENSE,sha256=yMLznCFyvxXAx7UUyAtq1gYFyzRsqGngYiaRF9R33Lg,10757
-nous_genai-0.1.0.dist-info/METADATA,sha256=UmxjLMmPE1GA4FpMFbo2HrjdThAB_BDMg4fMnhr1AT4,5474
-nous_genai-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-nous_genai-0.1.0.dist-info/entry_points.txt,sha256=j_cgAhxjPu7wtlo_zcdFLmz58dSxvnmSFM4f0A-ozEc,132
-nous_genai-0.1.0.dist-info/top_level.txt,sha256=yUcst4OAspsyKhX0y5ENzFkJKzR_gislA5MykV1pVbk,5
-nous_genai-0.1.0.dist-info/RECORD,,
+nous_genai-0.1.2.dist-info/licenses/LICENSE,sha256=yMLznCFyvxXAx7UUyAtq1gYFyzRsqGngYiaRF9R33Lg,10757
+nous_genai-0.1.2.dist-info/METADATA,sha256=umYJBfPzynwOUGrq5Gdf3qn8bJ6vtooqmO2lwCe08mE,5699
+nous_genai-0.1.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+nous_genai-0.1.2.dist-info/entry_points.txt,sha256=j_cgAhxjPu7wtlo_zcdFLmz58dSxvnmSFM4f0A-ozEc,132
+nous_genai-0.1.2.dist-info/top_level.txt,sha256=yUcst4OAspsyKhX0y5ENzFkJKzR_gislA5MykV1pVbk,5
+nous_genai-0.1.2.dist-info/RECORD,,