એજન્ટના પગલાં અને હેન્ડઓફ્સ

એજન્ટને પોતાની સૂચનાઓ, ટૂલ્સ અને એકત્રિત મૂલ્યો ધરાવતા પગલાંમાં વિભાજિત કરો અને કૉલ દરમિયાન એજન્ટો વચ્ચે કૉલ હસ્તાંતરિત કરો.

એક જ prompt મોડેલને આખું કામ એકસાથે આપે છે. પગલાં તેને કૉલનો એક સમયે એક તબક્કો આપે છે: દરેક પગલાંમાં પોતાની સૂચનાઓ, પોતાના ટૂલ્સ, શબ્દશઃ બોલવાની વૈકલ્પિક પંક્તિ અને આગળ વધતા પહેલાં એકત્ર કરવાના મૂલ્યો હોય છે. હેન્ડઓફ્સ તમારી સંસ્થાના બીજા એજન્ટને, ટ્રાન્સક્રિપ્ટ અકબંધ રાખીને, કૉલની વચ્ચે સંભાળ લેવા દે છે, જેથી કોલરને પોતાનું કહેવું ફરીથી ન કહેવું પડે.

દરેક એજન્ટ એક જ promptથી શરૂ થાય છે. તમે પગલાં અથવા હેન્ડઓફ્સ ઉમેરો ત્યાં સુધી તેમાં કંઈ બદલાતું નથી.

પગલાં કે એક જ prompt?#

પગલાં સ્ક્રિપ્ટેડ ફોન ટ્રી નથી. એક પગલાંની અંદર મોડેલ વાતચીત એ જ રીતે ચલાવે છે જે રીતે તે એક જ prompt સાથે ચલાવે છે. પગલું નક્કી કરે છે કે તે શું કામ કરી રહ્યું છે, કયા ટૂલ્સ વાપરી શકે છે અને બહાર નીકળતાં પહેલાં તેને શું જરૂરી છે.

પગલાંવાળો એજન્ટ કેવી રીતે બનાવાય છે#

જ્યારે એજન્ટમાં પગલાં હોય, ત્યારે તેનું prompt સહિયારી સૂચનાઓ ધરાવે છે: એવી પર્સોના અને નિયમો જે દરેક પગલાંમાં લાગુ પડે છે. દરેક પગલું તેના ઉપર પોતાની સૂચનાઓ ઉમેરે છે. દરેક ટર્નમાં મોડેલ સહિયારી સૂચનાઓ, વર્તમાન પગલાંનું નામ અને સૂચનાઓ, તથા અત્યાર સુધી એકત્ર કરેલા મૂલ્યો જુએ છે.

બિલ્ડરમાં, એજન્ટને એકલ promptમાંથી પગલાંમાં બદલો. તમને દરેક પગલાં માટે તેનું નામ, સૂચનાઓ, બોલવાની પંક્તિ, ટૂલ્સ, એકત્ર કરેલા મૂલ્યો અને ટ્રાન્ઝિશન્સ ધરાવતું કાર્ડ, હેન્ડઓફ્સ પિકર અને પગલાંનો ફક્ત-વાંચી-શકાય એવો ફ્લો ગ્રાફ મળશે. પાછા એક જ prompt પર બદલવાથી સહિયારી સૂચનાઓ અને દરેક પગલાંને મર્જ કરતો ફ્લેટન કરેલો prompt મળે છે.

API પર, steps અને handoffs એ એજન્ટ પરના ફીલ્ડ્સ છે. દરેક એજન્ટ ફીલ્ડની જેમ, PATCH તેમને ડ્રાફ્ટમાં સ્ટેજ કરે છે; POST /v1/agents/{agent_id}/deploy તેમને લાઇવ કરે છે. મોકલવાથી "steps": null એજન્ટને પાછા એક જ prompt પર બદલે છે. ટેસ્ટ કૉલ્સ અને વાત કરો ડ્રાફ્ટ ચલાવે છે.

પગલાંના ફીલ્ડ્સ#

ગ્રાફ પોતે {"start_step": "<step id>", "steps": [...]} છે. કૉલ start_stepમાં શરૂ થાય છે.

ટ્રાન્ઝિશન્સ#

દરેક ટ્રાન્ઝિશનમાં to, એક સ્ટેપ id અને નીચેનામાંથી ચોક્કસ એક હોય છે:

