---
title: "ഏജന്റ് ഘട്ടങ്ങളും കൈമാറ്റങ്ങളും"
description: "ഒരു ഏജന്റിനെ അതത് നിർദ്ദേശങ്ങൾ, ടൂളുകൾ, ശേഖരിച്ച മൂല്യങ്ങൾ എന്നിവയുള്ള ഘട്ടങ്ങളായി വിഭജിക്കുകയും, കോൾ നടക്കുന്നതിനിടെ ഏജന്റുകൾക്കിടയിൽ കോളുകൾ കൈമാറുകയും ചെയ്യുക."
---

ഒരൊറ്റ prompt മോഡലിന് മുഴുവൻ ജോലിയും ഒരേസമയം നൽകുന്നു. **ഘട്ടങ്ങൾ** അതിന് കോളിന്റെ ഓരോ ഘട്ടവും ഓരോ സമയത്ത് നൽകുന്നു: ഓരോ ഘട്ടത്തിനും അതിന്റേതായ നിർദ്ദേശങ്ങൾ, അതിന്റേതായ ടൂളുകൾ, വാക്കിന് വാക്ക് പറയുന്ന ഐച്ഛിക വരി, അടുത്ത ഘട്ടത്തിലേക്ക് പോകുന്നതിന് മുമ്പ് ശേഖരിക്കേണ്ട മൂല്യങ്ങൾ എന്നിവയുണ്ട്. **ഹാൻഡ്ഓഫുകൾ** നിങ്ങളുടെ സ്ഥാപനത്തിലെ മറ്റൊരു ഏജന്റിന് കോൾ നടക്കുന്നതിനിടെ ഏറ്റെടുക്കാൻ അനുവദിക്കുന്നു. ട്രാൻസ്ക്രിപ്റ്റ് അതേപടി നിലനിൽക്കുന്നതിനാൽ, വിളിക്കുന്നയാൾക്ക് സ്വയം വീണ്ടും പറയേണ്ടിവരില്ല.

ഓരോ ഏജന്റും ഒരൊറ്റ prompt ആയി ആരംഭിക്കുന്നു. നിങ്ങൾ ഘട്ടങ്ങളോ ഹാൻഡ്ഓഫുകളോ ചേർക്കുന്നതുവരെ അതിൽ ഒന്നും മാറില്ല.

## ഘട്ടങ്ങളോ ഒരൊറ്റ prompt-ഓ?

| ഘട്ടങ്ങൾ ഉപയോഗിക്കേണ്ട സന്ദർഭം | ഒരൊറ്റ prompt നിലനിർത്തേണ്ട സന്ദർഭം |
| --- | --- |
| കോൾ ക്രമത്തിൽ നടക്കേണ്ട ഘട്ടങ്ങളുള്ളപ്പോൾ: ആദ്യം സ്ഥിരീകരിക്കുക, തുടർന്ന് ബുക്ക് ചെയ്യുക. | സംഭാഷണം തുറന്ന സ്വഭാവമുള്ളപ്പോൾ: FAQ, റിസപ്ഷൻ, പൊതുവായ പിന്തുണ. |
| ഏജന്റ് മുന്നോട്ട് പോകുന്നതിന് മുമ്പ് ഒരു മൂല്യം പകർത്തേണ്ടപ്പോൾ. | നിശ്ചിത ക്രമത്തിൽ ഒന്നും ശേഖരിക്കേണ്ടതില്ലാത്തപ്പോൾ. |
| "18 വയസ്സിൽ താഴെയുള്ള വിളിക്കുന്നവരെ ഒരു രക്ഷിതാവിലേക്ക് അയയ്ക്കുക" എന്നതുപോലുള്ള, ഒരിക്കലും ലംഘിക്കരുതാത്ത നിയമമുള്ളപ്പോൾ. | ഓരോ ശാഖയ്ക്കും മോഡലിന്റെ വിലയിരുത്തൽ മതിയായപ്പോൾ. |
| കോളിലെ ഒരു നിശ്ചിത ഘട്ടത്തിൽ ഒരു ലുക്കപ്പ് പ്രവർത്തിപ്പിക്കേണ്ടപ്പോൾ. | വിളിക്കുന്നയാൾ ആവശ്യപ്പെടുമ്പോഴെല്ലാം ടൂളുകൾ വിളിക്കാനാകുമ്പോൾ. |
| കോളിന്റെ ഒരു ഭാഗം സ്വന്തമായ prompt-ഉം ശബ്ദവുമുള്ള മറ്റൊരു ഏജന്റിന്റെ ചുമതലയായപ്പോൾ. | ഒരു വ്യക്തിത്വം എല്ലാം കൈകാര്യം ചെയ്യുമ്പോൾ. |

