Doseedo

Generate an original song or instrumental from a text prompt (optionally with lyrics). Async: returns a task_id — poll with doseedo_wait_task kind="generate" (typically 1–3 minutes). The finished result is a list of downloadable audio file URLs.

{
  "type": "object",
  "properties": {
    "prompt": {
      "type": "string",
      "description": "Style/mood/instrumentation prompt, e.g. \"warm jazz trio, brushed drums, late-night ballad\"."
    },
    "lyrics": {
      "type": "string",
      "description": "Optional lyrics to sing. Omit for instrumental."
    },
    "duration_seconds": {
      "type": "number",
      "description": "Target length in seconds (e.g. 30–120). Omit for the model default."
    },
    "bpm": {
      "type": "number",
      "description": "Optional tempo in BPM (default 120)."
    },
    "time_signature": {
      "type": "string",
      "description": "Optional time signature, e.g. \"4/4\", \"3/4\"."
    },
    "seed": {
      "type": "number",
      "description": "Optional random seed for reproducibility."
    },
    "idempotency_key": {
      "type": "string",
      "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."
    }
  },
  "required": [
    "prompt"
  ],
  "additionalProperties": false
}

Re-render an uploaded song as a cover: keep its structure/melody while changing timbre, instruments, or lyrics. Optionally swap specific stems to other instruments, or export a DAW session too. Async: returns a task_id — poll with doseedo_wait_task kind="cover" (several minutes for full songs).

{
  "type": "object",
  "properties": {
    "audio_key": {
      "type": "string",
      "description": "R2 ingest key of an uploaded audio file (from doseedo_get_upload_url / POST /api/upload/r2/ingest-url; starts with \"ingest/\")."
    },
    "lyrics": {
      "type": "string",
      "description": "Optional replacement lyrics."
    },
    "instruments": {
      "type": "object",
      "description": "Optional per-stem instrument swap map, e.g. {\"piano\": \"electric_guitar\"}.",
      "additionalProperties": {
        "type": "string"
      }
    },
    "cover_noise_strength": {
      "type": "number",
      "description": "Optional 0–1 fidelity dial: higher departs further from the source."
    },
    "export": {
      "type": "string",
      "enum": [
        "logic",
        "ableton"
      ],
      "description": "Optionally also build a DAW session for this target."
    },
    "idempotency_key": {
      "type": "string",
      "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."
    }
  },
  "required": [
    "audio_key"
  ],
  "additionalProperties": false
}

Split an uploaded mix into stems (vocals, drums, bass, guitar, piano, other — or orchestral/auto-detected instruments), with optional per-stem MIDI transcription and DAW-session export. Async: returns a task_id — poll with doseedo_wait_task kind="separate" (~2 minutes).

{
  "type": "object",
  "properties": {
    "audio_key": {
      "type": "string",
      "description": "R2 ingest key of an uploaded audio file (from doseedo_get_upload_url / POST /api/upload/r2/ingest-url; starts with \"ingest/\")."
    },
    "models": {
      "type": "string",
      "enum": [
        "6stem",
        "auto",
        "orchestra",
        "detect"
      ],
      "description": "Separation model set. Default 6stem (vocals/drums/bass/guitar/piano/other); auto/orchestra/detect for wider instrument sets."
    },
    "instruments": {
      "type": "string",
      "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."
    },
    "include_midi": {
      "type": "boolean",
      "description": "Also transcribe each stem to MIDI (default true)."
    },
    "export": {
      "type": "string",
      "enum": [
        "logic",
        "ableton"
      ],
      "description": "Optionally also build a DAW session from the stems."
    },
    "idempotency_key": {
      "type": "string",
      "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."
    }
  },
  "required": [
    "audio_key"
  ],
  "additionalProperties": false
}

Transcribe audio to notes (pitch, onset/offset seconds, velocity, confidence as JSON — not a MIDI file). Works from an uploaded audio_key or a public audio_url. Async: returns a task_id — poll with doseedo_wait_task kind="transcribe" (usually ~15–60s).

