Ace Music

{
  "owner": "fspecii",
  "slug": "ace-music",
  "displayName": "ACE Music - Free Suno Alternative Generate unlimited AI music for free using ACE-Step 1.5. Full songs with vocals, lyrics, any genre, any language. No subscription, no credits, no limits. The open-source Suno alternative, powered by ACE Music's free API.",
  "latest": {
    "version": "1.0.0",
    "publishedAt": 1771464200986,
    "commit": "https://github.com/openclaw/skills/commit/c0a510771e56fb26aa12cecc444ad3d6f5b963a1"
  },
  "history": []
}

#!/usr/bin/env python3
"""
ACE-Step Music Generation via API
Usage: python generate.py <prompt> [options]

Options:
  --lyrics "..."       Lyrics text
  --duration 30        Duration in seconds
  --language en        Vocal language code (en, zh, ja, ko, ...)
  --instrumental       No vocals
  --output file.mp3    Output file path (default: output_<timestamp>.mp3)
  --bpm 120            Beats per minute
  --key "C major"      Musical key
  --seed 42            Random seed for reproducibility
  --sample-mode        Let AI generate everything (prompt + lyrics)
  --batch 3            Number of variations to generate
  --format mp3         Output format (mp3)
  --task cover         Task type: text2music (default), cover, repaint
  --repaint-start 10   Repaint start in seconds
  --repaint-end 30     Repaint end in seconds
  --cover-strength 0.8 Cover strength (0.0–1.0)
"""

import argparse
import base64
import os
import sys
import time

import requests


BASE_URL = os.environ.get("ACE_MUSIC_BASE_URL", "https://api.acemusic.ai")


def parse_args() -> argparse.Namespace:
    p = argparse.ArgumentParser(description="Generate music via ACE Music API", add_help=True)
    p.add_argument("prompt", nargs="?", default="", help="Music style / description")
    p.add_argument("--lyrics", default="")
    p.add_argument("--duration", type=float, default=None)
    p.add_argument("--language", default="en")
    p.add_argument("--instrumental", action="store_true")
    p.add_argument("--output", "-o", default=None)
    p.add_argument("--bpm", type=int, default=None)
    p.add_argument("--key", default=None)
    p.add_argument("--seed", type=int, default=None)
    p.add_argument("--sample-mode", action="store_true")
    p.add_argument("--batch", type=int, default=1)
    p.add_argument("--format", default="mp3")
    p.add_argument("--task", default="text2music", choices=["text2music", "cover", "repaint"])
    p.add_argument("--repaint-start", type=float, default=0.0)
    p.add_argument("--repaint-end", type=float, default=None)
    p.add_argument("--cover-strength", type=float, default=1.0)
    return p.parse_args()


def build_payload(args: argparse.Namespace) -> dict:
    # Build message content
    if args.lyrics and args.prompt:
        content = f"<prompt>{args.prompt}</prompt>\n<lyrics>{args.lyrics}</lyrics>"
    elif args.lyrics:
        content = args.lyrics
    else:
        content = args.prompt

    # audio_config
    audio_config: dict = {"vocal_language": args.language, "format": args.format}
    if args.duration is not None:
        audio_config["duration"] = args.duration
    if args.bpm is not None:
        audio_config["bpm"] = args.bpm
    if args.key:
        audio_config["key_scale"] = args.key
    if args.instrumental:
        audio_config["instrumental"] = True

    payload: dict = {
        "messages": [{"role": "user", "content": content}],
        "audio_config": audio_config,
        "stream": False,
        "task_type": args.task,
    }

    if args.sample_mode:
        payload["sample_mode"] = True
    if args.seed is not None:
        payload["seed"] = args.seed
    if args.batch > 1:
        payload["batch_size"] = args.batch
    if args.task == "repaint":
        payload["repainting_start"] = args.repaint_start
        if args.repaint_end is not None:
            payload["repainting_end"] = args.repaint_end
    if args.task == "cover":
        payload["audio_cover_strength"] = args.cover_strength

    return payload


def save_outputs(audios: list, output_path: str) -> list[str]:
    saved = []
    base, ext = (output_path.rsplit(".", 1) if "." in output_path else (output_path, "mp3"))
    for i, audio in enumerate(audios):
        url = audio["audio_url"]["url"]
        data = base64.b64decode(url.split(",", 1)[1])
        fname = output_path if len(audios) == 1 else f"{base}_{i + 1}.{ext}"
        with open(fname, "wb") as f:
            f.write(data)
        print(f"Saved: {fname}", file=sys.stderr)
        print(fname)  # stdout: file path for the caller (agent)
        saved.append(fname)
    return saved


