@petercjl/seedaudiocli 0.1.1 → 0.2.0

package/seedaudiocli/official.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+from typing import Any
+
+from .config import seedaudio_api_key, seedaudio_base_url
+
+
+class SeedAudioError(RuntimeError):
+    def __init__(self, message: str, code: str = "PROVIDER_FAILURE", *, details=None):
+        super().__init__(message)
+        self.code = code
+        self.details = details or {}
+
+
+class NoRedirect(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+
+def create_audio(payload: dict[str, Any], request_id: str, timeout: int = 300) -> dict:
+    # Validate destination before reading/sending the credential. No POST retry.
+    url = seedaudio_base_url() + "/api/v3/tts/create"
+    key = seedaudio_api_key()
+    if not key:
+        raise SeedAudioError("Import a Doubao Speech configuration file.", "CONFIG_REQUIRED")
+    req = urllib.request.Request(url, data=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
+                                headers={"X-Api-Key": key, "X-Api-Request-Id": request_id,
+                                         "Content-Type": "application/json"}, method="POST")
+    opener = urllib.request.build_opener(NoRedirect)
+    try:
+        with opener.open(req, timeout=timeout) as resp:
+            raw = resp.read()
+            logid = resp.headers.get("X-Tt-Logid")
+    except urllib.error.HTTPError as e:
+        logid = e.headers.get("X-Tt-Logid") if e.headers else None
+        try:
+            error = json.loads(e.read())
+        except (ValueError, OSError):
+            error = {}
+        if not isinstance(error, dict):
+            error = {}
+        code = "AUTH_REQUIRED" if e.code == 401 else "PERMISSION_REQUIRED" if e.code == 403 else "PROVIDER_FAILURE"
+        if e.code >= 500 or e.code == 408:
+            code = "SUBMISSION_UNKNOWN"
+        message = str(error.get("message", "Official service rejected the request.")).replace(key, "[REDACTED]")
+        raise SeedAudioError(message, code, details={"http_status": e.code,
+                            "provider_code": error.get("code"), "logid": logid,
+                            "request_id": request_id}) from None
+    except (urllib.error.URLError, TimeoutError, OSError):
+        raise SeedAudioError("Connection ended without a confirmed result. Do not automatically resubmit.",
+                             "SUBMISSION_UNKNOWN", details={"request_id": request_id}) from None
+    try:
+        data = json.loads(raw)
+        if not isinstance(data, dict):
+            raise ValueError()
+    except (ValueError, UnicodeError):
+        raise SeedAudioError("Official service returned an unreadable result; generation outcome is unknown.",
+                             "SUBMISSION_UNKNOWN", details={"request_id": request_id, "logid": logid}) from None
+    return {**data, "request_id": request_id, "logid": logid}

package/seedaudiocli/payloads.py

@@ -1,20 +1,21 @@
 from __future__ import annotations
 
+import base64
 import hashlib
 import json
 from pathlib import Path
+from urllib.parse import urlparse
 from typing import Any
 
 from .config import default_format, default_sample_rate, seedaudio_model
 
-
 FORMATS = {"wav", "mp3", "pcm", "ogg_opus"}
-SAMPLE_RATES = {8000, 16000, 24000, 32000, 44100, 48000}
+SAMPLE_RATES = {8000, 16000, 24000, 32000, 40000, 44100, 48000}
 
 
-def read_prompt(prompt: str | None, prompt_file: str | None) -> str:
+def read_prompt(prompt, prompt_file):
     if prompt and prompt_file:
-        raise ValueError("Use either --prompt or --prompt-file, not both.")
+        raise ValueError("Use either --prompt or --prompt-file.")
     if prompt_file:
         return Path(prompt_file).expanduser().read_text(encoding="utf-8").strip()
     if prompt:
@@ -22,86 +23,107 @@ def read_prompt(prompt: str | None, prompt_file: str | None) -> str:
     raise ValueError("Missing --prompt or --prompt-file.")
 
 
-def build_payload(
-    *,
-    prompt: str,
-    model: str | None = None,
-    audio_references: list[str] | None = None,
-    image_urls: list[str] | None = None,
-    output_format: str | None = None,
-    sample_rate: int | None = None,
-    speech_rate: float | None = None,
-    loudness_rate: float | None = None,
-    pitch_rate: int | None = None,
-    callback_url: str | None = None,
-) -> dict[str, Any]:
-    payload: dict[str, Any] = {
-        "model": model or seedaudio_model(),
-        "prompt": prompt,
-        "format": output_format or default_format(),
-        "sample_rate": sample_rate or default_sample_rate(),
-    }
-    if audio_references:
-        payload["audio_references"] = audio_references
-    if image_urls:
-        payload["image_urls"] = image_urls
-    if speech_rate is not None:
-        payload["speech_rate"] = speech_rate
-    if loudness_rate is not None:
-        payload["loudness_rate"] = loudness_rate
-    if pitch_rate is not None:
-        payload["pitch_rate"] = pitch_rate
-    if callback_url:
-        payload["callback_url"] = callback_url
-    return payload
-
-
-def validate_payload(payload: dict[str, Any]) -> list[str]:
-    errors: list[str] = []
-    prompt = payload.get("prompt")
-    if not isinstance(prompt, str) or not prompt.strip():
-        errors.append("prompt is required.")
-    elif len(prompt) > 1500:
-        errors.append("prompt must be <= 1500 characters.")
-
-    if payload.get("model") != "doubao-seed-audio-1-0":
-        errors.append("model must be doubao-seed-audio-1-0 unless the gateway adds another compatible model.")
-
-    fmt = payload.get("format")
+def local_reference(filename, kind):
+    p = Path(filename).expanduser()
+    allowed = {".wav", ".mp3", ".pcm", ".ogg", ".opus"} if kind == "audio" else {".jpg", ".jpeg", ".png", ".webp"}
+    if not p.is_file() or p.suffix.lower() not in allowed or not 0 < p.stat().st_size <= 10 * 1024 * 1024:
+        raise ValueError("Reference must be a supported non-empty file up to 10 MiB.")
+    return {kind + "_data": base64.b64encode(p.read_bytes()).decode("ascii")}
+
+
+def build_payload(*, prompt, model=None, audio_references=None, image_urls=None,
+                  audio_files=None, image_files=None, output_format=None, sample_rate=None,
+                  speech_rate=None, loudness_rate=None, pitch_rate=None, enable_subtitle=False):
+    config = {"format": output_format or default_format(), "sample_rate": sample_rate if sample_rate is not None else default_sample_rate()}
+    for key, value in [("speech_rate", speech_rate), ("loudness_rate", loudness_rate), ("pitch_rate", pitch_rate)]:
+        if value is not None:
+            config[key] = value
+    if enable_subtitle:
+        config["enable_subtitle"] = True
+    refs = [{"audio_url" if r.startswith(("http://", "https://")) else "speaker": r} for r in audio_references or []]
+    refs += [local_reference(f, "audio") for f in audio_files or []]
+    refs += [{"image_url": u} for u in image_urls or []]
+    refs += [local_reference(f, "image") for f in image_files or []]
+    result = {"model": model or seedaudio_model(), "text_prompt": prompt, "audio_config": config}
+    if refs:
+        result["references"] = refs
+    return result
+
+
+def validate_payload(payload):
+    if not isinstance(payload, dict):
+        return ["Payload must be a JSON object."]
+    errors = []
+    if set(payload) - {"model", "text_prompt", "references", "audio_config", "watermark"}:
+        errors.append("Unsupported top-level fields; use the official request schema.")
+    prompt = payload.get("text_prompt")
+    if not isinstance(prompt, str) or not prompt.strip() or len(prompt) > 3000:
+        errors.append("text_prompt must contain 1–3000 characters.")
+    if payload.get("model") != "seed-audio-1.0":
+        errors.append("model must be seed-audio-1.0.")
+    config = payload.get("audio_config", {})
+    if not isinstance(config, dict):
+        errors.append("audio_config must be an object.")
+        config = {}
+    if set(config) - {"format", "sample_rate", "speech_rate", "loudness_rate", "pitch_rate", "enable_subtitle"}:
+        errors.append("Unsupported audio_config fields.")
+    fmt = config.get("format", "wav")
+    rate = config.get("sample_rate", 40000 if fmt in {"wav", "pcm"} else 48000 if fmt == "ogg_opus" else 44100)
     if fmt not in FORMATS:
-        errors.append(f"format must be one of {sorted(FORMATS)}.")
-
-    sample_rate = payload.get("sample_rate")
-    if sample_rate not in SAMPLE_RATES:
-        errors.append(f"sample_rate must be one of {sorted(SAMPLE_RATES)}.")
-
-    audio_refs = payload.get("audio_references")
-    image_urls = payload.get("image_urls")
-    if audio_refs and image_urls:
-        errors.append("audio_references and image_urls are mutually exclusive.")
-    if audio_refs is not None:
-        if not isinstance(audio_refs, list):
-            errors.append("audio_references must be a list.")
-        elif len(audio_refs) > 3:
-            errors.append("audio_references supports at most 3 items.")
-    if image_urls is not None:
-        if not isinstance(image_urls, list):
-            errors.append("image_urls must be a list.")
-        elif len(image_urls) > 1:
-            errors.append("image_urls supports at most 1 item.")
-
-    for key in ("speech_rate", "loudness_rate"):
-        if key in payload:
-            value = payload[key]
-            if not isinstance(value, (int, float)) or value < 0.5 or value > 2:
-                errors.append(f"{key} must be between 0.5 and 2.0.")
-    if "pitch_rate" in payload:
-        value = payload["pitch_rate"]
-        if not isinstance(value, int) or value < -12 or value > 12:
-            errors.append("pitch_rate must be an integer between -12 and 12.")
+        errors.append("Unsupported audio format.")
+    if type(rate) is not int or rate not in SAMPLE_RATES or (fmt == "mp3" and rate == 40000) or (fmt == "ogg_opus" and rate != 48000):
+        errors.append("sample_rate is incompatible with the output format.")
+    for name, low, high in [("speech_rate", -50, 100), ("loudness_rate", -50, 100), ("pitch_rate", -12, 12)]:
+        if name in config and (type(config[name]) is not int or not low <= config[name] <= high):
+            errors.append(f"{name} must be an integer in [{low}, {high}].")
+    if "enable_subtitle" in config and type(config["enable_subtitle"]) is not bool:
+        errors.append("enable_subtitle must be boolean.")
+    refs = payload.get("references", [])
+    if not isinstance(refs, list):
+        errors.append("references must be a list.")
+        refs = []
+    audio, image = 0, 0
+    for ref in refs:
+        if not isinstance(ref, dict) or len(ref) != 1:
+            errors.append("Each reference must contain exactly one source field.")
+            continue
+        key, value = next(iter(ref.items()))
+        if key not in {"speaker", "audio_data", "audio_url", "image_data", "image_url"} or not isinstance(value, str) or not value.strip():
+            errors.append("Unsupported or empty reference.")
+            continue
+        image += int(key.startswith("image"))
+        audio += int(not key.startswith("image"))
+        if key.endswith("_url"):
+            u = urlparse(value)
+            if u.scheme not in {"http", "https"} or not u.hostname or u.username or u.password:
+                errors.append("Reference URL must be an HTTP(S) URL without credentials.")
+        if key.endswith("_data"):
+            try:
+                size = len(base64.b64decode(value, validate=True))
+                if not 0 < size <= 10 * 1024 * 1024:
+                    raise ValueError()
+            except ValueError:
+                errors.append("Reference base64 must decode to 1 byte–10 MiB.")
+    if audio and image:
+        errors.append("Audio and image references are mutually exclusive.")
+    if audio > 3 or image > 1:
+        errors.append("Use up to three audio references or one image reference.")
+    watermark = payload.get("watermark", {})
+    if not isinstance(watermark, dict):
+        errors.append("watermark must be an object.")
+    else:
+        if set(watermark) - {"aigc_watermark", "aigc_metadata"}:
+            errors.append("Unsupported watermark fields.")
+        if "aigc_watermark" in watermark and type(watermark["aigc_watermark"]) is not bool:
+            errors.append("aigc_watermark must be boolean.")
+        meta = watermark.get("aigc_metadata", {})
+        if not isinstance(meta, dict) or set(meta) - {"enable", "content_producer", "produce_id", "content_propagator", "propagate_id"}:
+            errors.append("Invalid aigc_metadata.")
+        elif any(type(v) is not bool if k == "enable" else not isinstance(v, str) for k, v in meta.items()):
+            errors.append("Invalid watermark metadata field type.")
     return errors
 
 
-def request_hash(payload: dict[str, Any]) -> str:
+def request_hash(payload):
     data = json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")
-    return hashlib.sha256(data).hexdigest()[:16]
+    return hashlib.sha256(data).hexdigest()

package/seedaudiocli.config.example.json

@@ -1,7 +1,7 @@
 {
   "SEEDAUDIO_API_KEY": "",
-  "SEEDAUDIO_BASE_URL": "https://api.evolink.ai",
-  "SEEDAUDIO_MODEL": "doubao-seed-audio-1-0",
+  "SEEDAUDIO_BASE_URL": "https://openspeech.bytedance.com",
+  "SEEDAUDIO_MODEL": "seed-audio-1.0",
   "SEEDAUDIO_DEFAULT_FORMAT": "mp3",
   "SEEDAUDIO_DEFAULT_SAMPLE_RATE": "44100"
 }

package/seedaudiocli.env.example

@@ -4,7 +4,7 @@
 # This is a local-only file. Do not commit real API keys.
 
 SEEDAUDIO_API_KEY=
-SEEDAUDIO_BASE_URL=https://api.evolink.ai
-SEEDAUDIO_MODEL=doubao-seed-audio-1-0
+SEEDAUDIO_BASE_URL=https://openspeech.bytedance.com
+SEEDAUDIO_MODEL=seed-audio-1.0
 SEEDAUDIO_DEFAULT_FORMAT=mp3
 SEEDAUDIO_DEFAULT_SAMPLE_RATE=44100

package/skills/seedaudiocli/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: seedaudiocli
-description: Generate audio through EvoLink Seed Audio using the seedaudiocli CLI; import configuration files, submit explicit audio requests, recover tasks, and download results.
+description: Generate audio through official Volcengine Seed Audio using the seedaudiocli CLI; import configuration files, submit explicit audio requests, recover tasks, and download results.
 ---
 
 # Seed Audio CLI
@@ -10,7 +10,7 @@ Inputs are an explicit audio prompt, selected reference mode, output settings an
 
 ## Runtime and discovery
 
-Requires Node.js 22+, Python 3.9+ with SSL, network access to EvoLink, and an authorized API key. Run `seedaudiocli version`, `seedaudiocli capabilities --json` and `seedaudiocli doctor --json`. Resolve the canonical Skill with `seedaudiocli skill source --json`; the returned `source` directory belongs to the installed npm package.
+Requires Node.js 22+, Python 3.9+ with SSL, network access to Doubao Speech, and an authorized API key. Run `seedaudiocli version`, `seedaudiocli capabilities --json` and `seedaudiocli doctor --json`. Resolve the canonical Skill with `seedaudiocli skill source --json`; the returned `source` directory belongs to the installed npm package.
 
 Use the current host's terminal execution capability. Its mapping is declared in [capabilities.json](capabilities.json) and the selected adapter: [Codex](adapters/codex.json) or [SealSeek](adapters/sealseek.json). Adapter mappings are implemented; host integration evidence is separate from CLI tests.
 
@@ -18,9 +18,9 @@ Use the current host's terminal execution capability. Its mapping is declared in
 
 1. Check `seedaudiocli auth status`. This checks local configuration only and does not prove the key is accepted remotely.
 2. If configuration is missing, ask the user for the local path to the administrator-provided JSON or env configuration file. Import with `seedaudiocli config import "FILE"`. Pass the file path to the CLI without displaying or reading its secret contents into the conversation. If configuration already exists, preserve it; an explicitly requested replacement uses `--replace`, which creates a backup. After import, return to step 1. Interactive terminal users can run `seedaudiocli setup`.
-3. Preserve the caller's prompt, model, reference mode and output choices. Choose `generate text`, `generate audio-ref`, or `generate image-ref` according to those inputs. Prompts support at most 1500 characters; audio mode accepts up to three preset IDs or public audio URLs; image mode accepts exactly one public image URL. Local references need an authorized hosting step outside this CLI.
+3. Preserve the caller's prompt, model, reference mode and output choices. Choose `generate text`, `generate audio-ref`, or `generate image-ref` according to those inputs. Prompts support 1–3000 characters. Audio mode accepts up to three preset speaker IDs, public URLs or local recordings (each at most 30 seconds and 10 MiB). Image mode accepts one JPEG/PNG/WebP URL or local image (at most 10 MiB). Use `--audio-file` / `--image-file` for local files; the CLI sends their bytes directly. Audio and image references are mutually exclusive.
 4. Validate the intended request with `--dry-run`. Validation must succeed before paid submission. Configuration import and dry-run do not submit generation jobs.
-5. Execute the authorized request with `--wait --download "OUTPUT_DIRECTORY"` when local delivery is required. Save the returned task ID. Generation can incur service charges.
+5. Execute the authorized request with `--download "OUTPUT_DIRECTORY"` when local delivery is required. The official call is synchronous; `--wait` remains a compatibility flag. Save the local task ID emitted before submission. The CLI saves the official response and audio in private local state. Generation can incur service charges.
 6. Inspect status and actual output paths. A completed task without an audio file is incomplete delivery. Report the task ID, file and material limitations; content quality remains the caller's acceptance responsibility.
 
 ## Invocation examples
@@ -28,28 +28,34 @@ Use the current host's terminal execution capability. Its mapping is declared in
 ```bash
 seedaudiocli generate text --prompt "Generate five seconds of instrumental piano." --dry-run
 seedaudiocli generate text --prompt "Generate five seconds of instrumental piano." --wait --download ./audio
-seedaudiocli generate audio-ref --audio-reference zh_female_vv_uranus_bigtts --prompt "@audio1 今天的咖啡刚刚好。" --wait --download ./audio
+seedaudiocli generate audio-ref --audio-reference zh_female_vv_uranus_bigtts --prompt "@音频1 今天的咖啡刚刚好。" --wait --download ./audio
 seedaudiocli generate image-ref --image-url "https://example.com/reference.jpg" --prompt "Generate audio matching the supplied reference." --dry-run
 seedaudiocli task get TASK_ID
 seedaudiocli task wait TASK_ID --download ./audio
 seedaudiocli task jobs --limit 20
 ```
 
-Use `@audio1` through `@audio3` in prompts to address the corresponding audio references. Supported formats are mp3, wav, pcm and ogg_opus. Use the command help for sample-rate and other constraints. Explicit unsupported requests require caller resolution.
+Use `@音频1` through `@音频3` to address references in order; `--audio-reference` entries precede `--audio-file` entries when mixed. Supported formats are mp3, wav, pcm and ogg_opus. Sample rates are 8000, 16000, 24000, 32000, 40000, 44100 and 48000; mp3 excludes 40000, and ogg_opus requires 48000. Speech/loudness adjustments are integers from -50 to 100 (0 unchanged); pitch is an integer from -12 to 12. `--subtitle` saves returned subtitle JSON. For advanced official watermark fields use a JSON payload with `payload validate` then `payload submit`. Explicit unsupported requirements return to the caller.
+
+The only provider endpoint is `https://openspeech.bytedance.com/api/v3/tts/create`, with model `seed-audio-1.0` and `X-Api-Key` authentication. Use a Doubao Speech API key authorized for Seed Audio. Ark credentials belong to another service. The official schema is documented at https://docs.volcengine.com/docs/DoubaoVoice/audio-generation-http?lang=zh.
 
 ## Error and recovery branches
 
 - `CONFIG_REQUIRED`: request the file path, import, then return to authentication check.
 - `CONFIG_INVALID` or `CONFIG_READ_FAILED`: request a corrected file/path. Preserve the saved configuration.
 - `CONFIG_EXISTS`: explain that configuration already exists; replace only when the user requests it.
-- `AUTH_REQUIRED`: the provider rejected credentials or permissions. Request a valid replacement or account correction, then resume the same intended operation.
+- `CONFIG_MIGRATION_REQUIRED`: import the administrator-provided official configuration with authorized `--replace`; a backup preserves the previous file. Return to step 1.
+- `AUTH_REQUIRED`: credentials were rejected. Request a valid Doubao Speech replacement, then return to step 1. `PERMISSION_REQUIRED` means the account needs service permission correction.
 - `PYTHON_REQUIRED`: install a supported Python runtime in the host's managed environment; verify with `doctor` before returning to the main flow.
-- Network failure or polling timeout: retain configuration and recover using the existing task ID. Do not submit a duplicate paid job to fix a polling error.
-- Unknown submission outcome: inspect task history and provider evidence before any new explicitly authorized submission. `--force` intentionally bypasses local request deduplication and can charge again.
+- `task get`, `task wait` and `task download` read local records and saved responses; they make no remote polling call and need no API key. Completed saved audio can be exported again even if the provider URL expires.
+- Network timeout or interrupted submission: keep the local ID and inspect `task get`. If no successful response was saved, the outcome remains unknown; the official API has no task-query operation.
+- `REQUEST_BUSY`: an identical request is active or its process was interrupted. Inspect history and verify no process is still using the lock before removing a stale local lock. Resume local recovery first.
+- `OUTPUT_EXISTS`: choose a new output name or directory; reuse the saved result without another paid call. `OUTPUT_CONTRACT_FAILED`: inspect the saved response and report incomplete delivery.
+- `SUBMISSION_UNKNOWN`: inspect local history and provider billing/support evidence before any new explicitly authorized submission. `--force` intentionally bypasses local request deduplication and can charge again.
 - Provider failure: report it with the task ID. Changing prompt, references or model is a caller decision.
 
 ## Installation and update
 
 `seedaudiocli skill install --agent codex` installs a managed copy. For SealSeek supply the actual discovery directory with `--root SKILLS_DIRECTORY` or `SEALSEEK_SKILLS_DIR`; installation refuses to guess the host's layout. Existing unmanaged Skills are preserved. `skill status` reports ownership and freshness; `skill update` backs up managed files and preserves customized UI metadata. Edited managed content requires reconciliation.
 
-Run `seedaudiocli update instructions` for the package update and Skill synchronization commands. Updates are explicit; configuration and history live outside the npm package and remain available afterward. Record recurring contract failures for a separately authorized package update.
+Global npm installations check stable `latest` before every invocation and install a newer version before executing the command once. Managed Skills are synchronized with backups. Offline checks retain the installed version. `seedaudiocli update check` inspects availability; `update install` performs an explicit update. Set `SEEDAUDIO_AUTO_UPDATE=0` for a deliberately pinned run. Development checkouts remain Git-managed. Within taobao-ai-ops use `taobao-ai-ops component run seedaudiocli ...`; the suite owns component updates. Configuration and task history remain in user directories. Record recurring contract failures for a separately authorized package update.

package/skills/seedaudiocli/capabilities.json

@@ -33,7 +33,13 @@
         "CONFIG_INVALID",
         "AUTH_REQUIRED",
         "PYTHON_REQUIRED",
-        "PROVIDER_FAILURE"
+        "PROVIDER_FAILURE",
+        "CONFIG_MIGRATION_REQUIRED",
+        "PERMISSION_REQUIRED",
+        "SUBMISSION_UNKNOWN",
+        "REQUEST_BUSY",
+        "OUTPUT_CONTRACT_FAILED",
+        "OUTPUT_EXISTS"
       ]
     }
   ]

