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

# Warteschlange, Zeitpläne und Tasks

> Mit SessionRpc des Laravel Copilot SDK verwalten Sie Warteschlange, Zeitpläne und Hintergrundaufgaben.

## Warteschlange, Zeitpläne und Tasks

Geltungsbereich: SessionRpc (sessionbezogene Operationen, die an eine Session gebunden sind)

Eine Übersicht über RPC und die Liste aller RPC-Seiten finden Sie unter [RPC](https://kawax.biz/de/packages/laravel-copilot-sdk/rpc.md).

```php theme={null}
// queue: Benutzerbezogene Einträge in der Warteschlange prüfen und verwalten
$pending = $session->rpc()->queue()->pendingItems();
// $pending->items - Array von QueuePendingItems
// $pending->items[0]->kind - QueuePendingItemsKind (Command / Message)

$removed = $session->rpc()->queue()->removeMostRecent();
// $removed->removed - Ob der letzte Eintrag entfernt werden konnte

$session->rpc()->queue()->clear();

// Eintrag an einer bestimmten Position einfügen (position beginnt bei 0)
use Revolution\Copilot\Types\Rpc\QueueInsertAtRequest;
use Revolution\Copilot\Types\Rpc\QueueInsertMessage;

$queue = $session->rpc()->queue();
$inserted = $queue->insertAt(new QueueInsertAtRequest(
    position: 0,
    message: new QueueInsertMessage(prompt: 'Review the changes'),
));
// $inserted->id - ID des eingefügten Eintrags

$queue->moveItem(['id' => $inserted->id, 'toPosition' => 1]);
$duplicated = $queue->duplicateAt(['id' => $inserted->id]);
$queue->updateText(['id' => $duplicated->id, 'prompt' => 'Review and test the changes']);
$removedAt = $queue->removeAt(['id' => $duplicated->id]);
// $removedAt->removed - Ob der Eintrag entfernt werden konnte

$sent = $queue->sendNow(['id' => $inserted->id]);
// $sent->steered - Ob er an den laufenden Turn gesendet wurde

// Drain pausieren. Die Pause wird nicht automatisch aufgehoben; setzen Sie sie immer mit false fort
$queue->setDrainPaused(['paused' => true]);
$queue->setDrainPaused(['paused' => false]);

// schedule (experimental: Verwaltung geplanter Prompts)
$schedule = $session->rpc()->schedule()->list();
// $schedule->entries - Array von ScheduleEntry

use Revolution\Copilot\Types\Rpc\ScheduleStopRequest;

$stopped = $session->rpc()->schedule()->stop(new ScheduleStopRequest(id: 1));
// $stopped->stopped - Ob das Stoppen erfolgreich war

// tasks (experimental: Verwaltung von Hintergrundaufgaben)
// Agent-Task starten und ID abrufen
use Revolution\Copilot\Types\Rpc\TasksStartAgentRequest;

$result = $session->rpc()->tasks()->startAgent(new TasksStartAgentRequest(
    agentType: 'explore',
    prompt: 'Search for all TODO comments in the codebase',
    name: 'todo-search',
    description: 'Find TODO items', // Optional
    model: 'gpt-4o', // Optional
));
// $result->agentId - ID der Hintergrundaufgabe

// Aktuelle Task-Liste abrufen
$list = $session->rpc()->tasks()->list();
// $list->tasks - Array von TaskAgentInfo, TaskShellInfo und TaskClientInfo

// Ausgabe einer abgetrennten Shell inkrementell per Cursor lesen
use Revolution\Copilot\Types\Rpc\TasksReadOutputRequest;

$cursor = null;
do {
    $output = $session->rpc()->tasks()->readOutput(new TasksReadOutputRequest(
        id: 'shell-1',
        cursor: $cursor,
        waitMs: 1000,
    ));
    echo $output->text;
    $cursor = $output->cursor;
} while ($output->exit === null);
// $output->exit->status - Endstatus der Task
// $output->exit->exitCode - Exit-Code des Prozesses (nullable)

// Ein Lesevorgang umfasst maximal 64 KiB. waitMs ist standardmäßig 0, maximal 30000ms.
// stdout und stderr werden zusammengeführt. Wird der Cursor ungültig, lesen Sie ohne Cursor erneut.

// Anwendungseigene Jobs als Task registrieren
use Revolution\Copilot\Types\Rpc\TasksRegisterRequest;

$registered = $session->rpc()->tasks()->register(new TasksRegisterRequest(
    clientTaskId: 'import-123',
    description: 'Import customer data',
    cancellable: true,
    displayName: 'Kundenimport', // Optional
));
// $registered->task->id - Von der CLI zugewiesene Task-ID
// $registered->created / $registered->reclaimed - Status: neu erstellt bzw. verwaiste Task zurückgeholt

// Fortschritt einer clientseitigen Task aktualisieren
use Revolution\Copilot\Enums\TaskClientActiveStatus;
use Revolution\Copilot\Enums\TaskClientUpdateKind;
use Revolution\Copilot\Types\Rpc\TaskClientUpdate;
use Revolution\Copilot\Types\Rpc\TasksUpdateRequest;

$updated = $session->rpc()->tasks()->update(new TasksUpdateRequest(
    id: $registered->task->id,
    sequence: 1,
    update: new TaskClientUpdate(
        kind: TaskClientUpdateKind::Progress,
        status: TaskClientActiveStatus::Running,
        phase: 'importing',
        percentage: 25,
    ),
));
// sequence bei jeder Aktualisierung erhöhen

// Abschluss melden
$completed = $session->rpc()->tasks()->update(new TasksUpdateRequest(
    id: $registered->task->id,
    sequence: 2,
    update: new TaskClientUpdate(
        kind: TaskClientUpdateKind::Completed,
        result: ['imported' => 100],
    ),
));

// Fortschritt der Task abrufen (null, wenn nicht verfolgt)
$progress = $session->rpc()->tasks()->getProgress(['id' => $registered->task->id])->progress;
// TaskAgentProgress, TaskClientProgress, TaskShellProgress oder null

// Status abgetrennter Shells aktualisieren und auf den Abschluss der Hintergrundarbeit warten
$session->rpc()->tasks()->refresh();
$session->rpc()->tasks()->waitForPending();

// Aktuell in den Hintergrund verschiebbare Task abrufen oder diese Task sofort in den Hintergrund verschieben
$promotable = $session->rpc()->tasks()->getCurrentPromotable()->task;
$promotedCurrent = $session->rpc()->tasks()->promoteCurrentToBackground()->task;

// Task in den Hintergrundmodus verschieben (synchrones Warten aufheben)
use Revolution\Copilot\Types\Rpc\TasksPromoteToBackgroundRequest;

$promoted = $session->rpc()->tasks()->promoteToBackground(
    new TasksPromoteToBackgroundRequest(id: $result->agentId)
);
// $promoted->promoted - Ob das Verschieben erfolgreich war

// Task abbrechen
use Revolution\Copilot\Types\Rpc\TasksCancelRequest;

$cancelled = $session->rpc()->tasks()->cancel(
    new TasksCancelRequest(id: $result->agentId)
);
// $cancelled->cancelled - Ob der Abbruch erfolgreich war

// Abgeschlossene oder abgebrochene Task entfernen
use Revolution\Copilot\Types\Rpc\TasksRemoveRequest;

$removed = $session->rpc()->tasks()->remove(
    new TasksRemoveRequest(id: $result->agentId)
);
// $removed->removed - Ob das Entfernen erfolgreich war

// Nachricht an eine laufende Agent-Task senden (Steering)
use Revolution\Copilot\Types\Rpc\TasksSendMessageRequest;

$sent = $session->rpc()->tasks()->sendMessage(
    new TasksSendMessageRequest(id: $result->agentId, message: 'Please search other directories too')
);
// $sent->sent - Ob die Nachricht erfolgreich gesendet wurde
// $sent->error - Fehlermeldung bei fehlgeschlagenem Senden (nullable)

// Nur den Haupt-Turn unterbrechen und die Prompts in der Warteschlange für den nächsten Turn behalten
use Revolution\Copilot\Types\Rpc\InterruptMainTurnRequest;

$interrupted = $session->rpc()->interruptMainTurn(
    new InterruptMainTurnRequest(flushQueued: true)
);
// $interrupted->interrupted - Ob der laufende Haupt-Turn unterbrochen werden konnte

// Alle laufenden Hintergrund-Agents abbrechen, ohne den Haupt-Turn zu unterbrechen
$cancelledCount = $session->rpc()->cancelAllBackgroundAgents();
// Anzahl der abgebrochenen Agents
```


## Related topics

- [RPC (Remote Procedure Call)](https://kawax.biz/de/packages/laravel-copilot-sdk/rpc.md)
- [Task-Scheduling](https://kawax.biz/de/scheduling.md)
- [Sessions, Host und Umgebung](https://kawax.biz/de/packages/laravel-copilot-sdk/rpc/server-sessions.md)
- [ServerRpc-Übersicht](https://kawax.biz/de/packages/laravel-copilot-sdk/rpc/server-overview.md)
- [Paket-Caches in optimize integrieren](https://kawax.biz/de/advanced/package-optimization.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.