def main() -> None:
    args = parse_args()

    api_key = os.environ.get("ACE_MUSIC_API_KEY", "")
    if not api_key:
        print("ERROR: ACE_MUSIC_API_KEY not set.", file=sys.stderr)
        print("Get your free API key at: https://acemusic.ai/playground/api-key", file=sys.stderr)
        sys.exit(1)

    if not args.prompt and not args.sample_mode and not args.lyrics:
        print("ERROR: Provide a prompt, --lyrics, or --sample-mode.", file=sys.stderr)
        sys.exit(1)

    output = args.output or f"output_{int(time.time())}.mp3"
    payload = build_payload(args)

    print(f"🎵 Generating music...", file=sys.stderr)
    print(f"   Prompt   : {args.prompt or '[lyrics/sample mode]'}", file=sys.stderr)
    if args.duration:
        print(f"   Duration : {args.duration}s", file=sys.stderr)
    print(f"   Language : {args.language}", file=sys.stderr)
    print(f"   Task     : {args.task}", file=sys.stderr)

    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json",
    }

    try:
        resp = requests.post(
            f"{BASE_URL}/v1/chat/completions",
            headers=headers,
            json=payload,
            timeout=300,
        )
        resp.raise_for_status()
    except requests.RequestException as e:
        print(f"ERROR: API request failed: {e}", file=sys.stderr)
        sys.exit(1)

    result = resp.json()

    if "choices" not in result:
        print("ERROR: Unexpected API response:", file=sys.stderr)
        print(result, file=sys.stderr)
        sys.exit(1)

    audios = result["choices"][0]["message"].get("audio", [])
    if not audios:
        print("ERROR: No audio in response.", file=sys.stderr)
        print(result, file=sys.stderr)
        sys.exit(1)

    save_outputs(audios, output)

    metadata = result["choices"][0]["message"].get("content", "")
    if metadata:
        print(f"\n📋 Metadata:\n{metadata}", file=sys.stderr)


if __name__ == "__main__":
    main()

#!/usr/bin/env bash
# ACE-Step Music Generation via API
# Usage: generate.sh <prompt> [options]
# Options: --lyrics "..." --duration 30 --language en --instrumental --output file.mp3
#          --bpm 120 --key "C major" --seed 42 --sample-mode --batch 2

set -euo pipefail

# Config
API_KEY="${ACE_MUSIC_API_KEY:-}"
BASE_URL="${ACE_MUSIC_BASE_URL:-https://api.acemusic.ai}"
OUTPUT="output_$(date +%s).mp3"

# Defaults
DURATION=""
LANGUAGE="en"
INSTRUMENTAL="null"
BPM=""
KEY_SCALE=""
SEED=""
SAMPLE_MODE="false"
BATCH_SIZE=1
LYRICS=""
PROMPT=""
FORMAT="mp3"

# Parse args
while [[ $# -gt 0 ]]; do
  case "$1" in
    --lyrics) LYRICS="$2"; shift 2 ;;
    --duration) DURATION="$2"; shift 2 ;;
    --language) LANGUAGE="$2"; shift 2 ;;
    --instrumental) INSTRUMENTAL="true"; shift ;;
    --output|-o) OUTPUT="$2"; shift 2 ;;
    --bpm) BPM="$2"; shift 2 ;;
    --key) KEY_SCALE="$2"; shift 2 ;;
    --seed) SEED="$2"; shift 2 ;;
    --sample-mode) SAMPLE_MODE="true"; shift ;;
    --batch) BATCH_SIZE="$2"; shift 2 ;;
    --format) FORMAT="$2"; shift 2 ;;
    *) PROMPT="$1"; shift ;;
  esac
done

if [[ -z "$API_KEY" ]]; then
  echo "ERROR: ACE_MUSIC_API_KEY not set." >&2
  echo "Get your free API key at: https://acemusic.ai/playground/api-key" >&2
  exit 1
fi

