वॉइस सीक्वेंस नोड संदर्भ

Warning: Voice sequences are in preview. Steps, entry data, and the sequence definition format can change in ways that break existing sequences and API requests.

कॉल बनाएँ के साथ भेजे जाने वाले sequence.definition को लिखने के लिए इस संदर्भ का उपयोग करें। Bird इनलाइन डेफ़िनिशन को एक बार चलाता है और उसे सहेजता नहीं। सीक्वेंस रखने के लिए इसे डैशबोर्ड एडिटर में बनाएँ।

डेफ़िनिशन

फ़ील्ड	मान
`schema_version`	`1`।
`expression_environment`	`"bird.cel.v1"`।
`nodes`	नोड ऑब्जेक्ट्स की ऐरे। ऐरे क्रम का निष्पादन पर कोई प्रभाव नहीं पड़ता।
`settings`	इसे छोड़ दें या `{}` भेजें। गैर-रिक्त ऑब्जेक्ट `unsupported_contract` के साथ विफल होता है; ऐसा मान जो ऑब्जेक्ट नहीं है, `invalid_envelope` के साथ विफल होता है।
`presentation`	वैकल्पिक एडिटर लेआउट और लेबल। यह निष्पादन को प्रभावित नहीं करता लेकिन आकार सीमा में गिना जाता है।

प्रत्येक नोड में ये फ़ील्ड होते हैं:

फ़ील्ड	मान
`id`	डेफ़िनिशन में अद्वितीय। एक लोअरकेस अक्षर से शुरू होता है, फिर लोअरकेस अक्षर, अंक, या `_`, अधिकतम 64 वर्ण।
`type`	इस पेज से एक नोड टाइप, जैसे `voice.say`।
`type_version`	इस पेज पर हर नोड टाइप के लिए `1`।
`config`	सेटअप जो नोड का स्वरूप तय करता है, जैसे घोषित outcomes। जब नोड में कोई न हो तो `{}` का उपयोग करें।
`input`	वे मान जो नोड चलते समय उपयोग करता है। जब नोड में कोई न हो तो `{}` का उपयोग करें।
`connections`	एक outcome नाम से `{ "node_id": "<target>", "port": "input" }` तक का मैप।

कनेक्शन में लूप नहीं होना चाहिए, और हर नोड किसी entry से पहुँच योग्य होना चाहिए। connections से बाहर छोड़ा गया outcome अनकनेक्टेड होता है। अनकनेक्टेड outcomes रन को सामान्य रूप से समाप्त करते हैं, सिवाय जहाँ कोई नोड अन्यथा कहता हो।

मान और एक्सप्रेशन

अधिकांश फ़ील्ड शाब्दिक JSON लेते हैं। binds चिह्नित फ़ील्ड $expr या $template भी स्वीकार करते हैं; expr चिह्नित फ़ील्ड केवल $expr भी स्वीकार करते हैं:

{"$expr": "trigger.data.customer_name"} एक टाइप्ड मान लौटाता है।
{"$template": ["Hello ", {"$expr": "trigger.data.customer_name"}, "."]} टेक्स्ट लौटाता है। टेम्प्लेट ऐरे होते हैं; {{name}} शाब्दिक टेक्स्ट बना रहता है।

एक्सप्रेशन CEL का उपयोग करते हैं और ये मान पढ़ सकते हैं:

मान	विवरण
`trigger.data`	एंट्री डेटा, जो एंट्री के `data_schema` से मेल खाता है।
`trigger.node_id`	उस एंट्री की ID जिसने इस विज़िट को शुरू किया।
`trigger.type`	उस एंट्री का प्रकार जिसने इस विज़िट को शुरू किया, जैसे `trigger.start_call`।
`steps.<id>.output`	इस विज़िट में पहले पूर्ण हुए नोड का आउटपुट।
`variables.<key>`	इस विज़िट में `data.set` नोड द्वारा सहेजे गए मान।
`execution.id`, `execution.started_at`	रन ID और उसका प्रारंभ समय। स्पीच में `string(execution.started_at)` का उपयोग करें।
`execution.call`	कॉल का `id`, `session_id`, और मूल पक्ष `orig` तथा `dest`, जिनमें से प्रत्येक `null` हो सकता है।

वैकल्पिक मानों को पढ़ने से पहले उनकी जाँच करें, उदाहरण के लिए has(trigger.data.name) ? trigger.data.name : 'caller'। has मैक्रो उपलब्ध है; map, filter, all, exists, और exists_one उपलब्ध नहीं हैं।

एंट्री

`trigger.start_call`

कॉल यहाँ से शुरू होती है। Create Call अनुरोध में entry_node_id इस नोड का नाम देता है।

