---
title: "एजंटची सुरुवातीपासून शेवटपर्यंत चाचणी करा (API)"
description: "ThunderPhone API द्वारे एकदाच चालणारी सिम्युलेशन्स, समांतर परिस्थिती बॅचेस आणि रिलीज-गेट सूट्स चालवा, जेणेकरून ग्राहकांना एजंटमधील प्रतिगमन ऐकू येण्यापूर्वी ते पकडले जातील."
---

<Note>
  डॅशबोर्ड पसंत आहे का? हीच क्षमता AI परिस्थिती निर्मितीसह **सिम्युलेशन्स**
  (`/dashboard/simulations`) मध्ये उपलब्ध आहे — [कॉल सिम्युलेट करा](/mr/guides/simulate-a-call) पहा.
  हे पृष्ठ प्रोग्रामॅटिक मार्गाबद्दल आहे.
</Note>

AI एजंटवर पुनरावृत्ती करणे म्हणजे त्याच्या prompt, त्याची साधने,
आणि तो एज केसेस कशा हाताळतो यावर पुनरावृत्ती करणे. **सिम्युलेशन्स API**
तुम्ही दिलेल्या परिस्थिती prompt चा वापर करून एजंटविरुद्ध वास्तविक
कॉल चालवते. एजंट लक्ष्य केल्यास बॉट-टू-बॉट रन तयार होते; फोन नंबर
लक्ष्य केल्यास SIP लूपबॅक रन तयार होते. प्रत्येक रनमधून ट्रान्स्क्रिप्ट,
ग्रेडिंग आणि बिलिंगसह वास्तविक कॉल लॉग तयार होतो, त्यामुळे एजंट नेमका
कसा वागतो आणि त्यासाठी किती खर्च येतो हे तुम्हाला दिसते.

यासाठी वापरा:

- प्रत्येक prompt संपादनानंतर प्री-डिप्लॉय स्मोक चाचण्या
- 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`) रिलीज गेट संच तयार करा — एजंट निवडा, परिस्थिती हाताने जोडा किंवा एजंटच्या
prompt वरून त्यांचा मसुदा तयार करण्यासाठी **AI सह परिस्थिती तयार करा** वर क्लिक करा
(पर्यायी एज-केस तपासणीसह), आणि त्यांना एका संचात गटबद्ध करा.
संच त्याच्या परिस्थिती आणि एजंटसोबत किमान पास दर आणि पर्यायी शून्य-गंभीर-अयशस्वी नियम निश्चित करतो.
यशस्वी रन स्वीकृत बेसलाइन बनतात; नंतरचे पास→अयशस्वी बदल रिग्रेशन म्हणून परत केले जातात.

CI मध्ये [संस्थेची API की](/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` रन आयडीसह `202` परत करते.
`GET /v1/orgs/{org_id}/suites/{suite_id}/runs/{run_id}` हे
`status`, `verdict`, `pass_rate`, `critical_failure_count`, आणि
बेसलाइन `regressions` सूची परत करते. दोन्ही एंडपॉइंट URL मधील संस्थेला
API कीच्या संस्थेशी जोडतात.

## वेळापत्रकानुसार संच चालवा

एजंटचा **सिम्युलेट** टॅब उघडा, **रिलीज गेट संच** निवडा, आणि संच तयार करा किंवा
संपादित करा. **वेळापत्रकानुसार चालवा** सुरू करा, **वारंवारता** आणि
**वेळ क्षेत्र** निवडा, नंतर दाखवल्याप्रमाणे **तासानंतरचे मिनिट**, **स्थानिक वेळ**, किंवा **दिवस** सेट करा.
**संच जतन करा** निवडा. **वेळापत्रकानुसार चालवा** निवड रद्द केल्याने
डॅशबोर्डचे वेळापत्रक काढले जाते.

### 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` पाठवा.

## नमुने

### प्रत्येक prompt साठी रिग्रेशन कॉर्पस

`{name, scenario_prompt, expected_outcome}` ट्युपल्सची JSON फाइल सांभाळा.
प्रत्येक prompt बदलानंतर, संपूर्ण संच बॅच म्हणून चालवा; मागील रनच्या तुलनेत
ट्रान्सक्रिप्ट्स आणि ग्रेड्समधील फरक तपासा.

### प्रत्येक रिलीजनंतर स्मोक टेस्ट

प्रत्येक deploy नंतर चालवायच्या पाच हॅपी-पाथ परिस्थितींची एकच बॅच.
हे लेटन्सी-संवेदनशील असल्याने, `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="/mr/webhooks/events">
    निकाल तुमच्या CI / Slack / PagerDuty मध्ये स्ट्रीम करा.
  </Card>
</CardGroup>