Server definition
- Hash
- sha256:e259efb1b8f1a2a1068955c3a16fbf36faf9d46b7847b39e031f4e5183bdf0d8
- What it is
- What a remote MCP server returned when asked what it offers: 53 tools
The blob, as servednamed by its sha256
{
"instructions": "doseedo = MUSIC & AUDIO FOR AGENTS: you write the notes, doseedo_render_midi plays them on 100+ instruments (doseedo_instruments, no key) + sound effects + AI audio (stems, transcribe, cover, mix, convert 10 DAWs) + FILM SCORING (doseedo_spot_video, doseedo_score_to_picture) + DAW SESSIONS (read, edit, download a Logic project; Dø Desktop applies edits live). RULES: (1) Before a session build call doseedo_edit_ops_reference ONCE (the default view fits; op:\"<name>\" / section:\"recipes\" for detail) and copy a recipe. (2) Never drive the user's screen (no clicking in Logic, no GUI scripting); without Dø Desktop hand over the downloaded project. (3) YOU write the music, doseedo plays it: every part's notes → doseedo_render_score / doseedo_render_midi (recipe compose-piece); doseedo_generate_music is a prompt-only sketch, never the deliverable. (4) AI renders return several takes that may miss or change notes — offer them, or pick by comparing to your notes. (5) After unzipping a download run EVERY place_local_files command or those tracks open empty (replay audio_source:\"place_local_files\" / a \"NOT bundled\" warning = action required). (6) Verify from the response (replay, cover.instrument_swaps), never by unzipping. (7) Result URLs are pre-signed: plain curl, no auth, 24 h, reusable as audio_url; name:\"x\" → files x_<part>.<ext>. (8) Errors carry code / retryable / next — act on next; service_unavailable or timeout = wait 30 s, retry ONCE, then tell the user which doseedo service is down; never loop. IDS & UNITS: beats are absolute from bar 1 (beat 0 = bar 1) at the project tempo. Faders: set_channel_volume 0.709 = 0 dB, 1.0 = +6 dB (a new track opens at 0 dB in the download). Ids: mint 12 random lowercase hex and on add_track ALWAYS pass both track_id t_<hex> and channel_id ch_<same hex> (bus ch_b_<hex>, marker m_<hex>); every other id (param_id, marker_id, clip_id) comes from doseedo_get_session. Quick Sampler: a one-shot plays at its recorded pitch on C3 = MIDI 60 and plays the WHOLE sample (sample_start_seconds / sample_end_seconds trim it; mode classic stops at note-off — size notes to the sampler's plays_beats from get_session; mode one_shot rings out; edit_midi_notes resizes existing notes by i / pitch / range). Send level 1 = unity (linear 0–2; level_raw 0–127 where offered). WORKFLOW (a session in 5 calls): 1) doseedo_create_session or doseedo_list_sessions → session_id. 2) doseedo_get_session → track ids, regions in beats AND seconds, tempo_bpm, time_signature, mixer, plugins, key_signature (when known), sync.live_edits. On a big session notes are omitted by default (notes_omitted:true) — pass include_notes:true with tracks:[ids] to read them. 3) doseedo_edit_session with ALL ops in ONE call (≤500, in order) + a batch_key so a retry dedups; atomic by default — a rejection names a code (unknown_op, unknown_id, duplicate_id, unknown_plugin, forbidden_group, …) and, where it can, a did_you_mean; fix and re-send the whole batch with the same batch_key. 4) doseedo_download_session → a no-auth URL + a `replay` report of what landed (per track: sample, notes, regions; deferred ops; warnings). 5) curl it into ~/Downloads, unzip, run place_local_files. Never poll the session for changes: doseedo_get_session is the read (the raw /edits feed is rate-limited). ★ FILES ON THE USER'S MACHINE never leave it and are not limited by plan: add_track content_type:\"instrument\" (Quick Sampler is the default instrument) → load_quick_sampler_sample {track_id, sample_path:\"/abs/path.wav\", audio_info:{…header numbers, below}, mode?:\"classic\"|\"one_shot\"|\"slicer\"} (audio_info is REQUIRED for a local sample — the sampler spans the whole file); audio regions: attach_audio {track_id, local_path, audio_info:{sample_rate, frame_count, channels, bits_per_sample, bytes, data_offset}, start_beats} (REPLACES the track's primary region — it does not stack), or N regions with set_track_clips {track_id, clips:[{start_beats, end_beats, audio_ref:{local_path, audio_info, source_offset_samples?}}…]} (the track's COMPLETE clip list — it replaces an earlier attach_audio; to ADD clips to a track that already has regions, e.g. into an empty stretch, send its regions back as doseedo_get_session lists them plus the new clips — in the user's own Logic project Dø Desktop keeps those where they are and places the rest beside them; cut one long stem into sections with source_offset_samples — no need to write a file per region). Use one sample rate for every file — the project runs at it. Read audio_info from the header, e.g. `python3 -c \"import wave,os,json,sys; w=wave.open(sys.argv[1]); print(json.dumps({'sample_rate':w.getframerate(),'frame_count':w.getnframes(),'channels':w.getnchannels(),'bits_per_sample':w.getsampwidth()*8,'bytes':os.path.getsize(sys.argv[1]),'data_offset':w.getfp().tell()+8}))\" file.wav` (data_offset = where the samples start; a wrong one makes Logic re-cut the regions). The project with its files in Media/Audio Files is then self-contained — zip and share it as is. doseedo_download_session then returns place_local_files — cp commands to run AFTER unzipping, for local samples and local audio alike — run them exactly as given. Upload only when the SERVER must read the audio (separation, transcription, cover, conversion) or the file is on another device: doseedo_get_upload_url → curl PUT → pass audio_key to a job, or doseedo_add_audio_to_session {audio_key} → sha256 for load_quick_sampler_sample / attach_audio {blob_sha256}. Uploads for processing accept WAV/AIFF/FLAC/MP3/M4A/Ogg on every plan; audio STORED in a session (doseedo_add_audio_to_session) stays lossless (WAV/AIFF/FLAC) only on Pro+ — below Pro+ lossless is not kept, so send Opus (audio/ogg) or use the local-path ops above. PLUGINS insert BY NAME: add_device {channel_id, device:{name:\"Quick Sampler\" | \"ES2\" | \"Channel EQ\" | …}} — no AU codes; a name the strip cannot load is rejected (unknown_plugin, with the closest names). doseedo_list_plugins shows the stock palette and, when the desktop is connected, the plugins on the user's Mac. set_device_param needs a param_id — read it from doseedo_get_session tracks[].plugins[].params (set_device_params_batch accepts param_id or id); rename/move/delete_marker take the marker_id get_session lists (beats ABSOLUTE from bar 1). KEY: doseedo_get_session reports key_signature when the session knows it (synced from Logic, or set); set it with the set_key_signature op {tonic, mode, beat?} where the ops reference lists it — doseedo_analyze_song on a reference (a stem, a take, an upload) gives the key to write in. THE USER'S OWN SOUND is written into the download, no desktop needed: channel_id \"ch_master\" is the project's Stereo Out — add_device Logic's own effects on it by name for a master chain. load_device_preset {channel_id, slot, preset_b64} writes the user's own Logic plug-in setting (.pst — `base64 -i file.pst`) into the stock plug-in in that slot (add_device first; on an instrument track slot 0 is the instrument, its first effect is slot 1). A third-party Audio Unit with its settings: add_device {channel_id, device:{aupreset_b64}} — the .aupreset names the plug-in and carries its state (track strips). A loop is ONE region: attach_audio {start_beats, end_beats: where the repeats stop} + set_clip_loop {on:true}, or loop:{on:true} on a set_track_clips clip. A BATCH can reuse one session: delete_track every track and add the next build in the same doseedo_edit_session call (ids may be reused) — the download holds only what the session holds now; replay.layout.ok confirms every region sits on its own track. LIVE vs OFFLINE — \"will my edit land in the user's Logic project?\" is ONE answer everywhere: live_edits:true|false + live_edits_reason on doseedo_desktop_status, doseedo_list_plugins and doseedo_get_session.sync — relay live_edits_reason to the user. Dø Desktop (macOS) puts edits into the Logic project it is linked to: it saves the project, keeps a backup, closes it, writes the edits and reopens it (~10–20 s; apply_mode:\"reopen\"; sync.last_apply says what landed or why it waits) — so send each change as ONE batch and warn the user the project will close and reopen. Otherwise they persist and land in the next download or open — nothing is lost. doseedo_download_session needs NO desktop (rebuilt server-side from the edit log); its replay.deferred lists ops the offline build could not synthesize. doseedo_bounce_session needs the desktop. A deleted session answers 410 session_deleted on every read — stop using its id. COMPOSING: doseedo does not write music — you do, and doseedo plays it. Background music for a video, an instrumental, a theme, a song: plan it (length → bars at your tempo, key, form, instruments from doseedo_instruments), write EVERY part as notes, then doseedo_render_score {parts} (one stem per part + a mix → doseedo_mix) or, for one instrument, doseedo_render_midi — the steps: doseedo_recipes name=\"compose-piece\". doseedo_generate_music is a prompt-only sketch with no notes behind it (no key, bpm/time_signature only tag the caption; a take is often near-silent, a drone or clicks): only when the user asks for exactly that, and never as the deliverable. For a part that must fit: doseedo_analyze_song {audio_url | audio_key} on the reference → key, bpm, meter, sections, chords (synchronous); the session tempo comes from doseedo_get_session. Write the notes yourself in that key ([{pitch, start_beats, duration_beats, velocity}] in beats from bar 1), optionally check them with doseedo_analyze_midi (free), then EITHER put them in the session (set_midi_notes on an instrument track — exact notes, played by the DAW instrument) OR render them as AI audio with doseedo_render_midi {notes | midi_url | session_id+track_id, instrument (+ timbre_preset) = an entry's `call` from doseedo_instruments, bpm, takes?, voice_split?, refine?} → job_id → doseedo_wait_task → result.takes[{url, rank, score}] best-first + seed. The notes are sent AS WRITTEN (no snapping). A chord part needs voice_split:true (one voice per render; result.voices maps them). ANALYSIS (synchronous, no credits): doseedo_analyze_song (key/tempo/sections/chords), doseedo_detect_chords (chord chart), doseedo_beat_grid (beat times), doseedo_analyze_midi (harmony of MIDI you wrote). SCORING (a cue, an arrangement, a film): a FILM starts with doseedo_spot_video {video_key | video_url} (the cue sheet: every cut frame-exact, shots with keyframe JPEGs, dialogue spans, cues with SMPTE in/out, hit points and a bpm — each cue's tempo_map_input goes straight to doseedo_tempo_map) and ends with doseedo_score_to_picture {video_key, tracks:[{audio_url: <mix_url>, start_timecode}]} (the cues laid at their timecodes, ducked under the dialogue, normalised to a delivery loudness and muxed onto the untouched picture — recipe score-a-film); in between you plan and write every part; doseedo_tempo_map turns hit points / SMPTE timecodes into a tempo_map that lands them on downbeats (free); doseedo_render_score plays ALL the parts in one call (parts[] you wrote, a multi-track midi_url, or a musicxml_url — dynamics, articulations, pizz./con sord. are performed; an instrument is one player, a SECTION is players: N on its part — an orchestra's strings are violins I / II, violas, cellos, basses with players 4–8; a CHOIR is Soprano / Alto / Tenor / Bass parts on instrument \"choir\" that sing parts[].lyrics (\"Ooh\" without), players 4–8 for a dense choir — recipe choir) → one stem per part, each with a fit receipt (did it play its notes); doseedo_mix {from_job} MIXES them (levelled, an orchestra seated, a hall, mastered) and returns the mix as a document you edit and re-render — never rebuild a mix by hand; doseedo_session_from_stems {from_job, mix_job} turns that into a Logic/Ableton project (audio + MIDI + tempo map, at the mix's levels and pans) — and {cues: [{cue, start_s, from_job, mix_job}…]} turns a WHOLE FILM into ONE editable project (every cue on one timeline, one joined tempo map with each cue on a bar line, a marker per cue); doseedo_generate_sound makes the hits and textures. MEASURE, don't guess: render_midi results carry takes[].check (notes heard, timing ms, LUFS) when the part was given as notes, doseedo_check_take measures any take, and revise_take_url + revise_start_beats/end_beats on doseedo_render_midi redoes just one region of a take. FREE PLAN: a render of several parts (doseedo_render_score, doseedo_cover_song, a drum kit's pieces) comes back as its MIX — each part by name, no audio link, and output.stems_locked.tell_user is what to tell the user: each part as its own stem, and the DAW session, come with Pro; the parts are kept, and the same job hands them back once the account is on Pro. doseedo_mix {from_job} still mixes it from every part. AI AUDIO is async: submit tools return a job_id plus kind (the registry name, e.g. separate_stems), eta_seconds and suggested_next_wait → doseedo_wait_task {job_id, timeout_seconds ≤50} (one call holds at most 50 s; repeat while still_running — ~15 s transcribe, 1–3 min render, ~4 min audio_to_session). Pass idempotency_key on a submit you might retry. doseedo_list_jobs finds earlier jobs (filter by kind / status / session_id), doseedo_cancel_job stops one (what a cancel can stop and refund differs per kind — each tool description says). Downloads: every result URL (takes, stems, MIDI, sessions, converted projects) is a pre-signed link — curl -OJ <url>, no auth header — valid until the artifact's expires_at (24 h); doseedo_check_task on the job re-issues fresh links after that. Hand a result URL straight to doseedo_transcribe / doseedo_analyze_song / doseedo_separate_stems / doseedo_render_midi timbre_audio_url / doseedo_add_audio_to_session as audio_url. A result too big for one answer comes back reshaped, never cut: `truncated` lists what was shortened and `next` says how to fetch the rest. INSTRUMENTS: doseedo_instruments (no key) — the catalog doseedo_render_midi plays: query:\"low brass\" / pitches:[…] / id:\"cello\"; copy the entry's call (a World instrument is its voice + timbre_preset, e.g. koto = acoustic_guitar + koto:preset1). BRING YOUR OWN SOUND: doseedo_train_instrument (30 s–3 min of ONE instrument → lora_id in ~1–2 min → doseedo_render_midi {…, lora_id} plays any notes in it); timbre_audio_url on doseedo_render_midi (your notes, a recording's tone) and per part on doseedo_render_score — a CHOIR sings as one singer by default (\"choir:trio\" / \"choir:m2\" the other voices) or in ANY SINGER'S voice: parts[].timbre_audio_url = their recording (recipe \"choir\"); a SOLO SINGER is instrument \"voice\" (doseedo_render_midi {instrument:\"voice\", lyrics, notes} — one singer (Solo) by default, \"voice:m2\" a man's voice, timbre_audio_url yours); doseedo_cover_stem (a recorded line — humming, a riff — re-played by another instrument). SOUND DESIGN / FOLEY: doseedo_generate_sound (hits, loops, textures: impacts, whooshes, footsteps, ambiences). DRUM GENERATORS: doseedo_generators lists ready-made kits and grooves (house, deep / tech / afro house… — read the list, it grows) and returns a loop's MIDI free; doseedo_generate_loop {generator, bars, bpm, seed, key} → a seamless drum loop as audio + MIDI + notes; a part's drum_genre naming a generator plays your own drum notes through its recorded kit. RECIPES: doseedo_recipes lists the named pipelines (stems, session, cover, transcribe, render-midi, score, custom-instrument, timbre-transfer, sound-design, analyze-song, convert, bounce, generate; the compose-piece, compose-part and score-a-film guides) with inputs, tool calls in order, outputs, cost/time and how to VERIFY — no key needed. COST: doseedo_quote {job, args} prices a job before submitting — spends nothing. HOUSEKEEPING: doseedo_list_sessions pages with offset; doseedo_delete_sessions soft-deletes in bulk (dry run first, show the user the count, then confirm:true). AUTH: an X-API-Key header on this MCP connection, or an OAuth sign-in (mint a key at https://doseedo.com/settings/api-keys). Scopes: doo / write:sessions = full; ops:<group> (mixer, regions, plugins, tracks, project, markers, automation, history) = only that op category; read:sessions = read-only (writes → 403 code=read_only_key — do not retry, tell the user which scope the key needs). ERRORS are JSON {error, code, retryable, plane, next, request_id}: act on next; quote request_id to support.",
"tools": [
{
"description": "Check the connected doseedo account: plan tier, the monthly credit pool (generation AND DAW conversions draw it), purchased extra-usage credits, and storage. Read-only — consumes nothing. Use it before starting expensive work to confirm there is budget.",
"inputSchema": {
"additionalProperties": false,
"properties": {},
"type": "object"
},
"name": "doseedo_account",
"outputSchema": null
},
{
"description": "Add an audio file to a session — from a public URL (a doseedo-generated song, a separated stem, any https audio) OR from a LOCAL file you uploaded (doseedo_get_upload_url → PUT the bytes → pass the returned audio_key here). Ingested server-side and returned as a sha256 you then use: place it on a track with attach_audio, or load it into a Quick Sampler with load_quick_sampler_sample {track_id, sample_path: \"<the sha>\"} (bakes into the exported .logicx, no desktop needed — the drum-pack/sample-swap path). Give audio_url OR audio_key.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"audio_key": {
"description": "audio_key from doseedo_get_upload_url after you PUT a local file to its upload_url (a file from the user's disk, e.g. a drum-pack WAV).",
"type": "string"
},
"audio_url": {
"description": "https URL of the audio — any public URL, or a doseedo result URL from a job (pre-signed links work as-is; no key needed).",
"type": "string"
},
"filename": {
"description": "Optional name for the asset.",
"type": "string"
},
"session_id": {
"type": "string"
}
},
"required": [
"session_id"
],
"type": "object"
},
"name": "doseedo_add_audio_to_session",
"outputSchema": null
},
{
"description": "Check the HARMONY of notes before rendering or placing them: factor a MIDI progression into its sonorities (mode \"midi\", default — chord-detection-free: each segment of simultaneously sounding pitches reduced to an anchor pitch class + register-exact shape, covered with recurring shape cells) or into chord symbols (mode \"chord\": one estimated chord per ~2 beats + a corpus-grammar cell cover with a schedule). Input: notes[] (the rows you would give doseedo_render_midi / set_midi_notes) with bpm, or midi_url (a .mid ≤2 MiB: a doseedo result link such as a stem's MIDI, or a public URL). Synchronous (~2–10 s), CPU, no credits. Returns sonorities[] or chords[], cover, cells, compression — read chords[].chord / sonorities[].anchor to confirm the key and progression you intended. Cancel: not applicable — the result is returned in the submit response; the job is already finished.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"beats_per_segment": {
"description": "mode chord: segment length in beats (0.25–8, default 2).",
"type": "number"
},
"bpm": {
"description": "Tempo of the notes (needed with notes; default 120).",
"type": "number"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"midi_url": {
"description": "Alternative to notes: https URL of a Standard MIDI File (≤2 MiB).",
"type": "string"
},
"min_seg_beats": {
"description": "mode midi: shortest sonority segment in beats (default 0.25).",
"type": "number"
},
"mode": {
"description": "\"midi\" (default): sonority / shape factoring. \"chord\": chord symbols per segment + cell cover.",
"enum": [
"midi",
"chord"
],
"type": "string"
},
"notes": {
"description": "The notes to analyze, in beats from bar 1 (same rows as doseedo_render_midi). Needs bpm.",
"items": {
"additionalProperties": false,
"properties": {
"duration_beats": {
"type": "number"
},
"pitch": {
"type": "number"
},
"start_beats": {
"type": "number"
},
"velocity": {
"type": "number"
}
},
"required": [
"pitch",
"start_beats",
"duration_beats"
],
"type": "object"
},
"type": "array"
},
"time_signature": {
"description": "Meter of the notes, e.g. \"4/4\" (default).",
"type": "string"
}
},
"type": "object"
},
"name": "doseedo_analyze_midi",
"outputSchema": null
},
{
"description": "Key detection, BPM/tempo detection, song structure and chords — musical analysis of a recording in one call: key (e.g. \"D minor\"), bpm + per-beat tempo_map, meter / beats_per_bar, downbeats (seconds), sections (intro/verse/chorus… with times), chords (a progression on the beat grid), dynamics, and cues: the pieces a recording holds (a film's temp: each piece's start, end, tempo, key and level). USE THIS to learn the key and tempo of a reference before writing a part — never guess or ask the user for what the audio already says. Pass audio_key (an upload) or audio_url (a result URL from another job as returned, or any public https URL). Up to 10 minutes of audio is analyzed. Synchronous (~5–20 s): the result is in this response. No separation, so a dense mix's chords are a draft — for a chord chart from stems use doseedo_detect_chords on the separated stems. Cancel: not applicable — the result is returned in the submit response; the job is already finished.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"audio_key": {
"description": "R2 ingest key of an uploaded audio file (from doseedo_get_upload_url / POST /api/upload/r2/ingest-url; starts with \"ingest/\"). Provide this or audio_url.",
"type": "string"
},
"audio_url": {
"description": "https URL of the audio (a doseedo result URL as returned, or any public URL). Alternative to audio_key.",
"type": "string"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
}
},
"type": "object"
},
"name": "doseedo_analyze_song",
"outputSchema": null
},
{
"description": "Turn an uploaded full mix into a complete multitrack DAW session (separated stems as tracks, tempo map, optional per-stem MIDI and chord guide). The result is a downloadable session zip for Logic Pro or Ableton. Async: returns a job_id — poll with doseedo_wait_task (~4 minutes). Cancel: cooperative — the build stops at its next stage boundary and the build's sound-tool unit is refunded (a GPU separation already run stays charged).",
"inputSchema": {
"additionalProperties": false,
"properties": {
"audio_key": {
"description": "R2 ingest key of an uploaded audio file (from doseedo_get_upload_url / POST /api/upload/r2/ingest-url; starts with \"ingest/\"). Provide this or audio_url.",
"type": "string"
},
"audio_url": {
"description": "https URL of the audio, as an alternative to audio_key: a doseedo result URL exactly as a job returned it (a stem, a take, a bounce), or any public URL. The gateway fetches it (≤256 MB) into your account's ingest storage before the job starts. Pass audio_key OR audio_url.",
"type": "string"
},
"chords": {
"description": "Add a detected-chords guide track (default false).",
"type": "boolean"
},
"crop_silence": {
"description": "Punch regions in where each stem plays instead of whole-length stems (default false).",
"type": "boolean"
},
"dereverb": {
"description": "Opt-in: lay DRY stems and recreate the room with a reverb plugin on each track (default false).",
"type": "boolean"
},
"drum_midi_split": {
"description": "With \"drums\" in midi_stems: one Quick Sampler track PER kit piece, each loaded with a synthesized one-shot (default false = one GM drum-roll track).",
"type": "boolean"
},
"drum_sampler": {
"description": "Sampled kits → a one-shot sampler track + MIDI (default false).",
"type": "boolean"
},
"drum_substems": {
"description": "Lay each drum piece as its own audio track on a Drums bus (default false; implied by stem_mode drumsep).",
"type": "boolean"
},
"guitar_split": {
"description": "Split the guitar stem into N players, each its own track + MIDI lane on a Guitar Section bus: \"0\" (off), \"auto\" (DEFAULT — a one-vs-two probe decides), \"2\"–\"4\".",
"type": "string"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"instruments": {
"description": "stem_mode orchestra/detect: optional comma list restricting the orchestral set, e.g. \"violin,cello,flute\".",
"type": "string"
},
"keep_stem_audio": {
"description": "With midi_stems: keep the audio stem next to its MIDI track (default true); false = the MIDI track REPLACES the audio.",
"type": "boolean"
},
"key": {
"description": "Detect the key and write it into the project (default true in the full build, false with simple).",
"type": "boolean"
},
"loops": {
"description": "Detect repeated clips and lay them as loops (default false).",
"type": "boolean"
},
"markers": {
"description": "Add section markers (intro/verse/chorus…) (default true in the full build, false with simple).",
"type": "boolean"
},
"midi_stems": {
"description": "Optional comma-separated stems to also add as MIDI tracks, e.g. \"piano,bass\" (include \"drums\" for a GM drum roll).",
"type": "string"
},
"name": {
"description": "Project name for the session file — it also names the download: <name>_session.zip.",
"type": "string"
},
"quantize_midi": {
"description": "Snap every pitched MIDI lane: \"grid\" = to the grid its own onsets support (straight/swing 8ths, 16ths, triplets, detected per lane); \"score\" = notation positions (straight 8ths). Default off (played timing).",
"enum": [
"grid",
"score"
],
"type": "string"
},
"retune": {
"description": "Default true: a mix sitting >35 cents off A440 is pitch-corrected onto the 12-TET grid before separation (every transcriber coin-flips otherwise). false = leave the tuning as recorded.",
"type": "boolean"
},
"separate": {
"description": "false = no separation: the mix lands as ONE audio track (default true).",
"type": "boolean"
},
"simple": {
"description": "Faster minimal build: meter + tempo + stems only, no MIDI (default false). Required for stem_mode orchestra/detect.",
"type": "boolean"
},
"stem_mode": {
"description": "Separation family. auto (DEFAULT): the 6 stems plus a residual cascade that peels detected orchestral sections out of \"other\" (no orchestral content → identical to 6stem). 6stem: vocals/drums/bass/guitar/piano/other. drumsep: the drum stem replaced by isolated kick/snare/hh/… tracks on a Drums bus. sections: the 6 stems with \"other\" split by the joint section model (trumpet/trombone/sax/violin/viola/cello), each transcribed per chair. orchestra / detect: the 53-instrument bank on the MIX (needs simple:true; detect auto-picks, orchestra takes `instruments`).",
"enum": [
"auto",
"6stem",
"drumsep",
"sections",
"orchestra",
"detect"
],
"type": "string"
},
"target": {
"description": "DAW target (default logic).",
"enum": [
"logic",
"ableton"
],
"type": "string"
},
"tempo_map": {
"description": "false = one constant tempo instead of a tempo map (default true).",
"type": "boolean"
}
},
"type": "object"
},
"name": "doseedo_audio_to_session",
"outputSchema": null
},
{
"description": "Beat detection / beat tracking: bpm, beats[] (seconds), downbeats[] (seconds), beats_per_bar, downbeat_offset, beat_map[{t, pos}], duration — the grid to place a part against a recording (beat n is at beats[n] seconds). Pass audio_key (an upload) or audio_url (a result URL from another job as returned, or any public https URL). Up to 10 minutes of audio is analyzed. Synchronous (~3–15 s). For key + sections + chords as well use doseedo_analyze_song. Cancel: not applicable — the result is returned in the submit response; the job is already finished.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"audio_key": {
"description": "R2 ingest key of an uploaded audio file (from doseedo_get_upload_url / POST /api/upload/r2/ingest-url; starts with \"ingest/\"). Provide this or audio_url.",
"type": "string"
},
"audio_url": {
"description": "https URL of the audio (a doseedo result URL as returned, or any public URL). Alternative to audio_key.",
"type": "string"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
}
},
"type": "object"
},
"name": "doseedo_beat_grid",
"outputSchema": null
},
{
"description": "Bounce a session (or specific tracks) to audio on the user's Mac — Dø Desktop renders them in the background WITHOUT the user opening the DAW (engine \"headless\"): each AUDIO track's regions as the arrangement places them, from bar 1, through the track's third-party Audio Units. Logic's own plug-ins and instrument/MIDI tracks render only inside Logic: each stem names the plug-ins it does not include (plugins_not_rendered), and an instrument track is reported, not rendered. engine \"live\" (Logic's own bounce) needs a live Logic connection, which the public Dø Desktop does not have. Each stem says its format: the requested wav/aiff, or \"opus\" when the plan cannot store lossless (the lossless file is then on the Mac at local_path). A track that could not render is named in the error with its reason. Async: returns a job_id — poll with doseedo_wait_task. The result is downloadable stem URLs. Needs Dø Desktop to run at some point to pick up the job; until then it stays queued. No credits (rendered on the user's machine). Cancel: a bounce still queued never renders (its budget is refunded); one mid-render has its result dropped on arrival.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"format": {
"description": "Output format (default wav).",
"enum": [
"wav",
"aiff"
],
"type": "string"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"session_id": {
"type": "string"
},
"stems": {
"description": "true (default) = one file per track; false = a single mixdown.",
"type": "boolean"
},
"tail_seconds": {
"description": "Extra seconds for reverb/delay to ring out (default 2).",
"type": "number"
},
"track_ids": {
"description": "Tracks to bounce (t_… ids from doseedo_get_session). Omit to bounce the whole session.",
"items": {
"type": "string"
},
"type": "array"
}
},
"required": [
"session_id"
],
"type": "object"
},
"name": "doseedo_bounce_session",
"outputSchema": null
},
{
"description": "Cancel a queued or running job. What that stops and refunds depends on the kind — generate_music / render_midi / cover_song: a render not yet on the GPU is stopped and its credits refunded; one already rendering finishes (credits spent), the job ends as canceled, output discarded. audio_to_session: cooperative — stops at the next stage boundary and refunds the build's sound-tool unit (a separation already run stays charged). bounce_session: a bounce still queued never renders (budget refunded); one mid-render has its result dropped. spot_video / score_to_picture / reframe_video: one still queued never starts and one running stops within seconds, refunded either way. separate_stems / transcribe / convert_project: no plane-side stop — the work completes (credits spent), the job ends as canceled and its output is discarded. The synchronous analyses are already finished (409 already_terminal).",
"inputSchema": {
"additionalProperties": false,
"properties": {
"job_id": {
"description": "The job_id from a submit tool or doseedo_list_jobs.",
"type": "string"
}
},
"required": [
"job_id"
],
"type": "object"
},
"name": "doseedo_cancel_job",
"outputSchema": null
},
{
"description": "MEASURE a take instead of guessing: give the audio (a render_midi take URL, any recording) and the notes it should play — notes[] + bpm (and tempo_map) or a midi_url — and get back how many written notes were heard at the right pitch and time (recall / precision / f1, octave errors, the first missed notes with their beats), the timing error in ms, loudness (integrated LUFS, peak dBFS, clipped share), any stretch where a note was written but nothing sounds, and a verdict (good / check / bad) with reasons in plain words. doseedo_render_midi results already carry this per take (takes[].check) when the part was given as notes. Method: an independent note transcriber (basic-pitch) — dense chords and very fast runs read less reliably; use it as a screen, and listen to anything marked check. Synchronous (~3–15 s), CPU, no credits. Cancel: not applicable — the result is returned in the submit response; the job is already finished.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"audio_key": {
"description": "R2 ingest key of an uploaded audio file (from doseedo_get_upload_url / POST /api/upload/r2/ingest-url; starts with \"ingest/\"). Alternative to audio_url.",
"type": "string"
},
"audio_url": {
"description": "The take: a doseedo result URL as returned, or any public https URL.",
"type": "string"
},
"bpm": {
"description": "Tempo of the notes (or tempo_map).",
"type": "number"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"instrument": {
"description": "The instrument (a drum/percussion name switches to onset-only matching).",
"type": "string"
},
"midi_url": {
"description": "Alternative to notes: the part as a Standard MIDI File (≤ 2 MiB).",
"type": "string"
},
"notes": {
"description": "The notes the take should play, in beats from bar 1 (the rows you sent doseedo_render_midi).",
"items": {
"additionalProperties": false,
"properties": {
"duration_beats": {
"type": "number"
},
"pitch": {
"type": "number"
},
"start_beats": {
"type": "number"
},
"velocity": {
"type": "number"
}
},
"required": [
"pitch",
"start_beats",
"duration_beats"
],
"type": "object"
},
"type": "array"
},
"onset_tolerance_ms": {
"description": "How far a heard onset may be from the written one and still count (default 50).",
"type": "number"
},
"tempo_map": {
"description": "Tempo changes [{beat, bpm}].",
"items": {
"additionalProperties": false,
"properties": {
"beat": {
"type": "number"
},
"bpm": {
"type": "number"
}
},
"required": [
"beat",
"bpm"
],
"type": "object"
},
"type": "array"
},
"time_signature": {
"description": "Meter (default 4/4).",
"type": "string"
}
},
"type": "object"
},
"name": "doseedo_check_take",
"outputSchema": null
},
{
"description": "Check an async doseedo task once. Returns current status, and the result (file URLs / notes) when finished. A big result comes back as a brief (each row cut to its deciding fields): parts: [\"<name>\" or index, …] returns those rows of the job record IN FULL — a render_score part's every receipt, a mix part's strip, rides (every point) and loudness, a supervised cue's full card (parts: [\"1M7\"]).",
"inputSchema": {
"additionalProperties": false,
"properties": {
"from": {
"description": "Optional, with parts naming ONE list of a spot_video cue sheet (scenes, shots, cuts, keyframes …): the first row to return (0-based). A long film's list comes in pages — an answer that was shortened says the next from.",
"minimum": 0,
"type": "integer"
},
"job_id": {
"description": "Alternatively the job_id (job_…) from a submit tool or the jobs API — replaces task_id + kind.",
"type": "string"
},
"kind": {
"description": "Which job kind created the task — the registry name the submit reply carried (generate_music, generate_sound, generate_loop, cover_stem, edit_lyrics, fill_gap, render_midi, train_instrument, render_score, mix, mix_preset, session_from_stems, spot_video, score_to_picture, reframe_video, cover_song, separate_stems, split_soundtrack, transcribe, audio_to_session, convert_project, bounce_session, analyze_song, detect_chords, beat_grid, identify_sound, check_take, analyze_midi, supervise_cues); the short codes (generate, sound, loop, coverstem, editlyrics, fillgap, render, train, score, mixpre, stemsess, spot, picture, reframe, cover, separate, soundtrack, session, convert, bounce, analyze, chords, beats, identify, check, harmony, supervise) are accepted aliases.",
"enum": [
"generate_music",
"generate_sound",
"generate_loop",
"cover_stem",
"edit_lyrics",
"fill_gap",
"render_midi",
"train_instrument",
"render_score",
"mix",
"mix_preset",
"session_from_stems",
"spot_video",
"score_to_picture",
"reframe_video",
"cover_song",
"separate_stems",
"split_soundtrack",
"transcribe",
"audio_to_session",
"convert_project",
"bounce_session",
"analyze_song",
"detect_chords",
"beat_grid",
"identify_sound",
"check_take",
"analyze_midi",
"supervise_cues",
"generate",
"sound",
"loop",
"coverstem",
"editlyrics",
"fillgap",
"render",
"train",
"score",
"mixpre",
"stemsess",
"spot",
"picture",
"reframe",
"cover",
"separate",
"soundtrack",
"session",
"convert",
"bounce",
"analyze",
"chords",
"beats",
"identify",
"check",
"harmony",
"supervise"
],
"type": "string"
},
"parts": {
"description": "Optional, on a finished job: the parts to return in full, by name (as the result names them) or index — e.g. [\"Oboes\", \"Timpani\"].",
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "number"
}
]
},
"type": "array"
},
"task_id": {
"description": "The task_id returned by a submit tool.",
"type": "string"
}
},
"type": "object"
},
"name": "doseedo_check_task",
"outputSchema": null
},
{
"description": "Finish a MULTIPART project upload started by doseedo_get_project_upload_url: pass every uploaded part's number and ETag (from the PUT response header; quotes optional). Returns the project_key to pass to doseedo_convert_project / doseedo_import_project. All parts except the last must be the same size (what `split -b` produces). abort:true discards the upload instead.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"abort": {
"description": "true = abandon the upload and free its parts (no project_key results).",
"type": "boolean"
},
"parts": {
"description": "[{part_number, etag}] for EVERY part, in order.",
"items": {
"additionalProperties": false,
"properties": {
"etag": {
"type": "string"
},
"part_number": {
"type": "number"
}
},
"required": [
"part_number",
"etag"
],
"type": "object"
},
"type": "array"
},
"project_key": {
"type": "string"
},
"upload_id": {
"type": "string"
}
},
"required": [
"project_key",
"upload_id"
],
"type": "object"
},
"name": "doseedo_complete_project_upload",
"outputSchema": null
},
{
"description": "DAW CONVERTER: a project rebuilt natively in the target: tracks, MIDI, audio clips, tempo and markers arrive editable (Logic/Ableton/Pro Tools/REAPER pairs also automation, buses/sends, plugin state; into FL 3rd-party plugins only). Sources: Logic .logicx, Ableton .als, FL Studio .flp, Pro Tools .ptx, REAPER .rpp, Cubase .cpr, Dorico .dorico/.musicxml, Studio One .song, GarageBand .band (SOURCE only — zip the .band package like a .logicx; a GarageBand 6 project must be re-saved in GarageBand 10), Bitwig = any .dawproject (Bitwig/Studio One/Cubase export it; a native .bwproject is refused — File > Export… > DAWproject in Bitwig). The enum lists the exact pairs. ★ ASYMMETRIC TARGETS (an undocumented native file is never written): TO Cubase, Studio One or Bitwig = ONE .dawproject the app imports, not a .cpr/.song/.bwproject; TO Dorico = MusicXML (.mxl, Dorico's own notation import), not a .dorico. FROM Cubase the .cpr carries tracks, tempo and MIDI parts but not the audio pool (audio tracks arrive empty). FROM Dorico a .dorico carries players and flows but NOT its notes: convert its MusicXML export instead (.musicxml/.mxl accepted under dorico2*). Every result carries a transfer REPORT: `report`, `lossy`, `summary[]` (what changed), `warnings[]` (read before opening) — relay them; silence is never \"lossless\". Upload first: doseedo_get_project_upload_url + PUT (zip a project FOLDER so its audio travels; a bare project file works too; multipart past ~4 GB). Directions: \"<source>2<target>\"; \"auto2<target>\" detects the source; \"<daw>2<daw>\" rebuilds Logic/Ableton/FL/REAPER/Pro Tools in place (e.g. options.third_party_plugins:\"disable\"). To EDIT a project use doseedo_import_project; to convert a session the tools built: doseedo_download_session → upload that zip → logic2<target> (not a session_id). Async: job_id → doseedo_wait_task (15 s–2 min; `stage`); `file` is a direct storage link. Cancel: no stop — it completes, the job ends canceled, output discarded; the credit is refunded only when the conversion itself fails.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"direction": {
"description": "Source and target as \"<source>2<target>\" (logic | ableton | fl | protools | reaper | cubase | dorico | studioone | bitwig | garageband | aaf), \"auto2<target>\" to let the server detect the source, or \"<daw>2<daw>\" to rebuild in the same format (Logic/Ableton/FL/REAPER/Pro Tools only). cubase2* reads a .cpr and *2cubase writes a .dawproject (Cubase 14+/Nuendo open it natively). dorico2* reads a .dorico, .musicxml or .mxl and *2dorico writes MusicXML (.mxl). studioone2* reads a .song and *2studioone writes a .dawproject (Studio One 6.5+ imports it). bitwig2* reads any .dawproject and *2bitwig writes a .dawproject (Bitwig 5+ imports it). garageband2* reads a zipped .band package (source only — no *2garageband). aaf2* reads an AAF (Pro Tools / Logic / Resolve / Premiere export) — zip the .aaf with its audio files so clips relink by name; audio only, every clip unwarped at its exact time, no *2aaf or aaf2dorico.",
"enum": [
"logic2ableton",
"ableton2logic",
"fl2logic",
"fl2ableton",
"ableton2fl",
"logic2fl",
"reaper2logic",
"reaper2ableton",
"reaper2fl",
"logic2reaper",
"ableton2reaper",
"fl2reaper",
"protools2logic",
"protools2ableton",
"protools2fl",
"protools2reaper",
"logic2protools",
"ableton2protools",
"fl2protools",
"reaper2protools",
"cubase2logic",
"cubase2ableton",
"cubase2fl",
"cubase2reaper",
"cubase2protools",
"cubase2dorico",
"logic2cubase",
"ableton2cubase",
"fl2cubase",
"reaper2cubase",
"protools2cubase",
"dorico2logic",
"dorico2ableton",
"dorico2fl",
"dorico2reaper",
"dorico2protools",
"dorico2cubase",
"logic2dorico",
"ableton2dorico",
"fl2dorico",
"reaper2dorico",
"protools2dorico",
"garageband2logic",
"garageband2ableton",
"garageband2fl",
"garageband2reaper",
"garageband2protools",
"garageband2cubase",
"garageband2dorico",
"bitwig2logic",
"bitwig2ableton",
"bitwig2fl",
"bitwig2reaper",
"bitwig2protools",
"bitwig2cubase",
"bitwig2dorico",
"logic2bitwig",
"ableton2bitwig",
"fl2bitwig",
"reaper2bitwig",
"protools2bitwig",
"cubase2bitwig",
"dorico2bitwig",
"studioone2logic",
"studioone2ableton",
"studioone2fl",
"studioone2reaper",
"studioone2protools",
"studioone2cubase",
"logic2studioone",
"ableton2studioone",
"fl2studioone",
"reaper2studioone",
"protools2studioone",
"cubase2studioone",
"aaf2logic",
"aaf2ableton",
"aaf2fl",
"aaf2reaper",
"aaf2protools",
"aaf2cubase",
"aaf2studioone",
"aaf2bitwig",
"logic2logic",
"ableton2ableton",
"fl2fl",
"reaper2reaper",
"protools2protools",
"auto2logic",
"auto2ableton",
"auto2fl",
"auto2reaper",
"auto2protools",
"auto2cubase",
"auto2dorico",
"auto2bitwig",
"auto2studioone"
],
"type": "string"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"options": {
"additionalProperties": false,
"description": "Conversion options (all optional). third_party_plugins:\"disable\" drops third-party AU/VST devices so the export opens clean on a machine without them; stock_plugins:\"disable\" leaves stock devices unmapped instead of mapping to the nearest target-DAW device; carry_plugin_presets:false strips plugin patches; lossless:true (→Logic) pins the project to the MAX clip sample rate so no clip is downsampled; project_rate (→Logic) pins an exact rate in Hz; silence_empty_sampler:false (→Logic) keeps Logic's audible default Quick Sampler on tracks whose sampler had no sample; source_name = the project's display name for the output file.",
"properties": {
"carry_plugin_presets": {
"type": "boolean"
},
"lossless": {
"type": "boolean"
},
"project_rate": {
"description": "Hz, ≥ 8000 (ableton2logic only; overrides lossless).",
"type": "number"
},
"silence_empty_sampler": {
"type": "boolean"
},
"source_name": {
"description": "Display name of the source project, e.g. \"My Song.als\" — names the output.",
"type": "string"
},
"stock_plugins": {
"enum": [
"map",
"disable"
],
"type": "string"
},
"third_party_plugins": {
"enum": [
"keep",
"disable"
],
"type": "string"
}
},
"type": "object"
},
"project_key": {
"description": "R2 key of the uploaded project (from doseedo_get_project_upload_url / POST /api/upload/r2/signed-url; starts with \"uploads/\").",
"type": "string"
}
},
"required": [
"project_key",
"direction"
],
"type": "object"
},
"name": "doseedo_convert_project",
"outputSchema": null
},
{
"description": "AI COVER / style transfer of a whole song: re-render an uploaded song as a cover, keeping its structure/melody while changing timbre, instruments, or lyrics. INSTRUMENT SWAP: instruments {\"piano\": \"electric_guitar\"} separates the song, transcribes the swapped stem and re-plays THOSE transcribed notes on the target instrument; by default only the swapped stem(s) are regenerated and every other stem passes through as the original separated audio (regen changes that). Because the swap replays a transcription, small note differences from the source are expected — verify from result.cover.instrument_swaps (applied or why not), and offer the user the result/takes to judge rather than promising a note-perfect copy. Target ids: GET https://api.doseedo.com/api/instruments (open). Optionally export a DAW session too. Async: returns a job_id — poll with doseedo_wait_task (several minutes for full songs). Result files are pre-signed links: curl -OJ <url>, no auth header (valid 24 h). Cancel: a render that has not reached the GPU yet is stopped and its credits refunded; one already rendering finishes on the GPU (its credits are spent), the job ends as canceled and the output is discarded.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"audio_key": {
"description": "R2 ingest key of an uploaded audio file (from doseedo_get_upload_url / POST /api/upload/r2/ingest-url; starts with \"ingest/\"). Provide this or audio_url.",
"type": "string"
},
"audio_url": {
"description": "https URL of the audio, as an alternative to audio_key: a doseedo result URL exactly as a job returned it (a stem, a take, a bounce), or any public URL. The gateway fetches it (≤256 MB) into your account's ingest storage before the job starts. Pass audio_key OR audio_url.",
"type": "string"
},
"cover_noise_strength": {
"description": "Optional 0–1 fidelity dial: higher departs further from the source.",
"type": "number"
},
"drum_split": {
"description": "true = explode the covered drums into isolated kick/snare/hh/… stems, each generated from its own slice of the drum roll (result.drum_stems).",
"type": "boolean"
},
"export": {
"description": "Optionally also build a DAW session for this target.",
"enum": [
"logic",
"ableton"
],
"type": "string"
},
"genre": {
"description": "Optional GENRE style transfer: the target genre in a few words, ≤ 64 characters (e.g. \"bossa nova\", \"80s synth-pop\", \"West End musical showstopper\") — a name, not a description; a longer one is cut at its last comma or word that fits, with a warning on the reply. Every regenerated stem is captioned with it. Outcome in result.cover.genre.",
"maxLength": 64,
"type": "string"
},
"guitar_split": {
"description": "Deal the guitar bucket into N players, each its own row/swap: \"2\"–\"4\", or \"auto\" (a one-vs-two probe decides). Outcome in result.cover.guitar_split.",
"type": "string"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"instruments": {
"additionalProperties": {
"type": "string"
},
"description": "Optional per-stem instrument SWAP map {source: target}, e.g. {\"piano\": \"electric_guitar\", \"sax\": \"violin\"}. Source = a stem (drums, bass, vocals, guitar, piano, other) or a detected instrument (sax, trumpet…); target = an instrument id from /api/instruments (an unknown target is refused up front).",
"type": "object"
},
"labels": {
"additionalProperties": {
"type": "string"
},
"description": "Optional identity CORRECTIONS {source: instrument}, same shape as instruments, e.g. {\"other\": \"trumpet\"} when the separation mislabels a stem. Only fixes what the stem is called (caption/timbre); nothing is re-played. Outcome in result.cover.stem_labels.",
"type": "object"
},
"lyrics": {
"description": "Optional replacement lyrics.",
"type": "string"
},
"midi_only": {
"description": "Optional: re-perform every regenerated stem from its transcribed MIDI with NO timbre from the recording (the stem's own sound is dropped). Stems with nothing to render are skipped (result.cover.midi_only.skipped).",
"type": "boolean"
},
"name": {
"description": "Optional: a name for this job's files, e.g. \"rainy-loop-3\". Every file it returns downloads as <name>_<part>.<ext> (rainy-loop-3_Celesta.wav, rainy-loop-3_rough-mix.wav; one take: rainy-loop-3.wav), so the user can find them. Give each job its own name (a second take: \"rainy-loop-3b\"). Default: doseedo-<last 6 characters of the job id>.",
"maxLength": 80,
"type": "string"
},
"regen": {
"description": "Optional: which stems to regenerate. Default with a swap = only the swapped stems (the rest are the original separated audio). \"all\" = cover every stem; or a comma list of stems/instruments, e.g. \"piano,other\" (a swapped stem is always regenerated).",
"type": "string"
},
"seed": {
"description": "Optional random seed for reproducibility.",
"type": "number"
},
"structure_key": {
"description": "Optional ingest key of audio whose STRUCTURE codes replace the source's (the Cover page's \"Structure: custom\").",
"type": "string"
},
"style_key": {
"description": "Optional ingest key (upload it first) of a reference MIX whose TIMBRE the regenerated stems take on (style transfer).",
"type": "string"
},
"swap_cns": {
"description": "Optional 0–1, only with instruments: how far the SWAPPED stems may depart from their source (overrides cover_noise_strength for them; server default 0.35). Lower = closer to the original timing/feel.",
"type": "number"
},
"timbre_preset": {
"description": "Optional named timbre preset — the fallback rung of the timbre ladder (stem latent > this > stock bank).",
"type": "string"
}
},
"type": "object"
},
"name": "doseedo_cover_song",
"outputSchema": null
},
{
"description": "TIMBRE TRANSFER (an instrument swap) from a recording: hum or whistle a melody, play it on a kazoo, take a guitar line — and get it back played by a cello, a trumpet, a koto (any doseedo_instruments call). Re-play ONE recorded part — a separated stem, a solo, a region of the user's session — on another instrument, straight from the audio: the recording's FSQ codes carry its structure into a take generated from noise, and the sound is the instrument's (caption + timbre_preset) — the FSQ + timbre combination the cond5 model was trained on (served on its turbo graft). No MIDI by default (midi:true adds the server's own pitch roll of the recording); `fidelity` > 0 also keeps that much of the recording's own latents (closer, but its sound leaks back in). For the exact notes, transcribe and doseedo_render_midi; a whole mix → doseedo_cover_song. result.recipe says what reached the model (fsq, timbre, cns). Async: job_id → doseedo_wait_task (~30–90 s) → takes[{url}] (pre-signed: curl -OJ, no auth header, 24 h). Cancel: a render that has not reached the GPU yet is stopped and its credits refunded; one already rendering finishes on the GPU (its credits are spent), the job ends as canceled and the output is discarded.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"audio_key": {
"description": "R2 ingest key of an uploaded audio file (from doseedo_get_upload_url / POST /api/upload/r2/ingest-url; starts with \"ingest/\"). Provide this, audio_url, or latent_key.",
"type": "string"
},
"audio_url": {
"description": "https URL of the audio, as an alternative to audio_key: a doseedo result URL exactly as a job returned it (a stem, a take, a bounce), or any public URL. The gateway fetches it (≤256 MB) into your account's ingest storage before the job starts. Pass audio_key OR audio_url.",
"type": "string"
},
"bpm": {
"description": "The recording's tempo (a hint; default 120).",
"type": "number"
},
"duration_seconds": {
"description": "REQUIRED. The recording's length in seconds (0.5–600): the take is this long.",
"type": "number"
},
"fidelity": {
"description": "How much of the recording's own latents the take keeps, 0–0.6 (cover noise strength over the source). Default 0: structure from its FSQ codes only, the sound all the instrument's.",
"type": "number"
},
"fsq": {
"description": "false = leave the recording's FSQ codes out: the take follows the server's note roll (needs midi: true) on the instrument's sound, with none of the source's phrasing or articulation carried over — for a line whose phrasing doesn't suit the new instrument (a sung vocal on a sax). Default true. recipe.fsq says which ran.",
"type": "boolean"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"instrument": {
"description": "REQUIRED. The instrument that plays it — call.instrument from doseedo_instruments (with its call.timbre_preset where it has one).",
"type": "string"
},
"latent_key": {
"description": "Instead of the audio: the recording already VAE-encoded (ACE-Step 1.5 VAE, 48 kHz stereo → [T, 64] at 25 Hz, the latent mean) as a 64-channel 25 Hz float WAV `*.latent.wav`, uploaded like audio (POST /api/jobs/uploads). The server skips its encode. Dø Desktop sends this when encoding on the Mac lands sooner than uploading the audio.",
"type": "string"
},
"lyrics": {
"description": "A SINGER's cover (instrument \"voice\" or \"choir\" — doseedo_instruments rows with sings:true): the words to sing, a line per phrase, in the order the recording sings them — e.g. the recording's own words transcribed. The take sings them in the recording's phrasing (its FSQ codes). ≤2000 chars. Without it a singer sings no words. Any other instrument: an error.",
"type": "string"
},
"midi": {
"description": "true = the server also transcribes the recording's notes into a roll that drives the MIDI hooks beside the FSQ codes — closer notes, a little slower (LatentPitch on audio; vaescriptor on a latent_key; a drum part — either route — gets its hits from vaescriptor_drums). recipe.midi_source names it. Default false: the codes alone.",
"type": "boolean"
},
"name": {
"description": "Optional: a name for this job's files, e.g. \"rainy-loop-3\". Every file it returns downloads as <name>_<part>.<ext> (rainy-loop-3_Celesta.wav, rainy-loop-3_rough-mix.wav; one take: rainy-loop-3.wav), so the user can find them. Give each job its own name (a second take: \"rainy-loop-3b\"). Default: doseedo-<last 6 characters of the job id>.",
"maxLength": 80,
"type": "string"
},
"seed": {
"description": "Optional random seed for reproducibility.",
"type": "number"
},
"takes": {
"description": "How many takes, 1–4 (default: the server's best-of-N).",
"type": "number"
},
"timbre_preset": {
"description": "A named timbre preset (the catalog's preset ids, e.g. \"cello:preset1\"). Omit for the instrument default.",
"type": "string"
}
},
"required": [
"instrument",
"duration_seconds"
],
"type": "object"
},
"name": "doseedo_cover_stem",
"outputSchema": null
},
{
"description": "Create a new, empty DAW session in the account (a blank project you can then populate with doseedo_edit_session, or target with doseedo_audio_to_session). Returns its session_id.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"daw": {
"description": "Bound DAW (default logic).",
"enum": [
"logic",
"ableton"
],
"type": "string"
},
"name": {
"description": "Session name.",
"type": "string"
}
},
"required": [
"name"
],
"type": "object"
},
"name": "doseedo_create_session",
"outputSchema": null
},
{
"description": "Delete DAW sessions in bulk — a SOFT delete (the sessions disappear from the account and every listing; nothing on the user's disk is touched). Select by ids, or by filters (daw_kind, created_before / created_after, name_contains); filters combine with AND. SAFE BY DEFAULT: without confirm:true this is a DRY RUN that deletes nothing and returns {matched, ids}. Always run the dry run first, show the user the count (and names if few), and call again with confirm:true only after they agree. Never delete sessions the user did not ask to remove.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"confirm": {
"description": "false/omitted = dry run (nothing deleted). true = actually delete — only after the user saw the dry-run count and agreed.",
"type": "boolean"
},
"created_after": {
"description": "ISO-8601 date/time: only sessions created after this.",
"type": "string"
},
"created_before": {
"description": "ISO-8601 date/time: only sessions created before this.",
"type": "string"
},
"daw_kind": {
"description": "Only sessions bound to this DAW, e.g. \"logic\", \"ableton\".",
"type": "string"
},
"ids": {
"description": "Session ids to delete (up to 500), from doseedo_list_sessions.",
"items": {
"type": "string"
},
"type": "array"
},
"limit": {
"description": "Cap on how many sessions one call may match (default and max 1000).",
"type": "number"
},
"name_contains": {
"description": "Only sessions whose name contains this text (case-insensitive).",
"type": "string"
}
},
"type": "object"
},
"name": "doseedo_delete_sessions",
"outputSchema": null
},
{
"description": "Is Dø Desktop running on the user's Mac, and can it put edits into their Logic project? Reports which sessions it holds, how it applies edits (apply_mode \"reopen\" = save, back up, close, apply, reopen), whether macOS lets it (logic_control), each session's last apply (reopen_results) and its applied cursor. Use it to know whether an edit will reach the project now or wait for the next session open. When it is NOT connected the result says how the user gets and pairs the app, and what still works without it. Read-only.",
"inputSchema": {
"additionalProperties": false,
"properties": {},
"type": "object"
},
"name": "doseedo_desktop_status",
"outputSchema": null
},
{
"description": "Chord detection on audio (a chord chart on the beat grid): chord_spans[{chord, start, end, start_beat, end_beat, confidence}], chords{\"<beat>\": \"Am7\"}, bpm, beats_per_bar, beat_map. Default = the deep ACE detector (GPU-backed, a CPU chroma detector is the automatic fallback); deep:false forces the fast CPU detector. Pass audio_key (an upload) or audio_url (a result URL from another job as returned, or any public https URL). Up to 10 minutes of audio is analyzed. Works best on a harmonic stem (piano/guitar/bass) or a clean mix. Synchronous (~5–30 s). Cancel: not applicable — the result is returned in the submit response; the job is already finished.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"audio_key": {
"description": "R2 ingest key of an uploaded audio file (from doseedo_get_upload_url / POST /api/upload/r2/ingest-url; starts with \"ingest/\"). Provide this or audio_url.",
"type": "string"
},
"audio_url": {
"description": "https URL of the audio (a doseedo result URL as returned, or any public URL). Alternative to audio_key.",
"type": "string"
},
"deep": {
"description": "true (default) = deep ACE detector; false = fast CPU chroma detector.",
"type": "boolean"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
}
},
"type": "object"
},
"name": "doseedo_detect_chords",
"outputSchema": null
},
{
"description": "Save a session as a native Logic project (.logicx.zip), rebuilt server-side from the session state — no desktop needed. Returns a short-lived NO-AUTH download_url (plain `curl -o ~/Downloads/…`, no header) plus `replay` = what the build put in the file (per track: kind, Quick Sampler sample + sampler {mode, sample_seconds, start/end, plays_beats}, MIDI note count, audio region count; bundled media; deferred ops the offline build could not synthesize) and `warnings` (e.g. a classic-mode sampler whose notes end before its sample; an unknown sample length). `replay.layout {ok, problems}` is read back from the built file (every region on its own track); `replay.master.plugins` is the Stereo Out chain (ch_master); `replay.not_built` counts the ops of tracks the session later deleted (a reused session builds only what it holds now). Verify from replay/warnings, never by unzipping ProjectData. `place_local_files` (when present) is ACTION-REQUIRED after unzipping — for Quick Sampler samples AND audio regions from local paths: a replay track with audio_source:\"place_local_files\" or a \"NOT bundled\" warning means that file is not in the zip until you run those cp commands; then tell the user the project is complete.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"daw": {
"description": "Target DAW (default logic; only logic is a one-shot native download — for others use doseedo_convert_project).",
"enum": [
"logic",
"ableton",
"fl",
"reaper"
],
"type": "string"
},
"session_id": {
"type": "string"
}
},
"required": [
"session_id"
],
"type": "object"
},
"name": "doseedo_download_session",
"outputSchema": null
},
{
"description": "LYRIC EDIT / VOCAL INPAINT: send a sung recording and its words as they should be, and get the recording back with the changed words sung in the SAME singer's voice on the same melody — punched in: every word left alone plays as recorded (bit-exact), only the changed words (with a word of context) are sung again and spliced in. A whole song works too: its vocal is separated, edited and mixed back into the song (vocal_only: true skips that for a vocal on its own). Best with `heard` — the recording's words with their times, as you heard them (Whisper): send EVERY heard line in `lyrics`, the ones to change in their new words, and each line is laid on its own phrase, changed word by word. Without it the server hears the words itself and matches your lines to its phrases. Async: job_id → doseedo_wait_task (~60–180 s) → takes[{url}] as long as the recording (pre-signed: curl -OJ, no auth header, 24 h); output.lyric_edit says what was heard, what was sung again where (splice), and the credits it settled. Cancel: a render that has not reached the GPU yet is stopped and its credits refunded; one already rendering finishes on the GPU (its credits are spent), the job ends as canceled and the output is discarded.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"audio_key": {
"description": "R2 ingest key of an uploaded audio file (from doseedo_get_upload_url / POST /api/upload/r2/ingest-url; starts with \"ingest/\"). Provide this or audio_url.",
"type": "string"
},
"audio_url": {
"description": "https URL of the audio, as an alternative to audio_key: a doseedo result URL exactly as a job returned it (a stem, a take, a bounce), or any public URL. The gateway fetches it (≤256 MB) into your account's ingest storage before the job starts. Pass audio_key OR audio_url.",
"type": "string"
},
"duration_seconds": {
"description": "REQUIRED. The recording's length in seconds (0.5–600).",
"type": "number"
},
"heard": {
"additionalProperties": false,
"description": "The recording's words as heard (e.g. Whisper word timestamps), so the edit lands exactly where they are sung: {text: the heard lines joined by \"\\n\", words: [{word, start, end}] in seconds of the audio sent}. A line of `text` is a phrase; `lyrics` then sends one line per phrase.",
"properties": {
"text": {
"type": "string"
},
"words": {
"items": {
"properties": {
"end": {
"type": "number"
},
"start": {
"type": "number"
},
"word": {
"type": "string"
}
},
"required": [
"word",
"start",
"end"
],
"type": "object"
},
"type": "array"
}
},
"required": [
"text",
"words"
],
"type": "object"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"lyrics": {
"description": "REQUIRED. The words as they should be sung, a line per phrase in the recording's order. With `heard`: every heard line, one each, the lines to change in their new words (a line left as heard is not sung again).",
"maxLength": 2000,
"type": "string"
},
"name": {
"description": "Optional: a name for this job's files, e.g. \"rainy-loop-3\". Every file it returns downloads as <name>_<part>.<ext> (rainy-loop-3_Celesta.wav, rainy-loop-3_rough-mix.wav; one take: rainy-loop-3.wav), so the user can find them. Give each job its own name (a second take: \"rainy-loop-3b\"). Default: doseedo-<last 6 characters of the job id>.",
"maxLength": 80,
"type": "string"
},
"notes": {
"description": "The new words placed NOTE BY NOTE, as an editor shows a vocal: the recording's melody as notes (e.g. the transcribe job's, instrument \"voice\") in seconds of the audio sent, each note to sing again carrying its `lyric` — \"glo-\" (more of the word follows), \"a\", a whole word, \"_\" (hold the syllable before) or \"\" (sing nothing there). A note without `lyric` plays as recorded. Only the runs of notes with a lyric are sung again — those syllables on those notes, exactly — and spliced in; `lyrics` is then just the words they sing.",
"items": {
"properties": {
"duration": {
"type": "number"
},
"lyric": {
"type": "string"
},
"pitch": {
"type": "number"
},
"start": {
"type": "number"
}
},
"required": [
"start",
"duration",
"pitch"
],
"type": "object"
},
"maxItems": 4000,
"type": "array"
},
"seed": {
"description": "Optional random seed for reproducibility.",
"type": "number"
},
"vocal_gender": {
"description": "The singer's voice, a hint for the vocal model (default: heard from the recording).",
"enum": [
"male",
"female"
],
"type": "string"
},
"vocal_only": {
"description": "true = the recording is a vocal on its own: never separated (a DAW's vocal track). Default: the server checks — a song's vocal is separated, edited and mixed back.",
"type": "boolean"
}
},
"required": [
"lyrics",
"duration_seconds"
],
"type": "object"
},
"name": "doseedo_edit_lyrics",
"outputSchema": null
},
{
"description": "The catalog of session edit ops doseedo_edit_session accepts, served in views that each fit one answer (never cut mid-JSON). DEFAULT (no args): units, ids, applies, groups, batching/policy, the recipe NAMES and every op as {op, group, applies, summary} — read it ONCE before a build. Then fetch what you need: op:\"load_quick_sampler_sample\" (or ops:[…]) → those ops in full (args, units, doc; an unknown name gets did_you_mean); section:\"recipes\" → the full recipes (drum kit from local samples, fix note lengths, one-shots on an audio track, remote sample, submix bus, verify) — copy one instead of discovering op order; section:\"ops\" → every op in full; \"units\" / \"ids\" / \"summary\" (the get_session field map + workflow + policy + batching) / \"all\" (fitted, may shorten). Each op says where it lands (applies: live in the open project | next_open | state). Read-only, no key needed.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"op": {
"description": "One op name, e.g. \"set_midi_notes\" — returns that op in full.",
"type": "string"
},
"ops": {
"description": "Several op names — returns each in full.",
"items": {
"type": "string"
},
"type": "array"
},
"section": {
"description": "Which part of the catalog. Omit for the default overview.",
"enum": [
"summary",
"ops",
"recipes",
"units",
"ids",
"all"
],
"type": "string"
}
},
"type": "object"
},
"name": "doseedo_edit_ops_reference",
"outputSchema": null
},
{
"description": "Edit a DAW session with a list of ops (regions, MIDI notes, sampler samples, tracks, mixer faders/pans/mutes, plugins, tempo, markers, key, …): ids and current values from doseedo_get_session, op arguments from doseedo_edit_ops_reference. When sync.live_edits is true Dø Desktop puts it into the user's Logic project (it saves, backs up, closes and reopens the project, ~10–20 s — tell the user); otherwise stored and applied at next open. CONTRACT: every op is validated before anything is stored; a rejection carries a code — unknown_op / unknown_plugin (with did_you_mean), unknown_id (with the valid ids), duplicate_id, forbidden_group, read_only_key — and a reason. atomic (default true): one rejection → NOTHING stored, all rejections listed; atomic:false stores the good ops. RETRY: re-send a timed-out call with the SAME batch_key and it dedups (deduped:true); without batch_key a retry duplicates. Ops apply on the desktop one at a time in order, no per-batch undo — verify with doseedo_download_session (replay).",
"inputSchema": {
"additionalProperties": false,
"properties": {
"atomic": {
"description": "Default true: any rejected op means nothing is stored. Set false to store the valid ops and receive the rest as `rejected`.",
"type": "boolean"
},
"batch_key": {
"description": "A stable id for THIS batch (e.g. \"drumkit-build-1\"). Same batch_key + same ops on a retry = the same client_op_ids = no duplicates. Always pass one for a build you might have to retry.",
"type": "string"
},
"ops": {
"description": "The edits, e.g. [{\"op\":\"set_track_crop\",\"args\":{\"track_id\":\"t_…\",\"start_beats\":4,\"end_beats\":124,\"prev_start_beats\":24}}, {\"op\":\"set_channel_volume\",\"args\":{\"channel_id\":\"ch_…\",\"value\":0.6}}]. See doseedo_edit_ops_reference.",
"items": {
"additionalProperties": false,
"properties": {
"args": {
"description": "The op arguments (see the ops reference).",
"type": "object"
},
"op": {
"description": "The op name, e.g. \"set_track_crop\".",
"type": "string"
}
},
"required": [
"op",
"args"
],
"type": "object"
},
"type": "array"
},
"session_id": {
"type": "string"
}
},
"required": [
"session_id",
"ops"
],
"type": "object"
},
"name": "doseedo_edit_session",
"outputSchema": null
},
{
"description": "INPAINT (repair) a part: send ONE recorded part (a stem, a DAW track's audio) with a gap in it — the silence between two clips, a bar to redo, a dropout — and get it back with the gap PLAYED: the take before and after the gap is kept bit-exact (spliced back), and the gap is generated against both, so it continues out of what comes before and leads into what follows. What fills it is planned first (the DSP plane's extend planner, which hears the part): the take's own LOOP when it has one — the gap is seeded from its own passes at the matching bar phase, so a groove keeps turning — else a part written in its key and over its chords, performed in the take's own sound. Pass the session's bpm and bar grid (bar_offset_seconds: where a bar line falls in the audio you send); the gap is in seconds of that audio. Send the part with some of the take on each side of the gap (8 bars or more before it is best). Async: job_id → doseedo_wait_task (~40–150 s) → takes[{url}]: WAVs as long as the audio you sent, the gap filled — cut out the gap (or the span you need) to drop it into the DAW. output.plan says what filled it (loop bars, or the writer and the changes). Cancel: a render that has not reached the GPU yet is stopped and its credits refunded; one already rendering finishes on the GPU (its credits are spent), the job ends as canceled and the output is discarded.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"audio_key": {
"description": "R2 ingest key of an uploaded audio file (from doseedo_get_upload_url / POST /api/upload/r2/ingest-url; starts with \"ingest/\"). The part, with the gap in it. Provide this or audio_url.",
"type": "string"
},
"audio_url": {
"description": "https URL of the audio, as an alternative to audio_key: a doseedo result URL exactly as a job returned it (a stem, a take, a bounce), or any public URL. The gateway fetches it (≤256 MB) into your account's ingest storage before the job starts. Pass audio_key OR audio_url.",
"type": "string"
},
"bar_offset_seconds": {
"description": "Where a bar line falls in the audio (seconds; default 0 = the audio starts on a downbeat). Sending a span of a DAW track that starts mid-bar? Give the first downbeat's time in it.",
"type": "number"
},
"bpm": {
"description": "REQUIRED. The session's tempo — the gap is filled on its bar grid.",
"type": "number"
},
"duration_seconds": {
"description": "REQUIRED. The audio's length in seconds (1–600).",
"type": "number"
},
"exact_grid": {
"description": "true = the audio is cut from a DAW session, so bpm and bar_offset_seconds are its EXACT grid: the fill keeps it (default false: the planner fine-tunes the grid to the audio's own onsets — right for a stem whose tempo you only know roughly).",
"type": "boolean"
},
"fill": {
"description": "What fills the gap: \"context\" = the span played AGAIN from the take around it — no plan, no notes: a variation of what is there, in its own sound and level (INPAINTING a span that has audio — the right default there); \"loop\" = the take's own passes (a groove that keeps turning), \"written\" = a part written in its key and chords, \"auto\" (default) = the loop when the part has one, else written.",
"enum": [
"auto",
"context",
"loop",
"written"
],
"type": "string"
},
"gap_end_seconds": {
"description": "REQUIRED. Where the gap ends (and the take resumes), in seconds of the audio.",
"type": "number"
},
"gap_start_seconds": {
"description": "REQUIRED. Where the gap starts, in seconds of the audio.",
"type": "number"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"instrument": {
"description": "What plays the part (an id from doseedo_instruments). Optional — the take's own sound is kept either way; a written fill is played by it.",
"type": "string"
},
"keep": {
"description": "fill \"context\": how much of what is in the span its regeneration keeps, 0.01–0.9 (default 0.05: a variation; 0.45 ≈ the same playing again).",
"type": "number"
},
"name": {
"description": "Optional: a name for this job's files, e.g. \"rainy-loop-3\". Every file it returns downloads as <name>_<part>.<ext> (rainy-loop-3_Celesta.wav, rainy-loop-3_rough-mix.wav; one take: rainy-loop-3.wav), so the user can find them. Give each job its own name (a second take: \"rainy-loop-3b\"). Default: doseedo-<last 6 characters of the job id>.",
"maxLength": 80,
"type": "string"
},
"notes": {
"description": "YOUR part for the gap — a custom part (a MIDI region drawn there in the DAW): [{pitch, start_seconds, duration_seconds, velocity?}], seconds of the audio you send. It is the written part, no planner: the take plays exactly these notes, in its own sound (notes outside the gap are ignored; silence where there are none). fill \"written\" or omitted. ≤2000.",
"items": {
"properties": {
"duration_seconds": {
"type": "number"
},
"pitch": {
"type": "number"
},
"start_seconds": {
"type": "number"
},
"velocity": {
"type": "number"
}
},
"required": [
"pitch",
"start_seconds",
"duration_seconds"
],
"type": "object"
},
"type": "array"
},
"role": {
"description": "The part's role, when you know it (the planner hears it otherwise).",
"enum": [
"drums",
"perc",
"bass",
"harmony",
"melody"
],
"type": "string"
},
"seed": {
"description": "Optional random seed (the same seed plans and renders the same).",
"type": "number"
},
"takes": {
"description": "How many takes, 1–4 (default: the server's best-of-N).",
"type": "number"
},
"time_signature": {
"description": "The session's meter, e.g. \"4/4\" (default) or \"3/4\".",
"type": "string"
},
"track_name": {
"description": "The part's track name in the DAW (\"Drums\", \"Bass\", \"Strings\") — the planner hears a role from the name first, then from the sound.",
"type": "string"
}
},
"required": [
"duration_seconds",
"gap_start_seconds",
"gap_end_seconds",
"bpm"
],
"type": "object"
},
"name": "doseedo_fill_gap",
"outputSchema": null
},
{
"description": "A DRUM LOOP from a generator — doseedo_generators lists them (house, deep_house, tech_house, afro_house, jackin_house… the list grows without a release). The groove is WRITTEN for the seed (kick, clap, hats, shaker, percussion voices, ghost notes, fills at the phrase ends, 16th swing) and PLAYED through the generator's kit of recorded one-shots (drawn by the seed, the kick tuned to key): the same generator + seed + bars + bpm is the same loop, another seed another groove and another kit. Returns the loop as audio (48 kHz WAV, exactly `bars` long, its tails wrapped round the loop point so it repeats seamlessly), its MIDI (midi_url, GM drums) and, for a short loop, the notes (notes[] — edit them and play them back with doseedo_render_midi {instrument:\"electronic\", drum_genre:\"<the generator's genre>\", notes}, or put them on a session track with set_midi_notes). MIDI only, free and instant: doseedo_generators {generator, bars, bpm, seed}. Wrong tool for drums you wrote (doseedo_render_midi) or a described sound (doseedo_generate_sound). Async: job_id → doseedo_wait_task (a few seconds) → files[0] (pre-signed: curl -OJ <url>, no auth header, valid 24 h). Cancel: a render that has not reached the GPU yet is stopped and its credits refunded; one already rendering finishes on the GPU (its credits are spent), the job ends as canceled and the output is discarded.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"bars": {
"description": "Length in bars of 4/4, 1–64. Default: the generator's (8).",
"type": "number"
},
"bpm": {
"description": "Tempo, 40–240. Default: the generator's own (house 124, deep 120, tech 127…).",
"type": "number"
},
"fills": {
"description": "false = no fills at the phrase ends (a loop that sits under a verse). Default true.",
"type": "boolean"
},
"generator": {
"description": "REQUIRED. A generator id from doseedo_generators (\"deep_house\", \"tech_house\"…) or genre words that name one (\"afro house\"). An unknown one is refused with the closest ids before anything is spent.",
"maxLength": 60,
"type": "string"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"key": {
"description": "The track's key, e.g. \"F minor\" — the kick is drawn near its root or fifth and tuned the rest of the way.",
"maxLength": 24,
"type": "string"
},
"name": {
"description": "Optional: a name for this job's files, e.g. \"rainy-loop-3\". Every file it returns downloads as <name>_<part>.<ext> (rainy-loop-3_Celesta.wav, rainy-loop-3_rough-mix.wav; one take: rainy-loop-3.wav), so the user can find them. Give each job its own name (a second take: \"rainy-loop-3b\"). Default: doseedo-<last 6 characters of the job id>.",
"maxLength": 80,
"type": "string"
},
"percussion": {
"description": "How many percussion voices (0–4). Default: the generator draws it.",
"type": "number"
},
"seed": {
"description": "The groove and the kit: the same seed is the same loop; omit for a new one each call (the result names it).",
"type": "number"
},
"swing": {
"description": "16th swing: 0.5 straight … 0.66 triplet. Default: the generator's.",
"type": "number"
}
},
"required": [
"generator"
],
"type": "object"
},
"name": "doseedo_generate_loop",
"outputSchema": null
},
{
"description": "NOT A COMPOSER: doseedo plays music, it does not write it — YOU write the piece. Background music for a video or a brand film, an instrumental, a theme, a song: compose every part yourself as notes ([{pitch, start_beats, duration_beats, velocity}], beats from bar 1 — melody, harmony, bass, in the key and at the tempo you choose), then play them: doseedo_render_score {parts} for several instruments (one stem each, then doseedo_mix) or doseedo_render_midi for one; doseedo_instruments lists the players and their ranges; the steps: doseedo_recipes name=\"compose-piece\" (to picture: \"score-a-film\"; one part in a session's key: \"compose-part\"). THIS tool is text to music from a PROMPT alone (optionally lyrics) with NO notes behind it: the instrument model then has nothing to play, and a take is often near-silent, a drone or clicks. Nothing in it is controlled — no key control (a key in the prompt is not honoured), no MIDI input, bpm/time_signature only tag the caption. Use it only when the user explicitly asks for a prompt-only AI sketch, listen before handing a take over, and never deliver one as the music. Async: job_id → doseedo_wait_task (typically 1–3 min) → audio URLs (pre-signed: curl -OJ <url>, no auth header, valid 24 h — see expires_at). Cancel: a render that has not reached the GPU yet is stopped and its credits refunded; one already rendering finishes on the GPU (its credits are spent), the job ends as canceled and the output is discarded.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"bpm": {
"description": "Optional tempo HINT in BPM, written into the caption (default 120). Not enforced — the output tempo can drift from it.",
"type": "number"
},
"duration_seconds": {
"description": "Target length in seconds (e.g. 30–120). Omit for the model default.",
"type": "number"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"lyrics": {
"description": "Optional lyrics to sing, ≤ 16000 characters. Omit for instrumental.",
"maxLength": 16000,
"type": "string"
},
"name": {
"description": "Optional: a name for this job's files, e.g. \"rainy-loop-3\". Every file it returns downloads as <name>_<part>.<ext> (rainy-loop-3_Celesta.wav, rainy-loop-3_rough-mix.wav; one take: rainy-loop-3.wav), so the user can find them. Give each job its own name (a second take: \"rainy-loop-3b\"). Default: doseedo-<last 6 characters of the job id>.",
"maxLength": 80,
"type": "string"
},
"prompt": {
"description": "Style/mood/instrumentation prompt, e.g. \"warm jazz trio, brushed drums, late-night ballad\". ≤ 16000 characters (a longer one is cut at a word boundary, with a warning).",
"maxLength": 16000,
"type": "string"
},
"seed": {
"description": "Optional random seed for reproducibility.",
"type": "number"
},
"time_signature": {
"description": "Optional meter HINT written into the caption, e.g. \"4/4\", \"3/4\". Not enforced.",
"type": "string"
}
},
"required": [
"prompt"
],
"type": "object"
},
"name": "doseedo_generate_music",
"outputSchema": null
},
{
"description": "SOUND EFFECTS (SFX) from words with Stable Audio Open — SOUND DESIGN and FOLEY for game audio, apps and video: impacts, whooshes, door slams, footsteps, UI blips, creature and sci-fi sounds, ambiences (\"rain on a tin roof\", \"busy café\"), risers, drum one-shots. A one-shot hit (\"punchy house kick\", \"snare with a short room\", \"a riser into the drop\"), a loop on the tempo grid (\"glitchy percussion\"), or a texture (\"vinyl crackle\", \"rain\"). kind picks which (hit | loop | texture); omitted, the server reads it off the words. Don't put a tempo in a hit's prompt — tempo words make it write a loop. Wrong tool for a part with notes (doseedo_render_midi) or a piece of music (you write it; doseedo_render_score plays it). Async: job_id → doseedo_wait_task (typically 15–40 s) → audio URLs (pre-signed: curl -OJ <url>, no auth header, valid 24 h). Cancel: a render that has not reached the GPU yet is stopped and its credits refunded; one already rendering finishes on the GPU (its credits are spent), the job ends as canceled and the output is discarded.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"bpm": {
"description": "Tempo a loop is cut to (default 120).",
"type": "number"
},
"duration_seconds": {
"description": "Length in seconds. Default: 2 s for a hit, 4 bars at bpm for a loop, 8 s for a texture.",
"type": "number"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"kind": {
"description": "hit = one sound (0.5–10 s), loop = 1–4 bars tiled at bpm, texture = a bed. Default: read off the prompt.",
"enum": [
"hit",
"loop",
"texture"
],
"type": "string"
},
"name": {
"description": "Optional: a name for this job's files, e.g. \"rainy-loop-3\". Every file it returns downloads as <name>_<part>.<ext> (rainy-loop-3_Celesta.wav, rainy-loop-3_rough-mix.wav; one take: rainy-loop-3.wav), so the user can find them. Give each job its own name (a second take: \"rainy-loop-3b\"). Default: doseedo-<last 6 characters of the job id>.",
"maxLength": 80,
"type": "string"
},
"prompt": {
"description": "What it sounds like, e.g. \"punchy house kick drum, single hit\" or \"dusty vinyl crackle\". ≤ 300 characters (a longer one is cut at a word boundary, with a warning).",
"maxLength": 300,
"type": "string"
},
"seed": {
"description": "Optional random seed for reproducibility.",
"type": "number"
},
"time_signature": {
"description": "Meter a loop is cut to, e.g. \"4/4\" (default).",
"type": "string"
}
},
"required": [
"prompt"
],
"type": "object"
},
"name": "doseedo_generate_sound",
"outputSchema": null
},
{
"description": "GENERATORS — music you do not have to write. BAND generators (has: [\"band\"] — jazz …; more genres are added without a release) write a WHOLE arranged piece in a genre: every part's notes (drums, bass, piano, a lead), its form and changes, for a seed. With generator + bars | seconds, bpm, key, seed, lead (\"none\" = rhythm section alone) → parts[] ({name, instrument, timbre_preset, notes}), form, changes and the .mid (midi_base64): free, instant, no audio. To HEAR it: doseedo_render_score {generator: {id, seed, bars, key, lead}, bpm} plays that exact piece — you pass no notes — and doseedo_mix {from_job} mixes it in the genre's own style (mix_style: a dub's spring tank and tape echo). A film cue or a song that calls for a generator's genre should use it rather than be composed. DRUM generators — ready-made kits and grooves: each generator is a KIT (recorded one-shots for a genre: doseedo_render_midi plays your drum notes through it when the part's drum_genre names it), a LOOP (a groove written for a seed: doseedo_generate_loop → the audio + its MIDI), or both (house, deep house, tech house, afro house, jackin' house — the list grows without a release, so read it rather than remember it). No args → every generator: id, what it has, the drum_genre words that reach its kit, its loop's tempo, swing and bars. With generator (+ bars, bpm, seed, swing, fills, percussion) → that generator's loop AS MIDI: notes[] [{pitch, start_beats, duration_beats, velocity}] (GM drums) and the .mid (midi_base64) — the SAME groove doseedo_generate_loop plays for that seed, instant, free, no audio: read a few seeds, pick or edit one, then render it (doseedo_generate_loop with the same seed, or doseedo_render_midi with your edited notes) or put it on a session track (set_midi_notes). Read-only, no key needed.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"bars": {
"description": "Bars of 4/4, 1–64 (default: the generator's, 8).",
"type": "number"
},
"bpm": {
"description": "Tempo written into the .mid, 40–240 (default: the generator's).",
"type": "number"
},
"direction": {
"description": "A BAND generator: what you want of the piece, as doseedo_render_score's generator takes it — {dynamics: [{at_seconds, level: none|low|medium|high|peak, ramp?}], hits: [{at_seconds, kind?: light|medium|full, who?, stroke?}] (who = only those parts land it; stroke = the one drum of the kit that sounds: kick, snare, rim, clap, hat, open hat, crash, tom, high tom, floor tom), lay_out: [{from_seconds?, to_seconds?, who?, only?}] (who rests: no name = the lead; a part, a family, \"rhythm\", \"all\"; no times with who or only = the whole piece), thin: [{from_seconds?, to_seconds?, to?: beats|halves|bars, who?}] (who plays thinner: keeps only the beats / the bar's halves / the bar lines), texture: [{from_seconds?, to_seconds?, who, plays?: held|pedal|pulse|arpeggio|ostinato|walk|stabs|comp|line|four_on_the_floor|backbeat|half_time|light|full, value?, level?}] (what a part plays there — taken from the style's own writing for that part over the same chords, never invented; not applied where the style does not play it), textures: true (the answer lists what each part can play: textures), builds: [{into_seconds, beats?, drop?}], ending: {kind: cut|button|ring|fade, at_seconds?, strength?, build?} (build: true = the band builds into the last chord), intro: false, swing: light|medium|hard, solo_swing: straight|light|medium|hard} — YOUR OWN BAND: band: [{instrument, timbre_preset?, name?, chair?}] (who is seated in place of the generator's own players) — and YOUR OWN MUSIC for it to arrange: theme: {notes: [[pitch, beat, beats, velocity], …] (beats from the tune's first bar line), statements?: [{at_seconds, on?, from_beat?, beats?, octave?, transpose?, stretch?}]} (the generator's own tune comes out and yours goes in, every note as written — with no statements, wherever its own tune was), changes: \"Dm | Bb | Gm | A\" (your chords, one cell a bar, as a loop; left out with a theme, the chords are harmonised to the theme). STYLE TRANSFER — song: {melody: [[pitch, beat, beats], …], changes: \"C | Am | F | G7\" (one cell a bar, the WHOLE song), sections: [{label, bars}], meter?, bpm?, key?} plays YOUR SONG in this genre and keeps it exactly: its length, its sections, its chart bar for bar and every note of its tune from bar one; the generator decides only how its chairs play it (lead: \"none\" = the genre's band without the tune). A melody alone is harmonised; chords alone get the genre's own tune; parts: [{name, notes}] (a MIDI arrangement) is read for its tune and chart. A genre in another metre (a waltz, 6/8, 12/8) plays the song re-metered by the meter-change rule and says what moved. only: \"bass\" | [\"bass\", \"drums\"] returns just those parts — the genre's line for one stem, written with the whole band. Times in seconds at this bpm, or at_beats / from_beats / to_beats / into_beats.",
"type": "object"
},
"fills": {
"description": "false = no fills at the phrase ends.",
"type": "boolean"
},
"generator": {
"description": "A generator id (\"deep_house\") or genre words (\"afro house\") → its loop as MIDI. Omit to list the generators.",
"maxLength": 60,
"type": "string"
},
"key": {
"description": "A BAND generator: the key, e.g. \"F\", \"C minor\" (default: drawn by the seed).",
"maxLength": 40,
"type": "string"
},
"lead": {
"description": "A BAND generator: the lead instrument (one of its leads), or \"none\" for the rhythm section alone.",
"maxLength": 40,
"type": "string"
},
"percussion": {
"description": "Percussion voices, 0–4 (default: drawn by the seed).",
"type": "number"
},
"seconds": {
"description": "A BAND generator: the piece's length in seconds (4–600) instead of bars — a film cue's duration.",
"type": "number"
},
"seed": {
"description": "Which groove: the same seed is the same pattern (default 1).",
"type": "number"
},
"swing": {
"description": "16th swing, 0.5 straight … 0.66 triplet (default: the generator's).",
"type": "number"
}
},
"type": "object"
},
"name": "doseedo_generators",
"outputSchema": null
},
{
"description": "Get a presigned upload for a DAW PROJECT file (for doseedo_convert_project / doseedo_import_project). Zip a project FOLDER so its audio travels with it — and a .logicx or GarageBand .band, which are folders (macOS packages). SIZE LIMITS: a single PUT takes up to 5 GB; guest and free accounts convert projects up to 2 GB, paid plans up to 12 GB (a larger one is refused as project_too_large with the cap and an upgrade link). Pass size_bytes: past 4 GB (or with multipart:true) you get a MULTIPART upload instead — a part_size, one presigned part_url per part, and the complete step (doseedo_complete_project_upload); each part is retried on its own, so a dropped connection costs one part, not the upload. Single PUT: `curl -sS -X PUT -H \"Content-Type: application/zip\" --data-binary @project.zip \"<upload_url>\"`, then pass project_key on. Multipart: `split -b <part_size_bytes> project.zip part.` then for each piece in order `curl -sS -X PUT --data-binary @part.aa \"<part_url>\" -D - -o /dev/null | grep -i etag` (keep each ETag), then doseedo_complete_project_upload {project_key, upload_id, parts}. Need more part URLs than one answer holds? Call this again with project_key + upload_id + part_numbers.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"content_type": {
"description": "MIME type: application/zip for zips (default), application/octet-stream for bare project files.",
"type": "string"
},
"filename": {
"description": "File name including extension, e.g. \"Song Project.zip\", \"My Song.band.zip\", \"beat.flp\", \"song.cpr\", \"Mix.song\", \"set.dawproject\" or \"score.mxl\".",
"type": "string"
},
"multipart": {
"description": "Force a multipart upload regardless of size (resumable per part).",
"type": "boolean"
},
"part_numbers": {
"description": "CONTINUATION: which part numbers (1-based) to sign now, ≤ 24 per call.",
"items": {
"type": "number"
},
"type": "array"
},
"project_key": {
"description": "CONTINUATION of a multipart upload: the key the first call returned.",
"type": "string"
},
"size_bytes": {
"description": "The file's size in bytes (stat it). Decides single PUT vs multipart and sizes the parts.",
"type": "number"
},
"upload_id": {
"description": "CONTINUATION: the upload_id the first call returned.",
"type": "string"
}
},
"type": "object"
},
"name": "doseedo_get_project_upload_url",
"outputSchema": null
},
{
"description": "Read a DAW session as the arrangement an agent edits against: every track with its wire ids (track_id t_…, mixer strip channel_id ch_…), regions in BOTH beats and seconds with their MIDI notes (i, pitch, velocity, start_beats, duration_beats — i is what edit_midi_notes selects by), mixer (volume with dB, pan, mute), plugins with params[{param_id, name, value}] (set_device_param needs param_id) and sampler {mode, sample_seconds, plays_beats, …}, sends/output as ch_b_… ids, buses, tempo_bpm + tempo_map, time_signature + meter_map, key_signature when known, markers (marker_id, beat ABSOLUTE from bar 1), automation lanes, instrument, counts, length — and `sync` with live_edits:true|false + live_edits_reason (will an edit reach Logic now?). Field-by-field map: doseedo_edit_ops_reference {section:\"summary\"}. BUDGET (never cut mid-JSON): notes come inline when the selected tracks hold ≤200 notes, else regions carry note_count + notes_omitted:true — pass include_notes:true with tracks:[ids] for a track's notes; include_params:false / include_automation:false drop params / points; a result still too big is paginated by track with `truncated` + `next` (the exact args for the rest). Read-only. Pass the ids straight to doseedo_edit_session, or a track_id to doseedo_render_midi {session_id, track_id}.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"include_automation": {
"description": "Include automation lanes with points (default true). false keeps a lane count per track.",
"type": "boolean"
},
"include_notes": {
"description": "Include MIDI notes. Default: true when the selected tracks hold ≤200 notes in all, else false (regions then carry note_count + notes_omitted:true).",
"type": "boolean"
},
"include_params": {
"description": "Include plugin params (default true). false keeps param_count only.",
"type": "boolean"
},
"session_id": {
"description": "From doseedo_list_sessions.",
"type": "string"
},
"tracks": {
"description": "Only these tracks (track_id t_… or channel_id ch_…; a track name matches too). The rest of the session (tempo, markers, buses, sync) is always included.",
"items": {
"type": "string"
},
"type": "array"
}
},
"required": [
"session_id"
],
"type": "object"
},
"name": "doseedo_get_session",
"outputSchema": null
},
{
"description": "Get a presigned upload for your own audio file — or a SCORE (.mid / .midi / .musicxml / .xml / .mxl / .mscz / .mscx → a score_key for doseedo_render_score: send a big score as a file, not as notes in the call). Returns an upload_url (PUT the raw file bytes there, e.g. `curl -X PUT -H \"Content-Type: <content_type>\" --data-binary @song.wav \"<upload_url>\"`) and an audio_key to pass to doseedo_separate_stems / doseedo_transcribe / doseedo_cover_song / doseedo_audio_to_session, or to doseedo_add_audio_to_session. A FILM (mp4, mov, m4v, webm, mkv; ≤ 2 GB) uploads the same way: pass the key as video_key to doseedo_spot_video / doseedo_score_to_picture. Formats: WAV, AIFF, FLAC, MP3, M4A/AAC, Ogg/Opus, WebM — all accepted for processing on every plan. Storing audio IN A SESSION (doseedo_add_audio_to_session) keeps WAV/AIFF/FLAC lossless only on Pro+; below Pro+ lossless is not kept there, so send Opus (audio/ogg). Samples/regions for a session that are on this machine need NO upload: use load_quick_sampler_sample sample_path / attach_audio local_path / set_track_clips audio_ref.local_path and run place_local_files after the download. A FILE ALREADY ONLINE (a film an editor exported — Canva, Adobe Express — or any public https URL): pass source_url and doseedo copies it in itself — nothing to PUT; the key comes back ready (≤ 256 MB).",
"inputSchema": {
"additionalProperties": false,
"properties": {
"content_type": {
"description": "MIME type; inferred from the extension when omitted (wav, aif/aiff, flac, mp3, m4a/aac, ogg/opus, webm; a film: mp4, mov, m4v, mkv). Required for any other extension.",
"type": "string"
},
"filename": {
"description": "File name including extension, e.g. \"song.wav\", \"film.mp4\", or \"cue.mid\" / \"cue.musicxml\" / \"cue.mscz\" for a score. With source_url: the name for the copy when the URL names none (its extension decides the type).",
"type": "string"
},
"source_url": {
"description": "A public https URL of an audio file or a film to copy in instead of uploading it (e.g. an editor's export link). Returns the key directly — no upload_url, nothing to PUT. ≤ 256 MB.",
"type": "string"
}
},
"required": [
"filename"
],
"type": "object"
},
"name": "doseedo_get_upload_url",
"outputSchema": null
},
{
"description": "Instrument recognition + genre classification of audio (a stem, a loop, a whole mix): instrument (e.g. \"sub_bass\", \"drum_machine\", \"synth_lead\", \"string_section\"), family, render (the doseedo_render_midi fields that play it), write (how its part is written), candidates[], resembles[] (what it sounds like without being it: a synth lead that resembles a brass section), confidence, notes {low, high, most} (its register), genre[] (top 3), character {tone bright|dark, drive clean|driven, length short|sustained, weight}, reads (playful | neutral | sleek: does it sound like a toy advert or a cartoon?) + playful 0–1, tags[] (AudioSet) and measured {rms_dbfs, centroid_hz, low_share, onsets_per_s}. USE THIS on a reference track and on each of its stems (doseedo_separate_stems returns stem_identity already) before writing: you cannot hear, and tempo and key say nothing about the SOUND. Run it on your own mix too and compare genre and character with the reference. A whole mix: read genre and character (instrument names only its loudest element). A silent stem answers silent:true — nothing to copy there. Pass audio_key (an upload) or audio_url (a result URL from another job as returned, or any public https URL). Up to 10 minutes of audio is analyzed. Synchronous (~1–5 s), no credits. Cancel: not applicable — the result is returned in the submit response; the job is already finished.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"audio_key": {
"description": "R2 ingest key of an uploaded audio file (from doseedo_get_upload_url / POST /api/upload/r2/ingest-url; starts with \"ingest/\"). Provide this or audio_url.",
"type": "string"
},
"audio_url": {
"description": "https URL of the audio (a doseedo result URL as returned — a stem, a take — or any public URL). Alternative to audio_key.",
"type": "string"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"want": {
"description": "Which answers to compute (default all three).",
"items": {
"enum": [
"instrument",
"genre",
"character"
],
"type": "string"
},
"type": "array"
}
},
"type": "object"
},
"name": "doseedo_identify_sound",
"outputSchema": null
},
{
"description": "Open an uploaded DAW project (Logic .logicx.zip, Ableton .als or project zip, FL .flp, REAPER .rpp, Pro Tools .ptx — zip the folder) as an EDITABLE doseedo session: returns a session_id the session tools then work on (doseedo_get_session → doseedo_edit_session → doseedo_download_session as a native Logic project, or convert that download to another DAW with doseedo_convert_project). The session gets the project's tempo (+ tempo map), meter, markers, and every track with its name, mixer level/pan, color and MIDI notes. AUDIO IS NOT CARRIED: the import reads the project, not its media — audio tracks arrive named and positioned (audio.placements lists each clip's file and beats) and audio.next says how to supply the files. Plugins and summing buses are reported, not recreated. Upload first with doseedo_get_project_upload_url; this call parses the project (seconds to minutes for a big one) — if it answers status:\"running\", call it again with the returned task_id until it hands back session_id.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"daw": {
"description": "The source DAW, when the filename does not say (optional; detected otherwise).",
"enum": [
"logic",
"ableton",
"fl",
"reaper",
"protools"
],
"type": "string"
},
"name": {
"description": "Session name (default: the project's own name).",
"type": "string"
},
"project_key": {
"description": "R2 key of the uploaded project (from doseedo_get_project_upload_url; starts with \"uploads/\").",
"type": "string"
},
"task_id": {
"description": "CONTINUATION: the task_id a previous call returned while the parse was still running.",
"type": "string"
}
},
"type": "object"
},
"name": "doseedo_import_project",
"outputSchema": null
},
{
"description": "The instrument list — the sound palette: every instrument doseedo can PLAY YOUR NOTES on (doseedo_render_midi) — orchestral strings, brass and winds, guitars, basses, keys, drums and percussion, and World instruments (koto, sitar, banjo, pedal steel, tabla, congas…). Each entry gives the EXACT render call (`call`: instrument, plus timbre_preset where one is needed — a koto is the acoustic_guitar model with the koto timbre), its playable range in concert MIDI pitch, whether it plays chords, its presets (pizz, muted, sax registers…) and a demo render. No args → the whole catalog; query:\"warm low brass\" / family / culture:\"India\" (a culture's own instruments: \"Indian\", \"Japanese\", \"Celtic\", \"Latin America\"…) / pitches:[…] (instruments whose range holds them) / chords:true narrow it; id:\"cello\" → one instrument in full. Read-only, free, no key needed — read it before writing a part.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"chords": {
"description": "true = only instruments one player can play chords on.",
"type": "boolean"
},
"culture": {
"description": "Only the instruments that are this culture's own sound — a culture (\"India\", \"Japan\", \"Middle East\", \"Celtic\", \"Cuba\", \"Mexico\", \"Brazil\", \"Americana\"…), a word for one (\"Indian\", \"Carnatic\", \"Irish\") or a region (\"South Asia\", \"Latin America\", \"Europe\"). The whole listing names every culture.",
"type": "string"
},
"family": {
"description": "Only this family.",
"enum": [
"strings",
"brass",
"winds",
"piano",
"guitar",
"bass",
"drums",
"world",
"pitched_percussion",
"unpitched_percussion",
"synth"
],
"type": "string"
},
"id": {
"description": "One instrument (id, alias or label, e.g. \"cello\", \"upright bass\", \"koto\") → its full entry: every preset with its own call and range, transposition, aliases, demo, page.",
"type": "string"
},
"pitches": {
"description": "MIDI pitches the part uses (concert, 60 = C4) — only instruments whose range holds every one.",
"items": {
"type": "number"
},
"type": "array"
},
"query": {
"description": "What the part needs, in words: an instrument (\"trumpet\"), a family (\"woodwinds\"), a technique (\"pizzicato\", \"muted\") or a register (\"low\", \"bright\"). Ranked best-first.",
"type": "string"
}
},
"type": "object"
},
"name": "doseedo_instruments",
"outputSchema": null
},
{
"description": "List the jobs this account submitted (generate / render_midi / cover / stems / transcribe / session / convert / bounce / the analyses), newest first — to find an earlier result, check what is still running, or resume after a lost connection. Each row names its artifacts (e.g. [\"vocals\", \"drums\", \"midi_piano\"]); doseedo_check_task {job_id} returns the full result with fresh links. Read-only.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"before": {
"description": "Page cursor: the next_cursor of a previous call.",
"type": "string"
},
"kind": {
"description": "Only this job kind (registry name): generate_music, generate_sound, generate_loop, cover_stem, edit_lyrics, fill_gap, render_midi, train_instrument, render_score, mix, mix_preset, session_from_stems, spot_video, score_to_picture, reframe_video, cover_song, separate_stems, split_soundtrack, transcribe, audio_to_session, convert_project, bounce_session, analyze_song, detect_chords, beat_grid, identify_sound, check_take, analyze_midi, supervise_cues. Short codes (generate, sound, loop, coverstem, editlyrics, fillgap, render, train, score, mixpre, stemsess, spot, picture, reframe, cover, separate, soundtrack, session, convert, bounce, analyze, chords, beats, identify, check, harmony, supervise) are accepted aliases.",
"type": "string"
},
"limit": {
"description": "How many (1–100, default 20).",
"type": "number"
},
"session_id": {
"description": "Only jobs whose input names this session — a bounce, stems registered into it, a render of one of its tracks (filtered within the fetched page).",
"type": "string"
},
"status": {
"enum": [
"queued",
"running",
"succeeded",
"failed",
"canceled"
],
"type": "string"
}
},
"type": "object"
},
"name": "doseedo_list_jobs",
"outputSchema": null
},
{
"description": "List the plugins you can insert on a strip with doseedo_edit_session's add_device op. Returns the stock Logic catalog (instruments + effects, always available) and — when Dø Desktop is connected — the actual plugins installed on the user's Mac (stock + third-party). Insert any of them BY NAME: add_device {channel_id, device: {name: \"…\"}}.",
"inputSchema": {
"additionalProperties": false,
"properties": {},
"type": "object"
},
"name": "doseedo_list_plugins",
"outputSchema": null
},
{
"description": "List the connected account's DAW sessions (most recently updated first) — their ids, names, DAW, and update time. Pages with limit + offset (the response carries total and next_offset); name_contains filters by name. Use a session id with doseedo_get_session and doseedo_edit_session; clean up old ones with doseedo_delete_sessions.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"limit": {
"description": "How many to return (default 25, max 200).",
"type": "number"
},
"name_contains": {
"description": "Only sessions whose name contains this text (case-insensitive).",
"type": "string"
},
"offset": {
"description": "How many to skip (default 0) — pass the previous response's next_offset to get the next page.",
"type": "number"
}
},
"type": "object"
},
"name": "doseedo_list_sessions",
"outputSchema": null
},
{
"description": "MIXING and MASTERING: each part levelled, panned, high-passed, given its depth on a shared reverb, mastered to a loudness target — a WAV AND `mixgraph`, the mix as a document. After doseedo_render_score pass from_job (its parts and the instruments they play are the stems); or stems: [{name, audio_url, instrument?}]. An orchestra (strings / winds / brass / timpani / harp…) is SEATED by default (film-orchestral: violins left, low strings right, brass behind, each seat at its depth in a 2.3 s hall, written dynamics riding the faders); others mixed blind. style: an id or words — the style parameter lists every id (scoring halls, jazz-combo, big-band, brass and marching bands, soul, rock-band and the other guitar bands, blues, country, reggae, disco, the decades). guitar_tone = guitar sound. balance {part: dB} moves parts on top of the levelling (+3 = a melody forward). Change the mix: edit the returned mixgraph — strips[] {stem, gain_db, pan, seat, chain, sends}, buses[] (verb = the hall; a section's fader_db = its level), master.chain, automation [{target: \"strips.<stem>.gain_db\", points: [[seconds, dB]…]}] for rides (dB off the strip's gain_db: 0 = as set, -60 mutes) — and call again with mix_job (this job_id) + only your edits (or the whole mixgraph + the same stems): rendered as written, rails reported, no credits. Then doseedo_session_from_stems {from_job, mix_job: <this job_id>} → the DAW project at this mix's levels and pans. TO PICTURE: dialogue (the VO; the music ducks under it), music_offset_s (bar 1 on the picture), length_s (cut + end fade). Async: job_id → doseedo_wait_task (~15–90 s). Cancel: the plane has no stop for a running mix — it runs to completion (credits spent), the job ends as canceled and its output is discarded. Only a job still queued at the plane is refunded by the plane's own failure refund.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"balance": {
"additionalProperties": {
"type": "number"
},
"description": "{part name: dB in -12..12} — your balance on top of the levelling (and of the written dynamics a from_job reads).",
"type": "object"
},
"bpm": {
"description": "The music's tempo: a guitar tone's echoes (an eighth, a dotted eighth) land on it. from_job fills it.",
"maximum": 400,
"minimum": 20,
"type": "number"
},
"dialogue": {
"description": "The VO / dialogue on the picture's timeline (≤ 4): [{name?, audio_url}]. The music ducks under each line until the voice sits duck.vo_over_db over it, with a 1–4 kHz carve while it talks; the voice joins after the music's master chain. Report: output.dialogue.lines [{start_s, end_s, duck_db, vo_over_music_db}] as mixed.",
"items": {
"additionalProperties": false,
"properties": {
"audio_url": {
"type": "string"
},
"name": {
"type": "string"
}
},
"required": [
"audio_url"
],
"type": "object"
},
"type": "array"
},
"duck": {
"additionalProperties": false,
"description": "How the music sits under the dialogue: {vo_over_db (default 7 dB — a broadcast mix's 6–10), carve_db (default 3, at 1–4 kHz), max_db (default 12), include (default true; false = the music bed alone, ducked as if the voice played)}.",
"properties": {
"carve_db": {
"type": "number"
},
"include": {
"type": "boolean"
},
"max_db": {
"type": "number"
},
"vo_over_db": {
"type": "number"
}
},
"type": "object"
},
"dynamics": {
"additionalProperties": {
"type": "array"
},
"description": "Fader rides from written dynamics: {part name: [[onset_seconds, velocity 0-127], …]}. from_job fills it from the score (pp to ff ≈ 17 dB); pass {} for no rides.",
"type": "object"
},
"dynamics_carried": {
"additionalProperties": {
"type": "number"
},
"description": "{part name: top velocity} — parts whose stems already play their written level (a render part's dynamics_level receipt, up to its top_vel). Their rides count it: no doubled swing. from_job fills it.",
"type": "object"
},
"dynamics_ride": {
"description": "How hard the written dynamics move the faders: 1 = default (pp to ff ≈ 17 dB), 0 = no rides, up to 1.5.",
"type": "number"
},
"end_fade_s": {
"description": "With length_s: the fade at the program's end (0–10 s, default 0.5).",
"type": "number"
},
"from_job": {
"description": "MCP: a doseedo_render_score job_id — its parts are the stems, each with the instrument it plays, and each part's written dynamics (its mean velocity) set its balance. A render made from a BAND GENERATOR (render_score {generator}) is mixed in the style that generator names for its genre — a dub in its spring tank and tape echo, surf guitars in a spring, a fifties slapback — at the tempo it plays, unless you pass style.",
"type": "string"
},
"from_jobs": {
"description": "MCP: ONE cue rendered as several doseedo_render_score jobs (its parts split across renders): every job's parts are the stems, balanced and ridden by their written dynamics as one score.",
"items": {
"type": "string"
},
"type": "array"
},
"guitar_tone": {
"anyOf": [
{
"maxLength": 80,
"type": "string"
},
{
"additionalProperties": {
"maxLength": 80,
"type": "string"
},
"type": "object"
}
],
"description": "The guitars' and bass guitar's own SOUND. Every guitar and bass-guitar part (an upright played pizzicato too; never a synth bass or an 808) gets a tone by default (\"auto\"): a mixing chain for the style — compression, the amp's voicing and speaker, chorus / phaser / tremolo, its own echo and reverb, in stereo — fitted to that stem (drive only where the genre is driven, and less on a take that already came out amped; an acoustic gets EQ, compression and a room, never an amp; a bass stays centred and dry). \"none\" = as rendered (dry, mono). Or name one: a tone id, or words (\"surf\", \"dark trap loop\", \"80s chorus\") — for every guitar, or {part name: tone} for one. Tones — electric: clean-studio, pop-shimmer, funk-quack, funk-phaser, disco-chank, neo-soul, motown-soul, jazz-archtop, jazz-fusion, country-twang, country-ballad, surf-drip, desert-twang, rockabilly-slap, fifties-tweed, sixties-jangle, british-chime, psychedelic-swirl, soft-rock-phase, eighties-chorus, city-pop, new-wave-flange, post-punk-chorus, grunge-chorus, dream-pop, indie-jangle, math-rock-clean, emo-twinkle, reggae-skank, ska-upstroke, dub-skank, afrobeat-clean, soukous-sparkle, bachata-requinto, cumbia-psych, gospel-clean, rnb-smooth, edm-funk, hiphop-sample, lofi-tape, trap-ambient, ambient-swell, cinematic-clean, prog-clean, blues-edge, blues-lead, heartland-edge, indie-rock-edge, worship-dotted, post-rock, seventies-crunch, southern-rock, slide-delta, alt-rock-crunch, britpop-wall, grunge-rhythm, eighties-arena-lead, synthwave-lead, shoegaze-wash, pop-punk-rhythm, punk-raw, metal-rhythm, metal-lead, djent-tight, doom-fuzz, garage-fuzz · acoustic: acoustic-natural, acoustic-pop-strum, acoustic-fingerstyle, acoustic-intimate, acoustic-country, acoustic-bluegrass, acoustic-rock, acoustic-celtic, acoustic-12-string, acoustic-lofi, acoustic-cinematic, acoustic-hiphop-loop, acoustic-worship, acoustic-latin-strum, acoustic-blues, acoustic-gypsy-jazz · nylon: nylon-bossa, nylon-classical, nylon-flamenco, nylon-latin-pop, nylon-lofi, nylon-cinematic · steel: pedal-steel-country, pedal-steel-ambient, lap-steel-island · bass: bass-studio, bass-sixties-thump, bass-finger-funk, bass-slap, bass-picked-rock, bass-driven-rock, bass-metal, bass-dub, bass-jazz-electric, bass-fretless, bass-eighties-chorus, bass-hiphop, bass-lofi, bass-country, bass-indie, bass-dance, bass-latin, bass-cinematic · upright: upright-jazz, upright-slap, upright-folk, upright-sampled, upright-latin, upright-cinematic. The mix says what it chose and why: mixgraph.provenance.guitar_tones {part: {tone, why, read, drive}}; the chain is the strip's own (strips[].chain), editable like the rest."
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"length_s": {
"description": "The program's length (a :30 = 30; ≤ 600 s): the mix is cut there with end_fade_s (default 0.5 s); the room's tail never runs past it.",
"maximum": 600,
"minimum": 0.5,
"type": "number"
},
"loop": {
"additionalProperties": false,
"description": "Make the mix a LOOP that repeats seamlessly: {bars, bpm, beats_per_bar?} (the loop is bars × beats_per_bar × 60 / bpm seconds; beats_per_bar default 4) or {seconds}, 0.5–240 s. For music WRITTEN to come round (a game level, a menu, a waiting screen: nothing ending on the last bar — the game_town and game_dungeon generators are). Send the stems as rendered, their tails past the last bar included (a render runs ~2 s past its last note): whatever still sounds at the loop point (a note's release, the room) is carried over the loop's start, and the mix is played round until its rooms and compressors have settled. The mix (and every print) comes back EXACTLY that long, to the sample: output.loop {length_s, samples, sr, seam_db}. With print_parts each part is a loop of the same length — layers that stay in time. Not with dialogue, music_offset_s or length_s.",
"properties": {
"bars": {
"type": "number"
},
"beats_per_bar": {
"type": "number"
},
"bpm": {
"type": "number"
},
"seconds": {
"type": "number"
}
},
"type": "object"
},
"mix_job": {
"description": "MCP: a doseedo_mix job_id to edit — its whole stored mix (every ride) is the base, mixgraph is applied on top, and its stems are reused when you pass no from_job / stems.",
"type": "string"
},
"mixgraph": {
"description": "An edited mix — the mixgraph a doseedo_mix returned, changed — rendered against the same stems (from_job or stems). With mix_job: ONLY what you change (strips[] by stem, automation[] rides by target — points: [] removes one, buses[] by id, master) — the rest is that mix as stored. A mixgraph marked `partial` (its rides summarized) is refused without mix_job. Omit for a fresh mix.",
"type": "object"
},
"music_offset_s": {
"description": "Where bar 1 of the music sits on the picture (seconds, ≤ 600; the program ≤ 600 s): every music stem — and its rides — starts this late; the dialogue does not move.",
"maximum": 600,
"minimum": 0,
"type": "number"
},
"name": {
"description": "Optional: a name for this job's files, e.g. \"rainy-loop-3\". Every file it returns downloads as <name>_<part>.<ext> (rainy-loop-3_Celesta.wav, rainy-loop-3_rough-mix.wav; one take: rainy-loop-3.wav), so the user can find them. Give each job its own name (a second take: \"rainy-loop-3b\"). Default: doseedo-<last 6 characters of the job id>.",
"maxLength": 80,
"type": "string"
},
"print_parts": {
"description": "Also print every PART alone as its own stem: output.part_stems [{name, url}] — a 24-bit WAV per part (that player, their room and hall share, through the mix's own master), all the mix's length and summing to the mix: the LAYERS a game fades in and out over a looping mix, or stems an editor mutes one by one. Instead of print_sections, not with it. About twice the render. Per-part stems come with Pro: a free plan is handed the mix.",
"type": "boolean"
},
"print_sections": {
"description": "Also print every section as its own stem: output.section_stems [{name, members, url}] — a 24-bit WAV per section (its players, their room and hall share, through the mix's own master), and the dialogue as one; the prints add up to the mix (report.prints.sum_error_db). Sections are the mix's group buses (film-orchestral-sections: strings / woodwinds / brass / percussion / keys_harp; parts in none print as \"other\"). About twice the render time; no extra credits. Works with mix_job too.",
"type": "boolean"
},
"room": {
"anyOf": [
{
"enum": [
"studio",
"stage",
"hall",
"cathedral"
],
"type": "string"
},
{
"maximum": 1,
"minimum": 0,
"type": "number"
}
],
"description": "An orchestra's room: \"studio\" (intimate scoring stage, ~1.2 s, close), \"stage\" (~1.8 s), \"hall\" (the default scoring hall, ~2.3 s), \"cathedral\" (~4 s, wet) — or 0..1 between them. Sets the decay, size and how wet every seat sits."
},
"stems": {
"description": "[{name, audio_url, instrument?}] — the stems (≤ 32). instrument = the sound it plays (a doseedo_instruments id: \"violin\", \"timpani\", \"harp\"), which decides how it is mixed; without it the name decides.",
"items": {
"additionalProperties": false,
"properties": {
"audio_url": {
"type": "string"
},
"instrument": {
"type": "string"
},
"name": {
"type": "string"
}
},
"required": [
"name",
"audio_url"
],
"type": "object"
},
"type": "array"
},
"style": {
"description": "A mix style: an id or words (\"dry 90s rock\"). Pick it for the picture — the default (film-orchestral, a 2.3 s scoring hall) suits film drama, not every orchestra: film-orchestral-sections = the same hall, the strings and winds seated wider, a fader per section (buses[].fader_db); cartoon-studio = a cartoon / animation orchestra (a close, dry, wide scoring stage, punchy rides); golden-age-cartoon = a 1940s–50s cartoon (mono, small studio, tape); film-scoring-stage = intimate TV / documentary; concert-hall; film-epic-hybrid = trailer / action; cathedral-choral; classical-chamber; 2020s-tech-ad = a tech / product / brand film (sleek modern electronic, matched to official tech ads); or jazz-combo (a small jazz band), big-band (a big band, seated in sections), sports-broadcast (a sports theme: brass and drumline, close, bright and loud, matched to network sports themes), marching-band (a marching band or drum corps on the field), brass-band (a New Orleans street brass band, a trad-jazz band: dry, close, the sousaphone as the bass), motown-soul (a sixties soul band: the bass forward, the lead in front of horns, strings and voices), doo-wop (a vocal group in an echo chamber, narrow, the lead in front), a guitar band by its genre — rock-band, punk-rock, surf-rock, grunge-rock, metal-band, doom-metal, indie-rock, post-rock, shoegaze (each gives the guitars the amp of that genre) — blues-band, country-band, reggae-band, disco, ambient, 1970s-analog-rock, 2020s-pop … Every id: film-orchestral, film-orchestral-sections, film-scoring-stage, concert-hall, film-epic-hybrid, cathedral-choral, choral-chapel, stadium-crowd, classical-chamber, cartoon-studio, golden-age-cartoon, jazz-combo, jazz-strings, big-band, brass-band, marching-band, sports-broadcast, motown-soul, wall-of-sound, soul-ballad, funk-band, psychedelic-soul, neo-soul, gospel, doo-wop, disco, rock-n-roll, rock-band, punk-rock, surf-rock, grunge-rock, metal-band, doom-metal, indie-rock, post-rock, shoegaze, blues-band, country-band, reggae-band, dub, calypso-band, soca-band, zouk, dancehall, jazz-fusion, smooth-jazz, house-club, french-house, acid-house, hardstyle, big-beat, phonk, spaghetti-western, spy-film, ambient, country-pop, metal-modern, 1950s-mono, 1960s-lcr-pop, 1970s-analog-rock, 1970s-dub, 1980s-pop-gated, 1990s-rock-dry, 1990s-hiphop, boom-bap, jazz-rap, hardcore-hiphop, west-coast-hiphop, g-funk, lofi-hiphop, 2000s-loudness-rock, 2010s-edm, 2010s-trap, 2020s-pop, 2020s-hyperpop, 2020s-tech-ad",
"type": "string"
},
"target_lufs": {
"description": "Master loudness, -24..-6 LUFS (default: the style's — -18 for film-orchestral, -14 for the blind default). Met within ~0.3 LU (a loud target clips the shortest transients first); output.loudness says what landed, and why when short. With mix_job it re-masters the stored mix.",
"type": "number"
},
"tonal_match": {
"description": "Nudge the master toward professionally mixed orchestral references (default on for the orchestral styles). Its presence and air are judged only where the score is written loud (written_level), so a pp passage keeps its darkness.",
"type": "boolean"
},
"vintage": {
"description": "A period medium over any style, after the mix: \"tape\" = 7.5 ips tape (saturation, wow and flutter, a low hiss); \"shellac\" = a 78 played back (mono, ~90 Hz–5.5 kHz with the reproducer's presence, a 1.3 Hz wow, surface noise that swishes once a turn, crackle). \"none\" takes a style's own medium off (golden-age-cartoon carries tape). Its node (master.chain type vintage: noise_db, crackle, hi_hz …) is editable in the returned mixgraph.",
"enum": [
"tape",
"shellac",
"none"
],
"type": "string"
},
"without": {
"description": "MCP, with from_job / from_jobs: the parts LEFT OUT of this mix, by name (a section's name leaves out its players) — the same render mixed again without them: nothing is played again, every other part keeps its take.",
"items": {
"type": "string"
},
"type": "array"
},
"written_level": {
"description": "[[seconds, velocity], …] — the whole score's written level, the loudest part sounding, held until the next row (0 = nothing plays). The tonal match reads only the passages it writes loud (f and louder), so a pp passage keeps its darkness. from_job fills it.",
"items": {
"items": {
"type": "number"
},
"maxItems": 2,
"minItems": 2,
"type": "array"
},
"maxItems": 4096,
"type": "array"
}
},
"type": "object"
},
"name": "doseedo_mix",
"outputSchema": null
},
{
"description": "POLISH A MIX: a mix preset is a model trained on finished, professionally mixed recordings. It covers YOUR mix and folds what it hears back in by frequency range. preset: \"cinematic_score\" (the default) = a whole orchestral / film-score mix, the tone and width of a finished score moved onto yours, below 8 kHz, with none of the model's own audio heard. \"jazz_mix\" = the same for a JAZZ mix (a combo, bossa / latin jazz — what the jazz band generators play), trained on finished jazz records: use it for those in place of cinematic_score. \"big_band_mix\" = the same for a BIG BAND (saxes, trumpets, trombones and a rhythm section — what the big_band_* generators play), trained on big-band records alone: use it for a big band in place of jazz_mix. Input: audio_url (a doseedo_mix mix_url as returned) or audio_key, a stereo mix of up to 10 minutes. The preset brings its own strength; cns (0.1–0.5) overrides it: how much of your mix's own sound the model's take keeps (higher = closer to the input). Async: job_id → doseedo_wait_task (~15–90 s) → mix_url (the polished mix, WAV), take_url (the model's raw take) and report: balance_vs_input_db per band and side_vs_input_db (the width change). Cancel: the plane has no stop for a running mix preset — it runs to completion (credits spent), the job ends as canceled and its output is discarded. Only a job still queued at the plane is refunded by the plane's own failure refund.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"audio_key": {
"description": "R2 ingest key of an uploaded audio file (from doseedo_get_upload_url / POST /api/upload/r2/ingest-url; starts with \"ingest/\").",
"type": "string"
},
"audio_url": {
"description": "https URL of the audio, as an alternative to audio_key: a doseedo result URL exactly as a job returned it (a stem, a take, a bounce), or any public URL. The gateway fetches it (≤256 MB) into your account's ingest storage before the job starts. Pass audio_key OR audio_url.",
"type": "string"
},
"cns": {
"description": "The model's strength over the preset's own: how much of the input's own sound its take keeps (0.1–0.5, higher = closer to the input).",
"maximum": 0.5,
"minimum": 0.1,
"type": "number"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"name": {
"description": "Optional: a name for this job's files, e.g. \"rainy-loop-3\". Every file it returns downloads as <name>_<part>.<ext> (rainy-loop-3_Celesta.wav, rainy-loop-3_rough-mix.wav; one take: rainy-loop-3.wav), so the user can find them. Give each job its own name (a second take: \"rainy-loop-3b\"). Default: doseedo-<last 6 characters of the job id>.",
"maxLength": 80,
"type": "string"
},
"preset": {
"description": "The mix preset: \"cinematic_score\" (default) — a whole orchestral / film-score mix; \"jazz_mix\" — a jazz mix (combo, bossa, latin jazz); \"big_band_mix\" — a big band.",
"type": "string"
},
"seed": {
"description": "Optional random seed (default 7).",
"type": "number"
}
},
"type": "object"
},
"name": "doseedo_mix_preset",
"outputSchema": null
},
{
"description": "Estimate what a job will cost in credits BEFORE submitting it, and whether the connected account can afford it right now. Spends nothing. Pass the job (generate_music, generate_sound, generate_loop, cover_stem, edit_lyrics, fill_gap, render_midi, train_instrument, cover_song, separate_stems, split_soundtrack, transcribe, audio_to_session, convert_project, bounce_session, spot_video, score_to_picture, reframe_video, analyze_song, detect_chords, beat_grid, identify_sound, supervise_cues, analyze_midi, render_score, mix, mix_preset, session_from_stems, check_take) and the same args you would give the job tool (duration_seconds, models, instruments; for render_midi: notes + bpm / tempo_map or duration_seconds, voice_split / voices, takes — takes are free, voices cost one batch per ~6; for render_score: parts + bpm / tempo_map — planned exactly as the job plans it (lines, player rows, length), and `refused` says when the job would refuse it). The estimate follows the planes' own price table; the gate is authoritative and a refusal names the exact price.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"args": {
"additionalProperties": true,
"description": "The arguments you intend to pass to the job tool; only the price-relevant ones matter.",
"type": "object"
},
"job": {
"description": "Which job to price (a doseedo_ tool name or recipe verb is accepted too).",
"enum": [
"generate_music",
"generate_sound",
"generate_loop",
"cover_stem",
"edit_lyrics",
"fill_gap",
"render_midi",
"train_instrument",
"cover_song",
"separate_stems",
"split_soundtrack",
"transcribe",
"audio_to_session",
"convert_project",
"bounce_session",
"spot_video",
"score_to_picture",
"reframe_video",
"analyze_song",
"detect_chords",
"beat_grid",
"identify_sound",
"supervise_cues",
"analyze_midi",
"render_score",
"mix",
"mix_preset",
"session_from_stems",
"check_take"
],
"type": "string"
}
},
"required": [
"job"
],
"type": "object"
},
"name": "doseedo_quote",
"outputSchema": null
},
{
"description": "The named pipelines people actually ask for — stems, session (mix → DAW project), cover, transcribe, generate, render-midi (your notes played by an instrument model), custom-instrument (train your own from a recording), timbre-transfer (your notes, a recording's tone), sound-design (SFX / foley / one-shots), analyze-song (key/tempo/sections/chords), convert, bounce, and the compose-part guide (a part in the session's key at its tempo: analyze → you write the MIDI → place or render it) — each with its inputs, the tool calls in order, outputs, a credit/time estimate and how to VERIFY success from the response. Call with no name for the index (pick by use_when), or with a name for the full recipe. Read-only.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"name": {
"description": "A recipe name or alias, e.g. \"session\" / \"stems-to-session\". Omit to list all.",
"type": "string"
}
},
"type": "object"
},
"name": "doseedo_recipes",
"outputSchema": null
},
{
"description": "REFRAME A VIDEO: the same video in another frame, for where it is posted — 9:16 (stories, reels, shorts), 4:5 (a feed post), 1:1 (square) or 16:9 (a landscape master). fit \"fit\" (default) keeps the whole picture, centred over a blurred fill of itself, so nothing is cut (captions at the top or bottom of a vertical ad stay); \"fill\" scales to cover the frame and centre-crops the rest (the report says how much of the picture is kept). The sound is kept as it is (a scored film's mix untouched). Up to 1080 px on the short side (never upscaled past the source's), H.264 MP4. A video already in that frame is copied, not re-encoded. Input: video_key (an upload) or video_url (a doseedo_score_to_picture video as returned, or any public https URL). CPU, no credits. Async: job_id → doseedo_wait_task. Cancel: a re-frame still queued never starts and one running stops within seconds; either way its credit is refunded and the job ends as canceled.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"aspect": {
"description": "The frame: 9:16 (stories, reels, shorts), 4:5 (feed), 1:1 (square), 16:9 (landscape).",
"enum": [
"9:16",
"4:5",
"1:1",
"16:9"
],
"type": "string"
},
"fit": {
"description": "fit (default): the whole picture over a blurred fill, nothing cut. fill: cropped to fill the frame.",
"enum": [
"fit",
"fill"
],
"type": "string"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"name": {
"description": "Optional: a name for this job's files, e.g. \"rainy-loop-3\". Every file it returns downloads as <name>_<part>.<ext> (rainy-loop-3_Celesta.wav, rainy-loop-3_rough-mix.wav; one take: rainy-loop-3.wav), so the user can find them. Give each job its own name (a second take: \"rainy-loop-3b\"). Default: doseedo-<last 6 characters of the job id>.",
"maxLength": 80,
"type": "string"
},
"video_key": {
"description": "R2 ingest key of the video (from doseedo_get_upload_url).",
"type": "string"
},
"video_url": {
"description": "The video's URL: a doseedo_score_to_picture video as returned, or a public https URL.",
"type": "string"
}
},
"required": [
"aspect"
],
"type": "object"
},
"name": "doseedo_reframe_video",
"outputSchema": null
},
{
"description": "MIDI to audio, a virtual instrument: plays a part you wrote. An AI instrument model (orchestral strings, brass, woodwinds, piano, guitar, bass, drums, World) performs your exact notes, in your key, at your bpm, and returns audio takes. Input ONE of: notes[] ({pitch, start_beats, duration_beats, velocity} — beats from bar 1), midi_url (a .mid ≤2 MiB: a doseedo result link or a public https URL), or session_id + track_id (that track's notes, read from the session). Required: instrument (an entry's `call` from doseedo_instruments, no key — stay inside its range) and bpm. The notes are sent AS GIVEN — no pitch snapping, no quantizing. One voice per part: a chord part is rendered one voice per output with voice_split:true (result.voices maps each voice to its files and notes). Takes come back best-first (takes[0] = the scorer's winner). Async: job_id → doseedo_wait_task (~1–3 min). Result: takes[{url, rank, score}] (pre-signed: curl -OJ, no auth header, 24 h), seed, duration, voices?, refine?, chain. A take may miss or change a note — read takes[].check (measured against your notes) or listen; offer the takes, never promise note-perfection. Free harmony check first: doseedo_analyze_midi. DRUMS (GM notes): the drum model (default) PLAYS a kit — the sound of acoustic drums; it can drop a hit (takes[].fit.missing). drum_engine:\"oneshot\" = a programmed sampler kit for drum_genre (default for \"electronic\"/\"808\"), every hit as written — drum machines only; real drums (a kit, boom bap) stay on the model (drop a hit: take again). \"synth\" = a one-shot patch (synth_role, synth_genre; \"performed\" = played, less 1-shot); result.oneshots = the samples. SOUND: a preset (timbre_preset), a recording's tone (timbre_audio_url = timbre transfer; a drum kit too: a ride / snare recording), or YOUR OWN instrument (lora_id from doseedo_train_instrument; result.lora.applied). Cancel: a render that has not reached the GPU yet is stopped and its credits refunded; one already rendering finishes on the GPU (its credits are spent), the job ends as canceled and the output is discarded.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"articulation": {
"anyOf": [
{
"maxLength": 64,
"type": "string"
},
{
"items": {
"type": "object"
},
"maxItems": 512,
"type": "array"
},
{
"type": "object"
}
],
"description": "HOW the part is played, a passage at a time — no per-note work needed: a style for the whole part (\"legato\"), passages [{from, to, style?, dynamics?}] (beats from bar 1, [from, to)), or {style?, passages?, notes?: [{at, pitch?, style?, vibrato?, hairpin?, curve?, bend?}], curve?: [[beat, dB], …], unit?: \"beats\"|\"seconds\"}. Styles: legato tenuto portato staccato staccatissimo spiccato accent marcato sfz fp swell crescendo decrescendo espressivo molto_vibrato senza_vibrato breathy growl bright dark fall doit scoop gliss (aliases: slur, short, >, ^, sf, cresc, dim, subtone, glissando…; a list combines them). dynamics: \"mf\", or a hairpin over the span \"p<f\", \"f>p\", \"p<f>p\" (ppp…fff). curve = a RELATIVE level curve (±18 dB) added to every note under it: a master / section swell over existing dynamics. Any span or note may also set vibrato, vibrato_rate, bright, breath, rough (0–1) and attack (\"slur\" | \"tongue\" | 0–1); a note: hairpin \"<\" \">\" \"<>\", curve (its level 0–127 through it), bend (semitones through it). Later passages / notes win field by field; curves add. On an instrument with an articulation model (doseedo_instruments articulation) the part plays on that model (vibrato, colour, attacks, in-note shapes); elsewhere lengths, accents, dynamics, curves and bends still apply. On a GUITAR (electric, or a steel-string acoustic) a LINE (a lead, a riff, a fill: one note at a time) plays on its model: bright is the drive (0 clean, straight into the board … 1 driven) and attack is the pick (0 a hammer-on or pull-off … 1 a hard pick); a chord part keeps the preset's own playing. SOLO: \"solo\" (or solo: true on the map) plays the part as a soloist — vibrato grows into its sustained notes after the attack, a sustained note before a rest dies away instead of stopping, it breathes in its rests; render_score does this by itself for the ONE melodic line sounding while it plays (solo: false stops it; solo: {vibrato?, vibrato_rate? 0–1, delay?, min_note?, tail? seconds} tunes it). Receipt: articulation {model, played_by, marked, styles, solo?: {by, played, vibrato, tails}}."
},
"bpm": {
"description": "REQUIRED (or tempo_map). Tempo of the notes (10–400). Written into the MIDI's tempo meta, so start_beats/duration_beats land at exactly this tempo.",
"type": "number"
},
"drum_engine": {
"description": "Who plays a drum part: \"model\" = the drum model (the default for every kit but electronic / 808): a drummer playing the kit in a room — cymbals ring, hits vary, ghost notes speak; the sound for acoustic drums. It can drop or smear a hit: read takes[].fit and take it again. \"oneshot\" = a sampler kit made for drum_genre (the default for electronic / 808; congas and bongos are recordings of the skins): every note lands exactly as written, but it sounds programmed (one sample per drum, the same on every hit) — for drum-machine genres only. An acoustic kit (drum_kit: rock, punk, jazz, soul, a band seen playing) stays on the model, never oneshot — and so does a real-drums drum_genre on whatever kit, which plays on drum_kit (funk, boom bap, lo-fi, breakbeat: a sampled break is a drummer; its dust comes from the mix, doseedo_mix style \"1990s-hiphop\" / \"lofi-hiphop\"; the submit reply says so, prepared.drums). A take that drops a hit is taken again (takes: 3, keep the best). Its pads (GM): kick 35/36, snare 38/40, rim 37, clap 39, hats 42/44/46, toms 41–50, crash 49/57, ride 51/59, tambourine 54, cowbell 56, bongos 60/61, congas 62–64, shaker 69/70/82, guiro 73/74, claves 75, woodblock 76/77, triangle 80/81.",
"enum": [
"oneshot",
"model"
],
"type": "string"
},
"drum_genre": {
"description": "The drum style. A drum machine (instrument \"electronic\" or \"808\"): the genre whose one-shot kit plays the part — \"house\", \"techno\", \"trap\", \"drill\", \"dnb\", \"amapiano\", \"synthwave\"… or free words. \"tech\" = the modern product-film sound (trap / electronic / pop, clean and minimal): a synthesized drum machine, its kick tuned to `key`, nothing generated. A real-drums style (\"boom bap\", \"lo-fi\", \"breakbeat\", \"funk\", \"rock\", \"jazz\"…) plays on the drum model's drum_kit instead, never a one-shot kit. Default: the instrument.",
"type": "string"
},
"duration_seconds": {
"description": "Length of the render in seconds (0.01–600). Default: the last note's end + 2 s of release. Each 30 s window costs 10 credits.",
"type": "number"
},
"dynamics": {
"description": "One target dynamic for the whole part's tone: \"pp\", \"p\", \"mp\", \"mf\", \"f\", \"ff\", \"fff\", a 0–1 number, or a MIDI velocity as text. Omit it to let the notes' velocities shape the tone (dynamics_curve).",
"type": "string"
},
"dynamics_curve": {
"description": "What colours the TONE over time: omitted/\"auto\" = the note velocities when they vary (soft notes darker, loud brighter — every instrument but drums, LoRAs included); \"off\" = one colour; \"cc11\"/\"cc1\" = that CC lane of a midi_url; or \"pos:level,…\" (pos and level 0–1, e.g. \"0:0.1,1:0.9\" = a crescendo). Receipt: result.dynamics.",
"type": "string"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"instrument": {
"description": "REQUIRED. The instrument from doseedo_instruments — its `call.instrument` (e.g. \"violin\", \"tenor_sax\", \"electric_guitar\", \"piano\"; a World name such as \"koto\" is resolved to its call). Keep the notes inside its range. An unknown name close to a catalog one is refused with did_you_mean before anything is spent.",
"type": "string"
},
"key": {
"description": "The music's key (\"D minor\", \"F#\", \"Bb major\"). A synthesized drum machine (drum_genre \"tech\") tunes its kick and toms to it.",
"maxLength": 24,
"type": "string"
},
"lora_id": {
"description": "A CUSTOM INSTRUMENT: the lora_id doseedo_train_instrument returned (16 hex). The render is played by that trained instrument; pass the same instrument it was trained as. Owner-only.",
"type": "string"
},
"lora_strength": {
"description": "With lora_id (or synth_engine \"performed\"): how strongly the custom instrument applies, 0–2 (default 1.0, or a tuned per-adapter default; ~0.6 when a small training set overshoots; performed synth 0.5 — up to ~0.75 plays it looser, past that it starts leaving the notes).",
"type": "number"
},
"lyrics": {
"description": "A SUNG part (instrument \"voice\" — a solo singer — or \"choir\"): the words, one syllable per note in time order (\"Hold the light a lit-tle lon-ger\": hyphens split a word where you want, \"_\" holds a syllable over the next note; one word such as \"Ah\" is sung on every note). ≤ 2000 characters. Without it a sung part sings \"Ooh\". Any other instrument: an error.",
"maxLength": 2000,
"type": "string"
},
"midi_url": {
"description": "Alternative to notes: https URL of a Standard MIDI File (≤2 MiB) — a doseedo result link (a stem's MIDI) or a public URL. Its own tempo map is used by the model; bpm still tags the caption and sizes the default duration.",
"type": "string"
},
"name": {
"description": "Optional: a name for this job's files, e.g. \"rainy-loop-3\". Every file it returns downloads as <name>_<part>.<ext> (rainy-loop-3_Celesta.wav, rainy-loop-3_rough-mix.wav; one take: rainy-loop-3.wav), so the user can find them. Give each job its own name (a second take: \"rainy-loop-3b\"). Default: doseedo-<last 6 characters of the job id>.",
"maxLength": 80,
"type": "string"
},
"notes": {
"description": "The part, as note rows in beats from bar 1 (beat 0 = bar 1 beat 1, quarter-note beats at `bpm`). Monophonic for one voice; chords need voice_split:true. Up to 4096 notes.",
"items": {
"additionalProperties": false,
"properties": {
"duration_beats": {
"description": "Length in beats (> 0).",
"type": "number"
},
"lyric": {
"description": "A SUNG part (instrument \"voice\" or \"choir\"): the syllable this note sings — \"glo-\" (more of the word follows), \"a\", a whole word, or \"_\" to hold the previous syllable over this note. Placed exactly (wins over `lyrics`); a note without one sings no word of its own.",
"type": "string"
},
"pitch": {
"description": "MIDI note number 0–127 (60 = middle C).",
"type": "number"
},
"start_beats": {
"description": "Onset in beats from bar 1.",
"type": "number"
},
"velocity": {
"description": "1–127 (default 96).",
"type": "number"
}
},
"required": [
"pitch",
"start_beats",
"duration_beats"
],
"type": "object"
},
"type": "array"
},
"prompt": {
"description": "Optional caption override (default: the instrument id), ≤ 16000 characters. Style words help a little; the notes are the control.",
"maxLength": 16000,
"type": "string"
},
"refine": {
"description": "Opt-in post-render correction. \"light\": attacks re-timed onto the score, exposed wrong pitch classes re-pitched inside the played octave, misfires muted (winds/brass/strings). \"shred\": play exactly the written line, octave included, mute anything the score never wrote (any pitched mono part). The raw render stays downloadable (result.refine.raw_url).",
"enum": [
"light",
"shred"
],
"type": "string"
},
"revise_end_beats": {
"description": "With revise_take_url: end of the region to redo (exclusive), beats from bar 1.",
"type": "number"
},
"revise_start_beats": {
"description": "With revise_take_url: start of the region to redo, beats from bar 1.",
"type": "number"
},
"revise_take_url": {
"description": "REVISE an earlier take instead of rendering a new one: the take's URL (as a render returned it). Only [revise_start_beats, revise_end_beats) is regenerated — steered by `notes` (send the whole part, with your corrections) — and spliced back with short crossfades; the rest of the take is kept as it was.",
"type": "string"
},
"seed": {
"description": "Random seed (−1 or 0–4294967295). Reuse a result's seed to re-render close to the same take.",
"type": "number"
},
"session_id": {
"description": "Alternative to notes: with track_id, render THAT session track's notes (read from doseedo_get_session's summary).",
"type": "string"
},
"synth_engine": {
"description": "Who plays a synth part: \"oneshot\" = a patch of one-shots made for it (the default for \"synth\"; every note the same sample), \"performed\" = that same patch (synth_role / synth_genre / synth_words pick it) played by the synth model trained on real synth loops — each note its own, the tone moving, the written notes kept (lora_strength 0.5 default; seed = another performance), and with timbre_audio_url (a reference track's bass / lead / pad stem) the patch is CUT FROM THAT RECORDING's own notes and the synth model performs it — the default for a synth part that brings a recording: your notes, its sound (result.synth_engine.patch_engine \"reference-patch\"; lora.error = no single note could be cut, the model played it with the recording as its timbre); \"oneshot\" with timbre_audio_url plays that cut patch exactly as written with no model pass (the default for role 808: the synth model loses a sub's pitches), \"model\" = the instrument model alone.",
"enum": [
"oneshot",
"performed",
"model"
],
"type": "string"
},
"synth_genre": {
"description": "instrument \"synth\": the genre the patch is made for — \"house\", \"techno\", \"trap\", \"synthwave\", \"lo-fi\", \"dnb\"… or free words. \"tech\" = the modern product-film sound: a computed synth voice (a sine sub that glides, a dark pluck, a filtered pad), exactly in tune, every note as written — synth_words still turn it (\"dark\", \"bright\", \"driven\", \"short\", \"wide\").",
"type": "string"
},
"synth_patch": {
"description": "instrument \"synth\": a SAMPLED patch in place of the genre's computed voice — recorded notes played by a sampler, every note as written. \"<pack>:<patch>\": a hardware synth preset by id or name (\"xv5080:PR-C/056\", \"xv5080:JUNO Strings\"), or a pitched pack by name (\"bass808\" = a recorded 808, chosen by synth_words: long / short, deep / distorted). A patch the server cannot read plays the computed voice (the receipt's synth_engine says which).",
"maxLength": 100,
"type": "string"
},
"synth_role": {
"description": "instrument \"synth\": the patch Stable Audio Open makes for the part — bass (an 808 where the genre's bass is one), 808, pad, lead, pluck. Default: from the notes (chords = pad, a low line = bass, else lead).",
"enum": [
"bass",
"808",
"pad",
"lead",
"pluck"
],
"type": "string"
},
"synth_words": {
"description": "instrument \"synth\": extra sound words for the patch (\"reese\", \"warm analog\", \"acid\"), ≤ 80 characters (a longer one is cut at a word boundary, with a warning).",
"maxLength": 80,
"type": "string"
},
"takes": {
"description": "How many takes to render, 1–4 (one GPU batch; no extra credits). Omit to let the server choose best-of-N for the part length.",
"type": "number"
},
"tempo_map": {
"description": "Tempo CHANGES for the notes: [{beat, bpm}] — each point holds from its beat (beats from bar 1) until the next; the first point is beat 0 (or bpm covers the beats before it). Written into the MIDI, so a ritardando or a tempo that lands a cue on a film hit plays exactly. doseedo_tempo_map builds one from hit times.",
"items": {
"additionalProperties": false,
"properties": {
"beat": {
"type": "number"
},
"bpm": {
"type": "number"
}
},
"required": [
"beat",
"bpm"
],
"type": "object"
},
"type": "array"
},
"timbre_audio_url": {
"description": "TIMBRE TRANSFER: https URL of a short recording (≤24 MB; its first 30 s are used) whose SOUND the render should take on — a doseedo result link or a public URL. The notes stay yours; the tone comes from the recording.",
"type": "string"
},
"timbre_preset": {
"description": "A preset from doseedo_instruments — an entry's call.timbre_preset or presets[].call.timbre_preset (e.g. \"violin:pizz\", \"sax:alto\", \"koto:preset1\"). Omit for the instrument default.",
"type": "string"
},
"time_signature": {
"description": "Meter of the part, e.g. \"4/4\", \"3/4\", \"6/8\" (default 4/4). Written into the MIDI and the caption.",
"type": "string"
},
"track_id": {
"description": "With session_id: the t_… id of the MIDI/instrument track to render.",
"type": "string"
},
"tune": {
"description": "Light intonation (default true): a held, clearly pitched note the model rendered 15–85 cents off its written pitch is moved toward it, to a small natural residual — attack and vibrato as played, fast notes left. Winds, brass and strings. false = the take exactly as rendered.",
"type": "boolean"
},
"vaefix": {
"description": "VAE spectral corrector (default true): trims the low-mid fog the decoder adds under the instrument's register and removes mic hiss only when the take carries it. Winds, brass and strings. Receipt: vaefix. false = the decode exactly as rendered.",
"type": "boolean"
},
"voice_split": {
"description": "true = the notes hold chords: split them into the voices one player of this instrument can hold and render every voice (result.voices). A SUNG chord (choir, voice) is sung one stem per voice, each in its register, one take each. Default false (a chord in a mono part is an error the model will fudge).",
"type": "boolean"
}
},
"required": [
"instrument"
],
"type": "object"
},
"name": "doseedo_render_midi",
"outputSchema": null
},
{
"description": "Plays a whole arrangement you wrote in one call — film scoring, orchestral arrangement, background music, a song or instrumental (a film cue, a string quartet, a big-band chart): each part played by its doseedo instrument, one stem per part from bar 1 at your tempo, plus a summed mix. Input ONE of: parts[] ({name, instrument, timbre_preset?, lora_id?, players?, notes[]} — doseedo_instruments calls), midi_url (multi-track SMF), or musicxml_url (notation played as marked, at concert pitch). A file's parts are matched by name, then GM program; name any part with instruments {\"<part name or index>\": {instrument, timbre_preset?, players?}}. A chord on a one-line instrument is split into voices (one stem each). ★ SECTIONS: an instrument is ONE player; give a part players: N (2–8) and its line is played by N different players, summed into ONE section stem — an orchestra = violins I / II, violas, cellos, basses as five parts with players 6 / 6 / 4 / 4 / 3, horns 2–4 in unison; a choir = S/A/T/B parts on \"choir\" (Solo, \"choir:trio\", \"choir:m2\" or YOUR singer: parts[].timbre_audio_url), which SINGS parts[].lyrics (\"Ooh\" without), players 4–8 (recipe \"choir\"); a solo: no players. The WHOLE orchestra in one call: ≤ 32 lines and ≤ 96 player rows (players: N = N rows), any instruments together, ≤ 600 s. Drums: the drum model is a real kit, drum_engine \"oneshot\" a drum machine. Synths: synth_role + synth_genre. Timing: bpm and/or tempo_map ([{beat, bpm}]; doseedo_tempo_map lands film hits on downbeats). Result: parts[{name, instrument, url, fit, timbre, lora, players}] — fit.verdict / coverage = did it PLAY its notes (a failed part is re-rolled once; fit.rolls.missed = a roll not played as one), lora.applied = its adapter played — plus mix_url. Next: doseedo_mix {from_job}, then doseedo_session_from_stems {from_job, mix_job}. Async: job_id → doseedo_wait_task (~1–4 min). Cancel: a render that has not reached the GPU yet is stopped and its credits refunded; one already rendering finishes on the GPU (its credits are spent), the job ends as canceled and the output is discarded.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"articulation": {
"anyOf": [
{
"maxLength": 64,
"type": "string"
},
{
"items": {
"type": "object"
},
"maxItems": 512,
"type": "array"
},
{
"type": "object"
}
],
"description": "The SCORE-WIDE articulation layer, under every part's own (parts[].articulation / instruments rows, applied after it): a master curve or a tutti passage legato for all. Same shape as parts[].articulation: HOW the part is played, a passage at a time — no per-note work needed: a style for the whole part (\"legato\"), passages [{from, to, style?, dynamics?}] (beats from bar 1, [from, to)), or {style?, passages?, notes?: [{at, pitch?, style?, vibrato?, hairpin?, curve?, bend?}], curve?: [[beat, dB], …], unit?: \"beats\"|\"seconds\"}. Styles: legato tenuto portato staccato staccatissimo spiccato accent marcato sfz fp swell crescendo decrescendo espressivo molto_vibrato senza_vibrato breathy growl bright dark fall doit scoop gliss (aliases: slur, short, >, ^, sf, cresc, dim, subtone, glissando…; a list combines them). dynamics: \"mf\", or a hairpin over the span \"p<f\", \"f>p\", \"p<f>p\" (ppp…fff). curve = a RELATIVE level curve (±18 dB) added to every note under it: a master / section swell over existing dynamics. Any span or note may also set vibrato, vibrato_rate, bright, breath, rough (0–1) and attack (\"slur\" | \"tongue\" | 0–1); a note: hairpin \"<\" \">\" \"<>\", curve (its level 0–127 through it), bend (semitones through it). Later passages / notes win field by field; curves add. On an instrument with an articulation model (doseedo_instruments articulation) the part plays on that model (vibrato, colour, attacks, in-note shapes); elsewhere lengths, accents, dynamics, curves and bends still apply. On a GUITAR (electric, or a steel-string acoustic) a LINE (a lead, a riff, a fill: one note at a time) plays on its model: bright is the drive (0 clean, straight into the board … 1 driven) and attack is the pick (0 a hammer-on or pull-off … 1 a hard pick); a chord part keeps the preset's own playing. SOLO: \"solo\" (or solo: true on the map) plays the part as a soloist — vibrato grows into its sustained notes after the attack, a sustained note before a rest dies away instead of stopping, it breathes in its rests; render_score does this by itself for the ONE melodic line sounding while it plays (solo: false stops it; solo: {vibrato?, vibrato_rate? 0–1, delay?, min_note?, tail? seconds} tunes it). Receipt: articulation {model, played_by, marked, styles, solo?: {by, played, vibrato, tails}}."
},
"bpm": {
"description": "Tempo of the parts (10–400). Required with parts[] unless tempo_map is given; on a file it sets the speed and keeps the score's fermatas / rit. / tempo changes.",
"type": "number"
},
"duration_seconds": {
"description": "Render length (default: the last note + 2 s; ≤ 600).",
"type": "number"
},
"generator": {
"description": "Alternative to parts: a BAND GENERATOR plays the piece — no notes written by you. Its id (\"jazz\") or {id, seed?, bars? | seconds?, key?, lead?, band?, theme?, changes?, song?, only?, dynamics?, hits?, lay_out?, thin?, texture?, builds?, ending?, intro?, swing?, solo_swing?}: the generator writes every part (drums, bass, piano and a lead for jazz — lead: \"none\" = the rhythm section alone, a bed under dialogue; \"scat\" = sung) in its genre, with its own form and changes, at this call's bpm / tempo_map; length = bars, or seconds, or duration_seconds. DIRECT it in seconds from the piece's start (turned into beats on your tempo_map) or in beats: dynamics [{at_seconds, level: none|low|medium|high|peak, ramp?}] — the band follows it bar by bar; ramp: true = the level is REACHED there, moving evenly from the mark before (a crescendo, a falling away); hits [{at_seconds, kind?: light|medium|full}] — the band lands that moment together (a cut, a punchline): full = everyone with a crash, medium = the rhythm section, light = one stroke; who = only those parts land it, stroke = the one drum of the kit that sounds (kick, snare, rim, clap, hat, open hat, crash, tom, high tom, floor tom); lay_out [{from_seconds?, to_seconds?, who?, only?}] — who RESTS where: no name = the lead (dialogue) while the rhythm section plays on; who = the parts that rest (a part's name, a family — strings, brass, winds, keys, percussion — \"rhythm\", \"lead\", \"all\" for a silence — a hit on its first beat is the stop chord, choked); only = the parts that play on while everyone else rests; no from_seconds = from the start (a part ENTERING at to_seconds), no to_seconds = to the end (a part LEAVING); thin [{from_seconds?, to_seconds?, to?: beats|halves|bars, who?}] — who plays THINNER there (under a voice, a low stretch): the named parts, or everyone but the tune, keep only what they play on the beat, on the bar's two halves, or on the bar line; texture [{from_seconds?, to_seconds?, who, plays? | level?, value?}] — WHAT a part plays there (whole bars), always the style's own writing for that part: plays held (a pad) | pedal (a drone) | pulse | arpeggio | ostinato | walk | stabs | comp | line, a drum part four_on_the_floor | backbeat | half_time | ride | light | full, value eighths | sixteenths … for an even one; the part's bars are replaced by bars the style wrote for it over the same chords (these bars at another level, or another stretch of the piece) that ARE that texture; level instead of plays = the part as the style plays it at that level while the band stays where it is. A texture the style does not play on that part is not applied — the answer's direction.texture says what the part can play (doseedo_generators {direction: {textures: true}} lists it up front); builds [{into_seconds, beats?, drop?}] — a build into a moment: everyone swells and the drums roll over the beats before it (one bar by default), drop: true = the bass and bass drum leave the last beat empty; ending {kind: cut|button|ring|fade, at_seconds?} — cut = nothing sounds from there on (a hard out), button = one short hit and nothing after, ring = a last chord held to the end, fade = the band falls away into a soft held chord; intro: false — it starts on the tune. YOUR OWN BAND: band [{instrument, timbre_preset?, name?, chair?: drums|bass|comp|lead|extra, players?}] — who is seated, in place of the generator's own players, each as a part takes it (doseedo_instruments): the style is written for THESE instruments and each comes back called exactly so. A player the style has no chair for is a guest (guests in the answer): it plays only what you give it — the theme, where a statement names it. YOUR OWN MUSIC, arranged by the generator (a score's theme and chords): theme {notes: [[pitch, beat, beats, velocity], …], statements?, also?} — the tune, beats from its first bar line; the generator's own tune comes out and yours goes in, every note as written. With no statements it is said wherever the generator's tune was, on whoever had it; statements [{at_seconds, on?, from_beat?, beats?, octave?, transpose?, stretch?, name?}] say where and by whom (on = part names as lay_out takes them; from_beat / beats = a part of it — its head, a fragment; octave; transpose in semitones; stretch 2 = notes twice as long; name = another tune from also {name: notes}). changes \"Dm | Bb | Gm | A\" — your chords, one cell a bar (\"Dm G7\" = two in a bar), as a loop, or [{at_seconds, changes}]; played bar after bar as given, so a statement placed on the loop's first bar is over its first chord. A theme with no changes is HARMONISED (the chords go to the tune; the tune is never changed), in key or the key the tune is in. FEEL (swung styles; left out, each piece and soloist draws its own as records do): swing light|medium|hard — the band's eighths; solo_swing straight|light|medium|hard — the soloist's (\"straight\" = even eighths laid back over the swing). STYLE TRANSFER — song: {melody: [[pitch, beat, beats], …], changes: \"C | Am | F | G7\" (one cell a bar, the WHOLE song), sections: [{label, bars}], meter?, bpm?, key?} plays YOUR SONG in this genre and keeps it exactly: its length, its sections, its chart bar for bar and every note of its tune from bar one; the generator decides only how its chairs play it (lead: \"none\" = the genre's band without the tune). A melody alone is harmonised; chords alone get the genre's own tune; parts: [{name, notes}] (a MIDI arrangement) is read for its tune and chart. A genre in another metre (a waltz, 6/8, 12/8) plays the song re-metered by the meter-change rule and says what moved. only: \"bass\" | [\"bass\", \"drums\"] returns just those parts — the genre's line for one stem, written with the whole band. The same seed is the same piece: doseedo_generators {generator, …} shows it (free) before you render. Result: parts as for any score, plus generator {id, seed, bars, key, form, changes, direction: what was applied, song: what was kept}.",
"oneOf": [
{
"maxLength": 60,
"type": "string"
},
{
"additionalProperties": false,
"properties": {
"band": {
"type": "array"
},
"bars": {
"type": "number"
},
"builds": {
"type": "array"
},
"changes": {
"type": [
"string",
"array"
]
},
"dynamics": {
"type": "array"
},
"ending": {
"type": [
"string",
"object"
]
},
"hits": {
"type": "array"
},
"id": {
"maxLength": 60,
"type": "string"
},
"intro": {
"type": "boolean"
},
"key": {
"maxLength": 40,
"type": "string"
},
"lay_out": {
"type": "array"
},
"lead": {
"maxLength": 40,
"type": "string"
},
"only": {
"type": [
"string",
"array"
]
},
"seconds": {
"type": "number"
},
"seed": {
"type": "number"
},
"solo_swing": {
"type": [
"string",
"number"
]
},
"song": {
"type": "object"
},
"swing": {
"type": [
"string",
"number"
]
},
"texture": {
"type": "array"
},
"theme": {
"type": [
"object",
"array"
]
},
"thin": {
"type": "array"
}
},
"required": [
"id"
],
"type": "object"
}
]
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"instruments": {
"description": "Name the instrument for any part: {\"Violin I\": {\"instrument\": \"violin\", \"players\": 6}, \"2\": {\"instrument\": \"acoustic_guitar\", \"timbre_preset\": \"koto:preset1\"}, \"Choir\": {\"instrument\": \"choir\", \"players\": 6, \"lyrics\": \"Glo-ri-a\"}} — key = the part name or its 0-based index; players makes a MIDI / MusicXML part a section, lyrics gives a sung part its words (as parts[].lyrics), timbre_audio_url / timbre_audio_urls its own singer or sound (as parts[]: {\"Soprano\": {\"timbre_audio_url\": \"https://…/singer.wav\"}}), drum_engine \"oneshot\" (+ drum_genre) plays a file's drum part on a one-shot kit ({\"Drums\": {\"drum_engine\": \"oneshot\"}} — no instrument keeps the part's own). Wins over the name/program match.",
"type": "object"
},
"midi_url": {
"description": "Alternative to parts: a multi-track Standard MIDI File (≤ 2 MiB) — a doseedo result link or a public https URL. Channel 10 = drums: the kit, or the one percussion instrument a part is named for (Bass Drum, Cymbals, Bass Drum & Cymbals, Triangle…). A track's CC11 lane (CC1 on a wind / brass / string / bass part) is its written dynamics: a held note swells as it says.",
"type": "string"
},
"mix": {
"description": "Ignored: every render bounces a summed mix of its parts (mix_url) — on a free plan the mix is what the render hands back.",
"type": "boolean"
},
"musicxml_url": {
"description": "Alternative to parts: a MusicXML score (.musicxml / .xml / .mxl, ≤ 8 MiB) exported from Dorico, Sibelius, Finale, MuseScore, or written by you — or a MuseScore file itself (.mscz / .mscx), read with all its markings.",
"type": "string"
},
"name": {
"description": "Optional: a name for this job's files, e.g. \"rainy-loop-3\". Every file it returns downloads as <name>_<part>.<ext> (rainy-loop-3_Celesta.wav, rainy-loop-3_rough-mix.wav; one take: rainy-loop-3.wav), so the user can find them. Give each job its own name (a second take: \"rainy-loop-3b\"). Default: doseedo-<last 6 characters of the job id>.",
"maxLength": 80,
"type": "string"
},
"parts": {
"description": "The parts you wrote: [{name?, instrument, timbre_preset?, lora_id?, players?, lyrics?, notes:[{pitch, start_beats, duration_beats, velocity?, lyric?}], dynamics?}] — beats from bar 1, concert pitch. lyrics / lyric: a choir part's words. instrument/timbre_preset = a doseedo_instruments call. players = how many play the line: 1 (default) a soloist, 2–8 a SECTION (e.g. Violins I players 6).",
"items": {
"additionalProperties": false,
"properties": {
"articulation": {
"anyOf": [
{
"maxLength": 64,
"type": "string"
},
{
"items": {
"type": "object"
},
"maxItems": 512,
"type": "array"
},
{
"type": "object"
}
],
"description": "HOW the part is played, a passage at a time — no per-note work needed: a style for the whole part (\"legato\"), passages [{from, to, style?, dynamics?}] (beats from bar 1, [from, to)), or {style?, passages?, notes?: [{at, pitch?, style?, vibrato?, hairpin?, curve?, bend?}], curve?: [[beat, dB], …], unit?: \"beats\"|\"seconds\"}. Styles: legato tenuto portato staccato staccatissimo spiccato accent marcato sfz fp swell crescendo decrescendo espressivo molto_vibrato senza_vibrato breathy growl bright dark fall doit scoop gliss (aliases: slur, short, >, ^, sf, cresc, dim, subtone, glissando…; a list combines them). dynamics: \"mf\", or a hairpin over the span \"p<f\", \"f>p\", \"p<f>p\" (ppp…fff). curve = a RELATIVE level curve (±18 dB) added to every note under it: a master / section swell over existing dynamics. Any span or note may also set vibrato, vibrato_rate, bright, breath, rough (0–1) and attack (\"slur\" | \"tongue\" | 0–1); a note: hairpin \"<\" \">\" \"<>\", curve (its level 0–127 through it), bend (semitones through it). Later passages / notes win field by field; curves add. On an instrument with an articulation model (doseedo_instruments articulation) the part plays on that model (vibrato, colour, attacks, in-note shapes); elsewhere lengths, accents, dynamics, curves and bends still apply. On a GUITAR (electric, or a steel-string acoustic) a LINE (a lead, a riff, a fill: one note at a time) plays on its model: bright is the drive (0 clean, straight into the board … 1 driven) and attack is the pick (0 a hammer-on or pull-off … 1 a hard pick); a chord part keeps the preset's own playing. SOLO: \"solo\" (or solo: true on the map) plays the part as a soloist — vibrato grows into its sustained notes after the attack, a sustained note before a rest dies away instead of stopping, it breathes in its rests; render_score does this by itself for the ONE melodic line sounding while it plays (solo: false stops it; solo: {vibrato?, vibrato_rate? 0–1, delay?, min_note?, tail? seconds} tunes it). Receipt: articulation {model, played_by, marked, styles, solo?: {by, played, vibrato, tails}}."
},
"break_plan": {
"description": "With drum_engine \"break\": the chops — {figure?: \"amen\", events: [[at, src, len, gain?, flags?, rate?], …]}: `len` sixteenths of the break from its step `src` (0–127) laid at sixteenth `at` of the piece (fractions allowed); flags 1 = reversed, 2 = far (heard through a high-pass); rate = an extra pitch-up. A band generator writes it; omit it to have the part's own drum notes pick the slices.",
"type": "object"
},
"drum_engine": {
"description": "A drum / percussion part: \"model\" (default) = the drum model — a drummer playing the kit in a room (cymbals ring, hits vary, ghost notes speak): the sound for any acoustic kit, rock to jazz to a film cue. A take may drop or add a hit (parts[].fit.voices: missing / extra): render the part again for another take. \"oneshot\" = a one-shot kit generated for drum_genre, one sample per drum: every written hit lands exactly as written (a half-time bar stays half-time, a stop-time hit stays a hit), but it sounds programmed — the kit for electronic / drum-machine genres only (house, trap, 808). An acoustic kit (drum_kit: rock, punk, jazz, soul, a band seen playing) stays on the model, never oneshot — and a kit whose drum_genre is real drums (funk, boom bap, lo-fi, breakbeat: a sampled break is a drummer; its dust comes from the mix, doseedo_mix style \"1990s-hiphop\" / \"lofi-hiphop\") plays on drum_kit whatever is asked (warnings say so). A take that drops a hit is rendered again. Its pads (GM): kick 35/36, snare 38/40, rim 37, clap 39, hats 42/44/46, toms 41–50, crash 49/57, ride 51/59, tambourine 54, cowbell 56, bongos 60/61, congas 62–64, shaker 69/70/82, guiro 73/74, claves 75, woodblock 76/77, triangle 80/81. \"break\" = a chopped BREAK, the way jungle and drum and bass make their drums: an acoustic break from the break library, sped up to the piece and sliced — by break_plan, or with no plan by the part's own drum notes (each note plays the slice that starts with that drum). A kit part only.",
"enum": [
"model",
"oneshot",
"break"
],
"type": "string"
},
"drum_genre": {
"description": "With drum_engine \"oneshot\": the kit's genre / words, e.g. \"house\", \"techno\", \"trap\", \"synthwave\": a dry drum-machine kit. A real-drums genre (\"boom bap\", \"lo-fi\", \"breakbeat\", \"funk\") puts the part on the drum model's drum_kit. Default: the instrument.",
"type": "string"
},
"dynamics": {
"description": "The part's written LEVEL over time, as a DAW automation lane: [{beat, velocity 1–127}] in beat order, linear between points, a step = two points on one beat, held after the last (p 52, mf 80, f 96, ff 112). A velocity says how a note STARTS; this says how it goes on — a crescendo on a held note: [{beat: 0, velocity: 52}, {beat: 8, velocity: 96}]. Its tone follows it, through a held note too, and doseedo_mix {from_job} rides the level to it. A MusicXML score's dynamics + hairpins arrive as this lane on their own.",
"items": {
"additionalProperties": false,
"properties": {
"beat": {
"type": "number"
},
"velocity": {
"type": "number"
}
},
"required": [
"beat",
"velocity"
],
"type": "object"
},
"type": "array"
},
"dynamics_curve": {
"description": "What colours this part's TONE over time: auto (default) = its dynamics lane when that moves, else its note velocities when they vary — soft darker, loud brighter, on every instrument but drums; off = one colour throughout; velocity = the velocities even with a lane; cc11/cc1 = that MIDI CC lane (a midi_url part). Receipt: parts[].dynamics.",
"enum": [
"auto",
"off",
"velocity",
"cc11",
"cc1"
],
"type": "string"
},
"instrument": {
"type": "string"
},
"lora_id": {
"type": "string"
},
"lyrics": {
"description": "A SUNG part (instrument \"choir\"): the words it sings, ONE SYLLABLE PER NOTE in time order, a new line per sung phrase — a chord's notes share an onset, so every voice sings that syllable. Hyphens split a word's syllables (\"Glo-ri-a in ex-cel-sis De-o\"), \"_\" alone holds the previous syllable over the next note (a melisma), one word (\"Ah\", \"Mm\") is sung on every note. Omit = \"Ooh\" on every note. notes[].lyric places syllables one by one instead (it wins). Other instruments ignore it.",
"type": "string"
},
"name": {
"type": "string"
},
"notes": {
"items": {
"additionalProperties": false,
"properties": {
"duration_beats": {
"type": "number"
},
"lyric": {
"description": "A sung part: the syllable this note sings (\"glo-\" = more of the word follows, \"a\", \"_\" = hold the previous syllable).",
"type": "string"
},
"pitch": {
"type": "number"
},
"start_beats": {
"type": "number"
},
"velocity": {
"type": "number"
}
},
"required": [
"pitch",
"start_beats",
"duration_beats"
],
"type": "object"
},
"type": "array"
},
"players": {
"description": "How many players play this line: 1 (default) = a soloist; 2–8 = a SECTION — the line played by that many different players (each its own recording and performance), summed into ONE section stem. A string section = violins I, violins II, violas, cellos, basses with players 4–8 each; a choir section = singers (Soprano players 6 = six sopranos). Each player renders (and costs) like a part.",
"type": "number"
},
"synth_engine": {
"description": "A synth part: \"oneshot\" = the patch (the default once synth_role / synth_genre / synth_words is given), \"model\" = the synth model.",
"enum": [
"oneshot",
"model"
],
"type": "string"
},
"synth_genre": {
"description": "With instrument \"synth\": the genre the patch is made for — \"trap\", \"house\", \"techno\", \"synthwave\", \"lo-fi\", \"dnb\"… or free words; \"tech\" = a computed voice (a gliding sine sub, a dark pluck, a filtered pad), exactly in tune.",
"type": "string"
},
"synth_patch": {
"description": "With instrument \"synth\": a SAMPLED patch in place of the computed voice — \"<pack>:<patch id or name>\" (\"xv5080:PR-C/056\") or a pitched pack (\"bass808\"). See render_midi synth_patch.",
"type": "string"
},
"synth_role": {
"description": "A part on instrument \"synth\": the patch made for it — \"808\" (a sub that follows the kick), \"bass\", \"pad\", \"lead\", \"pluck\". The patch plays every note exactly as written, beside the band. Without synth_role / synth_genre / synth_words the synth model plays the part.",
"enum": [
"bass",
"808",
"pad",
"lead",
"pluck"
],
"type": "string"
},
"synth_words": {
"description": "With instrument \"synth\": a few words that turn the patch (\"dark\", \"bright\", \"warm\", \"detuned\", \"short\").",
"type": "string"
},
"timbre_audio_url": {
"description": "This part's OWN timbre: a recording of the singer (a choir part) or sound it should take on (a drum part too: a kit, a ride or a snare recording on the drum model — not drum_engine \"oneshot\" or a sampled instrument, which play their own samples) — an https URL, or the audio_key doseedo_get_upload_url returned for a file on your machine. The first 30 s are used; a clean solo take of the voice, 10–30 s, works best. Wins over the preset's voice; a choir part keeps the choir's adapter and sings in THIS voice. receipt: parts[].timbre.",
"type": "string"
},
"timbre_audio_urls": {
"description": "Several recordings (≤ 6): a section's players (players: N) and a split chord's voices take them in turn — a choir section of several singers of your own.",
"items": {
"type": "string"
},
"type": "array"
},
"timbre_preset": {
"type": "string"
},
"tune": {
"description": "false = this part exactly as rendered (no light intonation pass; default true).",
"type": "boolean"
},
"vaefix": {
"description": "false = this part's decode exactly as rendered (no VAE spectral corrector; default true).",
"type": "boolean"
}
},
"required": [
"notes"
],
"type": "object"
},
"type": "array"
},
"score_key": {
"description": "Alternative to parts: a score file on YOUR machine — doseedo_get_upload_url {filename: \"cue.mid\" | \"cue.musicxml\" | \"cue.mscz\"} → PUT the file → its score_key (kept 24 h). A big score sent as a file, not as notes in this call.",
"type": "string"
},
"score_url": {
"description": "Alternative to parts: a score file URL — MIDI, MusicXML or a MuseScore .mscz / .mscx, told apart by its content.",
"type": "string"
},
"seed": {
"description": "Random seed (reuse to re-render close to the same performance).",
"type": "number"
},
"tempo_map": {
"description": "Tempo changes [{beat, bpm}] (first point at beat 0). Overrides a file's own tempo.",
"items": {
"additionalProperties": false,
"properties": {
"beat": {
"type": "number"
},
"bpm": {
"type": "number"
}
},
"required": [
"beat",
"bpm"
],
"type": "object"
},
"type": "array"
},
"time_signature": {
"description": "Meter, e.g. \"4/4\" (default, or the file's).",
"type": "string"
},
"tune": {
"description": "Light intonation on every winds / brass / strings part (default true): held, clearly pitched notes the model rendered 15–85 cents off are moved toward their written pitch, to a small natural residual — attacks, vibrato and fast notes as played. Receipt: parts[].tune. false = every part as rendered (or parts[].tune false for one).",
"type": "boolean"
},
"vaefix": {
"description": "VAE spectral corrector on every winds / brass / strings part (default true): the decoder's low-mid fog under each instrument's register is trimmed, mic hiss removed only where present. Receipt: parts[].vaefix. false = every decode as rendered (or parts[].vaefix false for one).",
"type": "boolean"
}
},
"type": "object"
},
"name": "doseedo_render_score",
"outputSchema": null
},
{
"description": "SCORE TO PICTURE: the last step of scoring a film. Lays each mixed cue (and any sound effect) on the video at its SMPTE timecode, with dialogue ducking (the lines found on the video's own soundtrack by VAD, or the spans you pass; the music dips ahead of each line and comes back after it), normalises the program to a delivery loudness (web −16, streaming −14, broadcast/ebu −23, atsc −24 LUFS, or a number; true peak under the ceiling) and muxes it onto the picture untouched (no re-encode). Returns the scored video, the printmaster WAV and the music-and-effects stem, plus a report of what it MEASURED: where each track landed (and what was cut at the film's edges), how far the music sits under the lines, and the final loudness and true peak. CPU, no credits. tracks: [{audio_url (a doseedo_mix mix_url as returned, or any public https URL) | audio_key, start_timecode (in the film's timecode) | start_s, gain_db?, role?: music|dialogue|effects, duck?, name?}], ≤ 64. Keep the production audio (default) or drop it (production_audio:\"drop\"). A FILM THAT ALREADY HAS MUSIC: keeping its audio mixes the old music under yours — split it first (doseedo_split_soundtrack) and lay its dialogue and effects stems back (start_s 0, role dialogue / effects) with production_audio:\"drop\": the old music is gone, the lines are kept, and the duck reads the lines off the dialogue stem; lay the old music stem back too with duck:false to keep it (or a part of it). With dialogue tracks the delivery also returns the dialogue / music / effects stems. Up to 25 minutes of film per call (a reel). Async: job_id → doseedo_wait_task. Cancel: a delivery still queued never starts and one running stops within seconds; either way its credit is refunded and the job ends as canceled.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"dialogue": {
"description": "Dialogue spans [{start_s, end_s}] to duck under, instead of detecting them (use the cue sheet's dialogue, or your own).",
"items": {
"additionalProperties": false,
"properties": {
"end_s": {
"type": "number"
},
"start_s": {
"type": "number"
}
},
"required": [
"start_s",
"end_s"
],
"type": "object"
},
"type": "array"
},
"duck": {
"additionalProperties": false,
"description": "Dialogue ducking (on by default): depth_db (default 10), attack_ms (250: how early before a line the music is down), release_ms (700), sfx (false: duck effects too), enabled.",
"properties": {
"attack_ms": {
"maximum": 3000,
"minimum": 0,
"type": "number"
},
"depth_db": {
"maximum": 40,
"minimum": 0,
"type": "number"
},
"enabled": {
"type": "boolean"
},
"release_ms": {
"maximum": 5000,
"minimum": 0,
"type": "number"
},
"sfx": {
"type": "boolean"
}
},
"type": "object"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"loudness": {
"anyOf": [
{
"enum": [
"web",
"streaming",
"broadcast",
"ebu",
"atsc"
],
"type": "string"
},
{
"type": "number"
}
],
"description": "Delivery loudness: \"web\" (−16 LUFS, default), \"streaming\" (−14), \"broadcast\" / \"ebu\" (−23), \"atsc\" (−24), or a LUFS number (−36…−8)."
},
"name": {
"description": "Optional: a name for this job's files, e.g. \"rainy-loop-3\". Every file it returns downloads as <name>_<part>.<ext> (rainy-loop-3_Celesta.wav, rainy-loop-3_rough-mix.wav; one take: rainy-loop-3.wav), so the user can find them. Give each job its own name (a second take: \"rainy-loop-3b\"). Default: doseedo-<last 6 characters of the job id>.",
"maxLength": 80,
"type": "string"
},
"production_audio": {
"description": "keep (default) mixes the video's own soundtrack — all of it, its music included — under the score; drop replaces it (lay a doseedo_split_soundtrack's dialogue + effects stems to keep the lines).",
"enum": [
"keep",
"drop"
],
"type": "string"
},
"production_gain_db": {
"description": "Trim on the production audio when kept (default 0).",
"maximum": 12,
"minimum": -60,
"type": "number"
},
"start_timecode": {
"description": "SMPTE timecode of the film's first frame (default: the file's own, else 00:00:00:00) — the clock the tracks' start_timecode is read on.",
"type": "string"
},
"tracks": {
"description": "What to lay on the film, in any order.",
"items": {
"additionalProperties": false,
"properties": {
"audio_key": {
"description": "An ingest key instead of audio_url.",
"type": "string"
},
"audio_url": {
"description": "The cue's mixed audio (doseedo_mix mix_url as returned) or any public https URL.",
"type": "string"
},
"duck": {
"description": "false = this music track is not ducked: a band seen playing in the scene or a drop (the scene's own sound, forward), or the film's own music laid back from doseedo_split_soundtrack (mixed under its lines already). Default true.",
"type": "boolean"
},
"fade_in_s": {
"description": "A longer fade in from its first heard sample (the first frame when its head is cut).",
"maximum": 30,
"minimum": 0,
"type": "number"
},
"fade_out_s": {
"description": "A longer fade out to its last heard sample — its own end, length_s, or the last frame: let a piece go over the last shot instead of cutting it.",
"maximum": 60,
"minimum": 0,
"type": "number"
},
"gain_db": {
"description": "Level trim (default 0).",
"maximum": 24,
"minimum": -60,
"type": "number"
},
"length_s": {
"description": "How much of the audio plays from source_start_s (default: to its end or the last frame). The cut is faded (declick).",
"maximum": 7200,
"minimum": 0.05,
"type": "number"
},
"name": {
"description": "A label for the report, e.g. 1M3.",
"type": "string"
},
"repeat_every_s": {
"description": "A LOOP: lay this audio again every this many seconds (its period, to the millisecond — a loop of N bars at one fixed tempo: N × beats per bar × 60 / bpm) until repeat_until_s. The file may be longer than its period: its tail rings over the seam. For music that repeats verbatim (a vamp, a bed, a picture that is itself a loop: the cue sheet's video.picture_loop) — render and mix the loop ONCE instead of every stem for the whole length. receipt: tracks[].repeats.",
"maximum": 7200,
"minimum": 1,
"type": "number"
},
"repeat_until_s": {
"description": "With repeat_every_s: no copy starts at or after this film second (default: the last frame).",
"maximum": 7200,
"minimum": 0,
"type": "number"
},
"role": {
"description": "music (default; ducked under the dialogue), dialogue (never ducked — the lines the rest ducks under; a split soundtrack's dialogue stem), effects / sfx (not ducked unless duck.sfx).",
"enum": [
"music",
"dialogue",
"effects",
"sfx"
],
"type": "string"
},
"source_start_s": {
"description": "Where in the AUDIO it starts playing (default 0): pick the stretch of a longer piece — a public-domain recording cut to a :30 starts at the phrase you chose. The cut is faded (declick).",
"maximum": 7200,
"minimum": 0,
"type": "number"
},
"start_s": {
"description": "Or where it starts in seconds from the first frame (negative = its head is before the first frame and cut there).",
"type": "number"
},
"start_timecode": {
"description": "Where it starts, in the film's timecode (HH:MM:SS:FF) — the cue sheet's start_timecode.",
"type": "string"
}
},
"type": "object"
},
"maxItems": 64,
"minItems": 1,
"type": "array"
},
"video_key": {
"description": "R2 ingest key of the video (the same upload doseedo_spot_video used).",
"type": "string"
},
"video_url": {
"description": "https URL of the video, as an alternative to video_key.",
"type": "string"
}
},
"required": [
"tracks"
],
"type": "object"
},
"name": "doseedo_score_to_picture",
"outputSchema": null
},
{
"description": "STEM SEPARATION and VOCAL REMOVER: split an uploaded mix into stems (vocals, drums, bass, guitar, piano, other — or orchestral/auto-detected instruments) to isolate vocals (the vocals stem is the acapella; the other stems are the karaoke backing), with optional per-stem MIDI transcription and DAW-session export. Async: returns a job_id — poll with doseedo_wait_task (~2 minutes). Result: stems{name: url}, midi{name: url}, drum_substems{kick, snare, …} (drum_split), vocals_lyrics / vocals_notes, session_tracks + session_tempo_bpm when session_id was given, models_effective (what the auto family gate actually ran), other_classification (what the \"other\" stem was heard as), guitar_split (outcome). Cancel: the plane has no stop for a running separation — it runs to completion (credits spent), the job ends as canceled and its output is discarded. Only a job still queued at the plane is refunded by the plane's own failure refund.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"audio_key": {
"description": "R2 ingest key of an uploaded audio file (from doseedo_get_upload_url / POST /api/upload/r2/ingest-url; starts with \"ingest/\"). Provide this or audio_url.",
"type": "string"
},
"audio_url": {
"description": "https URL of the audio, as an alternative to audio_key: a doseedo result URL exactly as a job returned it (a stem, a take, a bounce), or any public URL. The gateway fetches it (≤256 MB) into your account's ingest storage before the job starts. Pass audio_key OR audio_url.",
"type": "string"
},
"drum_split": {
"description": "true = also split the drum stem into isolated kick / snare / hi-hat / toms / ride / crash (+ perc) sub-stems (result.drum_substems).",
"type": "boolean"
},
"export": {
"description": "Optionally also build a DAW session from the stems.",
"enum": [
"logic",
"ableton"
],
"type": "string"
},
"guitar_split": {
"description": "Deal the guitar stem into N players (same-instrument separation): \"2\"–\"4\", or \"auto\" (a one-vs-two probe decides; no split when it hears one). Outcome in result.guitar_split.",
"type": "string"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"include_midi": {
"description": "Also transcribe each stem to MIDI (default true).",
"type": "boolean"
},
"instruments": {
"description": "models=orchestra only: comma-separated extractor targets, e.g. \"saxophone,trumpet,trombone\". Available: drums, percussion, bass, double_bass, guitar, electric_guitar, acoustic_guitar, piano, organ, harp, brass, trumpet, trombone, french_horn, tuba, saxophone, clarinet, oboe, bassoon, flute, woodwind, strings, violin, viola, cello. Omit for the curated default set.",
"type": "string"
},
"models": {
"description": "Separation model set. Default 6stem (vocals/drums/bass/guitar/piano/other); auto/orchestra/detect for wider instrument sets.",
"enum": [
"6stem",
"auto",
"orchestra",
"detect"
],
"type": "string"
},
"name": {
"description": "Optional: a name for this job's files, e.g. \"rainy-loop-3\". Every file it returns downloads as <name>_<part>.<ext> (rainy-loop-3_Celesta.wav, rainy-loop-3_rough-mix.wav; one take: rainy-loop-3.wav), so the user can find them. Give each job its own name (a second take: \"rainy-loop-3b\"). Default: doseedo-<last 6 characters of the job id>.",
"maxLength": 80,
"type": "string"
},
"parent_track_id": {
"description": "With session_id: the t_… track the mix sits on; the stems are added as its children.",
"type": "string"
},
"session_id": {
"description": "Register the stems INTO this doseedo session (from doseedo_list_sessions) as audio tracks — result.session_tracks lists them. Needs parent_track_id.",
"type": "string"
},
"stems_only": {
"description": "true = the stems and NOTHING derived from them (no MIDI, no lyrics, no latents) — the fastest, cheapest separation. Implies include_midi:false.",
"type": "boolean"
}
},
"type": "object"
},
"name": "doseedo_separate_stems",
"outputSchema": null
},
{
"description": "Build a native DAW PROJECT from stems: each stem on its own audio track from bar 1, optional MIDI tracks (the written parts) beside them, on your tempo (bpm or tempo_map) — Logic Pro (.logicx) or Ableton Live (.als), zipped. The deliverable after doseedo_render_score (pass from_job: its job_id and the stems, MIDI and tempo come from that job) or after any renders / separations you made (stems: [{name, audio_url}] — result links work as-is). After doseedo_mix add mix_job: each track at that mix's level and pan, the mix as a muted reference track. Async: job_id → doseedo_wait_task (~30–90 s) → file (pre-signed zip, curl -o session.zip <url>, 24 h). Cancel: the plane has no stop for a running session build — it runs to completion (credits spent), the job ends as canceled and its output is discarded. Only a job still queued at the plane is refunded by the plane's own failure refund.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"bpm": {
"description": "Project tempo (default 120).",
"type": "number"
},
"cues": {
"description": "MCP: ONE session for a whole scored film — [{cue: \"1M1\", start_s, from_job: <its doseedo_render_score job>, mix_job?: <its doseedo_mix job>, emotion?}] (≤ 12 cues, from the cue sheet's start_s). Every cue's stems and MIDI land on one timeline at its start, on ONE tempo map (each cue's own tempo_map joined, each cue's bar 1 on a bar line), a marker per cue, each track at its cue's mix level and pan, each cue's mix as a muted reference. Replaces from_job / mix_job / stems.",
"items": {
"additionalProperties": false,
"properties": {
"cue": {
"type": "string"
},
"emotion": {
"type": "string"
},
"from_job": {
"type": "string"
},
"mix_job": {
"type": "string"
},
"start_s": {
"type": "number"
}
},
"required": [
"cue",
"start_s",
"from_job"
],
"type": "object"
},
"type": "array"
},
"from_job": {
"description": "MCP: a doseedo_render_score job_id — its stems, parts' MIDI and tempo are used (no other input needed).",
"type": "string"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"markers": {
"description": "Arrangement markers [{name, beat}] — beat 0 = bar 1 on the project's tempo map. A scored film's cues are written as markers by `cues`.",
"items": {
"additionalProperties": false,
"properties": {
"beat": {
"type": "number"
},
"name": {
"type": "string"
}
},
"required": [
"name",
"beat"
],
"type": "object"
},
"type": "array"
},
"midi_tracks": {
"description": "Optional MIDI tracks: [{name, notes:[{pitch, start_beats, duration_beats, velocity?}]}].",
"items": {
"additionalProperties": false,
"properties": {
"name": {
"type": "string"
},
"notes": {
"items": {
"type": "object"
},
"type": "array"
}
},
"type": "object"
},
"type": "array"
},
"mix_job": {
"description": "MCP: a doseedo_mix job_id — every track takes that mix's level and pan, and the mix itself rides along as a muted reference track \"Mix (doseedo)\".",
"type": "string"
},
"mixgraph": {
"description": "A mix document (doseedo_mix → mixgraph): each stem named in it takes its strip's gain_db and pan. The EQ, compression, reverb and rides are not written into the project.",
"type": "object"
},
"name": {
"description": "Project name — the project inside the zip, and the zip itself downloads as <name>_session.zip.",
"type": "string"
},
"session_beats": {
"description": "Length of the session in beats (the tempo map is written this far; default: the last note). `cues` sets it.",
"type": "number"
},
"stems": {
"description": "[{name, audio_url | audio_key, gain_db?, pan?, mute?, position_beats?}] — the audio tracks, in order.",
"items": {
"additionalProperties": false,
"properties": {
"audio_key": {
"type": "string"
},
"audio_url": {
"type": "string"
},
"gain_db": {
"type": "number"
},
"mute": {
"type": "boolean"
},
"name": {
"type": "string"
},
"pan": {
"type": "number"
},
"position_beats": {
"type": "number"
}
},
"type": "object"
},
"type": "array"
},
"target": {
"description": "Which DAW (default logic): Logic Pro (.logicx), Ableton Live (.als) or REAPER (.rpp + media, with the film as a video track). Or a VIDEO EDITOR, for whoever cuts the picture: premiere (Premiere Pro: an FCP7 XML), finalcut (Final Cut Pro: an FCPXML) or resolve (DaVinci Resolve: both). An editor project is the film on V1, every stem as its own clip at its position (one track per part across the cues), a marker per cue, the sequence at the film's own start timecode, with its media beside it (48 kHz, 24-bit). Each stem's gain_db and pan are printed into its file, so clips sit at unity; midi_tracks and the tempo map are not written (a timeline holds none).",
"enum": [
"logic",
"ableton",
"reaper",
"premiere",
"finalcut",
"resolve"
],
"type": "string"
},
"tempo_map": {
"description": "Tempo changes [{beat, bpm}] for the project.",
"items": {
"additionalProperties": false,
"properties": {
"beat": {
"type": "number"
},
"bpm": {
"type": "number"
}
},
"required": [
"beat",
"bpm"
],
"type": "object"
},
"type": "array"
},
"time_signature": {
"description": "Meter (default 4/4).",
"type": "string"
},
"video": {
"additionalProperties": false,
"description": "The film the music is written to: {video_key: the ingest/ key of your upload (doseedo_get_upload_url), name?, start_s?}. It is re-encoded lean (720p) and travels inside the project: REAPER gets a muted video track, Logic Pro gets its Movie (inside the package; Logic finds it by name). Ableton projects are built without it (the answer says so).",
"properties": {
"name": {
"type": "string"
},
"start_s": {
"type": "number"
},
"video_key": {
"type": "string"
}
},
"required": [
"video_key"
],
"type": "object"
}
},
"type": "object"
},
"name": "doseedo_session_from_stems",
"outputSchema": null
},
{
"description": "SPLIT A FILM'S SOUNDTRACK (dialogue / music / effects — \"DME\" — separation): the film's own audio into three stems that sum back to it, plus a report of what it holds: whether there is music already, where it plays (spans in seconds) and how much of the film it covers, where the dialogue is (cleaner than VAD on the full mix: a song's singer stays in the music stem), each part's level, and how far the music sits under the lines. Use it before scoring a film that already has music (soundtrack.stems.music.present): to REPLACE that music, lay the dialogue and effects stems under your score with doseedo_score_to_picture (production_audio:\"drop\", tracks role \"dialogue\" / \"effects\"); to REMIX or RE-ORCHESTRATE it, the music stem goes to doseedo_separate_stems / doseedo_transcribe / doseedo_analyze_song; to KEEP it, score where the report shows no music. Input: video_key (the upload doseedo_spot_video read) or video_url; audio_key / audio_url for a soundtrack already on its own. One reel per call (≤ 30 min). The split is good, not perfect: a line the separator heard as music is moved back to the dialogue (soundtrack.dialogue_rescue says what moved; a sung or rapped voice stays in the music as the film's song), while some of the old music (its percussion most) reads as effects — about −10 dB of it stays in the dialogue + effects bed, which the new score masks. Async: job_id → doseedo_wait_task (about a third of the soundtrack's length: a 3-min scene ≈ 1 min, a 20-min reel ≈ 6 min). Cancel: the plane has no stop for a running split — it runs to completion (credits spent), the job ends as canceled and its output is discarded. Only a job still queued at the plane is refunded by the plane's own failure refund.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"audio_key": {
"description": "An ingest key of the soundtrack on its own (WAV/FLAC/MP3/M4A), instead of the film.",
"type": "string"
},
"audio_url": {
"description": "https URL of the soundtrack on its own, instead of the film.",
"type": "string"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"name": {
"description": "Optional: a name for this job's files, e.g. \"rainy-loop-3\". Every file it returns downloads as <name>_<part>.<ext> (rainy-loop-3_Celesta.wav, rainy-loop-3_rough-mix.wav; one take: rainy-loop-3.wav), so the user can find them. Give each job its own name (a second take: \"rainy-loop-3b\"). Default: doseedo-<last 6 characters of the job id>.",
"maxLength": 80,
"type": "string"
},
"video_key": {
"description": "R2 ingest key of the film (the same upload doseedo_spot_video read; starts with \"ingest/\").",
"type": "string"
},
"video_url": {
"description": "https URL of the film, as an alternative to video_key (fetched through the URL up to 256 MB; upload a bigger film).",
"type": "string"
}
},
"type": "object"
},
"name": "doseedo_split_soundtrack",
"outputSchema": null
},
{
"description": "SPOT A FILM: a video in, the music editor's cue sheet out — the first step of scoring to picture. Scene detection on EVERY frame, and it listens to the soundtrack (CPU, no credits): hard cuts frame-exact (dark, low-contrast footage included), fades, flashes and visual impacts; each shot's brightness, colour, warmth, contrast, motion and mood, with a keyframe JPEG per shot so you can SEE what it shows; SCENES — where the picture moves to a new place, at a cut or with none (a camera move, a dissolve) — each with its start, how it arrives, how fast the camera travels (pace) and a 640-px frame; and a storyboard: the whole film on one JPEG, a frame every few seconds; where dialogue is (Silero VAD) and loud audio hits; INTENSITY — the picture's energy (motion, cutting, camera, the sound) as sections [{start_s, end_s, level, rel: low | medium | high | peak}], and each scene's own: where the music steps up, settles and peaks; then cues placed where the picture wants music and the dialogue lets it (1M1, 1M2 …: start/end SMPTE timecode, emotion, energy, tension arc, hit points ranked by strength, a suggested bpm that lands them, and tempo_map_input — pass it to doseedo_tempo_map as is). It sees light, movement and editing, not meaning: read the scene frames and the storyboard for what each scene is about. Input: video_key (doseedo_get_upload_url accepts mp4/mov/m4v/webm/mkv) or video_url (public https), ≤ 2 GB and ≤ 3 h. Optional start_timecode (the first frame's, e.g. 01:00:00:00; default the file's own), coverage (0.05–0.98, default 0.55: how much of the film gets music), reel (cue ids <reel>M<n>), keyframes (0–60), spotter. Async: job_id → doseedo_wait_task (~1 min for a 10-min 1080p reel). Next: doseedo_tempo_map per cue → write the notes → doseedo_render_score → doseedo_mix → doseedo_score_to_picture. Cancel: a spotting pass still queued never starts and one running stops within seconds; either way its credit is refunded and the job ends as canceled.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"coverage": {
"description": "How much of the film gets music (default 0.55). Raise it for wall-to-wall scoring (a trailer, an animation), lower it for a dialogue drama.",
"maximum": 0.98,
"minimum": 0.05,
"type": "number"
},
"cut_threshold": {
"description": "Scene-change threshold at full contrast (default 0.3). Lower finds softer cuts, higher only the hardest.",
"maximum": 0.9,
"minimum": 0.05,
"type": "number"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"keyframes": {
"description": "How many shots get a keyframe JPEG (default 24; the longest shots first). 0 = no images at all (no scene frames, no storyboard).",
"maximum": 60,
"minimum": 0,
"type": "integer"
},
"name": {
"description": "Optional: a name for this job's files, e.g. \"rainy-loop-3\". Every file it returns downloads as <name>_<part>.<ext> (rainy-loop-3_Celesta.wav, rainy-loop-3_rough-mix.wav; one take: rainy-loop-3.wav), so the user can find them. Give each job its own name (a second take: \"rainy-loop-3b\"). Default: doseedo-<last 6 characters of the job id>.",
"maxLength": 80,
"type": "string"
},
"reel": {
"description": "Reel number for the cue ids (default 1 → 1M1, 1M2 …).",
"maximum": 99,
"minimum": 1,
"type": "integer"
},
"spotter": {
"description": "Who places the cues. \"rules\" (default): light, motion and editing, weighted by hand, at coverage. \"model\": a cue model trained on 200 human-scored films. It places the cues where a composer would, and gives each cue its tempo (suggested_bpm), dynamics marks (dynamics: pp–ff every 8 s), turns (where it comes in full or steps up or down) and hits. Its tempo_map_input lands the hits on a beat and the turns on a bar line. Without coverage it decides how much of the film gets music; cue_sheet.cue_model says what it decided.",
"enum": [
"rules",
"model"
],
"type": "string"
},
"start_timecode": {
"description": "SMPTE timecode of the first frame, HH:MM:SS:FF (\";\" before the frames = drop-frame at 29.97/59.94). Default: the file's embedded timecode, else 00:00:00:00.",
"type": "string"
},
"video_key": {
"description": "R2 ingest key of the uploaded video (doseedo_get_upload_url with the file name, e.g. reel1.mp4; starts with \"ingest/\").",
"type": "string"
},
"video_url": {
"description": "https URL of the video, as an alternative to video_key (a public file URL, fetched directly; ≤ 2 GB).",
"type": "string"
}
},
"type": "object"
},
"name": "doseedo_spot_video",
"outputSchema": null
},
{
"description": "MUSIC SUPERVISION, for a film whose direction is classical or orchestral: instead of writing every note, each cue is CUT FROM A REAL PUBLIC-DOMAIN SCORE (~1,000 orchestral pieces, Baroque to late Romantic, free to use in a film — no rights holds, no ShareAlike). The search fits each cue: its length to the frame (a passage bent ≤ ~17 % in tempo, cut on a bar line where it must), the cue sheet's turns on the score's own section changes, its hits on real accents, its mode and meter, its level over time (a quiet cue thins a tutti's doublings; the loudest moment lands on the source's own rise), and cues of one piece play fresh bars. SAY WHO PLAYS AND HOW BUSY IT IS, or a quiet piano-and-strings cue is cut from a tutti: instruments = the cue's players (the source plays only its parts for those); density = sparse | moderate | busy | driving, or notes a second; per film, or per_cue. Input: spot_job (the doseedo_spot_video job id — spotter \"model\" gives each second its level) or cue_sheet; cues (ids, default every score cue); direction {era: [\"Baroque\"|\"Classical\"|\"Romantic\"…], genre, composer: [\"Antonín Dvořák\"…], mode: major|minor}; prefer {cue: file} = take that cue from an alternative an earlier answer listed. Async: job_id → doseedo_wait_task (~5–60 s; a bad direction, cue or prefer fails at once), CPU, no credits. Result per cue: source {composer, title, licence, credit — the line a CC BY edition asks for}, edit (bars, stretch, cuts), render {score_url, instruments, name} = the doseedo_render_score call that plays it (pass it as is; change an instrument by editing instruments), mix_lufs_offset_db (master the cue at the delivery loudness plus this: doseedo_mix target_lufs), alternatives [{composer, title, file, cost}]. Cancel: the plane has no stop for a running catalogue search — it runs to completion (credits spent), the job ends as canceled and its output is discarded. Only a job still queued at the plane is refunded by the plane's own failure refund.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"cue_sheet": {
"description": "Alternative to spot_job: a cue sheet {video: {duration}, cues: [{id, kind?: \"score\", start_s, end_s, suggested_bpm?, turns?: [{time_s}], hits?: [{time_s}], dynamics?: [{at_s, mark}], instruments?: [names], density?}], cue_model?: {level_db_per_s}} — doseedo_spot_video's, or your own cue plan in its shape.",
"type": "object"
},
"cues": {
"description": "Only these cue ids (default: every score cue, ≤ 40).",
"items": {
"type": "string"
},
"type": "array"
},
"density": {
"anyOf": [
{
"type": "number"
},
{
"enum": [
"sparse",
"moderate",
"busy",
"driving"
],
"type": "string"
}
],
"description": "How busy every cue is, on the parts that play: notes a second, or sparse (~2) / moderate (~4.5) / busy (~8) / driving (~13). Music under speech is sparse."
},
"direction": {
"additionalProperties": false,
"description": "Steer the choice: era / genre / composer as a name or a list of names (the catalogue's own, e.g. era \"Romantic\", composer \"Pyotr Ilyich Tchaikovsky\"), mode \"major\" | \"minor\" for every cue.",
"properties": {
"composer": {
"anyOf": [
{
"type": "string"
},
{
"items": {
"type": "string"
},
"type": "array"
}
]
},
"era": {
"anyOf": [
{
"type": "string"
},
{
"items": {
"type": "string"
},
"type": "array"
}
]
},
"genre": {
"anyOf": [
{
"type": "string"
},
{
"items": {
"type": "string"
},
"type": "array"
}
]
},
"mode": {
"enum": [
"major",
"minor"
],
"type": "string"
}
},
"type": "object"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"instruments": {
"description": "The players every cue is cut for (a cue's own instruments win): \"violin\", \"cello\", \"piano\", \"harp\", \"horn\", \"strings\"… The source plays only its parts for these; an asked instrument it lacks is named on the card (ensemble.missing).",
"items": {
"type": "string"
},
"type": "array"
},
"name": {
"description": "Optional: a name for this job's files, e.g. \"rainy-loop-3\". Every file it returns downloads as <name>_<part>.<ext> (rainy-loop-3_Celesta.wav, rainy-loop-3_rough-mix.wav; one take: rainy-loop-3.wav), so the user can find them. Give each job its own name (a second take: \"rainy-loop-3b\"). Default: doseedo-<last 6 characters of the job id>.",
"maxLength": 80,
"type": "string"
},
"per_cue": {
"additionalProperties": {
"additionalProperties": false,
"properties": {
"density": {
"anyOf": [
{
"type": "number"
},
{
"type": "string"
}
]
},
"instruments": {
"items": {
"type": "string"
},
"type": "array"
}
},
"type": "object"
},
"description": "{cue id: {instruments?, density?}} — one cue's own players and density.",
"type": "object"
},
"prefer": {
"additionalProperties": {
"type": "string"
},
"description": "{cue id: catalogue file}: cut that cue from this piece (a file an earlier answer listed under alternatives).",
"type": "object"
},
"spot_job": {
"description": "The doseedo_spot_video job id (job_…): its cue sheet is read for you (MCP tool only; the jobs API takes cue_sheet).",
"type": "string"
}
},
"type": "object"
},
"name": "doseedo_supervise_cues",
"outputSchema": null
},
{
"description": "Scoring to picture: turn HIT POINTS (a cut, an impact, the title card — as seconds from the cue start or SMPTE timecodes) into a TEMPO MAP that lands each hit exactly on a downbeat (or a beat / an eighth — per hit with hits[].land), staying near your tempo and inside bpm_range. A cue whose pace changes (she runs faster, then stops): give the hit where it changes a bpm, and the map moves to that tempo from there, every hit still landed. An AD or any cue that must hold ONE tempo: fixed_bpm: true (+ max_deviation_bpm, tolerance_ms) finds the tempo and the bar-1 offset (music_offset_s) landing the most hits, and says which ones it could not. Returns tempo_map [{beat, bpm}] to pass unchanged to doseedo_render_midi / doseedo_render_score / doseedo_session_from_stems, and hits[] with the beat, bar and beat-in-bar each hit lands on — write the accent, stinger or change there. Handles 23.976 / 24 / 25 / 29.97 (\";\" = drop-frame) / 30 / 50 / 59.94 / 60 fps timecode. Pure math: free, instant, no key needed.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"bpm": {
"description": "The cue's tempo (20–300) — the map stays as close to it as the hits allow.",
"type": "number"
},
"bpm_range": {
"description": "Allowed tempo range [min, max] (default ±12 % of bpm).",
"items": {
"type": "number"
},
"type": "array"
},
"fixed_bpm": {
"description": "ONE tempo for the whole cue (an ad, a song-form cue): the solver picks the tempo (within max_deviation_bpm of bpm; default exactly bpm) and where bar 1 sits (music_offset_s, default within the first bar; offset_range_s) so the most hits land within tolerance_ms (default 40). Hits it cannot land come back landed:false with nearest_beat — never an error.",
"type": "boolean"
},
"fps": {
"description": "Frame rate of the timecodes: 23.976, 24, 25, 29.97, 30, 50, 59.94, 60.",
"type": "number"
},
"hits": {
"description": "The moments the music must land on: [{time_s} (seconds from the cue start) or {timecode: \"01:00:12:08\"} (film timecode, with fps and start_timecode), label?, land?, bpm?}] — land = THIS hit's landing (\"downbeat\", \"beat\" or \"eighth\"; default: the request's land), e.g. the big cuts on bar lines and a quick accent on an eighth. bpm = the tempo FROM this hit on, a new section (the chase at 160 from the cut where she starts running, back to 112 when she stops), until a later hit names another; the range around it scales with it. A bare number = {time_s}.",
"items": {
"anyOf": [
{
"type": "number"
},
{
"additionalProperties": false,
"properties": {
"bpm": {
"type": "number"
},
"label": {
"type": "string"
},
"land": {
"enum": [
"downbeat",
"beat",
"eighth"
],
"type": "string"
},
"priority": {
"description": "What this hit is worth when not every hit can land (tolerance_ms): \"must\" for the moment the cue is written to (the reveal, the title, the drop) — the map lands it first and the rest around it; \"low\" gives way first. Default \"normal\"; a downbeat hit already outweighs a beat.",
"enum": [
"must",
"high",
"normal",
"low"
],
"type": "string"
},
"time_s": {
"type": "number"
},
"timecode": {
"type": "string"
}
},
"type": "object"
}
]
},
"type": "array"
},
"land": {
"description": "Land hits on bar lines (default), on any beat, or on any eighth — the default for every hit without its own land.",
"enum": [
"downbeat",
"beat",
"eighth"
],
"type": "string"
},
"max_deviation_bpm": {
"description": "How far the tempo may move from bpm (both modes; in place of bpm_range). A variable map at 124 ±12 % can swing 11+ bpm between hits — 3 keeps it a steady groove.",
"type": "number"
},
"offset_range_s": {
"description": "fixed_bpm: where bar 1 may sit on the cue, [min, max] seconds (default [0, one bar]).",
"items": {
"type": "number"
},
"type": "array"
},
"start_s": {
"description": "Alternative: the cue start in seconds of film time (informational when hits are time_s).",
"type": "number"
},
"start_timecode": {
"description": "Film timecode of the cue's first downbeat (bar 1); hit timecodes are measured from it.",
"type": "string"
},
"time_signature": {
"description": "Meter (default 4/4).",
"type": "string"
},
"tolerance_ms": {
"description": "SOFT hits (0–250 ms): a hit within this of the grid counts as landed, and one the grid can't reach is reported (landed:false, with nearest_beat and off_ms), never refused. The map is fitted over the whole cue, so it lands the most hits — downbeats and priority \"must\" first. Every hit then carries error_ms; hit_rate = landed / all. A hit with landed:false gets no accent of its own (an accent between the beats sounds like a mistake).",
"type": "number"
}
},
"required": [
"hits",
"bpm"
],
"type": "object"
},
"name": "doseedo_tempo_map",
"outputSchema": null
},
{
"description": "Make a CUSTOM INSTRUMENT in your own sound: upload 30 s–3 min of ONE instrument playing (your own player, a rare or folk instrument, a prepared/invented instrument, a vintage synth) and doseedo trains a private adapter (LoRA) on its serving instrument model in about 1–2 minutes. After that, doseedo_render_midi {instrument: <the same instrument>, lora_id} plays ANY notes you write in that sound. Several takes help (up to 8 files; the first 3 min are used, ≥8 s required); a clean, solo, dry recording works best. instrument = the closest catalog instrument — it picks the model voice the adapter trains on (a shamisen trains as acoustic_guitar, a whistle as flute: doseedo_instruments lists each one's call.instrument). The notes are transcribed for you (pass notes to skip that). 20 credits. Result: lora_id, name, the windows it trained on, loss first→last, and `use` (the render args). Earlier ones: doseedo_list_jobs {kind:\"train_instrument\"}. Owner-only: no one else can render with it. Async: job_id → doseedo_wait_task (~1–2 min). Cancel: the plane has no stop for a running training — it runs to completion (credits spent), the job ends as canceled and its output is discarded. Only a job still queued at the plane is refunded by the plane's own failure refund.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"audio_key": {
"description": "R2 ingest key of an uploaded audio file (from doseedo_get_upload_url / POST /api/upload/r2/ingest-url; starts with \"ingest/\"). One recording; or audio_keys for several.",
"type": "string"
},
"audio_keys": {
"description": "Several uploaded takes of the SAME instrument (≤8).",
"items": {
"type": "string"
},
"type": "array"
},
"audio_url": {
"description": "https URL of a recording (a doseedo result link — a separated stem works — or any public URL). Alternative to audio_key.",
"type": "string"
},
"audio_urls": {
"description": "Several recording URLs of the same instrument (≤8).",
"items": {
"type": "string"
},
"type": "array"
},
"bpm": {
"description": "Optional tempo of the recording (30–300).",
"type": "number"
},
"drum_mode": {
"description": "true for an unpitched percussion recording.",
"type": "boolean"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"instrument": {
"description": "REQUIRED. The catalog instrument it is closest to (call.instrument from doseedo_instruments, e.g. \"violin\", \"acoustic_guitar\", \"flute\", \"percussion\").",
"type": "string"
},
"name": {
"description": "A name for it, e.g. \"Grandpa's banjo\" (≤80 chars).",
"type": "string"
},
"notes": {
"description": "Optional: the notes played, one list per file — [[{pitch, start, end, velocity?}…]] in SECONDS. Omitted, they are transcribed.",
"type": "array"
},
"seed": {
"description": "Random seed.",
"type": "number"
},
"steps": {
"description": "Training steps 50–800. Default 300 for ≤60 s of audio, 400 above.",
"type": "number"
}
},
"required": [
"instrument"
],
"type": "object"
},
"name": "doseedo_train_instrument",
"outputSchema": null
},
{
"description": "AUDIO TO MIDI transcription: a melody, a bass line or a part as notes (pitch, onset/offset seconds, velocity, confidence as JSON — not a MIDI file; for .mid files per stem use doseedo_separate_stems with transcription or doseedo_audio_to_session). Works from an uploaded audio_key or an audio_url — any public https URL, including a result URL from another doseedo job (a generate take, a stem) as it was returned. Async: returns a job_id — poll with doseedo_wait_task (usually ~15–60s). For the KEY / tempo / chords of a whole mix use doseedo_analyze_song instead. Cancel: the plane has no stop for a running transcription — it runs to completion (credits spent), the job ends as canceled and its output is discarded. Only a job still queued at the plane is refunded by the plane's own failure refund.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"audio_key": {
"description": "R2 ingest key of an uploaded audio file (from doseedo_get_upload_url / POST /api/upload/r2/ingest-url; starts with \"ingest/\"). Provide this or audio_url.",
"type": "string"
},
"audio_url": {
"description": "https URL of the audio to transcribe (alternative to audio_key): any public URL, or a doseedo result URL exactly as a job returned it — no key needed.",
"type": "string"
},
"backend": {
"description": "Advanced: force a transcription backend. Omit — the server routes by instrument.",
"type": "string"
},
"beats_per_bar": {
"description": "With tempo_bpm: beats per bar for the beat-domain times (default 4).",
"type": "number"
},
"chairs": {
"description": "polyphony=\"section\": register codes per chair, as an alternative to roster.",
"type": "string"
},
"family": {
"description": "Optional instrument family (e.g. \"brass\", \"reeds\", \"strings\") when the exact instrument is unknown.",
"type": "string"
},
"idempotency_key": {
"description": "Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one.",
"type": "string"
},
"instrument": {
"description": "Optional instrument hint, e.g. \"piano\", \"sax\", \"vocals\", \"bass\".",
"type": "string"
},
"polyphony": {
"description": "Optional: \"solo\" (monophonic line), \"poly\", or \"section\" (a horn section — see roster/chairs).",
"type": "string"
},
"register": {
"description": "Optional register hint for the instrument (e.g. \"soprano\", \"tenor\", \"bass\").",
"type": "string"
},
"roster": {
"description": "polyphony=\"section\": the chairs on the stem, e.g. \"trumpet,trumpet,trombone,tenor_sax\". Omit for the family default.",
"type": "string"
},
"strikes": {
"description": "With tempo_bpm: also return the harmony_strikes attack grid.",
"type": "boolean"
},
"tempo_bpm": {
"description": "Optional known tempo — enables beat-aligned note times.",
"type": "number"
},
"want": {
"description": "What to return: \"notes\" (default), \"f0\" (the continuous pitch contour — frame-rate Hz values, for glides/vibrato/intonation), or both.",
"enum": [
"notes",
"f0",
"notes,f0"
],
"type": "string"
}
},
"type": "object"
},
"name": "doseedo_transcribe",
"outputSchema": null
},
{
"description": "Wait for an async doseedo job to finish: polls server-side for up to timeout_seconds (5–50; one call can never hold longer than 50 s), then returns the result or the latest status. If it returns still_running:true, call it again — a submit reply's eta_seconds says how long the whole job usually takes (transcribe ~15 s, a render 1–3 min, audio_to_session ~4 min), so a 3-minute job is three or four calls, not one. A finished job answers with its output, artifacts (pre-signed links) and note.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"job_id": {
"description": "Alternatively the job_id (job_…) from a submit tool or the jobs API — replaces task_id + kind.",
"type": "string"
},
"kind": {
"description": "Which job kind created the task — the registry name the submit reply carried (generate_music, generate_sound, generate_loop, cover_stem, edit_lyrics, fill_gap, render_midi, train_instrument, render_score, mix, mix_preset, session_from_stems, spot_video, score_to_picture, reframe_video, cover_song, separate_stems, split_soundtrack, transcribe, audio_to_session, convert_project, bounce_session, analyze_song, detect_chords, beat_grid, identify_sound, check_take, analyze_midi, supervise_cues); the short codes (generate, sound, loop, coverstem, editlyrics, fillgap, render, train, score, mixpre, stemsess, spot, picture, reframe, cover, separate, soundtrack, session, convert, bounce, analyze, chords, beats, identify, check, harmony, supervise) are accepted aliases.",
"enum": [
"generate_music",
"generate_sound",
"generate_loop",
"cover_stem",
"edit_lyrics",
"fill_gap",
"render_midi",
"train_instrument",
"render_score",
"mix",
"mix_preset",
"session_from_stems",
"spot_video",
"score_to_picture",
"reframe_video",
"cover_song",
"separate_stems",
"split_soundtrack",
"transcribe",
"audio_to_session",
"convert_project",
"bounce_session",
"analyze_song",
"detect_chords",
"beat_grid",
"identify_sound",
"check_take",
"analyze_midi",
"supervise_cues",
"generate",
"sound",
"loop",
"coverstem",
"editlyrics",
"fillgap",
"render",
"train",
"score",
"mixpre",
"stemsess",
"spot",
"picture",
"reframe",
"cover",
"separate",
"soundtrack",
"session",
"convert",
"bounce",
"analyze",
"chords",
"beats",
"identify",
"check",
"harmony",
"supervise"
],
"type": "string"
},
"task_id": {
"description": "The task_id returned by a submit tool.",
"type": "string"
},
"timeout_seconds": {
"description": "Max seconds to wait in this call (5–50, default 45). Start with the submit reply's suggested_next_wait.",
"type": "number"
}
},
"type": "object"
},
"name": "doseedo_wait_task",
"outputSchema": null
}
]
}Verify it yourself
curl -s https://api.teppi.xyz/v1/evidence/sha256:e259efb1b8f1a2a1068955c3a16fbf36faf9d46b7847b39e031f4e5183bdf0d8 | sha256sum