{
  "type": "object",
  "properties": {
    "audio_key": {
      "type": "string",
      "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."
    },
    "audio_url": {
      "type": "string",
      "description": "Public https URL of the audio to transcribe (alternative to audio_key)."
    },
    "instrument": {
      "type": "string",
      "description": "Optional instrument hint, e.g. \"piano\", \"sax\", \"vocals\", \"bass\"."
    },
    "tempo_bpm": {
      "type": "number",
      "description": "Optional known tempo — enables beat-aligned note times."
    },
    "register": {
      "type": "string",
      "description": "Optional register hint for the instrument (e.g. \"soprano\", \"tenor\", \"bass\")."
    },
    "family": {
      "type": "string",
      "description": "Optional instrument family (e.g. \"brass\", \"reeds\", \"strings\") when the exact instrument is unknown."
    },
    "polyphony": {
      "type": "string",
      "description": "Optional: \"solo\" (monophonic line), \"poly\", or \"section\" (a horn section — see roster/chairs)."
    },
    "roster": {
      "type": "string",
      "description": "polyphony=\"section\": the chairs on the stem, e.g. \"trumpet,trumpet,trombone,tenor_sax\". Omit for the family default."
    },
    "chairs": {
      "type": "string",
      "description": "polyphony=\"section\": register codes per chair, as an alternative to roster."
    },
    "strikes": {
      "type": "boolean",
      "description": "With tempo_bpm: also return the harmony_strikes attack grid."
    },
    "beats_per_bar": {
      "type": "number",
      "description": "With tempo_bpm: beats per bar for the beat-domain times (default 4)."
    },
    "backend": {
      "type": "string",
      "description": "Advanced: force a transcription backend. Omit — the server routes by instrument."
    },
    "idempotency_key": {
      "type": "string",
      "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."
    }
  },
  "additionalProperties": false
}

Turn an uploaded full mix into a complete 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 task_id — poll with doseedo_wait_task kind="session" (~4 minutes).

{
  "type": "object",
  "properties": {
    "audio_key": {
      "type": "string",
      "description": "R2 ingest key of an uploaded audio file (from doseedo_get_upload_url / POST /api/upload/r2/ingest-url; starts with \"ingest/\")."
    },
    "target": {
      "type": "string",
      "enum": [
        "logic",
        "ableton"
      ],
      "description": "DAW target (default logic)."
    },
    "midi_stems": {
      "type": "string",
      "description": "Optional comma-separated stems to also add as MIDI tracks, e.g. \"piano,bass\"."
    },
    "chords": {
      "type": "boolean",
      "description": "Add a detected-chords guide track (default false)."
    },
    "simple": {
      "type": "boolean",
      "description": "Faster minimal build: meter + tempo + stems only, no MIDI (default false). Required for stem_mode=\"detect\"."
    },
    "separate": {
      "type": "boolean",
      "description": "false = no separation: the mix lands as ONE audio track (default true)."
    },
    "tempo_map": {
      "type": "boolean",
      "description": "false = one constant tempo instead of a tempo map (default true)."
    },
    "stem_mode": {
      "type": "string",
      "enum": [
        "6stem",
        "drumsep",
        "detect"
      ],
      "description": "Separation family: 6stem (default), drumsep (split the kit too) or detect (orchestral, auto-picked; needs simple=true)."
    },
    "instruments": {
      "type": "string",
      "description": "stem_mode=\"detect\": optional comma list restricting the orchestral set."
    },
    "crop_silence": {
      "type": "boolean",
      "description": "Punch regions in where each stem plays instead of whole-length stems (default false)."
    },
    "loops": {
      "type": "boolean",
      "description": "Detect repeated clips and lay them as loops (default false)."
    },
    "drum_sampler": {
      "type": "boolean",
      "description": "Sampled kits → a one-shot sampler track + MIDI (default false)."
    },
    "name": {
      "type": "string",
      "description": "Project name for the session file."
    },
    "idempotency_key": {
      "type": "string",
      "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."
    }
  },
  "required": [
    "audio_key"
  ],
  "additionalProperties": false
}