• 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>} છે:

eq, ne, in અને not_in ખાલી જગ્યાઓ દૂર કર્યા પછી લખાણની અપર-લોઅર કેસની પરવા કર્યા વિના સરખામણી કરે છે. સંખ્યાઓની સરખામણી સંખ્યાઓ તરીકે અને તારીખોની YYYY-MM-DD સ્ટ્રિંગ્સ તરીકે થાય છે. જે મૂલ્ય ક્યારેય એકત્રિત કરવામાં આવ્યું નથી તે missing સિવાય દરેક op ને false બનાવે છે.

when અને global_when ને કહેવા માટેની વાત તરીકે નહીં, પરંતુ શરત તરીકે લખો, જેમ કે "કૉલર એપૉઇન્ટમેન્ટ બુક કરવા માંગે છે". એજન્ટ તેમને આંતરિક રૂટિંગ નોંધો તરીકે જુએ છે અને તેમને ક્યારેય વાંચી સંભળાવવા અથવા તે સ્ટેપ બદલી રહ્યું છે તેનો ઉલ્લેખ ન કરવા માટે જણાવવામાં આવે છે.

જ્યારે મોડેલ go_to_step કૉલ કરે છે:

1. સ્ટેપમાંનું દરેક required મૂલ્ય હાજર હોવું આવશ્યક છે. જો એક ખૂટે, તો મોડેલને કયું ખૂટે છે તે જણાવવામાં આવે છે અને તે કૉલરને તે માટે પૂછે છે.
2. મૂલ્યો સંગ્રહિત થાય છે.
3. condition અને always ટ્રાન્ઝિશન્સ ક્રમમાં તપાસવામાં આવે છે. પ્રથમ મેળ લાગુ પડે છે.
4. અન્યથા એજન્ટ મોડેલે પસંદ કરેલા સ્ટેપ પર જાય છે.
5. જો કંઈ મેળ ન ખાય અને મોડેલે કોઈ સ્ટેપનું નામ ન આપ્યું હોય, તો એજન્ટ જ્યાં છે ત્યાં રહે છે.

ગ્લોબલ સ્ટેપ પર જમ્પ અપવાદ છે: કૉલરે વિષય બદલ્યો છે, તેથી વર્તમાન સ્ટેપમાં હજુ આવશ્યક મૂલ્યો ખૂટતા હોય ત્યારે પણ અને તે સ્ટેપની શરતો તપાસવામાં આવે તે પહેલાં પણ તે આગળ વધે છે.

દરેક વખતે સ્ટેપ દાખલ થાય ત્યારે condition અને always ટ્રાન્ઝિશન્સ પણ તપાસવામાં આવે છે, તેથી કોડ-નિર્ણિત સ્ટેપ્સની શ્રેણી એક જ વારમાં ચાલે છે. શ્રેણી અટકે છે:

• આ રનમાં તે પહેલેથી મુલાકાત લઈ ચૂક્યું હોય તેવા સ્ટેપ પર;
• 8 હોપ્સ પછી;
• એવા સ્ટેપ પર જેમાં હજુ આવશ્યક મૂલ્યો એકત્રિત કરવાના બાકી હોય, સિવાય કે સ્ટેપમાં on_enter_tool હોય (વેબહૂક સ્ટેપ હંમેશાં તેના પરિણામ પર રૂટ કરે છે).

શ્રેણી જ્યાં અટકે છે તે સ્ટેપની માત્ર say લાઇન બોલવામાં આવે છે.

ટ્રાન્ઝિશન્સ વિનાનો સ્ટેપ ટર્મિનલ છે. એજન્ટ ત્યાં પૂર્ણ કરે છે અને તેની સામાન્ય બિલ્ટ-ઇન ક્રિયાઓથી કૉલ સમાપ્ત કરે છે અથવા ટ્રાન્સફર કરે છે.

મૂલ્યો એકત્રિત કરવા#

સ્ટેપને જે જોઈએ તે collect માં સૂચિબદ્ધ કરો. મોડેલ જ્યારે go_to_step કૉલ કરે છે ત્યારે મૂલ્યો પાસ કરે છે, અને તે કૉલના બાકીના સમય માટે ઉપલબ્ધ રહે છે.