ഘട്ടങ്ങൾ ഒരു സ്ക്രിപ്റ്റ് ചെയ്ത ഫോൺ ട്രീയല്ല. ഒരു ഘട്ടത്തിനുള്ളിൽ, ഒരൊറ്റ prompt ഉപയോഗിക്കുന്നതുപോലെ മോഡൽ സംഭാഷണം നടത്തുന്നു. അത് ഏത് കാര്യത്തിലാണ് പ്രവർത്തിക്കുന്നത്, ഏത് ടൂളുകൾ ഉപയോഗിക്കാം, പുറത്തുപോകുന്നതിന് മുമ്പ് എന്താണ് ആവശ്യമായത് എന്നിവ ഘട്ടം തീരുമാനിക്കുന്നു.

## ഘട്ടങ്ങളുള്ള ഏജന്റ് എങ്ങനെ നിർമ്മിക്കപ്പെടുന്നു

ഒരു ഏജന്റിന് ഘട്ടങ്ങളുള്ളപ്പോൾ, അതിന്റെ `prompt` **പങ്കിടുന്ന നിർദ്ദേശങ്ങൾ** ഉൾക്കൊള്ളുന്നു: എല്ലാ ഘട്ടങ്ങൾക്കും ബാധകമായ വ്യക്തിത്വവും നിയമങ്ങളും. ഓരോ ഘട്ടവും അതിന് മുകളിൽ അതിന്റേതായ നിർദ്ദേശങ്ങൾ ചേർക്കുന്നു. ഓരോ ടേണിലും മോഡൽ പങ്കിടുന്ന നിർദ്ദേശങ്ങൾ, നിലവിലെ ഘട്ടത്തിന്റെ പേരും നിർദ്ദേശങ്ങളും, ഇതുവരെ ശേഖരിച്ച മൂല്യങ്ങളും കാണുന്നു.

ബിൽഡറിൽ, ഏജന്റിനെ **ഒരൊറ്റ prompt** എന്നതിൽ നിന്ന് **ഘട്ടങ്ങൾ** എന്നതിലേക്ക് മാറ്റുക. ഓരോ ഘട്ടത്തിനും അതിന്റെ പേര്, നിർദ്ദേശങ്ങൾ, പറയേണ്ട വരി, ടൂളുകൾ, ശേഖരിച്ച മൂല്യങ്ങൾ, ട്രാൻസിഷനുകൾ എന്നിവയുള്ള ഒരു കാർഡ്, ഹാൻഡ്ഓഫ് പിക്കർ, ഘട്ടങ്ങളുടെ വായന-മാത്രമുള്ള ഫ്ലോ ഗ്രാഫ് എന്നിവ ലഭിക്കും. ഒരൊറ്റ prompt-ലേക്ക് തിരിച്ചുമാറ്റുമ്പോൾ, പങ്കിടുന്ന നിർദ്ദേശങ്ങളും എല്ലാ ഘട്ടങ്ങളും ലയിപ്പിച്ച ഒരു ഫ്ലാറ്റൻ ചെയ്ത prompt ലഭിക്കും.

API വഴി, `steps` ഉം `handoffs` ഉം
[agent](/api-reference/agents)-ലെ ഫീൽഡുകളാണ്. എല്ലാ ഏജന്റ് ഫീൽഡുകളെയും പോലെ, ഒരു `PATCH` അവയെ ഡ്രാഫ്റ്റിൽ സജ്ജമാക്കുന്നു; `POST /v1/agents/{agent_id}/deploy` അവയെ ലൈവാക്കുന്നു. `"steps": null` അയയ്ക്കുന്നത് ഏജന്റിനെ ഒരൊറ്റ prompt-ലേക്ക് തിരിച്ചുമാറ്റുന്നു. ടെസ്റ്റ് കോളുകളും **സംസാരിക്കുക** എന്നതും ഡ്രാഫ്റ്റിലാണ് പ്രവർത്തിക്കുന്നത്.

<Tip>
  [copilot](/ml/guides/ask-the-copilot)-ന് ഒരു വിവരണത്തിൽ നിന്ന് ഘട്ടങ്ങൾ നിർമ്മിക്കാനാകും
  ("ബുക്ക് ചെയ്യുന്നതിന് മുമ്പ് ജനനത്തീയതി സ്ഥിരീകരിക്കുന്ന ഒരു ഘട്ടം ചേർക്കുക"), കൂടാതെ
  മറ്റുള്ളവയെ ബാധിക്കാതെ ഒരു ഘട്ടം എഡിറ്റ് ചെയ്യാനും കഴിയും.