Convert a complete DAW project between Logic Pro (.logicx), Ableton Live (.als), FL Studio (.flp), Pro Tools (.ptx), REAPER (.rpp), Cubase (.cpr) and Dorico (.dorico/.musicxml) — any pair, both ways. The project is rebuilt natively in the target format: tracks, MIDI, audio clips, tempo, and markers arrive editable (for Logic↔Ableton also automation, buses/sends, and plugin state). ★ CUBASE AND DORICO ARE ASYMMETRIC, by necessity — neither native format is documented, so a file we cannot guarantee opens is never written. TO Cubase you get a .dawproject (the open format Cubase 14+ and Nuendo import as a real editable session; Studio One and Bitwig read it too), not a .cpr. TO Dorico you get MusicXML (.mxl) — Dorico's own full-notation import route, which MuseScore, Finale and Sibelius also open — not a .dorico. FROM Cubase reads the native .cpr: tracks, tempo, signature and MIDI parts carry; its audio pool does not, so audio tracks arrive named but empty. FROM Dorico: a .dorico carries its players and flows but NOT its notes (score.dtn exposes no note position or duration), so export MusicXML from Dorico and convert THAT for the music — this tool accepts .musicxml/.mxl under the same dorico2* directions. Every conversion reports what it could not carry; read the task result rather than assuming silence means lossless. First call doseedo_get_project_upload_url and PUT the project there (zip a project FOLDER so its audio travels; a bare .als/.flp/.rpp/.ptx/.cpr/.dorico/.mxl or zipped .logicx works too). Async: returns a task_id — poll with doseedo_wait_task kind="convert" (typically 15s–2min).

{
  "type": "object",
  "properties": {
    "project_key": {
      "type": "string",
      "description": "R2 key of the uploaded project (from doseedo_get_project_upload_url / POST /api/upload/r2/signed-url; starts with \"uploads/\")."
    },
    "direction": {
      "type": "string",
      "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"
      ],
      "description": "Source and target as \"<source>2<target>\" (logic | ableton | fl | protools | reaper | cubase | dorico). 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)."
    },
    "idempotency_key": {
      "type": "string",
      "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."
    }
  },
  "required": [
    "project_key",
    "direction"
  ],
  "additionalProperties": false
}

Get a presigned upload for a DAW PROJECT file (for doseedo_convert_project). Returns an upload_url (PUT the bytes there, e.g. `curl -X PUT -H "Content-Type: application/zip" --data-binary @project.zip "<upload_url>"`) and a project_key to pass to doseedo_convert_project. Zip a project folder so its audio travels with it.

{
  "type": "object",
  "properties": {
    "filename": {
      "type": "string",
      "description": "File name including extension, e.g. \"Song Project.zip\", \"beat.flp\", \"song.cpr\" or \"score.mxl\"."
    },
    "content_type": {
      "type": "string",
      "description": "MIME type: application/zip for zips (default), application/octet-stream for bare project files."
    }
  },
  "required": [
    "filename"
  ],
  "additionalProperties": false
}

Get a presigned upload for your own audio file. 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.

{
  "type": "object",
  "properties": {
    "filename": {
      "type": "string",
      "description": "File name including extension, e.g. \"song.wav\"."
    },
    "content_type": {
      "type": "string",
      "description": "MIME type; inferred from the extension when omitted (audio/* only)."
    }
  },
  "required": [
    "filename"
  ],
  "additionalProperties": false
}

Check an async doseedo task once. Returns current status, and the result (file URLs / notes) when finished.

{
  "type": "object",
  "properties": {
    "task_id": {
      "type": "string",
      "description": "The task_id returned by a submit tool."
    },
    "kind": {
      "type": "string",
      "enum": [
        "generate",
        "cover",
        "separate",
        "transcribe",
        "session",
        "convert",
        "bounce"
      ],
      "description": "Which tool family created the task."
    },
    "job_id": {
      "type": "string",
      "description": "Alternatively the job_id (job_…) from a submit tool or the jobs API — replaces task_id + kind."
    }
  },
  "additionalProperties": false
}

Wait for an async doseedo task to finish (polls server-side for up to ~50s, then returns the latest status). If it returns while the task is still running, simply call this tool again — long jobs can take a few minutes total.

{
  "type": "object",
  "properties": {
    "task_id": {
      "type": "string",
      "description": "The task_id returned by a submit tool."
    },
    "kind": {
      "type": "string",
      "enum": [
        "generate",
        "cover",
        "separate",
        "transcribe",
        "session",
        "convert",
        "bounce"
      ],
      "description": "Which tool family created the task."
    },
    "job_id": {
      "type": "string",
      "description": "Alternatively the job_id (job_…) from a submit tool or the jobs API — replaces task_id + kind."
    },
    "timeout_seconds": {
      "type": "number",
      "description": "Max seconds to wait in this call (5–50, default 45)."
    }
  },
  "additionalProperties": false
}