फ़ील्ड	मान
`config.data_schema`	वैकल्पिक JSON Schema (draft 2020-12) ऑब्जेक्ट स्कीमा `trigger_data` के लिए। केवल लोकल `$ref` समर्थित है। इसके बिना, एंट्री केवल `{}` स्वीकार करती है।
आउटकम	`event`।

एंट्री डेटा 16 KiB तक सीमित है।

स्पीच और ऑडियो

`voice.say`

फ़ील्ड	मान
`input.text`	आवश्यक, binds। बोलने के लिए टेक्स्ट, अधिकतम 160 बाइट्स।
`input.language`	आवश्यक। स्पीच भाषा कोड, जैसे `en`।
आउटकम	`next`।

`voice.play`

फ़ील्ड	मान
`input.asset_id`	आवश्यक। इस वर्कस्पेस में उपलब्ध किसी ऑडियो एसेट का ID। जब स्टेप चलता है तब अनुपलब्ध एसेट कॉल को विफल कर सकता है।
आउटकम	`next`।

`voice.tone`

फ़ील्ड	मान
`input.frequency_hz`	आवश्यक। `100` से `3000`।
`input.duration_ms`	आवश्यक। `1` से `10000`।
आउटकम	`next`।

`logic.pause`

कॉल कनेक्ट रहते हुए प्रतीक्षा करता है।

फ़ील्ड	मान
`input.duration_ms`	आवश्यक। `1` से `60000`।
आउटकम	`next`।

कीपैड इनपुट

`voice.gather`

प्रॉम्प्ट चलाता है, जिन्हें कोई भी की प्रेस रोक सकता है, और कीपैड अंक एकत्र करता है।

फ़ील्ड	मान
`input.prompts`	आवश्यक। अधिकतम 4 प्रॉम्प्ट। हर एक `{"type": "say", "text", "language"}`, `{"type": "play", "asset_id"}`, `{"type": "tone", "frequency_hz", "duration_ms"}`, या `{"type": "pause", "duration_ms"}` है, जिसमें संबंधित नोड जैसी ही सीमाएँ हैं। टोन और पॉज़ की अवधि मिलाकर अधिकतम 60,000 ms है। प्रॉम्प्ट `text` binds।
`input.max_digits`	आवश्यक। `1` से `32`।
`input.timeout_seconds`	आवश्यक। पहली कुंजी के लिए प्रतीक्षा सेकंड, `1` से `10`।
`input.inter_digit_timeout_seconds`	आवश्यक। कुंजियों के बीच प्रतीक्षा सेकंड, `1` से `5`।
`input.finish_on_key`	आवश्यक। `0`–`9`, `*`, `#`, `A`–`D` में से कोई एक जो इनपुट समाप्त करे, या `null`।
`input.matches`	आवश्यक। आउटकम नाम से उन सटीक अंकों का मैप जो उसे चुनते हैं, जैसे `{"hours": "1"}`। नाम और अंक अद्वितीय होने चाहिए। नाम `input`, `timeout`, या `fallback` नहीं हो सकता। अंक अधिकतम `max_digits` लंबे हो सकते हैं और उनमें `finish_on_key` नहीं हो सकता।
`input.private`	वैकल्पिक, डिफ़ॉल्ट `false`। जब `true` हो, तो बाद के चरण अंकों को नहीं पढ़ सकते, और वे ट्रेस से बाहर रहते हैं।
आउटकम	`matches` में प्रत्येक नाम, कोई कुंजी न दबाए जाने पर `timeout`, और किसी भी अन्य इनपुट के लिए `fallback`।
आउटपुट	`digits` और `reason`: `initial_timeout`, `max_digits`, `finish_key`, या `inter_digit_timeout`।

लॉजिक और डेटा

`logic.branch`

शर्तों को क्रम में जाँचता है और पहली सही शर्त का अनुसरण करता है।

फ़ील्ड	मान
`config.cases`	आवश्यक। कम से कम एक `{"port": "<name>", "when": {"$expr": "<boolean>"}}`।
`config.default_port`	आवश्यक। जब कोई भी केस सही न हो तब का outcome नाम।
Outcomes	`cases` में प्रत्येक `port`, और `default_port`।
आउटपुट	`branch`: चयनित outcome का नाम।

`data.set`

उसी विज़िट में बाद के चरणों के लिए मान सहेजता है।

फ़ील्ड	मान
`input`	मानों का ऑब्जेक्ट, जिनमें से प्रत्येक binds करता है। प्रत्येक key `variables.<key>` बन जाती है। हर मान की गणना इस नोड से पहले की वेरिएबल स्थिति से होती है।
Outcome	`next`।
Output	सहेजा गया ऑब्जेक्ट।

कॉल और ट्रांसफ़र