</Tip>

### ഘട്ട ഫീൽഡുകൾ

| ഫീൽഡ് | അർത്ഥം |
| --- | --- |
| `id` | ആവശ്യമാണ്. ചെറിയക്ഷരങ്ങൾ, അക്കങ്ങൾ, അണ്ടർസ്കോറുകൾ എന്നിവ; അക്ഷരത്തിൽ ആരംഭിക്കണം, പരമാവധി 40 പ്രതീകങ്ങൾ. ഏജന്റിനുള്ളിൽ അദ്വിതീയം. |
| `name` | ആവശ്യമായ പ്രദർശന നാമം, 1 മുതൽ 80 വരെ പ്രതീകങ്ങൾ. |
| `instructions` | ആവശ്യമാണ്, പരമാവധി 20,000 പ്രതീകങ്ങൾ. `prompt` പോലെ `{{var}}` [കോൾ വേരിയബിളുകൾ](/ml/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` | ഈ ഘട്ടത്തിനായുള്ള ഐച്ഛിക voice id. ഏജന്റ് ഇഷ്ടാനുസൃത ശബ്ദ കോൺഫിഗറേഷൻ ഉപയോഗിക്കുമ്പോൾ അവഗണിക്കപ്പെടും. |

ഗ്രാഫ് തന്നെ `{"start_step": "<step id>", "steps": [...]}` ആണ്. കോൾ
`start_step`-ൽ ആരംഭിക്കുന്നു.

## മാറ്റങ്ങൾ

ഓരോ മാറ്റത്തിനും `to`, ഒരു സ്റ്റെപ്പ് ഐഡി, കൂടാതെ ഇനിപ്പറയുന്നതിൽ കൃത്യമായി ഒന്ന് ഉണ്ടായിരിക്കും:

- **`when`**: സാധാരണ ഭാഷയിൽ, **മോഡലാണ് തീരുമാനിക്കുന്നത്**. ഏജന്റിന്
  മാറാൻ കഴിയുന്ന സ്റ്റെപ്പുകളുടെ പട്ടികയുള്ള ഒരു ബിൽറ്റ്-ഇൻ `go_to_step` ടൂൾ ലഭിക്കും;
  ഓരോ `when`-ഉം അത് തിരഞ്ഞെടുക്കാനുള്ള കാരണമായിരിക്കും.
- **`condition`**: ശേഖരിച്ച മൂല്യങ്ങളെ അടിസ്ഥാനമാക്കിയുള്ള ഒരു നിയമം, കൂടാതെ **കോഡാണ് തീരുമാനിക്കുന്നത്**.
  മോഡലിന് ഇത് ഒഴിവാക്കാനോ ഇതിനെ മറികടന്ന് സംസാരിക്കാനോ കഴിയില്ല.
- **`"always": true`**: പരിശോധനയില്ലാതെ മുന്നോട്ട് പോകുക. കോഡ് ആദ്യം തീരുമാനിക്കും:
  ഒരു സ്റ്റെപ്പിൽ പ്രവേശിച്ചയുടൻ, അല്ലെങ്കിൽ അതിന്റെ ആവശ്യമായ മൂല്യങ്ങൾ ശേഖരിച്ചുകഴിഞ്ഞാൽ,
  മോഡലിന് ഒരു `when` തിരഞ്ഞെടുക്കാൻ കഴിയുന്നതിന് മുമ്പ് പൊരുത്തപ്പെടുന്ന ആദ്യത്തെ
  `condition` അല്ലെങ്കിൽ `always` മാറ്റം പ്രാബല്യത്തിൽ വരും. അതിനാൽ `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` സ്ട്രിംഗുകളായും
താരതമ്യം ചെയ്യുന്നു. ഒരിക്കലും ശേഖരിക്കാത്ത മൂല്യം `missing` ഒഴികെയുള്ള എല്ലാ ഓപ്പറേറ്ററുകളെയും തെറ്റാക്കും.

`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}}` കോൾ വേരിയബിളുകളെ പിന്തുണയ്ക്കുന്നു, എന്നാൽ ശേഖരിച്ച മൂല്യങ്ങളെ പിന്തുണയ്ക്കുന്നില്ല.

## വെബ്ഹുക്ക് ഘട്ടങ്ങൾ

`on_enter_tool` ഏജന്റിന്റെ ടൂളുകളിൽ ഒന്നായി സജ്ജമാക്കുക; മോഡലിനായി കാത്തിരിക്കാതെ ഘട്ടത്തിലേക്ക് പ്രവേശിച്ചയുടൻ അത് പ്രവർത്തിക്കും. ടൂളിന്റെ പാരാമീറ്റർ പേരുകളുമായി പൊരുത്തപ്പെടുന്ന പേരുകളുള്ള ശേഖരിച്ച മൂല്യങ്ങളാണ് അതിന്റെ ആർഗ്യുമെന്റുകൾ. ഫലം 4 KB ആയി ചുരുക്കി `<tool>_result` എന്ന പേരിലുള്ള ശേഖരിച്ച മൂല്യമായി സൂക്ഷിക്കുന്നു. തുടർന്ന് ഘട്ടത്തിലെ `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`-ഉം ആന്തരിക റൂട്ടിംഗ് കുറിപ്പാണ്; ഒരിക്കലും ഉച്ചരിക്കില്ല.

കൈമാറ്റം ചെയ്യുമ്പോൾ, "തീർച്ചയായും, ഞാൻ നിങ്ങളെ ഞങ്ങളുടെ ബില്ലിംഗ് ടീമിലേക്ക് ബന്ധിപ്പിക്കാം" എന്നതുപോലുള്ള, വിളിക്കുന്നയാൾ എവിടേക്കാണ് പോകുന്നതെന്ന് അറിയിക്കുന്ന ഒരു ചെറിയ വരി ഏജന്റ് സ്വന്തം ശബ്ദത്തിൽ പറയുന്നു. തുടർന്ന് ലക്ഷ്യ ഏജന്റിന്റെ 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`](/ml/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` | ഒരു വെബ്ഹുക്ക് സ്റ്റെപ്പിന്റെ ഫലത്തിൽ ഒരു ട്രാൻസിഷൻ പൊരുത്തപ്പെട്ടു. |
| `handoff` | മറ്റൊരു ഏജന്റ് ചുമതല ഏറ്റെടുത്തു. |

## സ്റ്റെപ്പുകൾ എവിടെ പ്രവർത്തിക്കുന്നു

ഓരോ ഏജന്റിലും (പഴയ ഉൽപ്പന്ന മൂല്യങ്ങളിലുമുള്ളത് ഉൾപ്പെടെ), ഇൻബൗണ്ട്, ഔട്ട്ബൗണ്ട്, കാമ്പെയ്ൻ കോളുകൾ, ടെസ്റ്റ് കോളുകൾ, വെബ്, വിജറ്റ് കോളുകൾ എന്നിവയിൽ ഘട്ടങ്ങൾ നേറ്റീവായി പ്രവർത്തിക്കുന്നു.

മറ്റെല്ലായിടത്തും ഏജന്റ് ഇപ്പോഴും പ്രവർത്തിക്കും, പക്ഷേ ഘടനയില്ലാതെ: പങ്കിട്ട നിർദ്ദേശങ്ങളെയും എല്ലാ സ്റ്റെപ്പുകളെയും ക്രമത്തിൽ ലയിപ്പിക്കുന്ന ഒരു ഫ്ലാറ്റൻഡ് prompt ആണ് പ്രവർത്തിപ്പിക്കുന്നത്. ഇതിൽ ഉൾപ്പെടുന്നത്:

- സംരക്ഷിച്ച ഏജന്റിനായുള്ള സെഷനുകൾ ഉൾപ്പെടെയുള്ള [Realtime](/ml/guides/use-with-openai-realtime) സെഷനുകൾ;
- ഒരു [ഡൈനാമിക് കോൾ കോൺഫിഗ്](/ml/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 |

ഒരു നിയമം ലംഘിക്കുന്ന സേവ്, `steps.steps[2].transitions[0].to` പോലുള്ള
തെറ്റായ ഫീൽഡിന്റെ പാതയോടെ `400` നൽകും. `tools`-ലെയും
`on_enter_tool`-ലെയും ടൂൾ പേരുകൾ ഏജന്റിൽ ചേർത്തിട്ടുള്ള ടൂളുകളായിരിക്കണം.

ഓരോ ഘട്ടത്തിനുമുള്ള ഭാഷകൾ, മോഡൽ ഒഴിവാക്കുന്ന സ്ക്രിപ്റ്റ് ചെയ്ത ഘട്ടങ്ങൾ, കൂടാതെ
say വരികൾക്കുള്ളിലെ ശേഖരിച്ച മൂല്യങ്ങൾ പിന്തുണയ്ക്കുന്നില്ല.

## ഇറക്കുമതി ചെയ്ത ഏജന്റുകൾ

Retell, Bland, Vapi, അല്ലെങ്കിൽ ElevenLabs എന്നിവയിൽ നിന്ന് [ഇറക്കുമതി ചെയ്യുന്നത്](/ml/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"}
  ]
}
```

fifteen എന്ന് പറയുന്ന ഒരു കോളർ, മോഡൽ എന്ത് തീരുമാനിച്ചാലും `guardian`-ലേക്ക് പോകും.
മറ്റെല്ലാവരും `book`-ലേക്ക് പോകും. ഗ്രാഫിലെ മറ്റിടങ്ങളിൽ രണ്ടും സാധാരണ ഘട്ടങ്ങളാണ്.

## ഉദാഹരണം: അക്കൗണ്ട് ലുക്ക്അപ്പ് webhook ഘട്ടം

വിളിക്കുന്നയാൾ ഒരു അക്കൗണ്ട് നമ്പർ നൽകുന്നു, അടുത്ത ഘട്ടത്തിലേക്ക് പ്രവേശിക്കുമ്പോൾ ലുക്ക്അപ്പ് പ്രവർത്തിക്കുന്നു,
അതിന്റെ ഫലം റൂട്ട് തിരഞ്ഞെടുക്കുന്നു. സംക്ഷിപ്തതയ്ക്കായി `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, tools, വോയ്‌സ് എന്നിവയുള്ള ഒരു ബില്ലിങ് ഏജന്റിന് (ഏജന്റ് `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"}
  ]
}
```

ഫ്രണ്ട് ഡെസ്ക് "Let me get you to our billing
team" പോലുള്ള ഒരു ചെറിയ വാചകം പറയുന്നു, ബില്ലിങ് ഏജന്റ് സ്വയം പരിചയപ്പെടുത്തി ഫ്രണ്ട് ഡെസ്ക്
നിർത്തിയിടത്ത് നിന്ന് സംഭാഷണം തുടരുന്നു. ബില്ലിങ് തിരികെ കൈമാറുമ്പോൾ, വിളിക്കുന്നയാളെ വീണ്ടും അഭിവാദ്യം ചെയ്യാതെ
ഫ്രണ്ട് ഡെസ്ക് നിർത്തിയിടത്ത് നിന്ന് പുനരാരംഭിക്കുന്നു. കോളിന്റെ ഉൽപ്പന്നം,
ഭാഷകൾ, സമ്മത അറിയിപ്പ്, മറ്റ് കോൾ ക്രമീകരണങ്ങൾ എന്നിവ ഫ്രണ്ട് ഡെസ്കിൽ തന്നെ തുടരും,
കാരണം അതാണ് മറുപടി നൽകിയത്.

ബില്ലിങ്ങിന് അതിന്റേതായ ഏജന്റ് വേണ്ടാതെ സ്വന്തം നിർദേശങ്ങൾ മാത്രം ആവശ്യമാണെങ്കിൽ, പകരം ഫ്രണ്ട് ഡെസ്കിൽ
ഒരു ഗ്ലോബൽ ഘട്ടം ഉപയോഗിക്കുക. ചോദ്യത്തിന് മറുപടി ലഭിക്കുമ്പോൾ, കോൾ വിളിക്കുന്നയാൾ ഉണ്ടായിരുന്ന
ഏത് ഘട്ടത്തിലേക്കാണോ അതിലേക്ക് തിരികെ പോകുന്നു:

```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="Prompting ഗൈഡ്" icon="pen" href="/ml/guides/prompting">
    ഫോണിൽ ഫലപ്രദമായി പ്രവർത്തിക്കുന്ന പങ്കിട്ട നിർദേശങ്ങളും ഘട്ട നിർദേശങ്ങളും എഴുതുക.
  </Card>
  <Card title="ടൂൾ ഇന്റഗ്രേഷൻ നിർമ്മിക്കുക" icon="code" href="/ml/guides/build-tool-integration">
    നിങ്ങളുടെ ഘട്ടങ്ങളും webhook ഘട്ടങ്ങളും വിളിക്കുന്ന ടൂളുകൾ സൃഷ്ടിക്കുക.
  </Card>
  <Card title="നിങ്ങളുടെ ഏജന്റുമാരെ പരീക്ഷിക്കുക" icon="flask" href="/ml/guides/test-agents">
    ഡിപ്ലോയ് ചെയ്യുന്നതിന് മുമ്പ് എല്ലാ ശാഖകൾക്കും എതിരെ ഒരേ സാഹചര്യങ്ങൾ പ്രവർത്തിപ്പിക്കുക.
  </Card>
  <Card title="ഏജന്റുമാരുടെ API" icon="robot" href="/api-reference/agents">
    എല്ലാ ഏജന്റ് ഫീൽഡുകളും, ഡ്രാഫ്റ്റും ഡിപ്ലോയും.
  </Card>
</CardGroup>