List the jobs this account submitted (generate / cover / stems / transcribe / session / convert / bounce), newest first — to find an earlier result, check what is still running, or resume after a lost connection. Read-only.

{
  "type": "object",
  "properties": {
    "limit": {
      "type": "number",
      "description": "How many (1–100, default 20)."
    },
    "kind": {
      "type": "string",
      "description": "Only this job kind, e.g. \"separate_stems\"."
    },
    "status": {
      "type": "string",
      "enum": [
        "queued",
        "running",
        "succeeded",
        "failed",
        "canceled"
      ]
    },
    "before": {
      "type": "string",
      "description": "Page cursor: the next_cursor of a previous call."
    }
  },
  "additionalProperties": false
}

Cancel a queued or running job. A generation that has not reached the GPU yet is stopped and its credit refunded; work a plane has already started may finish, but the job ends as canceled and its output is discarded.

{
  "type": "object",
  "properties": {
    "job_id": {
      "type": "string",
      "description": "The job_id from a submit tool or doseedo_list_jobs."
    }
  },
  "required": [
    "job_id"
  ],
  "additionalProperties": false
}

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.

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

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, cover_song, separate_stems, transcribe, audio_to_session, convert_project) and the same args you would give the job tool (duration_seconds, models, instruments, …). The estimate follows the planes' own price table; the gate is authoritative and a refusal names the exact price.

{
  "type": "object",
  "properties": {
    "job": {
      "type": "string",
      "enum": [
        "generate_music",
        "cover_song",
        "separate_stems",
        "transcribe",
        "audio_to_session",
        "convert_project"
      ],
      "description": "Which job to price (a doseedo_ tool name or recipe verb is accepted too)."
    },
    "args": {
      "type": "object",
      "description": "The arguments you intend to pass to the job tool; only the price-relevant ones matter.",
      "additionalProperties": true
    }
  },
  "required": [
    "job"
  ],
  "additionalProperties": false
}

The named pipelines people actually ask for — stems, session (mix → DAW project), cover, transcribe, generate, convert, bounce — 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.

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "A recipe name or alias, e.g. \"session\" / \"stems-to-session\". Omit to list all."
    }
  },
  "additionalProperties": false
}

List the connected account's DAW sessions (most recently updated first) — their ids, names, DAW, and update time. Use a session id with doseedo_get_session and doseedo_edit_session.

{
  "type": "object",
  "properties": {
    "limit": {
      "type": "number",
      "description": "How many to return (default 25, max 200)."
    }
  },
  "additionalProperties": false
}

Read a DAW session as a compact arrangement summary an agent can edit against: every track with its wire ids (track_id t_…, its mixer strip channel_id ch_…), its regions in BOTH beats and seconds, mixer state (volume with dB, pan, mute), and plugin chain (third-party flagged); plus tempo, time signature, markers, length, and a "sync" block saying whether Dø Desktop is live on this session and how far it has applied. Read-only. Pass these ids straight to doseedo_edit_session.

{
  "type": "object",
  "properties": {
    "session_id": {
      "type": "string",
      "description": "From doseedo_list_sessions."
    }
  },
  "required": [
    "session_id"
  ],
  "additionalProperties": false
}

