---
title: "שלבי סוכן והעברות"
description: "פצלו סוכן לשלבים עם הוראות, כלים וערכים שנאספו משלהם, והעבירו שיחות בין סוכנים במהלך השיחה."
---

הנחיה יחידה מעניקה למודל את כל המשימה בבת אחת. **שלבים** מעניקים לו שלב אחד בשיחה בכל פעם: לכל שלב יש הוראות משלו, כלים משלו, שורת אמירה אופציונלית שנאמרת מילה במילה, וערכים שעליו לאסוף לפני שהוא ממשיך. **העברות** מאפשרות לסוכן אחר בארגון שלכם להשתלט באמצע השיחה, כשהתמליל נשמר בשלמותו, כך שהמתקשר לעולם אינו צריך לחזור על דבריו.

כל סוכן מתחיל כהנחיה יחידה. דבר בו אינו משתנה עד שתוסיפו שלבים או העברות.

## שלבים או הנחיה יחידה?

| השתמשו בשלבים כאשר | השאירו הנחיה יחידה כאשר |
| --- | --- |
| לשיחה יש שלבים שחייבים להתבצע לפי הסדר: אימות ולאחר מכן קביעת פגישה. | השיחה פתוחה: שאלות נפוצות, קבלה, תמיכה כללית. |
| יש ללכוד ערך לפני שהסוכן ממשיך. | אין צורך לאסוף דבר בסדר קבוע. |
| אסור לחרוג מכלל, כגון "מתקשרים מתחת לגיל 18 מועברים לאפוטרופוס". | שיקול הדעת של המודל מספיק טוב עבור כל הסתעפות. |
| יש לבצע חיפוש בנקודה קבועה בשיחה. | אפשר לקרוא לכלים בכל פעם שהמתקשר מבקש זאת. |
| חלק מהשיחה שייך לסוכן אחר, עם הנחיה וקול משלו. | דמות אחת מטפלת בהכול. |

שלבים אינם עץ טלפוני מתוסרט. בתוך שלב, המודל מנהל את
השיחה כפי שהוא עושה עם הנחיה יחידה. השלב קובע על מה הוא
עובד, באילו כלים הוא יכול להשתמש ומה נדרש לפני שהוא יכול לצאת ממנו.

## כיצד נבנה סוכן עם שלבים

כאשר לסוכן יש שלבים, ה-`prompt` שלו מכיל את **ההוראות המשותפות**: את
הדמות והכללים שחלים בכל שלב. כל שלב מוסיף הוראות משלו
מעליהן. בכל תור המודל רואה את ההוראות המשותפות, את השם וההוראות של
השלב הנוכחי, ואת הערכים שנאספו עד כה.

בעורך של הסוכן, פתחו את **הוראות** ובחרו **פצלו לשלבים**
מתחת לכותרות ההנחיה. Zeus מציע את השלבים, ומציג כל חלק
מההנחיה לצד השלב שאליו הוא הופך; **השתמשו בשלבים אלה** שומר את השלבים ו-**השאירו הנחיה אחת** מחזיר אתכם לאחור. לאחר מכן, המתאר מציג את **הוראות משותפות** ואת כל השלבים. בדף של שלב מופיעים שמו, השורה הראשונה שלו מילה במילה, ההוראות שלו, הערכים שהוא אוסף והכלים שבהם הוא יכול להשתמש, ולצידם היעד הבא שלו והמקור שממנו מגיעים אליו. **זרימה** מציג את השלבים כגרף. העברות לסוכנים אחרים נמצאות תחת **כלים והעברות**.

האפשרות **שמור** של שלב שומרת את השלבים בטיוטה; המתקשרים יקבלו אותם לאחר שתבחרו **פרסמו** בכותרת הסוכן. המתג **הנחיה אחת** / **שלבים** בהוראות המשותפות מחזיר סוכן להנחיה יחידה שממזגת את ההוראות המשותפות ואת כל השלבים. בתצוגה הישנה, המתג **הנחיה יחידה** / **שלבים** של הבונה עושה את אותו הדבר.

דרך ה-API, `steps` ו-`handoffs` הם שדות של
[סוכן](/api-reference/agents). כמו כל שדה של סוכן, `PATCH` שומר אותם
בטיוטה; `POST /v1/agents/{agent_id}/deploy` מפרסם אותם. שליחת
`"steps": null` מחזירה את הסוכן להנחיה יחידה. קריאות בדיקה פועלות על הטיוטה.

<Tip>
  [Zeus](/he/guides/ask-the-copilot) יכול לבנות שלבים מתוך תיאור
  ("הוסיפו שלב שמאמת תאריך לידה לפני קביעת הזמנה") ולערוך שלב אחד
  בלי לגעת באחרים.
