# Stella Managed Media — Audio

Capabilities for speech-to-text, text-to-dialogue, sound effects, and audio separation.

Audience: AI agents. Plain text on purpose. Curl me.

## Capabilities

### `text_to_dialogue` — speak a script

- Single profile (`default`).
- Convenience field: `prompt` is mapped to the provider's `text` field.
- Useful `input` hints: voice settings, speaker mapping for multi-voice scripts.

```bash
curl -X POST "$STELLA_API/api/media/v1/generate" \
  -H "Authorization: Bearer $STELLA_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "capability": "text_to_dialogue",
    "prompt": "Welcome to Stella. How can I help today?"
  }'
```

### `sound_effects` — Foley / sfx from text

- Single profile (`default`).
- Convenience field: `prompt` → provider `text`.
- Required `input` hint: `duration_seconds` (gateway requires it for billing).

### `speech_to_text` — transcribe audio

- Single profile (`default`).
- Required: `source` (or `sourceUrl`) of the audio file.
- Output includes `text`, segments, and detected language.

### `audio_visual_separate` — isolate audio guided by video

- Single profile (`default`).
- Required inputs go in `sources`: `{ "video": "data:...", "audio": "data:..." }`.
- Output: separated stems / tracks.

## Notes for agents

- Audio outputs land in `state/media/outputs/` as `.mp3` / `.wav` and play
  inline in the Display sidebar — no need to manage playback yourself.
- For long transcriptions, the provider may take a while; keep the user
  updated only if the job is still pending after ~30s.

## Endpoint

POST <stella-api>/api/media/v1/generate
Content-Type: application/json
Authorization: Bearer <stella-session-token>

Where `<stella-api>` is the Stella backend base URL the desktop app is signed
in against (e.g. `https://api.stella.sh`). Reuse the user's existing session
token — do not invent your own credentials.

## Request body

```json
{
  "capability": "<id>",          // required; see per-kind sections below
  "profile": "<id>",             // optional; defaults to the capability's preferred profile
  "prompt": "...",               // optional convenience field; mapped to the capability's prompt key
  "aspectRatio": "16:9",         // optional convenience field for image/video; mapped to aspect_ratio
  "sourceUrl": "https://...",    // optional; for capabilities that take a public URL
  "source": "data:image/png;base64,...", // optional; for local files (preferred)
  "sources": { "video": "data:...", "audio": "data:..." }, // for multi-input capabilities
  "input": { /* provider-specific overrides, merged on top of the convenience fields */ }
}
```

`source` accepts a `data:` URI string or `{ "base64": "...", "mimeType": "image/png" }`.
The backend wraps the value into the right shape for the picked endpoint
(e.g. `image_urls: ["data:..."]` for image edit).

## Response (202 Accepted)

```json
{
  "jobId": "job_123",
  "capability": "text_to_image",
  "profile": "best",
  "status": "queued",
  "upstreamStatus": "IN_QUEUE",
  "subscription": {
    "query": "api.media_jobs.getByJobId",
    "args": { "jobId": "job_123" }
  }
}
```

## Watching for completion

Use the local `stella-media` command when you want normal
`exec_command`-style behavior. It submits the same gateway request, can wait
until the job reaches a terminal state, and saves completed outputs to
`state/media/outputs/`.

```bash
cat > /tmp/stella-media-request.json <<'JSON'
{
  "capability": "text_to_image",
  "prompt": "a clean product render of a translucent blue desk lamp",
  "aspectRatio": "1:1"
}
JSON

stella-media generate --request-file /tmp/stella-media-request.json --wait --timeout 240
```

Without `--wait`, `stella-media generate` returns after submit with a
`jobId`. To check a job later:

```bash
stella-media status --job-id <jobId> --save
```

The Stella desktop renderer also subscribes to every succeeded media job for
the signed-in user, downloads the output to
`state/media/outputs/<jobId>_<i>.<ext>`, and pops it open in the Display
sidebar automatically. If generation fails, Stella shows a failure
notification.

If you do need the raw status, subscribe to Convex:
`useQuery(api.media_jobs.getByJobId, { jobId })`. Status values:
`queued`, `running`, `succeeded`, `failed`, `canceled`.

## Auth failure (401)

If the user is not signed in, the endpoint returns a structured 401:

```json
{
  "error": "Sign in to Stella to use media generation.",
  "code": "auth_required",
  "action": "Ask the user to open the Stella desktop app and finish signing in (Settings → Account, or the welcome screen on first launch). Once they're signed in, retry the same request — no payload changes needed.",
  "docsUrl": "https://stella.sh/docs/media"
}
```

When you see `code: "auth_required"`:
1. Stop the in-flight job — do not retry on a backoff.
2. Surface `action` to the user verbatim so they know what to do.
3. Once they confirm sign-in, re-run the original request with the same payload.

The response also sets `WWW-Authenticate: Bearer realm="stella-media"` for
non-agent HTTP clients.

## Errors

All other errors return `{ "error": "human-readable message" }` with an
appropriate status. Upstream provider errors (content policy, validation,
rate limits) are parsed and forwarded as-is — show the message to the user.