Edit a DAW session by applying a list of ops (move/trim a region, set MIDI notes, add/remove a track, change a fader/pan/mute, insert or tweak a plugin, set tempo, add a marker, …). If Dø Desktop is running with the project open, the edits appear in Logic live within seconds; otherwise they persist and apply next time the session opens. Get ids and current values from doseedo_get_session first, and see doseedo_edit_ops_reference for every op and its arguments. CONTRACT: every op is validated before anything is stored (unknown ops and ops outside the key's ops:<group> scopes are refused). atomic (default true): one rejected op → NOTHING is stored and the response lists every rejection; atomic:false stores the good ops and lists the rest. RETRY: a call that timed out may have been stored — re-send it with the SAME batch_key and it dedups (deduped:true, original cursors); a retry without batch_key duplicates the edits. Stored ops are applied by the desktop one at a time in order; there is no per-batch undo group — verify what landed with doseedo_download_session (replay).

{
  "type": "object",
  "properties": {
    "session_id": {
      "type": "string"
    },
    "batch_key": {
      "type": "string",
      "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."
    },
    "atomic": {
      "type": "boolean",
      "description": "Default true: any rejected op means nothing is stored. Set false to store the valid ops and receive the rest as `rejected`."
    },
    "ops": {
      "type": "array",
      "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": {
        "type": "object",
        "properties": {
          "op": {
            "type": "string",
            "description": "The op name, e.g. \"set_track_crop\"."
          },
          "args": {
            "type": "object",
            "description": "The op arguments (see the ops reference)."
          }
        },
        "required": [
          "op",
          "args"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "session_id",
    "ops"
  ],
  "additionalProperties": false
}

The full catalog of session edit ops doseedo_edit_session accepts: every op with its arguments, units, and where it lands (live in the open project, at next open, or state-only) — plus the WORKFLOW, UNITS (ids, beats, 0.709 = 0 dB, Quick Sampler root C3 = 60) and RECIPES (drum kit from local samples, one-shots on an audio track, remote sample, submix bus, verify). Read it ONCE per session and copy a recipe. Read-only.

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

Is Dø Desktop running on the user's Mac and connected to their DAW? Reports which sessions it currently holds, whether a live Logic hook is answering, and its per-session applied cursor. Use it to know whether an edit will reach the DAW live now (desktop online + logic connected) or wait for the next session open. Read-only.

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

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.

{
  "type": "object",
  "properties": {
    "session_id": {
      "type": "string"
    },
    "audio_url": {
      "type": "string",
      "description": "Public https URL of the audio (e.g. a doseedo artifact URL)."
    },
    "audio_key": {
      "type": "string",
      "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)."
    },
    "filename": {
      "type": "string",
      "description": "Optional name for the asset."
    }
  },
  "required": [
    "session_id"
  ],
  "additionalProperties": false
}

Bounce a session (or specific tracks) to audio through their REAL plugin chains, offline — Dø Desktop renders them in the background WITHOUT the user opening the DAW (live via Logic if it's open, headless if it isn't; this is the thing stock DAWs can't do). Async: returns a task_id — poll with doseedo_wait_task kind="bounce". The result is downloadable stem URLs. Needs Dø Desktop to run at some point to pick up the job; until then it stays queued.

{
  "type": "object",
  "properties": {
    "session_id": {
      "type": "string"
    },
    "track_ids": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Tracks to bounce (t_… ids from doseedo_get_session). Omit to bounce the whole session."
    },
    "stems": {
      "type": "boolean",
      "description": "true (default) = one file per track; false = a single mixdown."
    },
    "tail_seconds": {
      "type": "number",
      "description": "Extra seconds for reverb/delay to ring out (default 2)."
    },
    "format": {
      "type": "string",
      "enum": [
        "wav",
        "aiff"
      ],
      "description": "Output format (default wav)."
    },
    "idempotency_key": {
      "type": "string",
      "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."
    }
  },
  "required": [
    "session_id"
  ],
  "additionalProperties": false
}

Save a session to the device as a native Logic project (.logicx.zip), rebuilt server-side from the current session state — no desktop needed. Returns a SHORT-LIVED, NO-AUTH download URL: fetch it with a plain `curl -o ~/Downloads/…` (no API key or header) and unzip. Use this to put the project in the user's Downloads folder. The result also carries `replay` — what the build actually put in the file (per track: kind, the sample its Quick Sampler plays, MIDI note count, audio region count; media in the bundle; ops the offline build could not synthesize) — and `warnings`. Verify from those; do not unzip and inspect ProjectData. `place_local_files` (when present) MUST be run after unzipping.

{
  "type": "object",
  "properties": {
    "session_id": {
      "type": "string"
    },
    "daw": {
      "type": "string",
      "enum": [
        "logic",
        "ableton",
        "fl",
        "reaper"
      ],
      "description": "Target DAW (default logic; only logic is a one-shot native download — for others use doseedo_convert_project)."
    }
  },
  "required": [
    "session_id"
  ],
  "additionalProperties": false
}

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: "…"}}.

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

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.

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "Session name."
    },
    "daw": {
      "type": "string",
      "enum": [
        "logic",
        "ableton"
      ],
      "description": "Bound DAW (default logic)."
    }
  },
  "required": [
    "name"
  ],
  "additionalProperties": false
}