</Tip>

### שדות שלב

| שדה | משמעות |
| --- | --- |
| `id` | נדרש. אותיות קטנות, ספרות וקווים תחתונים, המתחילים באות, עד 40 תווים. ייחודי בתוך הסוכן. |
| `name` | שם תצוגה נדרש, באורך 1 עד 80 תווים. |
| `instructions` | נדרש, עד 20,000 תווים. תומך ב[משתני שיחה](/he/guides/call-variables) מסוג `{{var}}`, בדומה ל-`prompt`. |
| `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` | מזהה קול אופציונלי עבור שלב זה. המערכת מתעלמת ממנו כאשר הסוכן משתמש בתצורת קול מותאמת אישית. |

התרשים עצמו הוא `{"start_step": "<step id>", "steps": [...]}`. השיחה
מתחילה ב-`start_step`.

## מעברים

לכל מעבר יש `to`, מזהה של שלב, ובדיוק אחד מהבאים:

- **`when`**: שפה טבעית, וה**מודל מחליט**. הסוכן מקבל כלי מובנה
  `go_to_step` שמפרט את השלבים שאליהם הוא רשאי לעבור, כאשר כל
  `when` הוא הסיבה לבחור בו.
- **`condition`**: כלל על ערכים שנאספו, וה**קוד מחליט**. המודל
  לא יכול לדלג עליו או לעקוף אותו באמצעות שיחה.
- **`"always": true`**: המשיכו ללא בדיקה. הקוד מחליט תחילה: מיד
  כשנכנסים לשלב, או לאחר שנאספו הערכים הנדרשים שלו, המעבר הראשון מסוג
  `condition` או `always` שתואם נבחר, לפני שהמודל יכול לבחור
  `when`. לכן הציבו את `always` אחרי התנאים כברירת המחדל שלהם, או
  לבדו כדי לשרשר שלב ישירות לשלב הבא. שלב עם `always` לעולם לא
  ממתין לבחירת `when`.

`condition` הוא `{"value": <collected name or dotted path>, "op": <op>, "target": <literal>}`:

| `op` | הערך מתקיים כאשר |
| --- | --- |
| `eq`, `ne` | הוא שווה, או אינו שווה, ל-`target` |
| `lt`, `lte`, `gt`, `gte` | הוא קטן מ-, לכל היותר, גדול מ-, או לפחות `target` |
| `in`, `not_in` | הוא אחד מהערכים ברשימת `target`, או אינו אחד מהם |
| `exists`, `missing` | הוא נאסף, או לא נאסף (ללא `target`) |

`eq`, `ne`, `in` ו-`not_in` משווים טקסט ללא תלות באותיות רישיות או
קטנות לאחר הסרת רווחים. מספרים מושווים כמספרים ותאריכים כמחרוזות
`YYYY-MM-DD`. ערך שמעולם לא נאסף גורם לכל op להיות false, למעט `missing`.

כתבו את `when` ואת `global_when` כתנאי, כגון "המתקשר רוצה לקבוע
פגישה", ולא כמשהו שיש לומר. הסוכן רואה אותם כהערות ניתוב פנימיות ומונחה
לעולם לא להקריא אותם או לציין שהוא מחליף שלבים.

כאשר המודל קורא ל-`go_to_step`:

1. כל ערך `required` בשלב חייב להיות קיים. אם אחד חסר, המודל מקבל מידע
   איזה ערך חסר ומבקש אותו מהמתקשר.
2. הערכים נשמרים.
3. מעברי `condition` ו-`always` נבדקים לפי הסדר. ההתאמה הראשונה
   נבחרת.
4. אחרת, הסוכן עובר לשלב שהמודל בחר.
5. אם אין התאמה והמודל לא ציין שלב, הסוכן נשאר בשלב הנוכחי.