એકત્રિત કરેલા મૂલ્યો કૉલ સામગ્રી છે. તે ટ્રાન્સક્રિપ્ટની બાજુમાં કૉલ પર દેખાય છે અને એ જ રિટેન્શન, ડિલીટ અને રેડેક્શન નિયમોનું પાલન કરે છે. જ્યારે એજન્ટનું કૉલ રેકોર્ડિંગ બંધ હોય, ત્યારે એકત્રિત કરેલા મૂલ્યો ન તો સંગ્રહિત થાય છે કે ન વેબહૂક્સમાં મોકલવામાં આવે છે; જોકે સ્ટેપ ટાઇમલાઇન રહે છે. જુઓ કૉલમાં તે ક્યાં જોવું.

બોલવાની પંક્તિઓ#

એજન્ટ સ્ટેપમાં પ્રવેશે ત્યારે say લખ્યું હોય તે જ રીતે બોલાય છે. ત્યારબાદ મોડેલને જાણ હોય છે કે પંક્તિ હમણાં જ બોલાઈ હતી, તેથી તે તેને પુનરાવર્તિત કર્યા વિના એ જ જવાબમાં નવા સ્ટેપમાં આગળ વધે છે. અભિવાદન, જરૂરી ખુલાસા અને નિશ્ચિત શબ્દરચના માટે say નો ઉપયોગ કરો અને જવાબનો બાકી ભાગ મોડેલ પર છોડી દો.

કોઈપણ સંમતિ ઘોષણા પછી, એજન્ટ પહેલાં બોલે ત્યારે પ્રારંભિક સ્ટેપનું say તેની શરૂઆતની પંક્તિ હોય છે. કૉલર પહેલાં બોલે ત્યારે, તે વ્યક્તિને એજન્ટના પ્રથમ જવાબની શરૂઆત કરે છે, ક્યારેય IVR અથવા વૉઇસમેઇલ અભિવાદનની નહીં.

કૉલ __previous__ અથવા હેન્ડ-બેક દ્વારા કોઈ સ્ટેપ પર પાછો આવે ત્યારે તે સ્ટેપનું say ફરી બોલાતું નથી. તે જે રીતે સંભળાવું જોઈએ તે રીતે લખો: અવાજ ખોટું વાંચી શકે તેવી દરેક બાબત સ્પષ્ટ રીતે લખો. બોલવાની પંક્તિઓ {{var}} કૉલ વેરિએબલને સપોર્ટ કરે છે, પરંતુ એકત્રિત કરેલી કિંમતોને નહીં.

વેબહૂક સ્ટેપ્સ#

on_enter_tool ને એજન્ટના કોઈ એક ટૂલ પર સેટ કરો; સ્ટેપમાં પ્રવેશતાની સાથે મોડેલની રાહ જોયા વિના તે ચાલે છે. તેના આર્ગ્યુમેન્ટ્સ એવી એકત્રિત કિંમતો છે, જેમનાં નામ ટૂલના પેરામીટર નામો સાથે મેળ ખાતાં હોય. પરિણામ <tool>_result નામની એકત્રિત કિંમત તરીકે સંગ્રહાય છે, 4 KB સુધી ટૂંકાવવામાં આવે છે, અને સ્ટેપના condition તથા always ટ્રાન્ઝિશન તરત જ ચકાસવામાં આવે છે, જેથી લુકઅપ પોતાના પરિણામના આધારે કૉલને રૂટ કરી શકે.

સંગ્રહિત કિંમતમાં બે ફીલ્ડ હોય છે:

બોડી ફીલ્ડના આધારે lookup_account_result.response.<field> વડે અને સ્ટેટસ કોડના આધારે lookup_account_result.status વડે રૂટ કરો.

લુકઅપ વધુમાં વધુ 8 સેકન્ડ સુધી અથવા ટૂલના પોતાના ટાઇમઆઉટ સુધી ચાલે છે, જે ઓછો હોય તે. જો તેમાં 3 સેકન્ડથી વધુ સમય લાગે, તો કૉલરને મૌનમાં ન રાખવા માટે એજન્ટ ટૂંકી પંક્તિ બોલે છે. તમારું એન્ડપોઇન્ટ 400 કે તેથી વધુ સ્ટેટસ પરત કરે અથવા સમયસર જવાબ ન આપે, તો એજન્ટ કૉલરને જણાવે છે કે તે હમણાં તે તપાસી શક્યો નથી અને જે કરી શકે તે સાથે આગળ વધે છે.

