---
title: "ഒരു ഏജന്റിനെ എൻഡ്-ടു-എൻഡ് ആയി ടെസ്റ്റ് ചെയ്യുക (API)"
description: "ഉപഭോക്താക്കൾ കേൾക്കുന്നതിന് മുമ്പ് ഏജന്റ് റെഗ്രഷനുകൾ കണ്ടെത്താൻ ThunderPhone API വഴി ഒറ്റത്തവണ സിമുലേഷനുകൾ, സമാന്തര സീനാരിയോ ബാച്ചുകൾ, റിലീസ്-ഗേറ്റ് സ്യൂട്ടുകൾ എന്നിവ പ്രവർത്തിപ്പിക്കുക."
---

<Note>
  ഡാഷ്ബോർഡാണ് ഇഷ്ടമോ? AI സിനാരിയോ ജനറേഷൻ ഉൾപ്പെടെ ഇതേ സൗകര്യം **സിമുലേഷനുകൾ**
  (`/dashboard/simulations`) എന്നിടത്തും ലഭ്യമാണ് —
  [ഒരു കോൾ സിമുലേറ്റ് ചെയ്യുക](/ml/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` | ഇന്റിജർ | അതെ | ഏജന്റ് ഐഡി (അല്ലെങ്കിൽ ഫോൺ നമ്പർ ഐഡി) |
| `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-യുമായി ബന്ധിപ്പിക്കുക

**Simulations** പേജിൽ
(`/dashboard/simulations`) ഒരു റിലീസ് ഗേറ്റ് സ്യൂട്ട് സൃഷ്ടിക്കുക — ഏജന്റ് തിരഞ്ഞെടുക്കുക, കൈകൊണ്ട് സീനാരിയോകൾ ചേർക്കുക അല്ലെങ്കിൽ ഏജന്റിന്റെ
prompt-ിൽ നിന്ന് അവയുടെ ഡ്രാഫ്റ്റ് തയ്യാറാക്കാൻ **AI ഉപയോഗിച്ച് സീനാരിയോകൾ സൃഷ്ടിക്കുക** ക്ലിക്ക് ചെയ്യുക
(ഓപ്ഷണൽ എഡ്ജ്-കേസ് പാസോടെ), തുടർന്ന് അവയെ ഒരു സ്യൂട്ടായി ഗ്രൂപ്പ് ചെയ്യുക.
ഒരു സ്യൂട്ട് അതിന്റെ സീനാരിയോകളും ഏജന്റും, കുറഞ്ഞ പാസ് നിരക്കും ഓപ്ഷണൽ സീറോ-ക്രിട്ടിക്കൽ-ഫെയില്യർ നിയമവും നിശ്ചയിക്കുന്നു. പാസ് ചെയ്യുന്ന റണ്ണുകൾ അംഗീകരിച്ച ബേസ്‌ലൈനാകും; പിന്നീട് pass→fail ട്രാൻസിഷനുകൾ റെഗ്രഷനുകളായി തിരികെ ലഭിക്കും.

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 കീയുടെ ഓർഗനൈസേഷനുമായി ബന്ധിപ്പിക്കുന്നു.

## ഒരു ഷെഡ്യൂളിൽ സ്യൂട്ട് പ്രവർത്തിപ്പിക്കുക

ഏജന്റിന്റെ **Simulate** ടാബ് തുറക്കുക, **Release gate suites** തിരഞ്ഞെടുക്കുക, തുടർന്ന് ഒരു സ്യൂട്ട് സൃഷ്ടിക്കുകയോ
എഡിറ്റ് ചെയ്യുകയോ ചെയ്യുക. **Run on a schedule** ഓണാക്കുക, **Frequency**, **Timezone** എന്നിവ തിരഞ്ഞെടുക്കുക,
തുടർന്ന് കാണിച്ചിരിക്കുന്നതുപോലെ **Minute past the hour**, **Local time**, അല്ലെങ്കിൽ **Day** സജ്ജമാക്കുക.
**Save suite** തിരഞ്ഞെടുക്കുക. **Run on a schedule** അൺചെക്ക് ചെയ്യുന്നത്
ഡാഷ്ബോർഡ് ഷെഡ്യൂൾ നീക്കം ചെയ്യും.

### API വഴി

സ്യൂട്ടിന്റെ ഷെഡ്യൂൾ ചേർക്കാനോ മാറ്റിസ്ഥാപിക്കാനോ PATCH ചെയ്യുക. പൂർണ്ണമായ
സ്യൂട്ട് ഒബ്ജക്റ്റിനും എൻഡ്‌പോയിന്റുകൾക്കും [Suites (release
gates)](/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-നുശേഷവും പ്രവർത്തിപ്പിക്കുന്ന അഞ്ച് happy-path സാഹചര്യങ്ങളുടെ ഒറ്റ ബാച്ച്. ലേറ്റൻസിയോട് സംവേദനക്ഷമമായതിനാൽ `stagger_seconds: 0` ആയി നിലനിർത്തുക.

### ലേറ്റൻസി ബെഞ്ച്മാർക്കിംഗ്

വ്യത്യസ്ത ഉൽപ്പന്ന ടിയറുകൾക്കെതിരെ (`spark`, `bolt`, `storm-base`) ഒരേ സാഹചര്യങ്ങൾ പ്രവർത്തിപ്പിക്കുക. ഫലമായി ലഭിക്കുന്ന ഓരോ കോൾ ലോഗിലെയും `call.graded` സ്കോറുകളും `duration_seconds`-ഉം താരതമ്യം ചെയ്യുക.

---

## അടുത്ത ഘട്ടങ്ങൾ

<CardGroup cols={2}>
  <Card title="ടെസ്റ്റ് കോളുകൾ റഫറൻസ്" icon="flask" href="/api-reference/test-calls">
    ഓരോ query parameter-ഉം, status code-ഉം, ബാച്ച് ഘടനയും.
  </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="/ml/webhooks/events">
    ഫലങ്ങൾ നിങ്ങളുടെ CI / Slack / PagerDuty-യിലേക്ക് സ്ട്രീം ചെയ്യുക.
  </Card>
</CardGroup>