ഒരു ഏജന്റിനെ എൻഡ്-ടു-എൻഡ് ആയി ടെസ്റ്റ് ചെയ്യുക (API)

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

ഒരു AI ഏജന്റിനെ മെച്ചപ്പെടുത്തുക എന്നത് അതിന്റെ prompt, ഉപകരണങ്ങൾ, എഡ്ജ് കേസുകൾ കൈകാര്യം ചെയ്യുന്ന രീതി എന്നിവ മെച്ചപ്പെടുത്തുന്നതാണ്. നിങ്ങൾ നൽകുന്ന സിനാരിയോ prompt ഉപയോഗിച്ച് സിമുലേഷൻ API ഒരു ഏജന്റിനെതിരെ യഥാർത്ഥ കോളുകൾ നടത്തുന്നു. ഒരു ഏജന്റിനെ ലക്ഷ്യമിടുന്നത് ബോട്ട്-ടു-ബോട്ട് റൺ സൃഷ്ടിക്കുന്നു; ഒരു ഫോൺ നമ്പറിനെ ലക്ഷ്യമിടുന്നത് SIP ലൂപ്പ്ബാക്ക് റൺ സൃഷ്ടിക്കുന്നു. ഓരോ റണ്ണും ട്രാൻസ്ക്രിപ്റ്റ്, ഗ്രേഡിംഗ്, ബില്ലിംഗ് എന്നിവയുള്ള യഥാർത്ഥ കോൾ ലോഗ് സൃഷ്ടിക്കും. അതിനാൽ ഏജന്റ് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും അതിന് എത്ര ചെലവാകുന്നുവെന്നും നിങ്ങൾക്ക് കൃത്യമായി കാണാം.

ഇവയ്ക്കായി ഉപയോഗിക്കുക:

• ഓരോ prompt എഡിറ്റിനും ശേഷമുള്ള പ്രീ-ഡിപ്ലോയ് സ്മോക്ക് ടെസ്റ്റുകൾ
• CI-യുമായി ബന്ധിപ്പിച്ച റിഗ്രഷൻ സ്യൂട്ടുകൾ (test-call.completed വെബ്ഹുക്ക് ഹുക്ക് ചെയ്യുക → സ്കോർ കുറഞ്ഞാൽ ബിൽഡ് പരാജയപ്പെടുത്തുക)
• കൺകറൻസി പരിധികളുടെ സ്ട്രെസ് ടെസ്റ്റിംഗ്

ഒറ്റത്തവണ: ഒരു റൺ#

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
  }'

ഫീൽഡുകൾ:

mode, target_type-ൽ നിന്ന് ലഭിക്കുന്ന റീഡ്-ഒൺലിയാണ്: agent mode="bot" സൃഷ്ടിക്കുന്നു, അതേസമയം phone_number mode="sip" സൃഷ്ടിക്കുന്നു.

പ്രതികരണം status="queued" എന്ന നിലയിലുള്ള ഒരു സിമുലേഷൻ റൺ ഒബ്ജക്റ്റ് ആണ്. status, completed അല്ലെങ്കിൽ failed ആകുന്നതുവരെ പോൾ ചെയ്യുക; call_id സജ്ജമായാൽ, GET /v1/calls/{call_id}/transcript മുഖേന ട്രാൻസ്ക്രിപ്റ്റ് ലോഡ് ചെയ്യുക.

ബാച്ചുകൾ: സമാന്തര സിനാരിയോകൾ#

അറിയപ്പെടുന്ന എല്ലാ എഡ്ജ് കേസുകളും സമാന്തരമായി കൈകാര്യം ചെയ്യുന്ന റിഗ്രഷൻ സ്യൂട്ടുകൾക്ക് ഉപകാരപ്രദമായി, N സിനാരിയോകൾ ഒരേസമയം പ്രവർത്തിപ്പിക്കുക:

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 ലിസ്റ്റ് ഉണ്ടായിരിക്കും. ബാച്ച് സ്റ്റാറ്റസ് നേടുക:

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 കീ ഉപയോഗിക്കുക. ഈ സ്ക്രിപ്റ്റ് സ്യൂട്ട് ട്രിഗർ ചെയ്യുകയും ഗ്രേഡിംഗും താരതമ്യവും പൂർത്തിയാകുന്നതുവരെ പോൾ ചെയ്യുകയും, വിധി pass അല്ലെങ്കിൽ നോൺസീറോ എക്സിറ്റോടെ അവസാനിക്കുകയും ചെയ്യുന്നു:

#!/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) കാണുക.

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-ഉം താരതമ്യം ചെയ്യുക.

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