વૈશ્વિક સ્ટેપ્સ#

global_when ધરાવતો સ્ટેપ, જ્યારે પણ તે વર્ણન લાગુ પડે ત્યારે, કોઈપણ સ્ટેપમાંથી પહોંચી શકાય છે. when ની જેમ, નિર્ણય મોડેલ લે છે. કૉલર કોઈપણ સમયે ઉઠાવી શકે એવા વિષયો માટે તેનો ઉપયોગ કરો: બિલિંગ પ્રશ્નો, વ્યક્તિ સાથે વાત કરવાની વિનંતી, ફરિયાદ.

વૈશ્વિક સ્ટેપ પર "to": "__previous__" ધરાવતું ટ્રાન્ઝિશન કૉલને તે પહેલાં સક્રિય સ્ટેપ પર પાછો મોકલે છે, જેથી કૉલર જ્યાં છોડ્યું હતું ત્યાંથી આગળ વધે. સ્ટેપ ફરી ચાલુ થાય છે: તેનું on_enter_tool ફરી ચાલતું નથી, તેનું say પુનરાવર્તિત થતું નથી, અને એજન્ટ તેને ફરીથી શરૂ કર્યા વિના આગળ ચાલુ રાખે છે.

હેન્ડઓફ્સ#

handoffs તમારી સંસ્થાના અન્ય એજન્ટોની યાદી આપે છે જે કૉલ સંભાળી શકે છે:

