> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt.

# Kolejkowanie połączeń

## Omówienie

Gdy agent lub workspace osiągnie limit równoczesnych połączeń, nowe połączenia są zwykle odrzucane od razu. Przy włączonym kolejkowaniu połączeń dzwoniący, którzy trafiają do agenta przy pełnym obciążeniu, pozostają na linii z muzyką oczekiwania i są automatycznie łączeni w kolejności zgłoszenia, gdy tylko zwolni się miejsce.

Kolejkowanie połączeń konfiguruje się osobno dla każdego agenta. Domyślnie jest wyłączone.

> **Note**
>
> Kolejkowanie połączeń działa po wykorzystaniu całej dostępnej pojemności, w tym pojemności burst, gdy dla agenta
> włączono [ceny burst](/docs/pl/eleven-agents/guides/burst-pricing).

## Jak działa kolejkowanie połączeń

1. **Sprawdzenie pojemności**: Gdy przychodzi połączenie, ElevenAgents sprawdza, czy agent i workspace mają wolne miejsce na równoczesne połączenie. Jeśli tak, połączenie jest łączone od razu.
2. **Kolejkowanie**: Jeśli nie ma wolnego miejsca, dzwoniący trafia do kolejki agenta i słyszy muzykę oczekiwania. Rozmowa nie zaczyna się, a podczas oczekiwania nic nie jest naliczane.
3. **Przyjęcie**: Gdy tylko zwolni się miejsce, dzwoniący na początku kolejki zostaje połączony i rozmowa zaczyna się jak zwykle.
4. **Limit czasu**: Jeśli żadne miejsce nie zwolni się w czasie **Maksymalnego czasu oczekiwania w kolejce**, połączenie zostanie rozłączone. Połączenia telefoniczne są normalnie kończone. Klienci WebSocket otrzymują zdarzenie `queue_status` ze statusem `timed_out`, a następnie połączenie zostaje zamknięte z kodem 4300.

Dzwoniący są łączeni ściśle według kolejności zgłoszenia dla danego agenta. Gdy kilku agentów współdzieli pulę równoczesnych połączeń workspace'u, zwykle jako pierwsi są łączeni dzwoniący, którzy czekali dłużej.

### Co słyszy dzwoniący

