---
title: "किसी एजेंट को एंड-टू-एंड टेस्ट करें (API)"
description: "ThunderPhone API के माध्यम से वन-शॉट सिमुलेशन, पैरेलल सिनेरियो बैच और रिलीज़-गेट सूट चलाएँ, ताकि ग्राहकों के सुनने से पहले एजेंट रिग्रेशन पकड़े जा सकें।"
---

<Note>
  क्या आप डैशबोर्ड पसंद करते हैं? यही क्षमता **Simulations**
  (`/dashboard/simulations`) में उपलब्ध है, जिसमें AI सिनेरियो जनरेशन भी शामिल है — देखें
  [कॉल सिमुलेट करें](/hi/guides/simulate-a-call)। यह पेज
  प्रोग्रामैटिक तरीके को कवर करता है।
</Note>

किसी AI एजेंट पर इटरेट करने का मतलब उसके प्रॉम्प्ट, उसके टूल्स,
और एज केस को हैंडल करने के तरीके पर इटरेट करना है। **simulations API** आपके दिए गए
सिनेरियो प्रॉम्प्ट का उपयोग करके एजेंट के विरुद्ध वास्तविक
कॉल चलाती है। किसी एजेंट को टारगेट करने पर बॉट-टू-बॉट रन बनता है; किसी फोन नंबर को टारगेट करने पर
SIP लूपबैक रन बनता है। हर रन ट्रांसक्रिप्ट, ग्रेडिंग और बिलिंग के साथ एक वास्तविक कॉल लॉग बनाता है,
ताकि आप ठीक से देख सकें कि एजेंट
कैसे व्यवहार करता है और इसकी लागत क्या है।

इसे इन कामों के लिए उपयोग करें:

- हर प्रॉम्प्ट एडिट के बाद प्री-डिप्लॉय स्मोक टेस्ट
- CI से जुड़े रिग्रेशन सूट (`test-call.completed` वेबहुक हुक करें
  → स्कोर घटने पर बिल्ड फेल करें)
- कॉन्करेंसी लिमिट का स्ट्रेस-टेस्टिंग

## वन-शॉट: सिंगल रन

```bash
curl -X POST https://api.thunderphone.com/v1/simulations \
  -H "Authorization: Bearer sk_live_YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "target_type":     "agent",
    "target_id":       12,
    "direction":       "outbound",
    "scenario_prompt": "You are a polite caller asking about refund policy for order 12345.",
    "consent_to_charge": true
  }'
```

फ़ील्ड:

| फ़ील्ड | टाइप | आवश्यक | विवरण |
|-------|------|----------|-------------|
| `target_type` | स्ट्रिंग | हाँ | `agent` या `phone_number` |
| `target_id` | इंटीजर | हाँ | एजेंट आईडी (या फ़ोन नंबर आईडी) |
| `direction` | स्ट्रिंग | नहीं | `outbound` (डिफ़ॉल्ट; टेस्ट कॉलर कॉल करता है) या `inbound` (टेस्ट कॉलर जवाब देता है) |
| `scenario_prompt` | स्ट्रिंग | नहीं | टेस्ट बॉट क्या कहता है, इसे नियंत्रित करता है |
| `language` / `primary_language` | स्ट्रिंग | नहीं | टेस्ट कॉलर की भाषा; असमर्थित कोड अस्वीकार किए जाते हैं |
| `simulator_product` | स्ट्रिंग | नहीं | `testing` (डिफ़ॉल्ट) या अधिक इंसान-जैसे सिम्युलेटेड कॉलर के लिए `spark`, जैसे वॉर्म-ट्रांसफर कंसल्ट टेस्ट |
| `consent_to_charge` | बूलियन | **हाँ** | `true` होना आवश्यक है। अनुमान में चुने गए एजेंट और सिम्युलेटेड कॉलर, दोनों के लिए एक समान प्रति-मिनट दर पर शुल्क लिया जाता है, साथ ही कोई भी टेलीफोनी लेग |
| `target_number` | स्ट्रिंग | नहीं | रिमोट साइड के लिए E.164 ओवरराइड; अन्यथा प्लेटफ़ॉर्म टेस्ट नंबर का उपयोग किया जाता है |

`mode`, `target_type` से केवल-पढ़ने योग्य रूप में निर्धारित होता है: `agent`
से `mode="bot"` बनता है, जबकि `phone_number` से `mode="sip"` बनता है।