קפיצה אל [שלב גלובלי](#global-steps) היא החריגה: המתקשר החליף נושא,
ולכן הקפיצה מתבצעת גם כאשר בשלב הנוכחי עדיין חסרים ערכים נדרשים, ולפני
שנבדקים התנאים של אותו שלב.

מעברי `condition` ו-`always` נבדקים גם בכל פעם שנכנסים לשלב, כך
שרצף של שלבים שהקוד מחליט עליהם מתבצע בפעולה אחת. השרשרת נעצרת:

- בשלב שכבר ביקרה בו במהלך הריצה הנוכחית;
- לאחר 8 מעברים;
- בשלב שעדיין יש בו ערכים נדרשים לאיסוף, אלא אם לשלב יש
  `on_enter_tool` (שלב webhook תמיד מנותב לפי התוצאה שלו).

רק שורת ה-`say` של השלב שבו השרשרת נעצרת נאמרת בקול.

שלב ללא מעברים הוא **סופי**. הסוכן מסיים בו ומנתק או מעביר את השיחה
באמצעות הפעולות המובנות הרגילות שלו.

## איסוף ערכים

פרטו ב-`collect` את מה ששלב צריך. המודל מעביר את הערכים כאשר הוא קורא
ל-`go_to_step`, והם נשארים זמינים למשך שארית השיחה.

| `type` | מכיל |
| --- | --- |
| `string` | כל טקסט |
| `number` | מספר |
| `boolean` | `true` או `false` |
| `date` | תאריך בפורמט `YYYY-MM-DD` |

ערכים שנאספו הם תוכן השיחה. הם מופיעים בפרטי השיחה לצד התמלול ופועלים
לפי אותם כללי שמירה, מחיקה והשחרה. כאשר הקלטת השיחה של הסוכן מושבתת,
ערכים שנאספו אינם נשמרים ואינם נשלחים ב-webhooks; ציר הזמן של השלב עדיין
נשמר. ראו
[היכן לראות זאת בשיחה](#where-to-see-it-on-a-call).

## שורות say

`say` נאמר בדיוק כפי שנכתב כאשר הסוכן נכנס לשלב. לאחר מכן המודל ממשיך בשלב החדש באותה תשובה, בידיעה שהשורה זה עתה נאמרה, ולכן אינו חוזר עליה. השתמשו ב-`say` לברכות, לגילויים נדרשים ולניסוח קבוע, והשאירו את יתר התשובה למודל.

ה-`say` של שלב ההתחלה הוא משפט הפתיחה של הסוכן כאשר הוא מדבר ראשון, לאחר כל הודעת הסכמה. כאשר המתקשר מדבר ראשון, הוא פותח את התשובה הראשונה של הסוכן לאדם, ולעולם לא ל-IVR או לברכת תא קולי.

ה-`say` של שלב אינו נאמר שוב כאשר השיחה חוזרת אליו דרך
`__previous__` או העברה חזרה. כתבו אותו כפי שהוא אמור להישמע: אייתו כל דבר שהקול עלול לקרוא באופן שגוי. שורות say תומכות במשתני שיחה `{{var}}`, אך לא בערכים שנאספו.

## שלבי Webhook

הגדירו את `on_enter_tool` לאחד מהכלים של הסוכן, והוא יופעל מיד עם הכניסה לשלב, בלי להמתין למודל. הארגומנטים שלו הם הערכים שנאספו ושמותיהם תואמים לשמות הפרמטרים של הכלי. התוצאה נשמרת כערך שנאסף בשם `<tool>_result`, מקוצצת ל-4 KB, ומעברי ה-`condition` וה-`always` של השלב נבדקים מיד, כך שהחיפוש יכול לנתב את השיחה לפי התוצאה שלו בלבד.

לערך השמור יש שני שדות:

| שדה | מכיל |
| --- | --- |
| `status` | קוד סטטוס ה-HTTP שנקודת הקצה שלכם החזירה. |
| `response` | גוף התגובה. |

נתבו לפי שדה בגוף התגובה באמצעות `lookup_account_result.response.<field>`, ולפי קוד הסטטוס באמצעות `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` הוא הערת ניתוב פנימית ולעולם אינו מוקרא בקול.

בעת העברה, הסוכן אומר שורה קצרה שמסבירה למתקשר לאן הוא מועבר, למשל "בוודאי, אעביר אותך לצוות החיוב שלנו", בקול שלו. לאחר מכן, ההנחיה, השלבים, הכלים והקול של סוכן היעד משתלטים, והשיחה ממשיכה עם אותו תמלול. הסוכן החדש מציג את עצמו בקצרה ועונה לבקשה האחרונה של המתקשר; הוא אינו מודיע על העברה. מאותו רגע, בסיס הידע של היעד זמין.

בפעם הראשונה ששיחה מגיעה לסוכן, היא מתחילה ב-`start_step` של אותו סוכן: ה-`on_enter_tool` של השלב מופעל וה-`say` שלו נאמר. כאשר השיחה מועברת בחזרה לסוכן שכבר ביקרה אצלו, הסוכן ממשיך מהשלב שבו היה, בלי להפעיל את `on_enter_tool`, לחזור על ה-`say` שלו או להציג את עצמו שוב. הערכים שנאספו משותפים לכל סוכן בשיחה.

- יעד חייב להיות סוכן באותו ארגון, וסוכן אינו יכול להעביר שיחה לעצמו.
- כל מה שברמת השיחה נשאר אצל הסוכן שענה: מוצר, שפות, מי מדבר ראשון, תא קולי, הודעת הסכמה וכל הגדרת שיחה אחרת.
- יעדים יכולים להעביר את השיחה הלאה וגם בחזרה. שיחה אחת יכולה להגיע לעד 8 סוכנים.
- שיחת בדיקה מפעילה את הטיוטה של הסוכן שאתם בודקים. הסוכנים שאליהם הוא מעביר שיחות מפעילים את הגרסאות שפורסמו שלהם.
- אם לשני סוכנים יש כלי בעל אותו שם והגדרות שונות, רק אחד נשמר עבור השיחה, והכלי של הסוכן שענה תמיד גובר. האפליקציה מזהירה אתכם בעת השמירה.
- לסוכן יכולים להיות ניתובים ללא שלבים. המערכת משתמשת בכל ההנחיה שלו כפי שהיא.

`go_to_step` ו-`hand_off` שמורים בסוכנים עם שלבים או העברות, ולכן הכלים שלכם אינם יכולים להשתמש בשמות אלה.

## היכן לראות זאת בשיחה

פתחו את השיחה ב-**היסטוריית שיחות**. ציר זמן של שלבים לצד התמלול מציג כל שלב שאליו השיחה נכנסה ומדוע, והערכים שנאספו מפורטים לצדו.

אובייקט [השיחה](/api-reference/calls#retrieve-a-call) וה-webhook של השלמת שיחה ([`telephony.complete` / `web.complete`](/he/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` הוא `a` ואחריו מזהה הסוכן. `via` מציין מה העביר את השיחה:

| `via` | משמעות |
| --- | --- |
| `start` | השיחה התחילה בשלב זה. |
| `model` | המודל בחר את השלב באמצעות `go_to_step`, ‏`when` או `global_when`. |
| `condition` | מעבר `condition` או `always` תאם. |
| `on_enter` | מעבר תאם לתוצאה של שלב webhook. |
| `handoff` | סוכן אחר השתלט. |

## היכן שלבים פועלים

שלבים פועלים באופן מובנה בכל סוכן (וגם בערכי המוצר הישנים יותר), בשיחות נכנסות, יוצאות וקמפיין, בשיחות בדיקה ובשיחות אינטרנט ו-widget.

בכל מקום אחר הסוכן עדיין פועל, רק ללא המבנה: הוא מפעיל הנחיה שטוחה שממזגת את ההוראות המשותפות ואת כל השלבים, לפי הסדר. זה כולל:

- הפעלות [Realtime](/he/guides/use-with-openai-realtime), כולל הפעלות עבור סוכן שמור;
- תצורות מוטבעות שמוחזרות על ידי webhook של [תצורת שיחה דינמית](/he/guides/dynamic-call-config). webhook שמחזיר `agent_id` משתמש בשלבים של אותו סוכן.

## מגבלות

| מגבלה | ערך |
| --- | --- |
| שלבים לכל סוכן | 100 |
| ערכים שנאספים בכל שלב | 20 |
| יעדי העברה לכל סוכן | 8 |
| סוכנים שניתן להגיע אליהם בשיחה אחת | 8 |
| גודל ה-JSON של `steps` | 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
אינם נתמכים.

## סוכנים מיובאים

[ייבוא](/he/guides/import-agents) מ-Retell, Bland, Vapi או ElevenLabs
מייבא סוכנים עם כמה פרומפטים, זרימות, נתיבים ותהליכי עבודה כשלבים, וצוותים
והעברות סוכנים כהעברות בין הסוכנים המיובאים. דף הסקירה מציג את שניהם לפני
הייבוא.

## דוגמה: קליטת מטופלים במרפאת שיניים

שלושה שלבים לפי הסדר: ברכה, איסוף פרטי המטופל, קביעת תור.

```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`) עונה לכל שיחה ומעביר שאלות
על חיובים לסוכן חיובים (סוכן `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"
}
```

## השלבים הבאים

<CardGroup cols={2}>
  <Card title="מדריך הנחיות" icon="pen" href="/he/guides/prompting">
    כתבו הוראות משותפות והוראות שלבים שפועלות היטב בשיחות טלפון.
  </Card>
  <Card title="בניית שילוב כלי" icon="code" href="/he/guides/build-tool-integration">
    צרו את הכלים שהשלבים שלכם ושלבי ה-webhook קוראים להם.
  </Card>
  <Card title="בדיקת הסוכנים שלכם" icon="flask" href="/he/guides/test-agents">
    הריצו את אותם תרחישים מול כל ענף לפני הפריסה.
  </Card>
  <Card title="API של סוכנים" icon="robot" href="/api-reference/agents">
    כל שדה של סוכן, טיוטה ופריסה.
  </Card>
</CardGroup>