* Dzwoniący na numery Twilio i SIP trunk słyszą muzykę oczekiwania w trakcie połączenia.
* Użytkownicy widgetu i SDK przeglądarkowego słyszą muzykę oczekiwania w przeglądarce. Widget (w wersji 0.17.0 lub nowszej) wyświetla też komunikat o oczekiwaniu i wyłącza wprowadzanie tekstu podczas oczekiwania w kolejce.
* Klienci bezpośredniego API WebSocket otrzymują muzykę oczekiwania jako zwykłe zdarzenia `audio`, a także zdarzenia `queue_status`, które pozwalają obsłużyć stan oczekiwania we własnym UI. Zobacz [Obsługa zdarzeń kolejki](#handling-queue-events-in-a-custom-websocket-client).

### Rozliczanie i czas trwania rozmowy

Czas spędzony w kolejce **nie jest rozliczany**, nie wlicza się do **Maksymalnego czasu trwania rozmowy** agenta i nie jest uwzględniany w raportowanym czasie trwania rozmowy. Szczegóły rozmowy w panelu pokazują, jak długo dzwoniący czekał przed połączeniem.

## Obsługiwane kanały

| Kanał                                       | Kolejkowanie połączeń |
| ------------------------------------------- | --------------------- |
| Połączenia przychodzące Twilio              | Obsługiwane           |
| Połączenia przychodzące SIP trunk           | Obsługiwane           |
| Widget i klienckie SDK (WebSocket i WebRTC) | Obsługiwane           |
| Bezpośrednie API WebSocket                  | Obsługiwane           |
| Połączenia wychodzące i wsadowe             | Nieobsługiwane        |
| Agenci tylko tekstowi                       | Nieobsługiwane        |
| Genesys, AudioCodes, Exotel, WhatsApp i SMS | Nieobsługiwane        |

> **Note**
>
> Dzienny limit połączeń nie podlega kolejce. Połączenie przekraczające dzienny limit agenta jest odrzucane
> od razu, ponieważ limit nie zwalnia się przed następnym dniem.

## Konfiguracja

Kolejkowanie połączeń konfiguruje się dla każdego agenta w sekcji **Limity** na karcie **Bezpieczeństwo** agenta.

| Ustawienie                                | Opis                                                                                                                                                                                                  | Domyślnie                   |
| ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------- |
| **Włącz kolejkowanie połączeń**           | Umieszczaj dzwoniących w kolejce, gdy agent osiągnie limit równoczesnych połączeń.                                                                                                                    | Wyłączone                   |
| **Maksymalny czas oczekiwania w kolejce** | Jak długo dzwoniący może czekać przed rozłączeniem, w sekundach. Od 1 do 1800 sekund (30 minut).                                                                                                      | 180 sekund (3 minuty)       |
| **Własna muzyka oczekiwania**             | Plik MP3 lub WAV odtwarzany w pętli dzwoniącym w kolejce. Maksymalnie 40 MB i 3 minuty. Jeśli nie prześlesz pliku, dzwoniący usłyszą domyślny sygnał oczekiwania. Prześlij go w panelu lub przez API. | Domyślny sygnał oczekiwania |

#### Aktualizacja w panelu

#### Otwórz ustawienia limitów

Otwórz agenta w panelu, przejdź do karty **Bezpieczeństwo** i przewiń do sekcji **Limity**.

#### Włącz kolejkowanie połączeń

Włącz **Włącz kolejkowanie połączeń** i ustaw **Maksymalny czas oczekiwania w kolejce**.

#### Prześlij muzykę oczekiwania (opcjonalnie)

W sekcji **Własna muzyka oczekiwania** prześlij plik MP3 lub WAV. Przed publikacją możesz odsłuchać domyślny sygnał oczekiwania i przesłany klip.

#### Opublikuj zmiany

Kliknij **Opublikuj**, aby zastosować nowe ustawienia.

#### Aktualizacja przez CLI

#### Pobierz konfigurację agenta

```bash
elevenlabs agents pull --agent "<agent-name>"
```

#### Edytuj \`agent_configs/\<agent-name>.json\`

Ustaw `platform_settings.queueing_config`:

```json
{
  "platform_settings": {
    "queueing_config": {
      "enabled": true,
      "wait_timeout_seconds": 300
    }
  }
}
```

#### Wyślij zmiany

```bash
elevenlabs agents push --agent "<agent-name>"
```

#### Aktualizacja przez API

```python
from dotenv import load_dotenv
from elevenlabs import ElevenLabs
import os

load_dotenv()

elevenlabs = ElevenLabs(
    api_key=os.getenv("ELEVENLABS_API_KEY"),
)

elevenlabs.conversational_ai.agents.update(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    platform_settings={
        "queueing_config": {
            "enabled": True,
            "wait_timeout_seconds": 300,
        },
    },
)
```

```typescript
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import "dotenv/config";

const elevenlabs = new ElevenLabsClient();

await elevenlabs.conversationalAi.agents.update("agent_7101k5zvyjhmfg983brhmhkd98n6", {
  platformSettings: {
    queueingConfig: {
      enabled: true,
      waitTimeoutSeconds: 300,
    },
  },
});
```

### Zarządzanie muzyką oczekiwania przez API

Prześlij plik MP3 lub WAV, aby ustawić własną muzykę oczekiwania agenta. Przesłanie nowego pliku zastępuje poprzedni. API obsługuje typy treści `audio/mpeg` i `audio/wav`, dlatego przykłady ustawiają typ jawnie.

```python
from dotenv import load_dotenv
from elevenlabs import ElevenLabs
import os

load_dotenv()

elevenlabs = ElevenLabs(
api_key=os.getenv("ELEVENLABS_API_KEY"),
)

elevenlabs.conversational_ai.agents.hold_audio.create(
agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
hold_audio_file=("hold-music.mp3", open("hold-music.mp3", "rb"), "audio/mpeg"),
)

```

```typescript
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import fs from "node:fs";
import "dotenv/config";

const elevenlabs = new ElevenLabsClient();

const holdAudioFile = new File([fs.readFileSync("hold-music.mp3")], "hold-music.mp3", {
  type: "audio/mpeg",
});

await elevenlabs.conversationalAi.agents.holdAudio.create("agent_7101k5zvyjhmfg983brhmhkd98n6", {
  holdAudioFile,
});
```

Usuń własny klip, aby wrócić do domyślnego sygnału oczekiwania:

```python
elevenlabs.conversational_ai.agents.hold_audio.delete(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
)
```

```typescript
await elevenlabs.conversationalAi.agents.holdAudio.delete("agent_7101k5zvyjhmfg983brhmhkd98n6");
```

Aktualny klip jest zwracany tylko do odczytu jako `platform_settings.queueing_config.hold_audio` przy agencie. Wysłanie `hold_audio` w żądaniu utworzenia lub aktualizacji agenta nie daje żadnego efektu.

## Obsługa zdarzeń kolejki we własnym kliencie WebSocket

Klienci połączeni przez [API WebSocket](/docs/pl/eleven-agents/libraries/web-sockets) otrzymują zdarzenia `queue_status`, gdy znajdują się w kolejce:

```json
{
  "type": "queue_status",
  "queue_status_event": {
    "status": "waiting"
  }
}
```

* `waiting` jest wysyłane raz, zaraz po `conversation_initiation_metadata` i przed muzyką oczekiwania.
* `admitted` jest wysyłane, gdy dzwoniący zostanie połączony. Rozmowa przebiega wtedy jak zwykle.
* `timed_out` jest wysyłane, gdy czas oczekiwania przekroczy maksymalny limit. Serwer następnie zamyka połączenie z kodem 4300.

Połączenia łączone od razu nigdy nie otrzymują zdarzeń `queue_status`. Zdarzenie jest zawsze wysyłane do dzwoniących w kolejce i nie trzeba go włączać w `client_events` agenta.

Muzyka oczekiwania jest dostarczana jako zwykłe zdarzenia `audio` w fragmentach trwających około sekundy, pod warunkiem że zdarzenia klienta agenta obejmują `audio`. Użyj `queue_status`, aby wyświetlić stan oczekiwania, zamiast traktować muzykę oczekiwania jako mowę agenta.

> **Info**
>
> SDK `@elevenlabs/client` i `@elevenlabs/react` nie udostępniają jeszcze osobnego callbacku dla tego
> zdarzenia. Użyj callbacku `onIncomingEvent`, aby obserwować surowe zdarzenia serwera, w tym
> `queue_status`.

## FAQ

#### Czy połączenie w kolejce wlicza się do limitu równoczesnych połączeń?

Nie. Dzwoniący w kolejce nie zajmuje miejsca na równoczesne połączenie, dopóki nie zostanie połączony z agentem.

#### Czy dzwoniący mogą usłyszeć pozycję w kolejce lub szacowany czas oczekiwania?

Jeszcze nie. Dzwoniący w kolejce słyszą tylko muzykę oczekiwania. Pozycja w kolejce i szacowany czas oczekiwania
nie są komunikowane.

#### Co się stanie, jeśli dzwoniący rozłączy się podczas oczekiwania?

Dzwoniący od razu opuszcza kolejkę, a wszyscy za nim przesuwają się o jedno miejsce. Nie są naliczane
żadne minuty rozmowy.

#### Czy kolejkowanie połączeń działa z połączeniami wychodzącymi?

Nie. Połączenia wychodzące i wsadowe są realizowane tylko wtedy, gdy dostępna jest pojemność, więc nigdy
nie trafiają do kolejki.