ಏಜೆಂಟ್ ಅನ್ನು ಆರಂಭದಿಂದ ಅಂತ್ಯದವರೆಗೆ ಪರೀಕ್ಷಿಸಿ (API)

ಗ್ರಾಹಕರು ಕೇಳುವ ಮೊದಲು ಏಜೆಂಟ್ ಹಿಂಜರಿತಗಳು ಪತ್ತೆಯಾಗುವಂತೆ ThunderPhone API ಮೂಲಕ ಒನ್-ಶಾಟ್ ಸಿಮ್ಯುಲೇಷನ್‌ಗಳು, ಸಮಾನಾಂತರ ಸನ್ನಿವೇಶ ಬ್ಯಾಚ್‌ಗಳು ಮತ್ತು ಬಿಡುಗಡೆ-ಗೇಟ್ ಸೂಟ್‌ಗಳನ್ನು ಚಲಾಯಿಸಿ.

AI ಏಜೆಂಟ್ ಅನ್ನು ಪುನರಾವರ್ತಿಸುವುದು ಎಂದರೆ ಅದರ prompt, ಅದರ ಸಾಧನಗಳು, ಮತ್ತು ಅದು ಅಂಚಿನ ಸಂದರ್ಭಗಳನ್ನು ನಿರ್ವಹಿಸುವ ವಿಧವನ್ನು ಪುನರಾವರ್ತಿಸುವುದಾಗಿದೆ. ಸಿಮ್ಯುಲೇಷನ್‌ಗಳ API ನೀವು ಒದಗಿಸುವ ಸನ್ನಿವೇಶ prompt ಬಳಸಿ ಏಜೆಂಟ್ ವಿರುದ್ಧ ನೈಜ ಕರೆಗಳನ್ನು ನಡೆಸುತ್ತದೆ. ಏಜೆಂಟ್ ಅನ್ನು ಗುರಿಯಾಗಿಸಿದರೆ ಬಾಟ್-ಟು-ಬಾಟ್ ಚಾಲನೆ ರಚನೆಯಾಗುತ್ತದೆ; ಫೋನ್ ಸಂಖ್ಯೆಯನ್ನು ಗುರಿಯಾಗಿಸಿದರೆ 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 ಟ್ಯಾಬ್ ತೆರೆಯಿರಿ, ಬಿಡುಗಡೆ ಗೇಟ್ ಸೂಟ್‌ಗಳು ಆಯ್ಕೆಮಾಡಿ, ಮತ್ತು ಸೂಟ್ ರಚಿಸಿ ಅಥವಾ ಸಂಪಾದಿಸಿ. ವೇಳಾಪಟ್ಟಿಯಲ್ಲಿ ರನ್ ಮಾಡಿ ಸಕ್ರಿಯಗೊಳಿಸಿ, ಆವರ್ತನ ಮತ್ತು ಸಮಯ ವಲಯ ಆಯ್ಕೆಮಾಡಿ, ನಂತರ ತೋರಿಸಿರುವಂತೆ ಗಂಟೆಯ ನಂತರದ ನಿಮಿಷ, ಸ್ಥಳೀಯ ಸಮಯ, ಅಥವಾ ದಿನ ಹೊಂದಿಸಿ. ಸೂಟ್ ಉಳಿಸಿ ಆಯ್ಕೆಮಾಡಿ. ವೇಳಾಪಟ್ಟಿಯಲ್ಲಿ ರನ್ ಮಾಡಿ ಗುರುತನ್ನು ತೆಗೆದುಹಾಕಿದರೆ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ವೇಳಾಪಟ್ಟಿ ತೆಗೆದುಹಾಕಲಾಗುತ್ತದೆ.

API ಮೂಲಕ#

ಅದರ ವೇಳಾಪಟ್ಟಿಯನ್ನು ಸೇರಿಸಲು ಅಥವಾ ಬದಲಾಯಿಸಲು ಸೂಟ್‌ಗೆ PATCH ಮಾಡಿ. ಸಂಪೂರ್ಣ ಸೂಟ್ ಆಬ್ಜೆಕ್ಟ್ ಮತ್ತು ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಳಿಗಾಗಿ ಸೂಟ್‌ಗಳು (ಬಿಡುಗಡೆ ಗೇಟ್‌ಗಳು) ನೋಡಿ.

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 ಅನ್ನು ಹೋಲಿಸಿ.

ಮುಂದಿನ ಹಂತಗಳು#