---
title: "ಏಜೆಂಟ್ ಅನ್ನು ಆರಂಭದಿಂದ ಅಂತ್ಯದವರೆಗೆ ಪರೀಕ್ಷಿಸಿ (API)"
description: "ಗ್ರಾಹಕರು ಕೇಳುವ ಮೊದಲು ಏಜೆಂಟ್ ಹಿಂಜರಿತಗಳು ಪತ್ತೆಯಾಗುವಂತೆ ThunderPhone API ಮೂಲಕ ಒನ್-ಶಾಟ್ ಸಿಮ್ಯುಲೇಷನ್‌ಗಳು, ಸಮಾನಾಂತರ ಸನ್ನಿವೇಶ ಬ್ಯಾಚ್‌ಗಳು ಮತ್ತು ಬಿಡುಗಡೆ-ಗೇಟ್ ಸೂಟ್‌ಗಳನ್ನು ಚಲಾಯಿಸಿ."
---

<Note>
  ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ಗೆ ಆದ್ಯತೆ ನೀಡುತ್ತೀರಾ? AI ಸನ್ನಿವೇಶ ರಚನೆ ಸೇರಿದಂತೆ ಇದೇ ಸಾಮರ್ಥ್ಯವು **ಸಿಮ್ಯುಲೇಷನ್‌ಗಳು**
  (`/dashboard/simulations`) ನಲ್ಲಿ ಲಭ್ಯವಿದೆ — [ಕರೆಯನ್ನು ಸಿಮ್ಯುಲೇಟ್ ಮಾಡಿ](/kn/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` | ಪೂರ್ಣಾಂಕ | ಹೌದು | ಏಜೆಂಟ್ ಐಡಿ (ಅಥವಾ ಫೋನ್ ಸಂಖ್ಯೆ ಐಡಿ) |
| `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** ಟ್ಯಾಬ್ ತೆರೆಯಿರಿ, **ಬಿಡುಗಡೆ ಗೇಟ್ ಸೂಟ್‌ಗಳು** ಆಯ್ಕೆಮಾಡಿ,
ಮತ್ತು ಸೂಟ್ ರಚಿಸಿ ಅಥವಾ ಸಂಪಾದಿಸಿ. **ವೇಳಾಪಟ್ಟಿಯಲ್ಲಿ ರನ್ ಮಾಡಿ** ಸಕ್ರಿಯಗೊಳಿಸಿ,
**ಆವರ್ತನ** ಮತ್ತು **ಸಮಯ ವಲಯ** ಆಯ್ಕೆಮಾಡಿ, ನಂತರ ತೋರಿಸಿರುವಂತೆ
**ಗಂಟೆಯ ನಂತರದ ನಿಮಿಷ**, **ಸ್ಥಳೀಯ ಸಮಯ**, ಅಥವಾ **ದಿನ** ಹೊಂದಿಸಿ.
**ಸೂಟ್ ಉಳಿಸಿ** ಆಯ್ಕೆಮಾಡಿ. **ವೇಳಾಪಟ್ಟಿಯಲ್ಲಿ ರನ್ ಮಾಡಿ** ಗುರುತನ್ನು ತೆಗೆದುಹಾಕಿದರೆ
ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ವೇಳಾಪಟ್ಟಿ ತೆಗೆದುಹಾಕಲಾಗುತ್ತದೆ.

### 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="/kn/webhooks/events">
    ಫಲಿತಾಂಶಗಳನ್ನು ನಿಮ್ಮ CI / Slack / PagerDuty ಗೆ ಸ್ಟ್ರೀಮ್ ಮಾಡಿ.
  </Card>
</CardGroup>