`voice.dial`

किसी अन्य नंबर पर कॉल करता है और उसे वर्तमान कॉल से जोड़ता है।

फ़ील्ड	मान
`input.to`	आवश्यक, binds। E.164 नंबर, जैसे `+12025550123`।
`input.timeout_seconds`	आवश्यक, expr। रिंग करने के सेकंड, `1` से `120`।
परिणाम	`success`, `busy`, `no_answer`, और `failure`। `success` कनेक्ट किए गए कॉल के समाप्त होने और मूल कॉल का ऑडियो पुनर्स्थापित होने के बाद आता है, गंतव्य द्वारा उत्तर देने पर नहीं। बिना कनेक्ट हुआ `failure` रन को विफल कर देता है।

`logic.voice_goto`

उसी डेफ़िनिशन में एक अन्य एंट्री शुरू करता है। नई विज़िट को ताज़ा trigger.data मिलता है और पहले के स्टेप आउटपुट व वेरिएबल्स साफ़ हो जाते हैं; कॉल जारी रहती है।

फ़ील्ड	मान
`input.entry_node_id`	आवश्यक। इस डेफ़िनिशन में एक `trigger.start_call` नोड का ID।
`input.data`	वैकल्पिक, expr, डिफ़ॉल्ट `{}`। उस नोड के स्कीमा के लिए एंट्री डेटा।
परिणाम	कोई नहीं।

कॉल समाप्त करना

`logic.exit`

कॉल को एक परिणाम के साथ समाप्त करता है।

फ़ील्ड	मान
`config.status`	आवश्यक। `succeeded` या `failed`।
`config.reason`	वैकल्पिक, expr। लोअरकेस अक्षरों, अंकों और `_` का स्थिर कोड, जो अक्षर या अंक से शुरू होता है, अधिकतम 64 वर्ण। `null` भेजने के बजाय इसे छोड़ दें।
`input.output`	आवश्यक ऑब्जेक्ट, जो `{}` हो सकता है। इसके शीर्ष-स्तरीय मान bind करते हैं।
आउटकम	कोई नहीं।

`voice.hangup`

कॉल को बिना किसी लिखित परिणाम के समाप्त करता है। इसमें कोई फ़ील्ड और कोई आउटकम नहीं है।

अर्ली एक्सेस स्टेप

voice.webhook, voice.record_start, voice.record_stop, और logic.voice_goto जिनमें dependency_id प्रबंधित वॉइसमेल या कॉल रिकॉर्डिंग के लिए है, अर्ली एक्सेस में हैं और यहाँ दस्तावेज़ित नहीं हैं। इन्हें उपयोग करने के लिए आपके वर्कस्पेस को एक्सेस की आवश्यकता है।

उदाहरण: किसी व्यक्ति को ट्रांसफ़र

यह डेफ़िनिशन प्राप्तकर्ता का अभिवादन करती है, एक सपोर्ट नंबर डायल करती है, और रिकॉर्ड करती है कि ट्रांसफ़र कनेक्ट हुआ या नहीं:

कोड उदाहरण

{
  "schema_version": 1,
  "expression_environment": "bird.cel.v1",
  "nodes": [
    {
      "id": "start",
      "type": "trigger.start_call",
      "type_version": 1,
      "config": {},
      "input": {},
      "connections": { "event": { "node_id": "greeting", "port": "input" } }
    },
    {
      "id": "greeting",
      "type": "voice.say",
      "type_version": 1,
      "config": {},
      "input": { "text": "Connecting you to our support team.", "language": "en" },
      "connections": { "next": { "node_id": "support", "port": "input" } }
    },
    {
      "id": "support",
      "type": "voice.dial",
      "type_version": 1,
      "config": {},
      "input": { "to": "+12025550123", "timeout_seconds": 30 },
      "connections": {
        "success": { "node_id": "connected", "port": "input" },
        "busy": { "node_id": "unavailable", "port": "input" },
        "no_answer": { "node_id": "unavailable", "port": "input" },
        "failure": { "node_id": "unavailable", "port": "input" }
      }
    },
    {
      "id": "connected",
      "type": "logic.exit",
      "type_version": 1,
      "config": { "status": "succeeded", "reason": "transferred" },
      "input": { "output": {} }
    },
    {
      "id": "unavailable",
      "type": "logic.exit",
      "type_version": 1,
      "config": { "status": "failed", "reason": "support_unavailable" },
      "input": { "output": {} }
    }
  ]
}

इसे sequence.definition के रूप में "entry_node_id": "start" और "trigger_data": {} के साथ भेजें।

इस विषय के लिए दस्तावेज़, गाइड और उदाहरणों के साथ आगे बढ़ें।

Voice sequences

संबंधित संसाधन