[{"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 સ્ટેપ્સ અથવા હેન્ડઓફ્સ ધરાવતા એજન્ટો પર આરક્ષિત છે, તેથી તમારા પોતાના ટૂલ્સ આ નામોનો ઉપયોગ કરી શકતા નથી.

કૉલમાં તેને ક્યાં જોવું#

કૉલ ઇતિહાસ માં કૉલ ખોલો. ટ્રાન્સક્રિપ્ટની બાજુમાં સ્ટેપ સમયરેખા કૉલ કયા સ્ટેપમાં દાખલ થયો અને શા માટે તે દર્શાવે છે, અને એકત્રિત કિંમતો તેની સાથે સૂચિબદ્ધ હોય છે.

કૉલ ઑબ્જેક્ટ અને કૉલ-પૂર્ણ વેબહૂક (telephony.complete / web.complete) માં steps_trace અને collected_values તરીકે સમાન ડેટા હોય છે. સ્ટેપ્સ વિનાના કૉલમાં બંને ગેરહાજર હોય છે.

"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 કૉલને શું ખસેડ્યું તે દર્શાવે છે:

સ્ટેપ્સ ક્યાં ચાલે છે#

સ્ટેપ્સ Spark, Bolt અને દરેક Storm પ્રોડક્ટ પર, ઇનબાઉન્ડ, આઉટબાઉન્ડ અને કૅમ્પેઇન કૉલ્સ, ટેસ્ટ કૉલ્સ તેમજ વેબ અને વિજેટ કૉલ્સ પર મૂળભૂત રીતે ચાલે છે.

અન્ય દરેક જગ્યાએ એજન્ટ હજી પણ કાર્ય કરે છે, ફક્ત રચના વિના: તે શેર કરેલી સૂચનાઓ અને દરેક સ્ટેપને ક્રમમાં મર્જ કરેલો સપાટ prompt ચલાવે છે. તેમાં આ આવરી લેવાય છે:

• પ્રાયોગિક Bolt પ્રોડક્ટ્સ;
• Realtime સત્રો, જેમાં સાચવેલા એજન્ટ માટેના સત્રોનો સમાવેશ થાય છે;
• ડાયનેમિક કૉલ કૉન્ફિગ વેબહૂક દ્વારા પરત કરાયેલા ઇનલાઇન રૂપરેખાંકનો. agent_id પરત કરતો વેબહૂક તે એજન્ટના સ્ટેપ્સનો ઉપયોગ કરે છે.

મર્યાદાઓ#

નિયમ તોડતો સેવ ખરાબ ફીલ્ડના પાથ સાથે 400 પરત કરે છે, જેમ કે steps.steps[2].transitions[0].to. tools અને on_enter_toolમાં ટૂલના નામ એજન્ટ સાથે જોડાયેલા ટૂલ્સ હોવા આવશ્યક છે.

પ્રતિ-સ્ટેપ ભાષાઓ, મોડેલને છોડતા સ્ક્રિપ્ટેડ સ્ટેપ્સ અને say લાઇનની અંદરના એકત્રિત મૂલ્યો સપોર્ટેડ નથી.

આયાત કરેલા એજન્ટ્સ#

Retell, Bland, Vapi અથવા ElevenLabsમાંથી આયાત કરવાથી મલ્ટી-prompt એજન્ટ્સ, ફ્લોઝ, પાથવેઝ અને વર્કફ્લોઝ સ્ટેપ્સ તરીકે આવે છે, અને સ્ક્વોડ્સ તથા એજન્ટ ટ્રાન્સફર્સ આયાત કરેલા એજન્ટ્સ વચ્ચે હેન્ડઓફ્સ તરીકે આવે છે. આયાત કરતાં પહેલાં રિવ્યૂ પેજ બંને બતાવે છે.

ઉદાહરણ: ડેન્ટલ ઇનટેક#

ક્રમમાં ત્રણ સ્ટેપ્સ: અભિવાદન, દર્દીની વિગતો એકત્રિત કરવી, બુકિંગ.

{
  "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 વૈકલ્પિક છે.

ઉદાહરણ: ઉંમર-આધારિત શાખા#

મોડેલ કોઈપણ સાથે વાત કરી શકે છે, પરંતુ કોનું બુકિંગ થાય તે કોડ નક્કી કરે છે. ઉંમર એકત્રિત કરો, પછી મોડેલની પોતાની પસંદ ધ્યાનમાં લેવાય તે પહેલાં તેના આધારે રૂટ કરો.

{
  "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 પર જાય છે. બંને ગ્રાફમાં અન્યત્ર સામાન્ય સ્ટેપ્સ છે.

ઉદાહરણ: એકાઉન્ટ લુકઅપ webhook સ્ટેપ#

કૉલર એકાઉન્ટ નંબર આપે છે, આગળના સ્ટેપમાં પ્રવેશતા લુકઅપ ચાલે છે, અને તેનું પરિણામ રૂટ પસંદ કરે છે. સંક્ષિપ્તતા માટે not_found, collections અને support સ્ટેપ્સ છોડવામાં આવ્યા છે.

[
  {
    "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) ને સોંપે છે.

ફ્રન્ટ ડેસ્ક પર:

{
  "handoffs": [
    {"agent_id": 413, "when": "The caller asks about a bill, a payment or a refund"}
  ]
}

બિલિંગ એજન્ટ પર, જેથી તે કૉલરને પાછા સોંપી શકે:

{
  "handoffs": [
    {"agent_id": 412, "when": "The billing question is resolved and the caller needs something else"}
  ]
}

ફ્રન્ટ ડેસ્ક "Let me get you to our billing team" જેવી ટૂંકી પંક્તિ કહે છે, અને બિલિંગ એજન્ટ પોતાનો પરિચય આપે છે તથા ફ્રન્ટ ડેસ્કે જ્યાં વાતચીત છોડી હતી ત્યાંથી આગળ વધારે છે. બિલિંગ પાછું સોંપે ત્યારે, ફ્રન્ટ ડેસ્ક કૉલરને ફરીથી અભિવાદન કર્યા વિના, જ્યાં હતું ત્યાંથી ફરી શરૂ કરે છે. કૉલનું પ્રોડક્ટ, ભાષાઓ, સંમતિની જાહેરાત અને અન્ય કૉલ સેટિંગ્સ ફ્રન્ટ ડેસ્ક સાથે જ રહે છે, કારણ કે તેણે જવાબ આપ્યો હતો.

જો બિલિંગને તેના પોતાના એજન્ટની નહીં, ફક્ત પોતાની સૂચનાઓની જરૂર હોય, તો તેના બદલે ફ્રન્ટ ડેસ્ક પર ગ્લોબલ સ્ટેપ વાપરો. પ્રશ્નનો જવાબ મળ્યા પછી, કૉલર જે સ્ટેપમાં હતો તે સ્ટેપ પર કૉલ પાછો જાય છે:

{
  "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"
}

આગળના પગલાં#