> ## Documentation Index
> Fetch the complete documentation index at: https://docs.youka.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Aufgaben

> Aufgaben prüfen und auf das Beenden asynchroner Vorgänge warten

Jeder asynchrone Vorgang in Youka läuft letztlich als Aufgabe, aber die primäre SDK-Oberfläche liefert inzwischen Operation-Handles statt roher Task-IDs zurück. Die meisten Aufrufer sollten `client.projects.wait(...)` oder `client.exports.wait(...)` verwenden und nur dann zu `client.tasks.*` greifen, wenn sie eine Low-Level-Inspektion von Aufgaben benötigen.

## `client.tasks.get(taskId, options?)`

Ruft den aktuellen Zustand einer Aufgabe anhand ihrer ID ab.

```ts theme={null}
const task = await client.tasks.get("tsk_abc123");
console.log(task.status, task.type);
```

### Aufgabenstatus

| Status        | Terminal? | Bedeutung                                                              |
| ------------- | --------- | ---------------------------------------------------------------------- |
| `created`     | No        | Aufgabe wurde erstellt, aber noch nicht in die Warteschlange gestellt. |
| `queued`      | No        | Aufgabe wartet auf die Ausführung.                                     |
| `in-progress` | No        | Aufgabe wird gerade ausgeführt.                                        |
| `completed`   | Yes       | Aufgabe wurde erfolgreich abgeschlossen.                               |
| `finalized`   | Yes       | Aufgabe ist abgeschlossen und die Nachbearbeitung ist fertig.          |
| `failed`      | Yes       | Aufgabe ist mit einem Fehler fehlgeschlagen.                           |
| `cancelled`   | Yes       | Aufgabe wurde abgebrochen.                                             |
| `timed-out`   | Yes       | Aufgabe hat ihr Zeitlimit erreicht.                                    |

## `client.tasks.wait(taskId, options?)`

Fragt eine Aufgabe so lange ab, bis sie einen terminalen Zustand erreicht. Gibt bei Erfolg die finale Aufgabe zurück, wirft bei Fehlern `YoukaTaskError`.

```ts theme={null}
const task = await client.tasks.wait("tsk_abc123", {
  pollIntervalMs: 3_000,
  signal: abortController.signal,
});
```

### Optionen

<ParamField path="pollIntervalMs" type="number">
  Millisekunden zwischen den Abfragen. Standard ist `2000`.
</ParamField>

<ParamField path="signal" type="AbortSignal">
  Bricht das Warten ab. Die laufende Anfrage und jede ausstehende Verzögerung werden
  sofort abgebrochen.
</ParamField>

### Fehler

`client.tasks.wait(...)` wirft `YoukaTaskError`, wenn die Aufgabe in `failed`, `cancelled` oder `timed-out` endet:

```ts theme={null}
import { YoukaTaskError } from "@youka/sdk";

try {
  await client.tasks.wait("tsk_abc123");
} catch (error) {
  if (error instanceof YoukaTaskError) {
    console.error(error.code); // TASK_FAILED | TASK_CANCELLED | TASK_TIMED_OUT
    console.error(error.task); // Full RestTask payload
  }
  throw error;
}
```

## `client.projects.wait(operation, options?)`

Wartet, bis eine projektbezogene Operation abgeschlossen ist, und lädt anschließend das Projekt erneut. Gibt das Operation-Handle, die terminale Aufgabe und das aktualisierte Projekt zurück.

```ts theme={null}
const operation = await client.projects.create({
  source: { type: "path", path: "./song.mp3" },
});

const { project, task } = await client.projects.wait(operation, {
  pollIntervalMs: 2_500,
});

console.log("Project ready:", project.id);
console.log("Task finished in state:", task.status);
```

<ParamField path="operation" type="ProjectOperation" required>
  Üblicherweise das Ergebnis von `client.projects.create(...)`,
  `client.projects.separateStems(...)` oder `client.projects.syncLyrics(...)`.
</ParamField>

## `client.exports.wait(operationOrId, options?)`

Wartet, bis ein Cloud-Export einen terminalen Zustand erreicht. Übergib entweder die von `client.exports.create(...)` zurückgegebene `ExportOperation` oder einen `exportId`-String.

```ts theme={null}
const operation = await client.exports.create("prj_abc123", {
  resolution: "1080p",
  quality: "high",
});

const finalized = await client.exports.wait(operation, {
  pollIntervalMs: 3_000,
});

console.log(finalized.status, finalized.url);
```

## Abbrechen

Übergib ein `AbortSignal`, um ein lang laufendes Warten abzubrechen:

```ts theme={null}
const controller = new AbortController();

setTimeout(() => controller.abort(), 60_000);

try {
  await client.projects.wait(operation, { signal: controller.signal });
} catch (error) {
  if (error instanceof Error && error.name === "AbortError") {
    console.log("Wait cancelled after 60s");
  } else {
    throw error;
  }
}
```

Dasselbe Signal bricht auch die zugrunde liegende Abfrage-Anfrage für Aufgaben oder Exporte ab.

## Was kommt als Nächstes

* [Errors](/de/sdk/errors) — `YoukaTaskError` und wiederholbare Fehler behandeln
* [Exports](/de/sdk/exports) — auf das Abschließen eines Exports warten
* [API async jobs](/de/api/async-jobs) — dasselbe Muster über reines HTTP