---
title: "એજન્ટને છેડેથી છેડે ચકાસો (API)"
description: "ThunderPhone API દ્વારા એક-વખતના સિમ્યુલેશન, સમાંતર દૃશ્ય બેચ અને રિલીઝ-ગેટ સ્યુટ ચલાવો, જેથી ગ્રાહકો એજન્ટમાં થયેલા રિગ્રેશન સાંભળે તે પહેલાં તે પકડાઈ જાય."
---

<Note>
  ડેશબોર્ડ પસંદ કરો છો? AI સિનારિયો જનરેશન સહિતની આ જ ક્ષમતા **સિમ્યુલેશન્સ**
  (`/dashboard/simulations`) માં ઉપલબ્ધ છે — [કૉલનું સિમ્યુલેશન કરો](/gu/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` | ઇન્ટિજર | હા | એજન્ટ 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 ફેરફાર પર, સમગ્ર સેટને બેચ તરીકે ચલાવો; ટ્રાન્સક્રિપ્ટ્સ અને ગ્રેડ્સની અગાઉના રન સાથે સરખામણી કરો.

### પ્રતિ-રિલીઝ સ્મોક ટેસ્ટ

દરેક 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="/gu/webhooks/events">
    પરિણામોને તમારા CI / Slack / PagerDuty માં સ્ટ્રીમ કરો.
  </Card>
</CardGroup>