package/seedaudiocli/evolink.py

@@ -1,149 +0,0 @@
-from __future__ import annotations
-
-import json
-import re
-import time
-import urllib.error
-import urllib.request
-from pathlib import Path
-from typing import Any
-
-from .config import seedaudio_api_key, seedaudio_base_url
-
-
-class SeedAudioError(RuntimeError):
-    def __init__(self, message: str, code: str = "PROVIDER_FAILURE"):
-        super().__init__(message)
-        self.code = code
-
-
-def _headers(json_body: bool = True) -> dict[str, str]:
-    key = seedaudio_api_key()
-    if not key:
-        raise SeedAudioError("Run seedaudiocli setup to import a configuration file.", "CONFIG_REQUIRED")
-    headers = {"Authorization": f"Bearer {key}"}
-    if json_body:
-        headers["Content-Type"] = "application/json"
-    return headers
-
-
-def api_root() -> str:
-    return seedaudio_base_url()
-
-
-def create_url() -> str:
-    return f"{api_root()}/v1/audios/generations"
-
-
-def task_url(task_id: str) -> str:
-    return f"{api_root()}/v1/tasks/{task_id}"
-
-
-def _request(method: str, url: str, body: dict[str, Any] | None = None, timeout: int = 120) -> dict[str, Any]:
-    data = json.dumps(body, ensure_ascii=False).encode("utf-8") if body is not None else None
-    req = urllib.request.Request(url, data=data, headers=_headers(json_body=body is not None), method=method)
-    try:
-        with urllib.request.urlopen(req, timeout=timeout) as resp:
-            text = resp.read().decode("utf-8")
-            if not text:
-                return {}
-            return json.loads(text)
-    except urllib.error.HTTPError as e:
-        text = e.read().decode("utf-8", errors="replace")
-        if e.code in {401, 403}:
-            raise SeedAudioError("Provider rejected authorization. Check key validity and account permissions.", "AUTH_REQUIRED") from e
-        raise SeedAudioError(f"HTTP {e.code}: {text}") from e
-    except urllib.error.URLError as e:
-        raise SeedAudioError(f"Network error: {e}") from e
-    except json.JSONDecodeError as e:
-        raise SeedAudioError(f"Non-JSON response from EvoLink: {e}") from e
-
-
-def _request_with_retry(method: str, url: str, body: dict[str, Any] | None = None, timeout: int = 120) -> dict[str, Any]:
-    last_error: SeedAudioError | None = None
-    for attempt in range(1, 4):
-        try:
-            return _request(method, url, body, timeout)
-        except SeedAudioError as e:
-            last_error = e
-            if attempt < 3:
-                time.sleep(min(2 * attempt, 8))
-    raise last_error or SeedAudioError("Request failed")
-
-
-def create_task(payload: dict[str, Any]) -> dict[str, Any]:
-    return _request("POST", create_url(), payload)
-
-
-def get_task(task_id: str) -> dict[str, Any]:
-    return _request_with_retry("GET", task_url(task_id), None, timeout=60)
-
-
-def extract_task_id(response: dict[str, Any]) -> str | None:
-    for key in ("id", "task_id", "taskId"):
-        value = response.get(key)
-        if value:
-            return str(value)
-    return None
-
-
-def extract_status(response: dict[str, Any]) -> str:
-    value = response.get("status")
-    return str(value).lower() if value else "unknown"
-
-
-def extract_audio_urls(response: dict[str, Any]) -> list[str]:
-    urls: list[str] = []
-    result_data = response.get("result_data")
-    if isinstance(result_data, list):
-        for item in result_data:
-            if isinstance(item, dict):
-                value = item.get("audio_url")
-                if isinstance(value, str) and value.startswith(("http://", "https://")):
-                    urls.append(value)
-    results = response.get("results")
-    if isinstance(results, list):
-        for value in results:
-            if isinstance(value, str) and value.startswith(("http://", "https://")):
-                urls.append(value)
-    seen: list[str] = []
-    for url in urls:
-        if url not in seen:
-            seen.append(url)
-    return seen
-
-
-def infer_extension(url: str, output_format: str | None = None) -> str:
-    match = re.search(r"\.(mp3|wav|ogg|opus|pcm)(\?|$)", url, re.I)
-    if match:
-        ext = match.group(1).lower()
-        return "ogg_opus" if ext == "opus" else ext
-    return output_format or "mp3"
-
-
-def wait_for_task(task_id: str, interval: int = 5, timeout: int = 1800) -> dict[str, Any]:
-    deadline = time.time() + timeout
-    last_response: dict[str, Any] = {}
-    while time.time() < deadline:
-        last_response = get_task(task_id)
-        status = extract_status(last_response)
-        if status in {"completed", "failed", "cancelled", "canceled", "expired"}:
-            return last_response
-        time.sleep(interval)
-    raise SeedAudioError(f"Timed out waiting for task {task_id}. Last response: {json.dumps(last_response, ensure_ascii=False)}")
-
-
-def download_url(url: str, out: Path) -> Path:
-    out.parent.mkdir(parents=True, exist_ok=True)
-    req = urllib.request.Request(url, headers={"User-Agent": "seedaudiocli/0.1"})
-    last_error: urllib.error.URLError | None = None
-    for attempt in range(1, 4):
-        try:
-            with urllib.request.urlopen(req, timeout=300) as resp:
-                out.write_bytes(resp.read())
-            return out
-        except urllib.error.URLError as e:
-            last_error = e
-            if attempt < 3:
-                time.sleep(min(2 * attempt, 8))
-    raise SeedAudioError(f"Download failed: {last_error}") from last_error