---
title: "ఏజెంట్‌ను ఎండ్-టు-ఎండ్‌గా పరీక్షించండి (API)"
description: "కస్టమర్‌లు వినకముందే ఏజెంట్ రిగ్రెషన్‌లను గుర్తించడానికి ThunderPhone API ద్వారా వన్-షాట్ సిమ్యులేషన్‌లు, సమాంతర సన్నివేశ బ్యాచ్‌లు మరియు విడుదల-గేట్ సూట్‌లను అమలు చేయండి."
---

<Note>
  డ్యాష్‌బోర్డ్‌ను ఇష్టపడుతున్నారా? ఇదే సామర్థ్యం AI దృశ్య జనరేషన్‌తో సహా **సిమ్యులేషన్లు**
  (`/dashboard/simulations`)లో ఉంది — [కాల్‌ను సిమ్యులేట్ చేయండి](/te/guides/simulate-a-call) చూడండి. ఈ పేజీ
  ప్రోగ్రామాటిక్ మార్గాన్ని వివరిస్తుంది.
</Note>

AI ఏజెంట్‌ను మెరుగుపరచడం అంటే దాని prompt, దాని టూల్స్,
మరియు ఎడ్జ్ కేస్‌లను అది నిర్వహించే విధానాన్ని మెరుగుపరచడమే. మీరు అందించే దృశ్య promptను ఉపయోగించి **సిమ్యులేషన్ల API**
ఏజెంట్‌తో నిజమైన కాల్‌లను నడుపుతుంది. ఏజెంట్‌ను లక్ష్యంగా ఎంచుకుంటే బాట్-టు-బాట్ రన్ సృష్టించబడుతుంది; ఫోన్ నంబర్‌ను లక్ష్యంగా ఎంచుకుంటే
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` | ఇంటీజర్ | అవును | ఏజెంట్ id (లేదా ఫోన్ నంబర్ 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
  }'
```

ప్రతిస్పందనలో చైల్డ్ రన్ idల `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` రన్ IDతో `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 మార్పుపై, పూర్తి సెట్‌ను బ్యాచ్‌గా అమలు చేయండి; ట్రాన్స్‌క్రిప్ట్‌లు మరియు గ్రేడ్‌లను
మునుపటి అమలుతో పోల్చండి.

### ప్రతి విడుదలకు స్మోక్ టెస్ట్

ప్రతి డిప్లాయ్ తర్వాత మీరు అమలు చేసే ఐదు సజావు-మార్గ పరిస్థితుల ఒకే బ్యాచ్.
ఇది లేటెన్సీకి సున్నితమైనది కాబట్టి, `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="/te/webhooks/events">
    ఫలితాలను మీ CI / Slack / PagerDutyలోకి స్ట్రీమ్ చేయండి.
  </Card>
</CardGroup>