---
title: "ਏਜੰਟ ਦੇ ਕਦਮ ਅਤੇ ਹੈਂਡਆਫ਼"
description: "ਏਜੰਟ ਨੂੰ ਆਪਣੀਆਂ ਹਦਾਇਤਾਂ, ਟੂਲਾਂ ਅਤੇ ਇਕੱਠੀਆਂ ਕੀਤੀਆਂ ਵੈਲਿਊਜ਼ ਵਾਲੇ ਕਦਮਾਂ ਵਿੱਚ ਵੰਡੋ ਅਤੇ ਕਾਲ ਦੌਰਾਨ ਏਜੰਟਾਂ ਵਿਚਕਾਰ ਕਾਲਾਂ ਹੈਂਡਆਫ਼ ਕਰੋ।"
---
ਇੱਕੋ prompt ਮਾਡਲ ਨੂੰ ਪੂਰਾ ਕੰਮ ਇੱਕੋ ਵਾਰ ਦਿੰਦਾ ਹੈ। **ਸਟੈਪਾਂ** ਇਸਨੂੰ ਕਾਲ ਦਾ ਇੱਕ ਪੜਾਅ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਦਿੰਦੀਆਂ ਹਨ: ਹਰ ਸਟੈਪ ਦੀਆਂ ਆਪਣੀਆਂ ਹਦਾਇਤਾਂ, ਆਪਣੇ ਟੂਲ, ਸ਼ਬਦ-ਬ-ਸ਼ਬਦ ਬੋਲੀ ਜਾਣ ਵਾਲੀ ਇੱਕ ਵਿਕਲਪਿਕ ਲਾਈਨ, ਅਤੇ ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ ਇਕੱਠੇ ਕਰਨ ਲਈ ਮੁੱਲ ਹੁੰਦੇ ਹਨ। **ਹੈਂਡਆਫ਼** ਤੁਹਾਡੀ ਸੰਸਥਾ ਦੇ ਕਿਸੇ ਹੋਰ ਏਜੰਟ ਨੂੰ ਕਾਲ ਦੇ ਵਿਚਕਾਰ ਕੰਮ ਸੰਭਾਲਣ ਦਿੰਦੇ ਹਨ, ਟ੍ਰਾਂਸਕ੍ਰਿਪਟ ਬਰਕਰਾਰ ਰਹਿੰਦੀ ਹੈ, ਇਸ ਲਈ ਕਾਲਰ ਨੂੰ ਕਦੇ ਵੀ ਆਪਣੀ ਗੱਲ ਦੁਹਰਾਉਣੀ ਨਹੀਂ ਪੈਂਦੀ।
ਹਰ ਏਜੰਟ ਇੱਕੋ prompt ਵਜੋਂ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ। ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਸਟੈਪਾਂ ਜਾਂ ਹੈਂਡਆਫ਼ ਨਹੀਂ ਜੋੜਦੇ, ਇਸ ਵਿੱਚ ਕੁਝ ਨਹੀਂ ਬਦਲਦਾ।
## ਸਟੈਪਾਂ ਜਾਂ ਇੱਕੋ prompt?
| ਸਟੈਪਾਂ ਕਦੋਂ ਵਰਤੋ | ਇੱਕੋ prompt ਕਦੋਂ ਰੱਖੋ |
| --- | --- |
| ਕਾਲ ਵਿੱਚ ਅਜਿਹੇ ਪੜਾਅ ਹਨ ਜੋ ਕ੍ਰਮ ਵਿੱਚ ਹੋਣੇ ਲਾਜ਼ਮੀ ਹਨ: ਪਹਿਲਾਂ ਪੁਸ਼ਟੀ ਕਰੋ, ਫਿਰ ਬੁੱਕ ਕਰੋ। | ਗੱਲਬਾਤ ਖੁੱਲ੍ਹੀ ਹੈ: FAQ, ਰਿਸੈਪਸ਼ਨ, ਆਮ ਸਹਾਇਤਾ। |
| ਏਜੰਟ ਦੇ ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ ਕੋਈ ਮੁੱਲ ਕੈਪਚਰ ਹੋਣਾ ਲਾਜ਼ਮੀ ਹੈ। | ਕਿਸੇ ਵੀ ਚੀਜ਼ ਨੂੰ ਨਿਰਧਾਰਤ ਕ੍ਰਮ ਵਿੱਚ ਇਕੱਠਾ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। |
| ਕੋਈ ਨਿਯਮ ਕਦੇ ਨਹੀਂ ਬਦਲਣਾ ਚਾਹੀਦਾ, ਜਿਵੇਂ ਕਿ "18 ਸਾਲ ਤੋਂ ਘੱਟ ਉਮਰ ਦੇ ਕਾਲਰ ਨੂੰ ਸਰਪ੍ਰਸਤ ਕੋਲ ਭੇਜੋ"। | ਮਾਡਲ ਦਾ ਫ਼ੈਸਲਾ ਹਰ ਸ਼ਾਖਾ ਲਈ ਕਾਫ਼ੀ ਵਧੀਆ ਹੈ। |
| ਕਾਲ ਵਿੱਚ ਕਿਸੇ ਨਿਰਧਾਰਤ ਬਿੰਦੂ 'ਤੇ lookup ਚਲਾਉਣਾ ਲਾਜ਼ਮੀ ਹੈ। | ਜਦੋਂ ਵੀ ਕਾਲਰ ਪੁੱਛੇ, ਟੂਲ ਕਾਲ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ। |
| ਕਾਲ ਦਾ ਕੋਈ ਹਿੱਸਾ ਕਿਸੇ ਹੋਰ ਏਜੰਟ ਦਾ ਹੈ, ਜਿਸਦਾ ਆਪਣਾ prompt ਅਤੇ ਆਵਾਜ਼ ਹੈ। | ਇੱਕ persona ਸਭ ਕੁਝ ਸੰਭਾਲਦੀ ਹੈ। |
ਸਟੈਪਾਂ ਸਕ੍ਰਿਪਟ ਕੀਤੀ ਹੋਈ ਫ਼ੋਨ ਟ੍ਰੀ ਨਹੀਂ ਹਨ। ਇੱਕ ਸਟੈਪ ਦੇ ਅੰਦਰ ਮਾਡਲ ਗੱਲਬਾਤ ਉਸੇ ਤਰ੍ਹਾਂ ਚਲਾਉਂਦਾ ਹੈ ਜਿਵੇਂ ਇੱਕੋ prompt ਨਾਲ ਚਲਾਉਂਦਾ ਹੈ। ਸਟੈਪ ਇਹ ਤੈਅ ਕਰਦਾ ਹੈ ਕਿ ਉਹ ਕਿਸ ਉੱਤੇ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ, ਕਿਹੜੇ ਟੂਲ ਵਰਤ ਸਕਦਾ ਹੈ ਅਤੇ ਬਾਹਰ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ ਉਸਨੂੰ ਕੀ ਚਾਹੀਦਾ ਹੈ।
## ਸਟੈਪਾਂ ਵਾਲਾ ਏਜੰਟ ਕਿਵੇਂ ਬਣਦਾ ਹੈ
ਜਦੋਂ ਕਿਸੇ ਏਜੰਟ ਵਿੱਚ ਸਟੈਪਾਂ ਹੁੰਦੀਆਂ ਹਨ, ਤਾਂ ਉਸਦਾ `prompt` **ਸਾਂਝੀਆਂ ਹਦਾਇਤਾਂ** ਰੱਖਦਾ ਹੈ: ਉਹ persona ਅਤੇ ਨਿਯਮ ਜੋ ਹਰ ਸਟੈਪ ਵਿੱਚ ਲਾਗੂ ਹੁੰਦੇ ਹਨ। ਹਰ ਸਟੈਪ ਇਸ ਦੇ ਉੱਪਰ ਆਪਣੀਆਂ ਹਦਾਇਤਾਂ ਜੋੜਦਾ ਹੈ। ਹਰ ਵਾਰੀ ਮਾਡਲ ਸਾਂਝੀਆਂ ਹਦਾਇਤਾਂ, ਮੌਜੂਦਾ ਸਟੈਪ ਦਾ ਨਾਮ ਅਤੇ ਹਦਾਇਤਾਂ, ਅਤੇ ਹੁਣ ਤੱਕ ਇਕੱਠੇ ਕੀਤੇ ਮੁੱਲ ਵੇਖਦਾ ਹੈ।
ਬਿਲਡਰ ਵਿੱਚ, ਏਜੰਟ ਨੂੰ **ਇੱਕੋ prompt** ਤੋਂ **ਸਟੈਪਾਂ** 'ਤੇ ਬਦਲੋ। ਤੁਹਾਨੂੰ ਹਰ ਸਟੈਪ ਲਈ ਉਸਦੇ ਨਾਮ, ਹਦਾਇਤਾਂ, say ਲਾਈਨ, ਟੂਲਾਂ, ਇਕੱਠੇ ਕੀਤੇ ਮੁੱਲਾਂ ਅਤੇ ਟ੍ਰਾਂਜ਼ਿਸ਼ਨਾਂ ਵਾਲਾ ਕਾਰਡ, ਇੱਕ ਹੈਂਡਆਫ਼ ਪਿਕਰ, ਅਤੇ ਸਟੈਪਾਂ ਦਾ ਸਿਰਫ਼-ਪੜ੍ਹਨ-ਲਈ ਫ਼ਲੋ ਗ੍ਰਾਫ਼ ਮਿਲਦਾ ਹੈ। ਇੱਕੋ prompt 'ਤੇ ਵਾਪਸ ਬਦਲਣ ਨਾਲ ਇੱਕ ਸਮਤਲ ਕੀਤਾ prompt ਮਿਲਦਾ ਹੈ ਜੋ ਸਾਂਝੀਆਂ ਹਦਾਇਤਾਂ ਅਤੇ ਹਰ ਸਟੈਪ ਨੂੰ ਮਿਲਾ ਦਿੰਦਾ ਹੈ।
API ਰਾਹੀਂ, `steps` ਅਤੇ `handoffs` [ਏਜੰਟ](/api-reference/agents) ਦੇ ਫ਼ੀਲਡ ਹਨ। ਹਰ ਏਜੰਟ ਫ਼ੀਲਡ ਵਾਂਗ, ਇੱਕ `PATCH` ਇਹਨਾਂ ਨੂੰ ਡਰਾਫ਼ਟ ਵਿੱਚ ਸਟੇਜ ਕਰਦਾ ਹੈ; `POST /v1/agents/{agent_id}/deploy` ਇਹਨਾਂ ਨੂੰ ਲਾਈਵ ਕਰਦਾ ਹੈ। `"steps": null` ਭੇਜਣ ਨਾਲ ਏਜੰਟ ਵਾਪਸ ਇੱਕੋ prompt 'ਤੇ ਆ ਜਾਂਦਾ ਹੈ। ਟੈਸਟ ਕਾਲਾਂ ਅਤੇ **ਗੱਲਬਾਤ** ਡਰਾਫ਼ਟ ਚਲਾਉਂਦੇ ਹਨ।
[copilot](/pa/guides/ask-the-copilot) ਵੇਰਵੇ ਤੋਂ ਸਟੈਪਾਂ ਬਣਾ ਸਕਦਾ ਹੈ
("ਬੁਕਿੰਗ ਤੋਂ ਪਹਿਲਾਂ ਜਨਮ ਮਿਤੀ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਵਾਲਾ ਸਟੈਪ ਜੋੜੋ") ਅਤੇ ਬਾਕੀਆਂ ਨੂੰ ਛੂਹੇ ਬਿਨਾਂ
ਇੱਕ ਸਟੈਪ ਸੋਧ ਸਕਦਾ ਹੈ।
### ਸਟੈਪ ਫ਼ੀਲਡ
| ਫ਼ੀਲਡ | ਅਰਥ |
| --- | --- |
| `id` | ਲਾਜ਼ਮੀ। ਛੋਟੇ ਅੱਖਰ, ਅੰਕ ਅਤੇ ਅੰਡਰਸਕੋਰ, ਅੱਖਰ ਨਾਲ ਸ਼ੁਰੂ, ਵੱਧ ਤੋਂ ਵੱਧ 40 ਅੱਖਰ। ਏਜੰਟ ਦੇ ਅੰਦਰ ਵਿਲੱਖਣ। |
| `name` | ਲਾਜ਼ਮੀ ਡਿਸਪਲੇ ਨਾਮ, 1 ਤੋਂ 80 ਅੱਖਰ। |
| `instructions` | ਲਾਜ਼ਮੀ, ਵੱਧ ਤੋਂ ਵੱਧ 20,000 ਅੱਖਰ। `prompt` ਵਾਂਗ `{{var}}` [ਕਾਲ ਵੇਰੀਏਬਲਾਂ](/pa/guides/call-variables) ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ। |
| `say` | ਸਟੈਪ ਵਿੱਚ ਦਾਖਲ ਹੋਣ 'ਤੇ ਸ਼ਬਦ-ਬ-ਸ਼ਬਦ ਬੋਲੀ ਜਾਣ ਵਾਲੀ ਵਿਕਲਪਿਕ ਲਾਈਨ, ਵੱਧ ਤੋਂ ਵੱਧ 1,000 ਅੱਖਰ। `{{var}}` ਦਾ ਸਮਰਥਨ ਕਰਦੀ ਹੈ। |
| `tools` | `null` ਸਟੈਪ ਨੂੰ ਏਜੰਟ ਨਾਲ ਜੁੜਿਆ ਹਰ ਟੂਲ ਦਿੰਦਾ ਹੈ। ਸੂਚੀ ਸਟੈਪ ਨੂੰ ਨਾਮ ਅਨੁਸਾਰ ਉਹਨਾਂ ਟੂਲਾਂ ਤੱਕ ਸੀਮਤ ਕਰਦੀ ਹੈ। ਬਿਲਟ-ਇਨ ਕਾਰਵਾਈਆਂ, ਜਿਵੇਂ `end_call` ਅਤੇ `transfer_call`, ਹਰ ਸਟੈਪ ਵਿੱਚ ਏਜੰਟ ਦੀਆਂ ਸੈਟਿੰਗਾਂ ਦੀ ਪਾਲਣਾ ਕਰਦੀਆਂ ਹਨ। |
| `collect` | ਸਟੈਪ ਵੱਲੋਂ ਇਕੱਠੇ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਵੱਧ ਤੋਂ ਵੱਧ 20 ਮੁੱਲ। ਹਰੇਕ ਵਿੱਚ `name`, `type`, `description` ਅਤੇ `required` ਹੁੰਦੇ ਹਨ (ਡਿਫੌਲਟ `true`)। |
| `on_enter_tool` | ਵਿਕਲਪਿਕ ਟੂਲ ਨਾਮ, ਜੋ ਸਟੈਪ ਵਿੱਚ ਦਾਖਲ ਹੋਣ 'ਤੇ ਆਪਣੇ ਆਪ ਕਾਲ ਹੁੰਦਾ ਹੈ। [Webhook ਸਟੈਪਾਂ](#webhook-steps) ਵੇਖੋ। |
| `transitions` | ਸਟੈਪ ਅੱਗੇ ਕਿੱਥੇ ਜਾ ਸਕਦਾ ਹੈ, ਇਸਦੀ ਕ੍ਰਮਬੱਧ ਸੂਚੀ। [ਟ੍ਰਾਂਜ਼ਿਸ਼ਨ](#transitions) ਵੇਖੋ। |
| `global_when` | ਵਿਕਲਪਿਕ। ਸਟੈਪ ਨੂੰ ਕਿਸੇ ਵੀ ਸਟੈਪ ਤੋਂ ਪਹੁੰਚਯੋਗ ਬਣਾਉਂਦਾ ਹੈ। [ਗਲੋਬਲ ਸਟੈਪਾਂ](#global-steps) ਵੇਖੋ। |
| `voice` | ਇਸ ਸਟੈਪ ਲਈ ਵਿਕਲਪਿਕ ਆਵਾਜ਼ id। ਜਦੋਂ ਏਜੰਟ ਕਸਟਮ ਆਵਾਜ਼ ਕੌਂਫ਼ਿਗਰੇਸ਼ਨ ਵਰਤਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਅਣਡਿੱਠਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। |
ਗ੍ਰਾਫ਼ ਆਪਣੇ ਆਪ ਵਿੱਚ `{"start_step": "", "steps": [...]}` ਹੈ। ਕਾਲ `start_step` ਵਿੱਚ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ।
## ਟ੍ਰਾਂਜ਼ਿਸ਼ਨ
ਹਰ ਟ੍ਰਾਂਜ਼ਿਸ਼ਨ ਵਿੱਚ `to`, ਇੱਕ ਸਟੈਪ id, ਅਤੇ ਹੇਠਾਂ ਦਿੱਤਿਆਂ ਵਿੱਚੋਂ ਬਿਲਕੁਲ ਇੱਕ ਹੁੰਦਾ ਹੈ:
- **`when`**: ਸਾਦੀ ਭਾਸ਼ਾ, ਅਤੇ **ਮਾਡਲ ਫ਼ੈਸਲਾ ਕਰਦਾ ਹੈ**। ਏਜੰਟ ਨੂੰ ਇੱਕ
ਬਿਲਟ-ਇਨ `go_to_step` ਟੂਲ ਮਿਲਦਾ ਹੈ ਜੋ ਉਹਨਾਂ ਸਟੈਪਾਂ ਦੀ ਸੂਚੀ ਦਿੰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ 'ਤੇ ਇਹ ਜਾ ਸਕਦਾ ਹੈ, ਅਤੇ ਹਰ
`when` ਉਸਨੂੰ ਚੁਣਨ ਦਾ ਕਾਰਨ ਹੁੰਦਾ ਹੈ।
- **`condition`**: ਇਕੱਠੇ ਕੀਤੇ ਮੁੱਲਾਂ ਲਈ ਇੱਕ ਨਿਯਮ, ਅਤੇ **ਕੋਡ ਫ਼ੈਸਲਾ ਕਰਦਾ ਹੈ**। ਮਾਡਲ
ਇਸਨੂੰ ਛੱਡ ਨਹੀਂ ਸਕਦਾ ਜਾਂ ਗੱਲਾਂ ਨਾਲ ਇਸ ਤੋਂ ਬਚ ਨਹੀਂ ਸਕਦਾ।
- **`"always": true`**: ਬਿਨਾਂ ਜਾਂਚ ਦੇ ਅੱਗੇ ਵਧੋ। ਕੋਡ ਪਹਿਲਾਂ ਫ਼ੈਸਲਾ ਕਰਦਾ ਹੈ: ਜਿਵੇਂ ਹੀ
ਕਿਸੇ ਸਟੈਪ ਵਿੱਚ ਦਾਖਲ ਹੁੰਦੇ ਹੋ, ਜਾਂ ਇਸਦੇ ਲੋੜੀਂਦੇ ਮੁੱਲ ਇਕੱਠੇ ਹੋ ਜਾਂਦੇ ਹਨ, ਪਹਿਲਾ
ਮਿਲਦਾ `condition` ਜਾਂ `always` ਟ੍ਰਾਂਜ਼ਿਸ਼ਨ ਲਾਗੂ ਹੁੰਦਾ ਹੈ, ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਮਾਡਲ ਕੋਈ
`when` ਚੁਣ ਸਕੇ। ਇਸ ਲਈ `always` ਨੂੰ ਸ਼ਰਤਾਂ ਤੋਂ ਬਾਅਦ ਉਹਨਾਂ ਦੇ ਫਾਲਬੈਕ ਵਜੋਂ ਰੱਖੋ, ਜਾਂ
ਕਿਸੇ ਸਟੈਪ ਨੂੰ ਸਿੱਧਾ ਅਗਲੇ ਨਾਲ ਜੋੜਨ ਲਈ ਇਕੱਲਾ ਰੱਖੋ। `always` ਵਾਲਾ ਸਟੈਪ ਕਦੇ ਵੀ
`when` ਚੋਣ ਦੀ ਉਡੀਕ ਨਹੀਂ ਕਰਦਾ।
ਇੱਕ `condition` ਇਹ ਹੁੰਦੀ ਹੈ: `{"value": , "op": , "target": }`:
| `op` | ਮੁੱਲ ਸਹੀ ਹੁੰਦਾ ਹੈ ਜਦੋਂ |
| --- | --- |
| `eq`, `ne` | `target` ਦੇ ਬਰਾਬਰ ਹੋਵੇ, ਜਾਂ ਬਰਾਬਰ ਨਾ ਹੋਵੇ |
| `lt`, `lte`, `gt`, `gte` | `target` ਤੋਂ ਘੱਟ ਹੋਵੇ, ਵੱਧ ਤੋਂ ਵੱਧ ਹੋਵੇ, ਵੱਧ ਹੋਵੇ, ਜਾਂ ਘੱਟੋ-ਘੱਟ ਹੋਵੇ |
| `in`, `not_in` | `target` ਸੂਚੀ ਦੇ ਮੁੱਲਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੋਵੇ, ਜਾਂ ਨਾ ਹੋਵੇ |
| `exists`, `missing` | ਇਕੱਠਾ ਕੀਤਾ ਗਿਆ ਹੋਵੇ, ਜਾਂ ਨਾ ਕੀਤਾ ਗਿਆ ਹੋਵੇ (`target` ਨਹੀਂ) |
`eq`, `ne`, `in` ਅਤੇ `not_in` ਖਾਲੀ ਥਾਵਾਂ ਹਟਾਉਣ ਤੋਂ ਬਾਅਦ ਟੈਕਸਟ ਦੀ ਤੁਲਨਾ ਅੱਖਰਾਂ ਦੇ ਕੇਸ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਕੇ
ਕਰਦੇ ਹਨ। ਨੰਬਰਾਂ ਦੀ ਤੁਲਨਾ ਨੰਬਰਾਂ ਵਜੋਂ ਅਤੇ ਤਾਰੀਖਾਂ ਦੀ `YYYY-MM-DD` ਸਟਰਿੰਗਾਂ ਵਜੋਂ ਹੁੰਦੀ ਹੈ। ਉਹ ਮੁੱਲ
ਜੋ ਕਦੇ ਇਕੱਠਾ ਹੀ ਨਹੀਂ ਕੀਤਾ ਗਿਆ, `missing` ਤੋਂ ਇਲਾਵਾ ਹਰ op ਨੂੰ ਗਲਤ ਬਣਾਉਂਦਾ ਹੈ।
`when` ਅਤੇ `global_when` ਨੂੰ ਕਿਸੇ ਸ਼ਰਤ ਵਾਂਗ ਲਿਖੋ, ਜਿਵੇਂ ਕਿ "ਕਾਲਰ ਅਪਾਇੰਟਮੈਂਟ
ਬੁੱਕ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹੈ", ਨਾ ਕਿ ਕਹਿਣ ਵਾਲੀ ਕਿਸੇ ਗੱਲ ਵਾਂਗ। ਏਜੰਟ ਇਹਨਾਂ ਨੂੰ ਅੰਦਰੂਨੀ
ਰੂਟਿੰਗ ਨੋਟਾਂ ਵਜੋਂ ਦੇਖਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਇਹਨਾਂ ਨੂੰ ਕਦੇ ਉੱਚੀ ਆਵਾਜ਼ ਵਿੱਚ ਨਾ ਪੜ੍ਹਨ ਜਾਂ ਇਹ ਨਾ ਦੱਸਣ ਲਈ
ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਕਿ ਇਹ ਸਟੈਪ ਬਦਲ ਰਿਹਾ ਹੈ।
ਜਦੋਂ ਮਾਡਲ `go_to_step` ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ:
1. ਸਟੈਪ ਵਿੱਚ ਹਰ `required` ਮੁੱਲ ਮੌਜੂਦ ਹੋਣਾ ਲਾਜ਼ਮੀ ਹੈ। ਜੇ ਕੋਈ ਮੁੱਲ ਗੁੰਮ ਹੈ, ਤਾਂ
ਮਾਡਲ ਨੂੰ ਦੱਸਿਆ ਜਾਂਦਾ ਹੈ ਕਿ ਕਿਹੜਾ ਮੁੱਲ ਗੁੰਮ ਹੈ ਅਤੇ ਇਹ ਕਾਲਰ ਤੋਂ ਉਹ ਮੰਗਦਾ ਹੈ।
2. ਮੁੱਲ ਸਟੋਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।
3. `condition` ਅਤੇ `always` ਟ੍ਰਾਂਜ਼ਿਸ਼ਨਾਂ ਦੀ ਕ੍ਰਮ ਅਨੁਸਾਰ ਜਾਂਚ ਹੁੰਦੀ ਹੈ। ਪਹਿਲਾ ਮਿਲਦਾ
ਟ੍ਰਾਂਜ਼ਿਸ਼ਨ ਲਾਗੂ ਹੁੰਦਾ ਹੈ।
4. ਨਹੀਂ ਤਾਂ ਏਜੰਟ ਉਸ ਸਟੈਪ 'ਤੇ ਜਾਂਦਾ ਹੈ ਜੋ ਮਾਡਲ ਨੇ ਚੁਣਿਆ ਸੀ।
5. ਜੇ ਕੁਝ ਵੀ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ ਅਤੇ ਮਾਡਲ ਨੇ ਕੋਈ ਸਟੈਪ ਨਹੀਂ ਦੱਸਿਆ, ਤਾਂ ਏਜੰਟ ਉੱਥੇ ਹੀ ਰਹਿੰਦਾ ਹੈ।
ਕਿਸੇ [ਗਲੋਬਲ ਸਟੈਪ](#global-steps) 'ਤੇ ਜਾਣਾ ਅਪਵਾਦ ਹੈ: ਕਾਲਰ ਨੇ ਵਿਸ਼ਾ ਬਦਲ ਦਿੱਤਾ ਹੈ,
ਇਸ ਲਈ ਇਹ ਉਸ ਵੇਲੇ ਵੀ ਅੱਗੇ ਵਧਦਾ ਹੈ ਜਦੋਂ ਮੌਜੂਦਾ ਸਟੈਪ ਵਿੱਚ ਲੋੜੀਂਦੇ ਮੁੱਲ ਅਜੇ ਗੁੰਮ ਹਨ, ਅਤੇ ਉਸ ਸਟੈਪ ਦੀਆਂ
ਸ਼ਰਤਾਂ ਦੀ ਜਾਂਚ ਤੋਂ ਪਹਿਲਾਂ।
ਹਰ ਵਾਰ ਸਟੈਪ ਵਿੱਚ ਦਾਖਲ ਹੋਣ 'ਤੇ `condition` ਅਤੇ `always` ਟ੍ਰਾਂਜ਼ਿਸ਼ਨਾਂ ਦੀ ਵੀ ਜਾਂਚ ਹੁੰਦੀ ਹੈ,
ਇਸ ਲਈ ਕੋਡ-ਨਿਰਧਾਰਤ ਸਟੈਪਾਂ ਦੀ ਲੜੀ ਇੱਕੋ ਵਾਰ ਵਿੱਚ ਚੱਲਦੀ ਹੈ। ਲੜੀ ਰੁਕਦੀ ਹੈ:
- ਉਸ ਸਟੈਪ 'ਤੇ ਜਿਸ 'ਤੇ ਇਹ ਇਸ ਚਲਾਣ ਦੌਰਾਨ ਪਹਿਲਾਂ ਹੀ ਜਾ ਚੁੱਕੀ ਹੈ;
- 8 ਹਾਪਾਂ ਤੋਂ ਬਾਅਦ;
- ਉਸ ਸਟੈਪ 'ਤੇ ਜਿਸ ਵਿੱਚ ਅਜੇ ਵੀ ਇਕੱਠੇ ਕਰਨ ਲਈ ਲੋੜੀਂਦੇ ਮੁੱਲ ਹਨ, ਜਦੋਂ ਤੱਕ ਸਟੈਪ ਵਿੱਚ
`on_enter_tool` ਨਾ ਹੋਵੇ (ਇੱਕ ਵੈੱਬਹੁੱਕ ਸਟੈਪ ਹਮੇਸ਼ਾ ਆਪਣੇ ਨਤੀਜੇ ਦੇ ਆਧਾਰ 'ਤੇ ਰੂਟ ਕਰਦਾ ਹੈ)।
ਸਿਰਫ਼ ਉਸ ਸਟੈਪ ਦੀ `say` ਲਾਈਨ ਬੋਲੀ ਜਾਂਦੀ ਹੈ ਜਿੱਥੇ ਲੜੀ ਰੁਕਦੀ ਹੈ।
ਬਿਨਾਂ ਟ੍ਰਾਂਜ਼ਿਸ਼ਨਾਂ ਵਾਲਾ ਸਟੈਪ **ਅੰਤਿਮ** ਹੁੰਦਾ ਹੈ। ਏਜੰਟ ਉੱਥੇ ਸਮਾਪਤ ਕਰਦਾ ਹੈ ਅਤੇ ਆਪਣੀਆਂ
ਆਮ ਬਿਲਟ-ਇਨ ਕਾਰਵਾਈਆਂ ਨਾਲ ਕਾਲ ਖਤਮ ਜਾਂ ਟ੍ਰਾਂਸਫ਼ਰ ਕਰਦਾ ਹੈ।
## ਮੁੱਲ ਇਕੱਠੇ ਕਰਨਾ
ਸਟੈਪ ਨੂੰ ਕੀ ਚਾਹੀਦਾ ਹੈ, ਇਹ `collect` ਵਿੱਚ ਸੂਚੀਬੱਧ ਕਰੋ। ਮਾਡਲ `go_to_step` ਨੂੰ ਕਾਲ ਕਰਨ ਵੇਲੇ
ਮੁੱਲ ਭੇਜਦਾ ਹੈ, ਅਤੇ ਇਹ ਕਾਲ ਦੇ ਬਾਕੀ ਸਮੇਂ ਲਈ ਉਪਲਬਧ ਰਹਿੰਦੇ ਹਨ।
| `type` | ਰੱਖਦਾ ਹੈ |
| --- | --- |
| `string` | ਕੋਈ ਵੀ ਟੈਕਸਟ |
| `number` | ਇੱਕ ਨੰਬਰ |
| `boolean` | `true` ਜਾਂ `false` |
| `date` | `YYYY-MM-DD` ਦੇ ਰੂਪ ਵਿੱਚ ਇੱਕ ਤਾਰੀਖ |
ਇਕੱਠੇ ਕੀਤੇ ਮੁੱਲ ਕਾਲ ਸਮੱਗਰੀ ਹੁੰਦੇ ਹਨ। ਇਹ ਟ੍ਰਾਂਸਕ੍ਰਿਪਟ ਦੇ ਨਾਲ ਕਾਲ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ ਅਤੇ
ਇਹਨਾਂ 'ਤੇ ਉਹੀ ਰਿਟੇਨਸ਼ਨ, ਮਿਟਾਉਣ ਅਤੇ ਰੀਡੈਕਸ਼ਨ ਨਿਯਮ ਲਾਗੂ ਹੁੰਦੇ ਹਨ। ਜਦੋਂ
ਏਜੰਟ ਦੀ ਕਾਲ ਰਿਕਾਰਡਿੰਗ ਬੰਦ ਹੁੰਦੀ ਹੈ, ਇਕੱਠੇ ਕੀਤੇ ਮੁੱਲ ਨਾ ਤਾਂ ਸਟੋਰ ਹੁੰਦੇ ਹਨ
ਨਾ ਹੀ ਵੈੱਬਹੁੱਕਾਂ ਵਿੱਚ ਭੇਜੇ ਜਾਂਦੇ ਹਨ; ਸਟੈਪ ਟਾਈਮਲਾਈਨ ਫਿਰ ਵੀ ਰਹਿੰਦੀ ਹੈ। ਵੇਖੋ
[ਕਾਲ ਵਿੱਚ ਇਸਨੂੰ ਕਿੱਥੇ ਦੇਖਣਾ ਹੈ](#where-to-see-it-on-a-call)।
## ਕਹਿਣ ਵਾਲੀਆਂ ਲਾਈਨਾਂ
ਜਦੋਂ ਏਜੰਟ ਸਟੈਪ ਵਿੱਚ ਦਾਖਲ ਹੁੰਦਾ ਹੈ, ਤਾਂ `say` ਬਿਲਕੁਲ ਲਿਖੇ ਅਨੁਸਾਰ ਬੋਲਿਆ ਜਾਂਦਾ ਹੈ। ਮਾਡਲ ਫਿਰ ਉਸੇ ਜਵਾਬ ਵਿੱਚ ਨਵੇਂ ਸਟੈਪ ਵਿੱਚ ਅੱਗੇ ਵਧਦਾ ਹੈ ਅਤੇ ਜਾਣਦਾ ਹੈ ਕਿ ਲਾਈਨ ਹੁਣੇ ਕਹੀ ਗਈ ਸੀ, ਇਸ ਲਈ ਉਹ ਇਸਨੂੰ ਦੁਹਰਾਉਂਦਾ ਨਹੀਂ। ਸਲਾਮਾਂ, ਲਾਜ਼ਮੀ ਖੁਲਾਸਿਆਂ ਅਤੇ ਨਿਸ਼ਚਿਤ ਸ਼ਬਦਾਵਲੀ ਲਈ `say` ਵਰਤੋ ਅਤੇ ਬਾਕੀ ਜਵਾਬ ਮਾਡਲ ਉੱਤੇ ਛੱਡੋ।
ਸ਼ੁਰੂਆਤੀ ਸਟੈਪ ਦਾ `say` ਏਜੰਟ ਦੀ ਸ਼ੁਰੂਆਤੀ ਲਾਈਨ ਹੁੰਦੀ ਹੈ ਜਦੋਂ ਉਹ ਕਿਸੇ ਵੀ ਸਹਿਮਤੀ ਐਲਾਨ ਤੋਂ ਬਾਅਦ ਪਹਿਲਾਂ ਬੋਲਦਾ ਹੈ। ਜਦੋਂ ਕਾਲਰ ਪਹਿਲਾਂ ਬੋਲਦਾ ਹੈ, ਤਾਂ ਇਹ ਕਿਸੇ ਵਿਅਕਤੀ ਨੂੰ ਏਜੰਟ ਦੇ ਪਹਿਲੇ ਜਵਾਬ ਨਾਲ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਕਦੇ ਵੀ IVR ਜਾਂ ਵੌਇਸਮੇਲ ਸਲਾਮ ਨਾਲ ਨਹੀਂ।
ਜਦੋਂ ਕਾਲ `__previous__` ਜਾਂ ਵਾਪਸ ਸੌਂਪਣ ਰਾਹੀਂ ਕਿਸੇ ਸਟੈਪ ਉੱਤੇ ਵਾਪਸ ਆਉਂਦੀ ਹੈ, ਤਾਂ ਉਸ ਸਟੈਪ ਦਾ `say` ਦੁਬਾਰਾ ਨਹੀਂ ਬੋਲਿਆ ਜਾਂਦਾ। ਇਸਨੂੰ ਉਸੇ ਤਰ੍ਹਾਂ ਲਿਖੋ ਜਿਵੇਂ ਇਹ ਸੁਣਾਈ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ: ਉਹ ਸਭ ਕੁਝ ਸਪੈਲ ਕਰਕੇ ਲਿਖੋ ਜਿਸਨੂੰ ਆਵਾਜ਼ ਗਲਤ ਪੜ੍ਹ ਸਕਦੀ ਹੈ। ਕਹਿਣ ਵਾਲੀਆਂ ਲਾਈਨਾਂ `{{var}}` ਕਾਲ ਵੇਰੀਏਬਲਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦੀਆਂ ਹਨ, ਪਰ ਇਕੱਠੇ ਕੀਤੇ ਮੁੱਲਾਂ ਦਾ ਨਹੀਂ।
## Webhook ਸਟੈਪ
`on_enter_tool` ਨੂੰ ਏਜੰਟ ਦੇ ਕਿਸੇ ਟੂਲ ਉੱਤੇ ਸੈੱਟ ਕਰੋ ਅਤੇ ਸਟੈਪ ਵਿੱਚ ਦਾਖਲ ਹੁੰਦੇ ਹੀ ਇਹ ਮਾਡਲ ਦੀ ਉਡੀਕ ਕੀਤੇ ਬਿਨਾਂ ਚੱਲਦਾ ਹੈ। ਇਸਦੇ ਆਰਗੂਮੈਂਟ ਉਹ ਇਕੱਠੇ ਕੀਤੇ ਮੁੱਲ ਹੁੰਦੇ ਹਨ ਜਿਨ੍ਹਾਂ ਦੇ ਨਾਮ ਟੂਲ ਦੇ ਪੈਰਾਮੀਟਰ ਨਾਮਾਂ ਨਾਲ ਮਿਲਦੇ ਹਨ। ਨਤੀਜਾ `_result` ਨਾਮ ਦੇ ਇਕੱਠੇ ਕੀਤੇ ਮੁੱਲ ਵਜੋਂ ਸਟੋਰ ਹੁੰਦਾ ਹੈ, 4 KB ਤੱਕ ਸੀਮਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਸਟੈਪ ਦੀਆਂ `condition` ਅਤੇ `always` ਟ੍ਰਾਂਜ਼ੀਸ਼ਨਾਂ ਤੁਰੰਤ ਜਾਂਚੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਤਾਂ ਜੋ ਲੁੱਕਅੱਪ ਆਪਣੇ ਨਤੀਜੇ ਦੇ ਆਧਾਰ ਉੱਤੇ ਕਾਲ ਨੂੰ ਰੂਟ ਕਰ ਸਕੇ।
ਸਟੋਰ ਕੀਤੇ ਮੁੱਲ ਵਿੱਚ ਦੋ ਫੀਲਡ ਹੁੰਦੇ ਹਨ:
| ਫੀਲਡ | ਇਸ ਵਿੱਚ ਹੁੰਦਾ ਹੈ |
| --- | --- |
| `status` | ਤੁਹਾਡੇ ਐਂਡਪੌਇੰਟ ਵੱਲੋਂ ਵਾਪਸ ਕੀਤਾ ਗਿਆ HTTP ਸਟੇਟਸ ਕੋਡ। |
| `response` | ਜਵਾਬ ਦਾ ਬਾਡੀ। |
ਬਾਡੀ ਫੀਲਡ ਦੇ ਆਧਾਰ ਉੱਤੇ `lookup_account_result.response.` ਨਾਲ ਅਤੇ ਸਟੇਟਸ ਕੋਡ ਦੇ ਆਧਾਰ ਉੱਤੇ `lookup_account_result.status` ਨਾਲ ਰੂਟ ਕਰੋ।
ਲੁੱਕਅੱਪ ਵੱਧ ਤੋਂ ਵੱਧ 8 ਸਕਿੰਟਾਂ ਲਈ ਚੱਲਦਾ ਹੈ, ਜਾਂ ਜੇ ਟੂਲ ਦਾ ਆਪਣਾ ਟਾਈਮਆਉਟ ਇਸ ਤੋਂ ਘੱਟ ਹੈ ਤਾਂ ਉਸ ਲਈ। ਜੇ ਇਸਨੂੰ 3 ਸਕਿੰਟਾਂ ਤੋਂ ਵੱਧ ਸਮਾਂ ਲੱਗਦਾ ਹੈ, ਤਾਂ ਏਜੰਟ ਇੱਕ ਛੋਟੀ ਲਾਈਨ ਬੋਲਦਾ ਹੈ ਤਾਂ ਜੋ ਕਾਲਰ ਚੁੱਪ ਵਿੱਚ ਨਾ ਰਹੇ। ਜੇ ਤੁਹਾਡਾ ਐਂਡਪੌਇੰਟ 400 ਜਾਂ ਇਸ ਤੋਂ ਵੱਧ ਦਾ ਸਟੇਟਸ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਜਾਂ ਸਮੇਂ ਸਿਰ ਜਵਾਬ ਨਹੀਂ ਦਿੰਦਾ, ਤਾਂ ਏਜੰਟ ਕਾਲਰ ਨੂੰ ਦੱਸਦਾ ਹੈ ਕਿ ਉਹ ਇਸਨੂੰ ਇਸ ਵੇਲੇ ਜਾਂਚ ਨਹੀਂ ਸਕਿਆ ਅਤੇ ਜੋ ਉਹ ਕਰ ਸਕਦਾ ਹੈ ਉਸ ਨਾਲ ਅੱਗੇ ਵਧਦਾ ਹੈ।
## ਗਲੋਬਲ ਸਟੈਪ
`global_when` ਵਾਲੇ ਸਟੈਪ ਤੱਕ ਕਿਸੇ ਵੀ ਸਟੈਪ ਤੋਂ ਪਹੁੰਚਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜਦੋਂ ਵੀ ਉਹ ਵੇਰਵਾ ਲਾਗੂ ਹੁੰਦਾ ਹੈ। ਮਾਡਲ, `when` ਵਾਂਗ, ਫੈਸਲਾ ਕਰਦਾ ਹੈ। ਇਸਨੂੰ ਉਹਨਾਂ ਵਿਸ਼ਿਆਂ ਲਈ ਵਰਤੋ ਜੋ ਕਾਲਰ ਕਿਸੇ ਵੀ ਸਮੇਂ ਉਠਾ ਸਕਦਾ ਹੈ: ਬਿਲਿੰਗ ਸਵਾਲ, ਕਿਸੇ ਮਨੁੱਖ ਨਾਲ ਗੱਲ ਕਰਨ ਦੀ ਬੇਨਤੀ, ਸ਼ਿਕਾਇਤ।
ਗਲੋਬਲ ਸਟੈਪ ਉੱਤੇ `"to": "__previous__"` ਵਾਲੀ ਟ੍ਰਾਂਜ਼ੀਸ਼ਨ ਕਾਲ ਨੂੰ ਉਸ ਸਟੈਪ ਉੱਤੇ ਵਾਪਸ ਲੈ ਜਾਂਦੀ ਹੈ ਜੋ ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਸਰਗਰਮ ਸੀ, ਤਾਂ ਜੋ ਕਾਲਰ ਉੱਥੋਂ ਜਾਰੀ ਰੱਖੇ ਜਿੱਥੇ ਉਹ ਰੁਕਿਆ ਸੀ। ਸਟੈਪ ਮੁੜ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ: ਇਸਦਾ `on_enter_tool` ਦੁਬਾਰਾ ਨਹੀਂ ਚੱਲਦਾ, ਇਸਦਾ `say` ਦੁਹਰਾਇਆ ਨਹੀਂ ਜਾਂਦਾ, ਅਤੇ ਏਜੰਟ ਇਸਨੂੰ ਦੁਬਾਰਾ ਸ਼ੁਰੂ ਕੀਤੇ ਬਿਨਾਂ ਜਾਰੀ ਰੱਖਦਾ ਹੈ।
## ਹੈਂਡਆਫ਼
`handoffs` ਤੁਹਾਡੀ ਸੰਸਥਾ ਦੇ ਹੋਰ ਏਜੰਟਾਂ ਦੀ ਸੂਚੀ ਦਿੰਦਾ ਹੈ ਜੋ ਕਾਲ ਸੰਭਾਲ ਸਕਦੇ ਹਨ:
```json
[{"agent_id": 413, "when": "The caller asks about billing or a refund"}]
```
ਏਜੰਟ ਨੂੰ ਉਨ੍ਹਾਂ ਏਜੰਟਾਂ ਅਤੇ ਕਾਰਨਾਂ ਨਾਲ ਇੱਕ ਬਿਲਟ-ਇਨ `hand_off` ਟੂਲ ਮਿਲਦਾ ਹੈ। ਟ੍ਰਾਂਜ਼ਿਸ਼ਨਾਂ ਵਾਂਗ, ਹਰ `when` ਅੰਦਰੂਨੀ ਰੂਟਿੰਗ ਨੋਟ ਹੁੰਦਾ ਹੈ ਅਤੇ ਕਦੇ ਵੀ ਬੋਲ ਕੇ ਨਹੀਂ ਸੁਣਾਇਆ ਜਾਂਦਾ।
ਹੈਂਡਆਫ਼ ਕਰਨ ਵੇਲੇ, ਏਜੰਟ ਕਾਲਰ ਨੂੰ ਉਹ ਕਿੱਥੇ ਜਾ ਰਹੇ ਹਨ ਦੱਸਣ ਲਈ ਆਪਣੀ ਆਵਾਜ਼ ਵਿੱਚ ਇੱਕ ਛੋਟੀ ਲਾਈਨ ਕਹਿੰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ "ਜ਼ਰੂਰ, ਮੈਂ ਤੁਹਾਨੂੰ ਸਾਡੀ ਬਿਲਿੰਗ ਟੀਮ ਕੋਲ ਭੇਜ ਦਿੰਦਾ ਹਾਂ"। ਫਿਰ ਟਾਰਗੇਟ ਏਜੰਟ ਦਾ prompt, ਸਟੈਪ, ਟੂਲ ਅਤੇ ਆਵਾਜ਼ ਕੰਟਰੋਲ ਸੰਭਾਲ ਲੈਂਦੇ ਹਨ ਅਤੇ ਕਾਲ ਉਸੇ ਟ੍ਰਾਂਸਕ੍ਰਿਪਟ ਨਾਲ ਜਾਰੀ ਰਹਿੰਦੀ ਹੈ। ਨਵਾਂ ਏਜੰਟ ਸੰਖੇਪ ਵਿੱਚ ਆਪਣੀ ਪਛਾਣ ਕਰਵਾਉਂਦਾ ਹੈ ਅਤੇ ਕਾਲਰ ਦੀ ਆਖਰੀ ਬੇਨਤੀ ਦਾ ਜਵਾਬ ਦਿੰਦਾ ਹੈ; ਇਹ ਟ੍ਰਾਂਸਫ਼ਰ ਦਾ ਐਲਾਨ ਨਹੀਂ ਕਰਦਾ। ਉਸ ਸਮੇਂ ਤੋਂ ਟਾਰਗੇਟ ਦਾ ਨੌਲਿਜ ਬੇਸ ਉਪਲਬਧ ਹੁੰਦਾ ਹੈ।
ਜਦੋਂ ਕਾਲ ਪਹਿਲੀ ਵਾਰ ਕਿਸੇ ਏਜੰਟ ਤੱਕ ਪਹੁੰਚਦੀ ਹੈ, ਤਾਂ ਇਹ ਉਸ ਏਜੰਟ ਦੇ `start_step` ਵਿੱਚ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ: ਸਟੈਪ ਦਾ `on_enter_tool` ਚੱਲਦਾ ਹੈ ਅਤੇ ਉਸ ਦਾ `say` ਬੋਲਿਆ ਜਾਂਦਾ ਹੈ। ਜਦੋਂ ਕਾਲ ਉਸ ਏਜੰਟ ਨੂੰ ਵਾਪਸ ਹੈਂਡਆਫ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਿਸ ਨੂੰ ਇਹ ਪਹਿਲਾਂ ਮਿਲ ਚੁੱਕੀ ਹੈ, ਤਾਂ ਉਹ ਏਜੰਟ `on_enter_tool` ਚਲਾਏ ਬਿਨਾਂ, ਆਪਣਾ `say` ਦੁਹਰਾਏ ਬਿਨਾਂ ਜਾਂ ਦੁਬਾਰਾ ਆਪਣੀ ਪਛਾਣ ਕਰਵਾਏ ਬਿਨਾਂ, ਉਸੇ ਸਟੈਪ ਤੋਂ ਮੁੜ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ ਜਿਸ ਉੱਤੇ ਉਹ ਸੀ। ਇਕੱਠੀਆਂ ਕੀਤੀਆਂ ਵੈਲਿਊਆਂ ਕਾਲ ਦੇ ਹਰ ਏਜੰਟ ਨਾਲ ਸਾਂਝੀਆਂ ਹੁੰਦੀਆਂ ਹਨ।
- ਟਾਰਗੇਟ ਉਸੇ ਸੰਸਥਾ ਦਾ ਏਜੰਟ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਕੋਈ ਏਜੰਟ ਆਪਣੇ ਆਪ ਨੂੰ ਹੈਂਡਆਫ਼ ਨਹੀਂ ਕਰ ਸਕਦਾ।
- ਕਾਲ-ਪੱਧਰ ਦੀ ਹਰ ਚੀਜ਼ ਜਵਾਬ ਦੇਣ ਵਾਲੇ ਏਜੰਟ ਕੋਲ ਰਹਿੰਦੀ ਹੈ: ਪ੍ਰੋਡਕਟ, ਭਾਸ਼ਾਵਾਂ, ਪਹਿਲਾਂ ਕੌਣ ਬੋਲਦਾ ਹੈ, ਵੌਇਸਮੇਲ, ਸਹਿਮਤੀ ਘੋਸ਼ਣਾ ਅਤੇ ਹਰ ਹੋਰ ਕਾਲ ਸੈਟਿੰਗ।
- ਟਾਰਗੇਟ ਅੱਗੇ ਅਤੇ ਵਾਪਸ ਵੀ ਹੈਂਡਆਫ਼ ਕਰ ਸਕਦੇ ਹਨ। ਇੱਕ ਕਾਲ ਵੱਧ ਤੋਂ ਵੱਧ 8 ਏਜੰਟਾਂ ਤੱਕ ਪਹੁੰਚ ਸਕਦੀ ਹੈ।
- ਟੈਸਟ ਕਾਲ ਉਸ ਏਜੰਟ ਦਾ ਡਰਾਫ਼ਟ ਚਲਾਉਂਦੀ ਹੈ ਜਿਸ ਦੀ ਤੁਸੀਂ ਜਾਂਚ ਕਰਦੇ ਹੋ। ਜਿਨ੍ਹਾਂ ਏਜੰਟਾਂ ਨੂੰ ਇਹ ਹੈਂਡਆਫ਼ ਕਰਦੀ ਹੈ, ਉਹ ਆਪਣੇ ਡਿਪਲੌਇ ਕੀਤੇ ਵਰਜਨ ਚਲਾਉਂਦੇ ਹਨ।
- ਜੇ ਦੋ ਏਜੰਟਾਂ ਦੇ ਇੱਕੋ ਨਾਮ ਵਾਲੇ ਟੂਲ ਦੀਆਂ ਪਰਿਭਾਸ਼ਾਵਾਂ ਵੱਖਰੀਆਂ ਹਨ, ਤਾਂ ਕਾਲ ਲਈ ਸਿਰਫ਼ ਇੱਕ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਜਵਾਬ ਦੇਣ ਵਾਲੇ ਏਜੰਟ ਦਾ ਟੂਲ ਹਮੇਸ਼ਾ ਚੁਣਿਆ ਜਾਂਦਾ ਹੈ। ਸੇਵ ਕਰਨ ਵੇਲੇ ਬਿਲਡਰ ਤੁਹਾਨੂੰ ਚੇਤਾਵਨੀ ਦਿੰਦਾ ਹੈ।
- ਕਿਸੇ ਏਜੰਟ ਕੋਲ ਸਟੈਪਾਂ ਤੋਂ ਬਿਨਾਂ ਵੀ ਹੈਂਡਆਫ਼ ਹੋ ਸਕਦੇ ਹਨ। ਉਸ ਦਾ ਪੂਰਾ prompt ਜਿਵੇਂ ਦਾ ਤਿਵੇਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
`go_to_step` ਅਤੇ `hand_off` ਸਟੈਪਾਂ ਜਾਂ ਹੈਂਡਆਫ਼ ਵਾਲੇ ਏਜੰਟਾਂ ਲਈ ਰਾਖਵੇਂ ਹਨ, ਇਸ ਲਈ ਤੁਹਾਡੇ ਆਪਣੇ ਟੂਲ ਇਹ ਨਾਮ ਨਹੀਂ ਵਰਤ ਸਕਦੇ।
## ਕਾਲ ਵਿੱਚ ਇਸਨੂੰ ਕਿੱਥੇ ਦੇਖਣਾ ਹੈ
ਕਾਲ ਨੂੰ **ਕਾਲ ਇਤਿਹਾਸ** ਵਿੱਚ ਖੋਲ੍ਹੋ। ਟ੍ਰਾਂਸਕ੍ਰਿਪਟ ਦੇ ਨਾਲ ਇੱਕ ਸਟੈਪ ਟਾਈਮਲਾਈਨ ਹਰ ਉਸ ਸਟੈਪ ਨੂੰ ਦਿਖਾਉਂਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਕਾਲ ਗਈ ਅਤੇ ਇਸ ਦਾ ਕਾਰਨ ਕੀ ਸੀ, ਅਤੇ ਇਕੱਠੀਆਂ ਕੀਤੀਆਂ ਵੈਲਿਊਆਂ ਇਸ ਦੇ ਨਾਲ ਸੂਚੀਬੱਧ ਹੁੰਦੀਆਂ ਹਨ।
[ਕਾਲ ਆਬਜੈਕਟ](/api-reference/calls#retrieve-a-call) ਅਤੇ ਕਾਲ-ਪੂਰਾ ਵੈੱਬਹੁੱਕ ([`telephony.complete` / `web.complete`](/pa/webhooks/call-complete)) ਵਿੱਚ `steps_trace` ਅਤੇ `collected_values` ਵਜੋਂ ਉਹੀ ਡਾਟਾ ਹੁੰਦਾ ਹੈ। ਸਟੈਪਾਂ ਤੋਂ ਬਿਨਾਂ ਕਾਲਾਂ ਵਿੱਚ ਦੋਵੇਂ ਮੌਜੂਦ ਨਹੀਂ ਹੁੰਦੇ।
```json
"steps_trace": [
{"t_ms": 0, "agent": "a412", "step": "greet", "via": "start"},
{"t_ms": 51230, "agent": "a412", "step": "verify", "via": "model"},
{"t_ms": 98410, "agent": "a412", "step": "minor", "via": "condition"}
],
"collected_values": {"full_name": "Dana Reyes", "dob": "2010-04-02", "age": 15}
```
`agent`, ਏਜੰਟ id ਤੋਂ ਪਹਿਲਾਂ ਲੱਗਿਆ `a` ਹੁੰਦਾ ਹੈ। `via` ਦੱਸਦਾ ਹੈ ਕਿ ਕਾਲ ਨੂੰ ਕਿਸ ਚੀਜ਼ ਨੇ ਅੱਗੇ ਵਧਾਇਆ:
| `via` | ਅਰਥ |
| --- | --- |
| `start` | ਕਾਲ ਇਸ ਸਟੈਪ ਵਿੱਚ ਸ਼ੁਰੂ ਹੋਈ। |
| `model` | ਮਾਡਲ ਨੇ `go_to_step`, `when` ਜਾਂ `global_when` ਰਾਹੀਂ ਸਟੈਪ ਚੁਣਿਆ। |
| `condition` | ਇੱਕ `condition` ਜਾਂ `always` ਟ੍ਰਾਂਜ਼ਿਸ਼ਨ ਮੇਲ ਖਾਂਦਾ ਸੀ। |
| `on_enter` | ਵੈੱਬਹੁੱਕ ਸਟੈਪ ਦੇ ਨਤੀਜੇ ਨਾਲ ਇੱਕ ਟ੍ਰਾਂਜ਼ਿਸ਼ਨ ਮੇਲ ਖਾਂਦਾ ਸੀ। |
| `handoff` | ਕਿਸੇ ਹੋਰ ਏਜੰਟ ਨੇ ਕੰਟਰੋਲ ਸੰਭਾਲ ਲਿਆ। |
## ਸਟੈਪ ਕਿੱਥੇ ਚੱਲਦੇ ਹਨ
ਸਟੈਪ **Spark**, **Bolt** ਅਤੇ ਹਰ **Storm** ਪ੍ਰੋਡਕਟ ਉੱਤੇ ਮੂਲ ਰੂਪ ਵਿੱਚ ਚੱਲਦੇ ਹਨ, ਇਨਬਾਊਂਡ, ਆਊਟਬਾਊਂਡ ਅਤੇ ਕੈਂਪੇਨ ਕਾਲਾਂ, ਟੈਸਟ ਕਾਲਾਂ, ਅਤੇ ਵੈੱਬ ਤੇ ਵਿਜਿਟ ਕਾਲਾਂ ਉੱਤੇ।
ਹਰ ਹੋਰ ਥਾਂ ਏਜੰਟ ਫਿਰ ਵੀ ਕੰਮ ਕਰਦਾ ਹੈ, ਬਸ ਸਟ੍ਰਕਚਰ ਤੋਂ ਬਿਨਾਂ: ਇਹ ਇੱਕ ਫਲੈਟ ਕੀਤੇ prompt ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ ਜੋ ਸਾਂਝੀਆਂ ਹਦਾਇਤਾਂ ਅਤੇ ਹਰ ਸਟੈਪ ਨੂੰ ਕ੍ਰਮ ਵਿੱਚ ਮਿਲਾਉਂਦਾ ਹੈ। ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ:
- ਪ੍ਰਯੋਗਾਤਮਕ Bolt ਪ੍ਰੋਡਕਟ;
- [Realtime](/pa/guides/use-with-openai-realtime) ਸੈਸ਼ਨ, ਜਿਸ ਵਿੱਚ ਸੇਵ ਕੀਤੇ ਏਜੰਟ ਦੇ ਸੈਸ਼ਨ ਵੀ ਸ਼ਾਮਲ ਹਨ;
- [ਡਾਇਨਾਮਿਕ ਕਾਲ ਕੌਂਫਿਗ](/pa/guides/dynamic-call-config) ਵੈੱਬਹੁੱਕ ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੀਆਂ ਇਨਲਾਈਨ ਕੌਂਫਿਗਰੇਸ਼ਨਾਂ। `agent_id` ਵਾਪਸ ਕਰਨ ਵਾਲਾ ਵੈੱਬਹੁੱਕ ਉਸ ਏਜੰਟ ਦੇ ਸਟੈਪ ਵਰਤਦਾ ਹੈ।
## ਸੀਮਾਵਾਂ
| ਸੀਮਾ | ਮੁੱਲ |
| --- | --- |
| ਪ੍ਰਤੀ ਏਜੰਟ ਕਦਮ | 100 |
| ਪ੍ਰਤੀ ਕਦਮ ਇਕੱਠੇ ਕੀਤੇ ਮੁੱਲ | 20 |
| ਪ੍ਰਤੀ ਏਜੰਟ ਹੈਂਡਆਫ ਟਾਰਗੇਟ | 8 |
| ਇੱਕ ਕਾਲ ਵਿੱਚ ਪਹੁੰਚਯੋਗ ਏਜੰਟ | 8 |
| `steps` JSON ਦਾ ਆਕਾਰ | 200 KB |
| ਕਦਮ `instructions` | 20,000 ਅੱਖਰ |
| `say` ਲਾਈਨ | 1,000 ਅੱਖਰ |
| ਸਟੋਰ ਕੀਤਾ `on_enter_tool` ਨਤੀਜਾ | 4 KB |
ਕਿਸੇ ਨਿਯਮ ਨੂੰ ਤੋੜਨ ਵਾਲੀ ਸੇਵ `400` ਵਾਪਸ ਕਰਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਗਲਤ ਫੀਲਡ ਦਾ ਪਾਥ ਹੁੰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ `steps.steps[2].transitions[0].to`। `tools` ਅਤੇ
`on_enter_tool` ਵਿੱਚ ਟੂਲ ਨਾਮ ਏਜੰਟ ਨਾਲ ਜੁੜੇ ਹੋਏ ਟੂਲ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ।
ਪ੍ਰਤੀ-ਕਦਮ ਭਾਸ਼ਾਵਾਂ, ਮਾਡਲ ਨੂੰ ਛੱਡਣ ਵਾਲੇ ਸਕ੍ਰਿਪਟ ਕੀਤੇ ਕਦਮ, ਅਤੇ
say ਲਾਈਨਾਂ ਦੇ ਅੰਦਰ ਇਕੱਠੇ ਕੀਤੇ ਮੁੱਲ ਸਮਰਥਿਤ ਨਹੀਂ ਹਨ।
## ਇੰਪੋਰਟ ਕੀਤੇ ਏਜੰਟ
Retell, Bland, Vapi ਜਾਂ ElevenLabs ਤੋਂ [ਇੰਪੋਰਟ ਕਰਨਾ](/pa/guides/import-agents)
ਮਲਟੀ-prompt ਏਜੰਟਾਂ, ਫਲੋ, ਪਾਥਵੇਅ ਅਤੇ ਵਰਕਫਲੋ ਨੂੰ ਕਦਮਾਂ ਵਜੋਂ ਲਿਆਉਂਦਾ ਹੈ, ਅਤੇ
ਸਕੁਆਡਾਂ ਅਤੇ ਏਜੰਟ ਟ੍ਰਾਂਸਫਰਾਂ ਨੂੰ ਇੰਪੋਰਟ ਕੀਤੇ ਏਜੰਟਾਂ ਵਿਚਕਾਰ ਹੈਂਡਆਫ ਵਜੋਂ ਲਿਆਉਂਦਾ ਹੈ। ਤੁਸੀਂ ਇੰਪੋਰਟ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ
ਰਿਵਿਊ ਪੇਜ ਦੋਵੇਂ ਦਿਖਾਉਂਦਾ ਹੈ।
## ਉਦਾਹਰਨ: ਦੰਦਾਂ ਦੀ ਮੁੱਢਲੀ ਜਾਣਕਾਰੀ
ਕ੍ਰਮ ਵਿੱਚ ਤਿੰਨ ਕਦਮ: ਸਵਾਗਤ ਕਰੋ, ਮਰੀਜ਼ ਦੀ ਜਾਣਕਾਰੀ ਇਕੱਠੀ ਕਰੋ, ਬੁੱਕ ਕਰੋ।
```json
{
"prompt": "You are Ava, the front desk assistant at Acme Dental. Be warm and brief. Ask one question at a time.",
"steps": {
"start_step": "greet",
"steps": [
{
"id": "greet",
"name": "Greeting",
"instructions": "Greet the caller and ask how you can help.",
"say": "Thanks for calling Acme Dental, this is Ava. How can I help you today?",
"tools": null,
"collect": [],
"transitions": [
{"to": "details", "when": "The caller wants to book an appointment"}
]
},
{
"id": "details",
"name": "Patient details",
"instructions": "Ask for the caller's full name, date of birth and the reason for the visit. Read the date of birth back and ask the caller to confirm it.",
"tools": null,
"collect": [
{"name": "full_name", "type": "string", "description": "Caller's full name", "required": true},
{"name": "dob", "type": "date", "description": "Date of birth", "required": true},
{"name": "reason", "type": "string", "description": "Reason for the visit", "required": true},
{"name": "new_patient", "type": "boolean", "description": "First visit to the practice", "required": false}
],
"transitions": [
{"to": "book", "when": "The caller has confirmed their details"}
]
},
{
"id": "book",
"name": "Book",
"instructions": "Offer the two earliest open slots from book_slot and book the one the caller picks. Confirm the date and time, then say goodbye and end the call.",
"tools": ["book_slot"],
"collect": [],
"transitions": []
}
]
}
}
```
ਇਸਨੂੰ `PATCH /v1/agents/{agent_id}` ਨਾਲ ਸਟੇਜ ਕਰੋ, **ਗੱਲ ਕਰੋ** ਨਾਲ ਅਜ਼ਮਾਓ, ਫਿਰ ਡਿਪਲੌਇ ਕਰੋ।
`details` ਕਦਮ ਨਾਮ, ਜਨਮ ਮਿਤੀ ਅਤੇ ਕਾਰਨ ਇਕੱਠੇ ਹੋਣ ਤੱਕ ਬੁਕਿੰਗ ਨੂੰ ਹੈਂਡਆਫ ਨਹੀਂ ਕਰ ਸਕਦਾ;
`new_patient` ਵਿਕਲਪਿਕ ਹੈ।
## ਉਦਾਹਰਨ: ਉਮਰ-ਨਿਯੰਤਰਿਤ ਸ਼ਾਖਾ
ਮਾਡਲ ਕਿਸੇ ਨਾਲ ਵੀ ਗੱਲ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਕੋਡ ਤੈਅ ਕਰਦਾ ਹੈ ਕਿ ਕਿਸ ਦੀ ਬੁਕਿੰਗ ਹੋਵੇਗੀ। ਉਮਰ ਇਕੱਠੀ ਕਰੋ,
ਫਿਰ ਮਾਡਲ ਦੀ ਆਪਣੀ ਚੋਣ 'ਤੇ ਵਿਚਾਰ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਉਸਦੇ ਆਧਾਰ 'ਤੇ ਰੂਟ ਕਰੋ।
```json
{
"id": "verify",
"name": "Verify age",
"instructions": "Ask for the caller's age.",
"tools": null,
"collect": [
{"name": "age", "type": "number", "description": "Caller's age in years", "required": true}
],
"transitions": [
{"to": "guardian", "condition": {"value": "age", "op": "lt", "target": 18}},
{"to": "book", "when": "The caller has given their age"}
]
}
```
ਜੋ ਕਾਲਰ ਪੰਦਰਾਂ ਕਹਿੰਦਾ ਹੈ, ਉਹ `guardian` 'ਤੇ ਜਾਂਦਾ ਹੈ, ਭਾਵੇਂ ਮਾਡਲ ਜੋ ਮਰਜ਼ੀ ਤੈਅ ਕਰੇ।
ਹੋਰ ਹਰ ਕੋਈ `book` 'ਤੇ ਜਾਂਦਾ ਹੈ। ਗ੍ਰਾਫ ਵਿੱਚ ਦੋਵੇਂ ਹੋਰ ਥਾਵਾਂ 'ਤੇ ਆਮ ਕਦਮ ਹਨ।
## ਉਦਾਹਰਨ: ਖਾਤਾ ਲੁੱਕਅੱਪ ਵੈੱਬਹੁੱਕ ਸਟੈਪ
ਕਾਲਰ ਖਾਤਾ ਨੰਬਰ ਦਿੰਦਾ ਹੈ, ਅਗਲੇ ਸਟੈਪ ਵਿੱਚ ਦਾਖਲ ਹੋਣ 'ਤੇ ਲੁੱਕਅੱਪ ਚੱਲਦਾ ਹੈ,
ਅਤੇ ਇਸਦਾ ਨਤੀਜਾ ਰੂਟ ਚੁਣਦਾ ਹੈ। ਸੰਖੇਪਤਾ ਲਈ `not_found`, `collections` ਅਤੇ `support`
ਸਟੈਪ ਛੱਡੇ ਗਏ ਹਨ।
```json
[
{
"id": "identify",
"name": "Identify",
"instructions": "Ask for the caller's account number and read it back digit by digit.",
"tools": null,
"collect": [
{"name": "account_number", "type": "string", "description": "Account number", "required": true}
],
"transitions": [
{"to": "lookup", "when": "The caller has confirmed their account number"}
]
},
{
"id": "lookup",
"name": "Look up account",
"instructions": "Tell the caller what you found on their account and ask how you can help.",
"tools": ["lookup_account"],
"collect": [],
"on_enter_tool": "lookup_account",
"transitions": [
{"to": "not_found", "condition": {"value": "lookup_account_result.response.found", "op": "eq", "target": false}},
{"to": "collections", "condition": {"value": "lookup_account_result.response.account_status", "op": "in", "target": ["past_due", "suspended"]}},
{"to": "support", "when": "The caller needs help with an active account"}
]
}
]
```
`lookup_account` ਨੂੰ `account_number` ਮਿਲਦਾ ਹੈ ਕਿਉਂਕਿ ਇਸਦੇ ਪੈਰਾਮੀਟਰ ਦਾ ਇਹੀ
ਨਾਮ ਹੈ। ਜੇ ਰਿਸਪਾਂਸ ਬਾਡੀ ਵਿੱਚ `"found": false` ਹੈ, ਤਾਂ ਕਾਲ `not_found` ਵੱਲ ਜਾਂਦੀ ਹੈ।
ਜੇ ਇਸਦਾ `account_status` `past_due` ਜਾਂ `suspended` ਹੈ, ਤਾਂ ਇਹ `collections` ਵੱਲ ਜਾਂਦੀ ਹੈ।
ਸਰਗਰਮ ਖਾਤਾ `lookup` ਵਿੱਚ ਹੀ ਰਹਿੰਦਾ ਹੈ, ਜਿੱਥੇ ਮਾਡਲ ਮਦਦ ਕਰਦਾ ਹੈ ਅਤੇ
ਫਿਰ `support` ਵੱਲ ਵਧਦਾ ਹੈ। ਅਸਫਲ ਲੁੱਕਅੱਪ ਨੂੰ ਉਸਦੇ ਆਪਣੇ ਸਟੈਪ ਵੱਲ ਭੇਜਣ ਲਈ,
ਪਹਿਲਾਂ ਸਟੇਟਸ ਦੀਆਂ ਸ਼ਰਤਾਂ ਸ਼ਾਮਲ ਕਰੋ: ਇੱਕ ਗਲਤੀ ਰਿਸਪਾਂਸ ਆਪਣਾ ਸਟੇਟਸ ਕੋਡ ਸਟੋਰ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ
`{"value": "lookup_account_result.status", "op": "gte", "target": 400}`
ਇਸਨੂੰ ਫੜ ਲੈਂਦਾ ਹੈ, ਅਤੇ ਟਾਈਮਆਉਟ ਜਾਂ ਕੋਈ ਜਵਾਬ ਨਾ ਮਿਲਣ 'ਤੇ `"error"` ਸਟੋਰ ਹੁੰਦਾ ਹੈ, ਇਸ ਲਈ
`{"value": "lookup_account_result.status", "op": "eq", "target": "error"}`
ਉਸਨੂੰ ਫੜ ਲੈਂਦਾ ਹੈ।
## ਉਦਾਹਰਨ: ਫਰੰਟ ਡੈੱਸਕ ਤੋਂ ਬਿਲਿੰਗ
ਦੋ ਏਜੰਟ। ਫਰੰਟ ਡੈੱਸਕ (ਏਜੰਟ `412`) ਹਰ ਕਾਲ ਦਾ ਜਵਾਬ ਦਿੰਦਾ ਹੈ ਅਤੇ ਬਿਲਿੰਗ
ਸਵਾਲਾਂ ਨੂੰ ਆਪਣੇ prompt, ਟੂਲਜ਼ ਅਤੇ ਆਵਾਜ਼ ਵਾਲੇ ਬਿਲਿੰਗ ਏਜੰਟ (ਏਜੰਟ `413`) ਕੋਲ ਭੇਜਦਾ ਹੈ।
ਫਰੰਟ ਡੈੱਸਕ 'ਤੇ:
```json
{
"handoffs": [
{"agent_id": 413, "when": "The caller asks about a bill, a payment or a refund"}
]
}
```
ਬਿਲਿੰਗ ਏਜੰਟ 'ਤੇ, ਤਾਂ ਜੋ ਉਹ ਕਾਲਰ ਨੂੰ ਵਾਪਸ ਭੇਜ ਸਕੇ:
```json
{
"handoffs": [
{"agent_id": 412, "when": "The billing question is resolved and the caller needs something else"}
]
}
```
ਫਰੰਟ ਡੈੱਸਕ ਇੱਕ ਛੋਟੀ ਲਾਈਨ ਕਹਿੰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ "ਮੈਂ ਤੁਹਾਨੂੰ ਸਾਡੀ ਬਿਲਿੰਗ
ਟੀਮ ਨਾਲ ਜੋੜ ਦਿੰਦਾ ਹਾਂ", ਅਤੇ ਬਿਲਿੰਗ ਏਜੰਟ ਆਪਣਾ ਪਰਿਚਯ ਦਿੰਦਾ ਹੈ ਤੇ ਗੱਲਬਾਤ ਨੂੰ
ਉੱਥੋਂ ਅੱਗੇ ਵਧਾਉਂਦਾ ਹੈ ਜਿੱਥੇ ਫਰੰਟ ਡੈੱਸਕ ਨੇ ਛੱਡਿਆ ਸੀ। ਜਦੋਂ ਬਿਲਿੰਗ ਵਾਪਸ ਭੇਜਦਾ ਹੈ, ਫਰੰਟ ਡੈੱਸਕ
ਉੱਥੋਂ ਮੁੜ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ ਜਿੱਥੇ ਉਹ ਸੀ, ਕਾਲਰ ਨੂੰ ਦੁਬਾਰਾ ਨਮਸਕਾਰ ਕੀਤੇ ਬਿਨਾਂ। ਕਾਲ ਦਾ ਪ੍ਰੋਡਕਟ,
ਭਾਸ਼ਾਵਾਂ, ਸਹਿਮਤੀ ਘੋਸ਼ਣਾ ਅਤੇ ਹੋਰ ਕਾਲ ਸੈਟਿੰਗਾਂ ਫਰੰਟ ਡੈੱਸਕ ਕੋਲ ਹੀ ਰਹਿੰਦੀਆਂ ਹਨ,
ਕਿਉਂਕਿ ਉਸਨੇ ਜਵਾਬ ਦਿੱਤਾ ਸੀ।
ਜੇ ਬਿਲਿੰਗ ਨੂੰ ਸਿਰਫ਼ ਆਪਣੀਆਂ ਹਦਾਇਤਾਂ ਦੀ ਲੋੜ ਹੈ ਅਤੇ ਆਪਣੇ ਏਜੰਟ ਦੀ ਨਹੀਂ, ਤਾਂ ਇਸਦੀ ਬਜਾਏ
ਫਰੰਟ ਡੈੱਸਕ 'ਤੇ ਇੱਕ ਗਲੋਬਲ ਸਟੈਪ ਵਰਤੋ। ਜਦੋਂ ਸਵਾਲ ਦਾ ਜਵਾਬ ਮਿਲ ਜਾਂਦਾ ਹੈ, ਕਾਲ
ਉਸ ਸਟੈਪ 'ਤੇ ਵਾਪਸ ਜਾਂਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਕਾਲਰ ਸੀ:
```json
{
"id": "billing",
"name": "Billing questions",
"instructions": "Answer questions about bills and payments. Offer to send a payment link by email.",
"tools": null,
"collect": [],
"transitions": [
{"to": "__previous__", "when": "The billing question is answered"}
],
"global_when": "The caller asks about a bill or payment at any point"
}
```
## ਅਗਲੇ ਕਦਮ
ਸਾਂਝੀਆਂ ਹਦਾਇਤਾਂ ਅਤੇ ਕਦਮਾਂ ਦੀਆਂ ਹਦਾਇਤਾਂ ਲਿਖੋ ਜੋ ਫ਼ੋਨ ਉੱਤੇ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਰਹਿਣ।
ਉਹ ਟੂਲ ਬਣਾਓ ਜਿਨ੍ਹਾਂ ਨੂੰ ਤੁਹਾਡੇ ਕਦਮ ਅਤੇ webhook ਕਦਮ ਕਾਲ ਕਰਦੇ ਹਨ।
ਡਿਪਲੋਇ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਹਰ ਬ੍ਰਾਂਚ ਲਈ ਇੱਕੋ ਜਿਹੇ ਦ੍ਰਿਸ਼ ਚਲਾਓ।
ਹਰ ਏਜੰਟ ਫ਼ੀਲਡ, ਡਰਾਫਟ ਅਤੇ ਡਿਪਲੋਇ।