if [[ -z "$PROMPT" && "$SAMPLE_MODE" == "false" ]]; then
  echo "Usage: generate.sh <prompt> [--lyrics '...'] [--duration 30] [--language en] [--instrumental] [--output file.mp3]" >&2
  exit 1
fi

# Build audio_config
AUDIO_CONFIG="{\"vocal_language\":\"$LANGUAGE\",\"format\":\"$FORMAT\""
[[ -n "$DURATION" ]] && AUDIO_CONFIG="$AUDIO_CONFIG,\"duration\":$DURATION"
[[ -n "$BPM" ]] && AUDIO_CONFIG="$AUDIO_CONFIG,\"bpm\":$BPM"
[[ "$INSTRUMENTAL" != "null" ]] && AUDIO_CONFIG="$AUDIO_CONFIG,\"instrumental\":$INSTRUMENTAL"
[[ -n "$KEY_SCALE" ]] && AUDIO_CONFIG="$AUDIO_CONFIG,\"key_scale\":\"$KEY_SCALE\""
AUDIO_CONFIG="$AUDIO_CONFIG}"

# Build message content
if [[ -n "$LYRICS" && -n "$PROMPT" ]]; then
  # Tagged mode
  CONTENT="<prompt>${PROMPT}</prompt>\n<lyrics>${LYRICS}</lyrics>"
elif [[ -n "$LYRICS" ]]; then
  CONTENT="$LYRICS"
else
  CONTENT="$PROMPT"
fi

# Escape for JSON
CONTENT_ESCAPED=$(echo -n "$CONTENT" | python3 -c "import sys,json; print(json.dumps(sys.stdin.read()))" | sed 's/^"//;s/"$//')

# Build request body
BODY="{\"messages\":[{\"role\":\"user\",\"content\":\"$CONTENT_ESCAPED\"}],\"audio_config\":$AUDIO_CONFIG,\"stream\":false"
[[ -n "$LYRICS" && -n "$PROMPT" ]] || true  # tagged mode handled via content
[[ "$SAMPLE_MODE" == "true" ]] && BODY="$BODY,\"sample_mode\":true"
[[ -n "$SEED" ]] && BODY="$BODY,\"seed\":$SEED"
[[ "$BATCH_SIZE" -gt 1 ]] && BODY="$BODY,\"batch_size\":$BATCH_SIZE"
BODY="$BODY}"

echo "🎵 Generating music..." >&2
echo "   Prompt: ${PROMPT:-[lyrics/sample mode]}" >&2
[[ -n "$DURATION" ]] && echo "   Duration: ${DURATION}s" >&2
echo "   Language: $LANGUAGE" >&2

# API call
RESPONSE=$(curl -s -X POST "${BASE_URL}/v1/chat/completions" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d "$BODY")

# Check for errors
if echo "$RESPONSE" | python3 -c "import sys,json; d=json.load(sys.stdin); exit(0 if 'choices' in d else 1)" 2>/dev/null; then
  # Extract metadata
  METADATA=$(echo "$RESPONSE" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d['choices'][0]['message'].get('content',''))" 2>/dev/null || echo "")
  
  # Extract and save audio(s)
  COUNT=$(echo "$RESPONSE" | python3 -c "
import sys,json
d=json.load(sys.stdin)
audios=d['choices'][0]['message'].get('audio',[])
print(len(audios))
" 2>/dev/null || echo "0")

  if [[ "$COUNT" -eq 0 ]]; then
    echo "ERROR: No audio in response" >&2
    echo "$RESPONSE" >&2
    exit 1
  fi

  echo "$RESPONSE" | python3 -c "
import sys, json, base64
d = json.load(sys.stdin)
audios = d['choices'][0]['message'].get('audio', [])
output = '$OUTPUT'
for i, a in enumerate(audios):
    url = a['audio_url']['url']
    b64 = url.split(',', 1)[1]
    fname = output if len(audios) == 1 else output.rsplit('.', 1)[0] + f'_{i+1}.' + output.rsplit('.', 1)[1]
    with open(fname, 'wb') as f:
        f.write(base64.b64decode(b64))
    print(f'Saved: {fname}', file=sys.stderr)
    print(fname)
"

  if [[ -n "$METADATA" ]]; then
    echo "" >&2
    echo "📋 Metadata:" >&2
    echo "$METADATA" >&2
  fi
else
  echo "ERROR: API request failed" >&2
  echo "$RESPONSE" >&2
  exit 1
fi