रिस्पॉन्स में `status="queued"` वाला [सिमुलेशन रन ऑब्जेक्ट](/api-reference/test-calls#test-call-run-object)
होता है। `status` के `completed` या
`failed` होने तक पोल करें; `call_id` सेट होने पर, ट्रांसक्रिप्ट को
[`GET /v1/calls/{call_id}/transcript`](/api-reference/calls#get-transcript) के जरिए लोड करें।

## बैच: पैरलल सिनेरियो

N सिनेरियो एक साथ चलाएँ — उन रिग्रेशन सूट के लिए उपयोगी जो
हर ज्ञात एज केस को पैरलल में टेस्ट करते हैं:

```bash
curl -X POST https://api.thunderphone.com/v1/simulations/batches \
  -H "Authorization: Bearer sk_live_YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "target_type":     "agent",
    "target_id":       12,
    "direction":       "outbound",
    "run_count":       5,
    "stagger_seconds": 2,
    "scenario_prompts": [
      "Ask about refund policy.",
      "Ask for hours of operation.",
      "Complain about a delayed shipment.",
      "Ask to speak with a human.",
      "Ask an unrelated trivia question."
    ],
    "consent_to_charge": true
  }'
```

रिस्पॉन्स में चाइल्ड रन आईडी की `run_ids` सूची होती है। बैच
स्टेटस प्राप्त करें:

```bash
curl https://api.thunderphone.com/v1/simulations/batches/{batch_id} \
  -H "Authorization: Bearer sk_live_YOUR_API_KEY"
```

`run_count` की अधिकतम सीमा 20 है; एजेंट पर अत्यधिक लोड से बचने के लिए `stagger_seconds`
स्पॉन को अलग-अलग अंतराल पर चलाता है (0–60 सेकंड)।

## इसे CI में जोड़ें

**सिमुलेशंस** पेज
(`/dashboard/simulations`) पर एक रिलीज़ गेट सूट बनाएं — एजेंट चुनें, हाथ से सिनेरियो जोड़ें या
एजेंट के प्रॉम्प्ट से उनका ड्राफ्ट बनाने के लिए **AI के साथ सिनेरियो जनरेट करें** पर
क्लिक करें (वैकल्पिक एज-केस पास के साथ), और उन्हें एक सूट में समूहित करें।
एक सूट अपने सिनेरियो और एजेंट के साथ-साथ न्यूनतम पास रेट और वैकल्पिक
शून्य-क्रिटिकल-फेल्योर नियम को पिन करता है। पास होने वाले रन स्वीकृत
बेसलाइन बन जाते हैं; बाद के पास→फेल ट्रांज़िशन रिग्रेशन के रूप में लौटाए जाते हैं।

CI में [संगठन API key](/api-reference/developer-api-keys) का उपयोग करें।
यह स्क्रिप्ट सूट ट्रिगर करती है, ग्रेडिंग और तुलना पूरी होने तक पोल करती है,
और वर्डिक्ट `pass` न होने पर नॉनज़ीरो के साथ एग्ज़िट करती है:

```bash
#!/usr/bin/env bash
set -euo pipefail

: "${THUNDERPHONE_API_KEY:?Set THUNDERPHONE_API_KEY}"
: "${THUNDERPHONE_ORG_ID:?Set THUNDERPHONE_ORG_ID}"
: "${THUNDERPHONE_SUITE_ID:?Set THUNDERPHONE_SUITE_ID}"

base="https://api.thunderphone.com/v1/orgs/${THUNDERPHONE_ORG_ID}/suites/${THUNDERPHONE_SUITE_ID}"
auth="Authorization: Bearer ${THUNDERPHONE_API_KEY}"

run_id="$(curl --fail --silent --show-error -X POST "${base}/run" \
  -H "$auth" -H "Content-Type: application/json" -d '{}' | jq -r '.id')"

deadline=$((SECONDS + 1800))
while (( SECONDS < deadline )); do
  result="$(curl --fail --silent --show-error \
    "${base}/runs/${run_id}" -H "$auth")"
  status="$(jq -r '.status' <<<"$result")"
  if [[ "$status" == "completed" ]]; then
    jq . <<<"$result"
    [[ "$(jq -r '.verdict' <<<"$result")" == "pass" ]]
    exit
  fi
  sleep 10
done

echo "ThunderPhone suite timed out" >&2
exit 1
```

`POST /v1/orgs/{org_id}/suites/{suite_id}/run` रन id के साथ `202` लौटाता है।
`GET /v1/orgs/{org_id}/suites/{suite_id}/runs/{run_id}` `status`, `verdict`,
`pass_rate`, `critical_failure_count`, और बेसलाइन `regressions` सूची लौटाता है।
दोनों एंडपॉइंट URL संगठन को API key के संगठन से बाइंड करते हैं।

## शेड्यूल पर सूट चलाएं

एजेंट का **सिमुलेट** टैब खोलें, **रिलीज़ गेट सूट्स** चुनें, और एक सूट बनाएं या
एडिट करें। **शेड्यूल पर चलाएं** चालू करें, **फ्रीक्वेंसी** और **टाइमज़ोन** चुनें,
फिर दिखाए गए अनुसार **घंटे के बाद मिनट**, **लोकल समय**, या **दिन** सेट करें।
**सूट सहेजें** चुनें। **शेड्यूल पर चलाएं** को अनचेक करने से डैशबोर्ड शेड्यूल
हट जाता है।

### API के माध्यम से

सूट का शेड्यूल जोड़ने या बदलने के लिए उसे PATCH करें। संपूर्ण
सूट ऑब्जेक्ट और एंडपॉइंट्स के लिए [सूट्स (रिलीज़
गेट्स)](/api-reference/test-scenarios#suites-release-gates) देखें।

```bash
curl -X PATCH https://api.thunderphone.com/v1/suites/{suite_id} \
  -H "Authorization: Bearer sk_live_YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "schedule": {
      "enabled": true,
      "frequency": "daily",
      "timezone": "America/Chicago",
      "hour": 6,
      "minute": 30
    }
  }'
```

`frequency` `hourly`, `daily`, या `weekly` हो सकती है। IANA टाइमज़ोन का उपयोग करें।
प्रति घंटे के शेड्यूल `minute` का उपयोग करते हैं; दैनिक शेड्यूल `hour` और `minute`
का उपयोग करते हैं; साप्ताहिक शेड्यूल `weekday` का भी उपयोग करते हैं, जहाँ सोमवार
`0` और रविवार `6` है। सूट रिस्पॉन्स में `next_run_at` और `last_run_at` शामिल होते हैं।

समय चुने गए टाइमज़ोन के डेलाइट-सेविंग बदलावों का पालन करता है। शेड्यूल किए गए रन
सूट की रन हिस्ट्री में दिखाई देते हैं और उसके मौजूदा एजेंट, सिनेरियो, मापदंडों,
और स्वीकृत बेसलाइन का उपयोग करते हैं। हर जनरेटेड टेस्ट कॉल
`test-call.completed` एमिट करती है; सूट-लेवल कंप्लीशन वेबहुक नहीं है। शेड्यूल की
गई कॉलों का मूल्य निर्धारण मैन्युअल सूट रन के समान सिमुलेशन रेट पर होता है और
वे सूट रन पर `trigger: "schedule"` रिकॉर्ड करती हैं।

टाइमिंग बदले बिना किसी शेड्यूल को पॉज़ करने के लिए, पूरे मौजूदा शेड्यूल ऑब्जेक्ट को
`"enabled": false` के साथ PATCH करें। `frequency` आवश्यक है; छोड़े गए टाइमज़ोन और
समय फ़ील्ड अपने डिफ़ॉल्ट पर रीसेट हो जाते हैं, इसलिए मौजूदा वैल्यू शामिल करें।
शेड्यूल हटाने के लिए `"schedule": null` भेजें।

## पैटर्न

### प्रति-प्रॉम्प्ट रिग्रेशन कॉर्पस

`{name, scenario_prompt, expected_outcome}` ट्यूपल्स की एक JSON फ़ाइल बनाए रखें। हर प्रॉम्प्ट बदलाव पर, पूरे सेट को बैच के रूप में चलाएँ; ट्रांसक्रिप्ट और ग्रेड की तुलना पिछले रन से करें।

### प्रति-रिलीज़ स्मोक टेस्ट

पाँच हैप्पी-पाथ सिनेरियो का एक बैच, जिसे आप हर डिप्लॉय के बाद चलाते हैं। यह लेटेंसी-सेंसिटिव है, इसलिए `stagger_seconds: 0` रखें।

### लेटेंसी बेंचमार्किंग

अलग-अलग प्रोडक्ट टियर्स (`spark`, `bolt`, `storm-base`) के विरुद्ध समान सिनेरियो चलाएँ। हर परिणामी कॉल लॉग के `call.graded` स्कोर और `duration_seconds` की तुलना करें।

---

## अगले चरण

<CardGroup cols={2}>
  <Card title="टेस्ट कॉल्स संदर्भ" icon="flask" href="/api-reference/test-calls">
    हर क्वेरी पैरामीटर, स्टेटस कोड और बैच शेप।
  </Card>
  <Card title="AI ग्रेडिंग" icon="chart-line" href="/api-reference/calls#ai-call-grading">
    समय के साथ गुणवत्ता ट्रैक करने के लिए हर टेस्ट रन को ऑटो-स्कोर करें।
  </Card>
  <Card title="इश्यू रिपोर्ट्स" icon="triangle-exclamation" href="/api-reference/issue-reports">
    मानव समीक्षा के लिए विशिष्ट टेस्ट को फ़्लैग करें।
  </Card>
  <Card title="test-call.completed वेबहुक" icon="bolt" href="/hi/webhooks/events">
    परिणामों को अपने CI / Slack / PagerDuty में स्ट्रीम करें।
  </Card>
</CardGroup>